/* this file has been autogenerated by vtkNodeJsWrap */
/* editing this might proof futile */

#define VTK_WRAPPING_CXX
#define VTK_STREAMS_FWD_ONLY
#include <nan.h>

#include "vtkObjectWrap.h"
#include "vtkDataObjectWrap.h"
#include "vtkObjectBaseWrap.h"
#include "vtkInformationWrap.h"
#include "vtkFieldDataWrap.h"
#include "vtkDataSetAttributesWrap.h"
#include "vtkAbstractArrayWrap.h"
#include "vtkInformationStringKeyWrap.h"
#include "vtkInformationDataObjectKeyWrap.h"
#include "vtkInformationIntegerKeyWrap.h"
#include "vtkInformationIntegerPointerKeyWrap.h"
#include "vtkInformationIntegerVectorKeyWrap.h"
#include "vtkInformationDoubleKeyWrap.h"
#include "vtkInformationInformationVectorKeyWrap.h"
#include "vtkInformationDoubleVectorKeyWrap.h"
#include "vtkInformationVectorWrap.h"
#include "../../plus/plus.h"

using namespace v8;

extern Nan::Persistent<v8::Object> vtkNodeJsNoWrap;
Nan::Persistent<v8::FunctionTemplate> VtkDataObjectWrap::ptpl;

VtkDataObjectWrap::VtkDataObjectWrap()
{ }

VtkDataObjectWrap::VtkDataObjectWrap(vtkSmartPointer<vtkDataObject> _native)
{ native = _native; }

VtkDataObjectWrap::~VtkDataObjectWrap()
{ }

void VtkDataObjectWrap::Init(v8::Local<v8::Object> exports)
{
	Nan::SetAccessor(exports, Nan::New("vtkDataObject").ToLocalChecked(), ConstructorGetter);
	Nan::SetAccessor(exports, Nan::New("DataObject").ToLocalChecked(), ConstructorGetter);
}

void VtkDataObjectWrap::ConstructorGetter(
	v8::Local<v8::String> property,
	const Nan::PropertyCallbackInfo<v8::Value>& info)
{
	InitPtpl();
	info.GetReturnValue().Set(Nan::New(ptpl)->GetFunction());
}

void VtkDataObjectWrap::InitPtpl()
{
	if (!ptpl.IsEmpty()) return;
	v8::Local<v8::FunctionTemplate> tpl = Nan::New<v8::FunctionTemplate>(New);
	VtkObjectWrap::InitPtpl( );
	tpl->Inherit(Nan::New<FunctionTemplate>(VtkObjectWrap::ptpl));
	tpl->SetClassName(Nan::New("VtkDataObjectWrap").ToLocalChecked());
	tpl->InstanceTemplate()->SetInternalFieldCount(1);

	Nan::SetPrototypeMethod(tpl, "ALL_PIECES_EXTENT", ALL_PIECES_EXTENT);

	Nan::SetPrototypeMethod(tpl, "BOUNDING_BOX", BOUNDING_BOX);

	Nan::SetPrototypeMethod(tpl, "CELL_DATA_VECTOR", CELL_DATA_VECTOR);

	Nan::SetPrototypeMethod(tpl, "CopyInformationFromPipeline", CopyInformationFromPipeline);
	Nan::SetPrototypeMethod(tpl, "copyInformationFromPipeline", CopyInformationFromPipeline);

	Nan::SetPrototypeMethod(tpl, "CopyInformationToPipeline", CopyInformationToPipeline);
	Nan::SetPrototypeMethod(tpl, "copyInformationToPipeline", CopyInformationToPipeline);

	Nan::SetPrototypeMethod(tpl, "DATA_EXTENT", DATA_EXTENT);

	Nan::SetPrototypeMethod(tpl, "DATA_EXTENT_TYPE", DATA_EXTENT_TYPE);

	Nan::SetPrototypeMethod(tpl, "DATA_NUMBER_OF_GHOST_LEVELS", DATA_NUMBER_OF_GHOST_LEVELS);

	Nan::SetPrototypeMethod(tpl, "DATA_NUMBER_OF_PIECES", DATA_NUMBER_OF_PIECES);

	Nan::SetPrototypeMethod(tpl, "DATA_OBJECT", DATA_OBJECT);

	Nan::SetPrototypeMethod(tpl, "DATA_PIECE_NUMBER", DATA_PIECE_NUMBER);

	Nan::SetPrototypeMethod(tpl, "DATA_TIME_STEP", DATA_TIME_STEP);

	Nan::SetPrototypeMethod(tpl, "DATA_TYPE_NAME", DATA_TYPE_NAME);

	Nan::SetPrototypeMethod(tpl, "DataHasBeenGenerated", DataHasBeenGenerated);
	Nan::SetPrototypeMethod(tpl, "dataHasBeenGenerated", DataHasBeenGenerated);

	Nan::SetPrototypeMethod(tpl, "DeepCopy", DeepCopy);
	Nan::SetPrototypeMethod(tpl, "deepCopy", DeepCopy);

	Nan::SetPrototypeMethod(tpl, "EDGE_DATA_VECTOR", EDGE_DATA_VECTOR);

	Nan::SetPrototypeMethod(tpl, "FIELD_ACTIVE_ATTRIBUTE", FIELD_ACTIVE_ATTRIBUTE);

	Nan::SetPrototypeMethod(tpl, "FIELD_ARRAY_TYPE", FIELD_ARRAY_TYPE);

	Nan::SetPrototypeMethod(tpl, "FIELD_ASSOCIATION", FIELD_ASSOCIATION);

	Nan::SetPrototypeMethod(tpl, "FIELD_ATTRIBUTE_TYPE", FIELD_ATTRIBUTE_TYPE);

	Nan::SetPrototypeMethod(tpl, "FIELD_NAME", FIELD_NAME);

	Nan::SetPrototypeMethod(tpl, "FIELD_NUMBER_OF_COMPONENTS", FIELD_NUMBER_OF_COMPONENTS);

	Nan::SetPrototypeMethod(tpl, "FIELD_NUMBER_OF_TUPLES", FIELD_NUMBER_OF_TUPLES);

	Nan::SetPrototypeMethod(tpl, "FIELD_OPERATION", FIELD_OPERATION);

	Nan::SetPrototypeMethod(tpl, "FIELD_RANGE", FIELD_RANGE);

	Nan::SetPrototypeMethod(tpl, "GetActiveFieldInformation", GetActiveFieldInformation);
	Nan::SetPrototypeMethod(tpl, "getActiveFieldInformation", GetActiveFieldInformation);

	Nan::SetPrototypeMethod(tpl, "GetActualMemorySize", GetActualMemorySize);
	Nan::SetPrototypeMethod(tpl, "getActualMemorySize", GetActualMemorySize);

	Nan::SetPrototypeMethod(tpl, "GetAssociationTypeAsString", GetAssociationTypeAsString);
	Nan::SetPrototypeMethod(tpl, "getAssociationTypeAsString", GetAssociationTypeAsString);

	Nan::SetPrototypeMethod(tpl, "GetAssociationTypeFromString", GetAssociationTypeFromString);
	Nan::SetPrototypeMethod(tpl, "getAssociationTypeFromString", GetAssociationTypeFromString);

	Nan::SetPrototypeMethod(tpl, "GetAttributeTypeForArray", GetAttributeTypeForArray);
	Nan::SetPrototypeMethod(tpl, "getAttributeTypeForArray", GetAttributeTypeForArray);

	Nan::SetPrototypeMethod(tpl, "GetAttributes", GetAttributes);
	Nan::SetPrototypeMethod(tpl, "getAttributes", GetAttributes);

	Nan::SetPrototypeMethod(tpl, "GetAttributesAsFieldData", GetAttributesAsFieldData);
	Nan::SetPrototypeMethod(tpl, "getAttributesAsFieldData", GetAttributesAsFieldData);

	Nan::SetPrototypeMethod(tpl, "GetData", GetData);
	Nan::SetPrototypeMethod(tpl, "getData", GetData);

	Nan::SetPrototypeMethod(tpl, "GetDataObjectType", GetDataObjectType);
	Nan::SetPrototypeMethod(tpl, "getDataObjectType", GetDataObjectType);

	Nan::SetPrototypeMethod(tpl, "GetDataReleased", GetDataReleased);
	Nan::SetPrototypeMethod(tpl, "getDataReleased", GetDataReleased);

	Nan::SetPrototypeMethod(tpl, "GetExtentType", GetExtentType);
	Nan::SetPrototypeMethod(tpl, "getExtentType", GetExtentType);

	Nan::SetPrototypeMethod(tpl, "GetFieldData", GetFieldData);
	Nan::SetPrototypeMethod(tpl, "getFieldData", GetFieldData);

	Nan::SetPrototypeMethod(tpl, "GetGlobalReleaseDataFlag", GetGlobalReleaseDataFlag);
	Nan::SetPrototypeMethod(tpl, "getGlobalReleaseDataFlag", GetGlobalReleaseDataFlag);

	Nan::SetPrototypeMethod(tpl, "GetInformation", GetInformation);
	Nan::SetPrototypeMethod(tpl, "getInformation", GetInformation);

	Nan::SetPrototypeMethod(tpl, "GetNamedFieldInformation", GetNamedFieldInformation);
	Nan::SetPrototypeMethod(tpl, "getNamedFieldInformation", GetNamedFieldInformation);

	Nan::SetPrototypeMethod(tpl, "GlobalReleaseDataFlagOff", GlobalReleaseDataFlagOff);
	Nan::SetPrototypeMethod(tpl, "globalReleaseDataFlagOff", GlobalReleaseDataFlagOff);

	Nan::SetPrototypeMethod(tpl, "GlobalReleaseDataFlagOn", GlobalReleaseDataFlagOn);
	Nan::SetPrototypeMethod(tpl, "globalReleaseDataFlagOn", GlobalReleaseDataFlagOn);

	Nan::SetPrototypeMethod(tpl, "Initialize", Initialize);
	Nan::SetPrototypeMethod(tpl, "initialize", Initialize);

	Nan::SetPrototypeMethod(tpl, "NewInstance", NewInstance);
	Nan::SetPrototypeMethod(tpl, "newInstance", NewInstance);

	Nan::SetPrototypeMethod(tpl, "ORIGIN", ORIGIN);

	Nan::SetPrototypeMethod(tpl, "PIECE_EXTENT", PIECE_EXTENT);

	Nan::SetPrototypeMethod(tpl, "POINT_DATA_VECTOR", POINT_DATA_VECTOR);

	Nan::SetPrototypeMethod(tpl, "PrepareForNewData", PrepareForNewData);
	Nan::SetPrototypeMethod(tpl, "prepareForNewData", PrepareForNewData);

	Nan::SetPrototypeMethod(tpl, "ReleaseData", ReleaseData);
	Nan::SetPrototypeMethod(tpl, "releaseData", ReleaseData);

	Nan::SetPrototypeMethod(tpl, "RemoveNamedFieldInformation", RemoveNamedFieldInformation);
	Nan::SetPrototypeMethod(tpl, "removeNamedFieldInformation", RemoveNamedFieldInformation);

	Nan::SetPrototypeMethod(tpl, "SIL", SIL);

	Nan::SetPrototypeMethod(tpl, "SPACING", SPACING);

	Nan::SetPrototypeMethod(tpl, "SafeDownCast", SafeDownCast);
	Nan::SetPrototypeMethod(tpl, "safeDownCast", SafeDownCast);

	Nan::SetPrototypeMethod(tpl, "SetActiveAttribute", SetActiveAttribute);
	Nan::SetPrototypeMethod(tpl, "setActiveAttribute", SetActiveAttribute);

	Nan::SetPrototypeMethod(tpl, "SetActiveAttributeInfo", SetActiveAttributeInfo);
	Nan::SetPrototypeMethod(tpl, "setActiveAttributeInfo", SetActiveAttributeInfo);

	Nan::SetPrototypeMethod(tpl, "SetFieldData", SetFieldData);
	Nan::SetPrototypeMethod(tpl, "setFieldData", SetFieldData);

	Nan::SetPrototypeMethod(tpl, "SetGlobalReleaseDataFlag", SetGlobalReleaseDataFlag);
	Nan::SetPrototypeMethod(tpl, "setGlobalReleaseDataFlag", SetGlobalReleaseDataFlag);

	Nan::SetPrototypeMethod(tpl, "SetInformation", SetInformation);
	Nan::SetPrototypeMethod(tpl, "setInformation", SetInformation);

	Nan::SetPrototypeMethod(tpl, "SetPointDataActiveScalarInfo", SetPointDataActiveScalarInfo);
	Nan::SetPrototypeMethod(tpl, "setPointDataActiveScalarInfo", SetPointDataActiveScalarInfo);

	Nan::SetPrototypeMethod(tpl, "ShallowCopy", ShallowCopy);
	Nan::SetPrototypeMethod(tpl, "shallowCopy", ShallowCopy);

	Nan::SetPrototypeMethod(tpl, "VERTEX_DATA_VECTOR", VERTEX_DATA_VECTOR);

#ifdef VTK_NODE_PLUS_VTKDATAOBJECTWRAP_INITPTPL
	VTK_NODE_PLUS_VTKDATAOBJECTWRAP_INITPTPL
#endif
	ptpl.Reset( tpl );
}

void VtkDataObjectWrap::New(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	if(!info.IsConstructCall())
	{
		Nan::ThrowError("Constructor not called in a construct call.");
		return;
	}

	if(info.Length() == 0)
	{
		vtkSmartPointer<vtkDataObject> native = vtkSmartPointer<vtkDataObject>::New();
		VtkDataObjectWrap* obj = new VtkDataObjectWrap(native);
		obj->Wrap(info.This());
	}
	else
	{
		if(info[0]->ToObject() != vtkNodeJsNoWrap )
		{
			Nan::ThrowError("Parameter Error");
			return;
		}
	}

	info.GetReturnValue().Set(info.This());
}

void VtkDataObjectWrap::ALL_PIECES_EXTENT(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkDataObjectWrap *wrapper = ObjectWrap::Unwrap<VtkDataObjectWrap>(info.Holder());
	vtkDataObject *native = (vtkDataObject *)wrapper->native.GetPointer();
	vtkInformationIntegerVectorKey * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->ALL_PIECES_EXTENT();
	VtkInformationIntegerVectorKeyWrap::InitPtpl();
	v8::Local<v8::Value> argv[1] =
		{ Nan::New(vtkNodeJsNoWrap) };
	v8::Local<v8::Function> cons =
		Nan::New<v8::FunctionTemplate>(VtkInformationIntegerVectorKeyWrap::ptpl)->GetFunction();
	v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
	VtkInformationIntegerVectorKeyWrap *w = new VtkInformationIntegerVectorKeyWrap();
	w->native = r;
	w->Wrap(wo);
	info.GetReturnValue().Set(wo);
}

void VtkDataObjectWrap::BOUNDING_BOX(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkDataObjectWrap *wrapper = ObjectWrap::Unwrap<VtkDataObjectWrap>(info.Holder());
	vtkDataObject *native = (vtkDataObject *)wrapper->native.GetPointer();
	vtkInformationDoubleVectorKey * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->BOUNDING_BOX();
	VtkInformationDoubleVectorKeyWrap::InitPtpl();
	v8::Local<v8::Value> argv[1] =
		{ Nan::New(vtkNodeJsNoWrap) };
	v8::Local<v8::Function> cons =
		Nan::New<v8::FunctionTemplate>(VtkInformationDoubleVectorKeyWrap::ptpl)->GetFunction();
	v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
	VtkInformationDoubleVectorKeyWrap *w = new VtkInformationDoubleVectorKeyWrap();
	w->native = r;
	w->Wrap(wo);
	info.GetReturnValue().Set(wo);
}

void VtkDataObjectWrap::CELL_DATA_VECTOR(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkDataObjectWrap *wrapper = ObjectWrap::Unwrap<VtkDataObjectWrap>(info.Holder());
	vtkDataObject *native = (vtkDataObject *)wrapper->native.GetPointer();
	vtkInformationInformationVectorKey * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->CELL_DATA_VECTOR();
	VtkInformationInformationVectorKeyWrap::InitPtpl();
	v8::Local<v8::Value> argv[1] =
		{ Nan::New(vtkNodeJsNoWrap) };
	v8::Local<v8::Function> cons =
		Nan::New<v8::FunctionTemplate>(VtkInformationInformationVectorKeyWrap::ptpl)->GetFunction();
	v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
	VtkInformationInformationVectorKeyWrap *w = new VtkInformationInformationVectorKeyWrap();
	w->native = r;
	w->Wrap(wo);
	info.GetReturnValue().Set(wo);
}

void VtkDataObjectWrap::CopyInformationFromPipeline(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkDataObjectWrap *wrapper = ObjectWrap::Unwrap<VtkDataObjectWrap>(info.Holder());
	vtkDataObject *native = (vtkDataObject *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkInformationWrap::ptpl))->HasInstance(info[0]))
	{
		VtkInformationWrap *a0 = ObjectWrap::Unwrap<VtkInformationWrap>(info[0]->ToObject());
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->CopyInformationFromPipeline(
			(vtkInformation *) a0->native.GetPointer()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkDataObjectWrap::CopyInformationToPipeline(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkDataObjectWrap *wrapper = ObjectWrap::Unwrap<VtkDataObjectWrap>(info.Holder());
	vtkDataObject *native = (vtkDataObject *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkInformationWrap::ptpl))->HasInstance(info[0]))
	{
		VtkInformationWrap *a0 = ObjectWrap::Unwrap<VtkInformationWrap>(info[0]->ToObject());
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->CopyInformationToPipeline(
			(vtkInformation *) a0->native.GetPointer()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkDataObjectWrap::DATA_EXTENT(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkDataObjectWrap *wrapper = ObjectWrap::Unwrap<VtkDataObjectWrap>(info.Holder());
	vtkDataObject *native = (vtkDataObject *)wrapper->native.GetPointer();
	vtkInformationIntegerPointerKey * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->DATA_EXTENT();
	VtkInformationIntegerPointerKeyWrap::InitPtpl();
	v8::Local<v8::Value> argv[1] =
		{ Nan::New(vtkNodeJsNoWrap) };
	v8::Local<v8::Function> cons =
		Nan::New<v8::FunctionTemplate>(VtkInformationIntegerPointerKeyWrap::ptpl)->GetFunction();
	v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
	VtkInformationIntegerPointerKeyWrap *w = new VtkInformationIntegerPointerKeyWrap();
	w->native = r;
	w->Wrap(wo);
	info.GetReturnValue().Set(wo);
}

void VtkDataObjectWrap::DATA_EXTENT_TYPE(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkDataObjectWrap *wrapper = ObjectWrap::Unwrap<VtkDataObjectWrap>(info.Holder());
	vtkDataObject *native = (vtkDataObject *)wrapper->native.GetPointer();
	vtkInformationIntegerKey * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->DATA_EXTENT_TYPE();
	VtkInformationIntegerKeyWrap::InitPtpl();
	v8::Local<v8::Value> argv[1] =
		{ Nan::New(vtkNodeJsNoWrap) };
	v8::Local<v8::Function> cons =
		Nan::New<v8::FunctionTemplate>(VtkInformationIntegerKeyWrap::ptpl)->GetFunction();
	v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
	VtkInformationIntegerKeyWrap *w = new VtkInformationIntegerKeyWrap();
	w->native = r;
	w->Wrap(wo);
	info.GetReturnValue().Set(wo);
}

void VtkDataObjectWrap::DATA_NUMBER_OF_GHOST_LEVELS(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkDataObjectWrap *wrapper = ObjectWrap::Unwrap<VtkDataObjectWrap>(info.Holder());
	vtkDataObject *native = (vtkDataObject *)wrapper->native.GetPointer();
	vtkInformationIntegerKey * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->DATA_NUMBER_OF_GHOST_LEVELS();
	VtkInformationIntegerKeyWrap::InitPtpl();
	v8::Local<v8::Value> argv[1] =
		{ Nan::New(vtkNodeJsNoWrap) };
	v8::Local<v8::Function> cons =
		Nan::New<v8::FunctionTemplate>(VtkInformationIntegerKeyWrap::ptpl)->GetFunction();
	v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
	VtkInformationIntegerKeyWrap *w = new VtkInformationIntegerKeyWrap();
	w->native = r;
	w->Wrap(wo);
	info.GetReturnValue().Set(wo);
}

void VtkDataObjectWrap::DATA_NUMBER_OF_PIECES(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkDataObjectWrap *wrapper = ObjectWrap::Unwrap<VtkDataObjectWrap>(info.Holder());
	vtkDataObject *native = (vtkDataObject *)wrapper->native.GetPointer();
	vtkInformationIntegerKey * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->DATA_NUMBER_OF_PIECES();
	VtkInformationIntegerKeyWrap::InitPtpl();
	v8::Local<v8::Value> argv[1] =
		{ Nan::New(vtkNodeJsNoWrap) };
	v8::Local<v8::Function> cons =
		Nan::New<v8::FunctionTemplate>(VtkInformationIntegerKeyWrap::ptpl)->GetFunction();
	v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
	VtkInformationIntegerKeyWrap *w = new VtkInformationIntegerKeyWrap();
	w->native = r;
	w->Wrap(wo);
	info.GetReturnValue().Set(wo);
}

void VtkDataObjectWrap::DATA_OBJECT(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkDataObjectWrap *wrapper = ObjectWrap::Unwrap<VtkDataObjectWrap>(info.Holder());
	vtkDataObject *native = (vtkDataObject *)wrapper->native.GetPointer();
	vtkInformationDataObjectKey * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->DATA_OBJECT();
	VtkInformationDataObjectKeyWrap::InitPtpl();
	v8::Local<v8::Value> argv[1] =
		{ Nan::New(vtkNodeJsNoWrap) };
	v8::Local<v8::Function> cons =
		Nan::New<v8::FunctionTemplate>(VtkInformationDataObjectKeyWrap::ptpl)->GetFunction();
	v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
	VtkInformationDataObjectKeyWrap *w = new VtkInformationDataObjectKeyWrap();
	w->native = r;
	w->Wrap(wo);
	info.GetReturnValue().Set(wo);
}

void VtkDataObjectWrap::DATA_PIECE_NUMBER(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkDataObjectWrap *wrapper = ObjectWrap::Unwrap<VtkDataObjectWrap>(info.Holder());
	vtkDataObject *native = (vtkDataObject *)wrapper->native.GetPointer();
	vtkInformationIntegerKey * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->DATA_PIECE_NUMBER();
	VtkInformationIntegerKeyWrap::InitPtpl();
	v8::Local<v8::Value> argv[1] =
		{ Nan::New(vtkNodeJsNoWrap) };
	v8::Local<v8::Function> cons =
		Nan::New<v8::FunctionTemplate>(VtkInformationIntegerKeyWrap::ptpl)->GetFunction();
	v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
	VtkInformationIntegerKeyWrap *w = new VtkInformationIntegerKeyWrap();
	w->native = r;
	w->Wrap(wo);
	info.GetReturnValue().Set(wo);
}

void VtkDataObjectWrap::DATA_TIME_STEP(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkDataObjectWrap *wrapper = ObjectWrap::Unwrap<VtkDataObjectWrap>(info.Holder());
	vtkDataObject *native = (vtkDataObject *)wrapper->native.GetPointer();
	vtkInformationDoubleKey * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->DATA_TIME_STEP();
	VtkInformationDoubleKeyWrap::InitPtpl();
	v8::Local<v8::Value> argv[1] =
		{ Nan::New(vtkNodeJsNoWrap) };
	v8::Local<v8::Function> cons =
		Nan::New<v8::FunctionTemplate>(VtkInformationDoubleKeyWrap::ptpl)->GetFunction();
	v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
	VtkInformationDoubleKeyWrap *w = new VtkInformationDoubleKeyWrap();
	w->native = r;
	w->Wrap(wo);
	info.GetReturnValue().Set(wo);
}

void VtkDataObjectWrap::DATA_TYPE_NAME(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkDataObjectWrap *wrapper = ObjectWrap::Unwrap<VtkDataObjectWrap>(info.Holder());
	vtkDataObject *native = (vtkDataObject *)wrapper->native.GetPointer();
	vtkInformationStringKey * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->DATA_TYPE_NAME();
	VtkInformationStringKeyWrap::InitPtpl();
	v8::Local<v8::Value> argv[1] =
		{ Nan::New(vtkNodeJsNoWrap) };
	v8::Local<v8::Function> cons =
		Nan::New<v8::FunctionTemplate>(VtkInformationStringKeyWrap::ptpl)->GetFunction();
	v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
	VtkInformationStringKeyWrap *w = new VtkInformationStringKeyWrap();
	w->native = r;
	w->Wrap(wo);
	info.GetReturnValue().Set(wo);
}

void VtkDataObjectWrap::DataHasBeenGenerated(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkDataObjectWrap *wrapper = ObjectWrap::Unwrap<VtkDataObjectWrap>(info.Holder());
	vtkDataObject *native = (vtkDataObject *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->DataHasBeenGenerated();
}

void VtkDataObjectWrap::DeepCopy(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkDataObjectWrap *wrapper = ObjectWrap::Unwrap<VtkDataObjectWrap>(info.Holder());
	vtkDataObject *native = (vtkDataObject *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkDataObjectWrap::ptpl))->HasInstance(info[0]))
	{
		VtkDataObjectWrap *a0 = ObjectWrap::Unwrap<VtkDataObjectWrap>(info[0]->ToObject());
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->DeepCopy(
			(vtkDataObject *) a0->native.GetPointer()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkDataObjectWrap::EDGE_DATA_VECTOR(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkDataObjectWrap *wrapper = ObjectWrap::Unwrap<VtkDataObjectWrap>(info.Holder());
	vtkDataObject *native = (vtkDataObject *)wrapper->native.GetPointer();
	vtkInformationInformationVectorKey * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->EDGE_DATA_VECTOR();
	VtkInformationInformationVectorKeyWrap::InitPtpl();
	v8::Local<v8::Value> argv[1] =
		{ Nan::New(vtkNodeJsNoWrap) };
	v8::Local<v8::Function> cons =
		Nan::New<v8::FunctionTemplate>(VtkInformationInformationVectorKeyWrap::ptpl)->GetFunction();
	v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
	VtkInformationInformationVectorKeyWrap *w = new VtkInformationInformationVectorKeyWrap();
	w->native = r;
	w->Wrap(wo);
	info.GetReturnValue().Set(wo);
}

void VtkDataObjectWrap::FIELD_ACTIVE_ATTRIBUTE(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkDataObjectWrap *wrapper = ObjectWrap::Unwrap<VtkDataObjectWrap>(info.Holder());
	vtkDataObject *native = (vtkDataObject *)wrapper->native.GetPointer();
	vtkInformationIntegerKey * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->FIELD_ACTIVE_ATTRIBUTE();
	VtkInformationIntegerKeyWrap::InitPtpl();
	v8::Local<v8::Value> argv[1] =
		{ Nan::New(vtkNodeJsNoWrap) };
	v8::Local<v8::Function> cons =
		Nan::New<v8::FunctionTemplate>(VtkInformationIntegerKeyWrap::ptpl)->GetFunction();
	v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
	VtkInformationIntegerKeyWrap *w = new VtkInformationIntegerKeyWrap();
	w->native = r;
	w->Wrap(wo);
	info.GetReturnValue().Set(wo);
}

void VtkDataObjectWrap::FIELD_ARRAY_TYPE(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkDataObjectWrap *wrapper = ObjectWrap::Unwrap<VtkDataObjectWrap>(info.Holder());
	vtkDataObject *native = (vtkDataObject *)wrapper->native.GetPointer();
	vtkInformationIntegerKey * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->FIELD_ARRAY_TYPE();
	VtkInformationIntegerKeyWrap::InitPtpl();
	v8::Local<v8::Value> argv[1] =
		{ Nan::New(vtkNodeJsNoWrap) };
	v8::Local<v8::Function> cons =
		Nan::New<v8::FunctionTemplate>(VtkInformationIntegerKeyWrap::ptpl)->GetFunction();
	v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
	VtkInformationIntegerKeyWrap *w = new VtkInformationIntegerKeyWrap();
	w->native = r;
	w->Wrap(wo);
	info.GetReturnValue().Set(wo);
}

void VtkDataObjectWrap::FIELD_ASSOCIATION(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkDataObjectWrap *wrapper = ObjectWrap::Unwrap<VtkDataObjectWrap>(info.Holder());
	vtkDataObject *native = (vtkDataObject *)wrapper->native.GetPointer();
	vtkInformationIntegerKey * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->FIELD_ASSOCIATION();
	VtkInformationIntegerKeyWrap::InitPtpl();
	v8::Local<v8::Value> argv[1] =
		{ Nan::New(vtkNodeJsNoWrap) };
	v8::Local<v8::Function> cons =
		Nan::New<v8::FunctionTemplate>(VtkInformationIntegerKeyWrap::ptpl)->GetFunction();
	v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
	VtkInformationIntegerKeyWrap *w = new VtkInformationIntegerKeyWrap();
	w->native = r;
	w->Wrap(wo);
	info.GetReturnValue().Set(wo);
}

void VtkDataObjectWrap::FIELD_ATTRIBUTE_TYPE(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkDataObjectWrap *wrapper = ObjectWrap::Unwrap<VtkDataObjectWrap>(info.Holder());
	vtkDataObject *native = (vtkDataObject *)wrapper->native.GetPointer();
	vtkInformationIntegerKey * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->FIELD_ATTRIBUTE_TYPE();
	VtkInformationIntegerKeyWrap::InitPtpl();
	v8::Local<v8::Value> argv[1] =
		{ Nan::New(vtkNodeJsNoWrap) };
	v8::Local<v8::Function> cons =
		Nan::New<v8::FunctionTemplate>(VtkInformationIntegerKeyWrap::ptpl)->GetFunction();
	v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
	VtkInformationIntegerKeyWrap *w = new VtkInformationIntegerKeyWrap();
	w->native = r;
	w->Wrap(wo);
	info.GetReturnValue().Set(wo);
}

void VtkDataObjectWrap::FIELD_NAME(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkDataObjectWrap *wrapper = ObjectWrap::Unwrap<VtkDataObjectWrap>(info.Holder());
	vtkDataObject *native = (vtkDataObject *)wrapper->native.GetPointer();
	vtkInformationStringKey * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->FIELD_NAME();
	VtkInformationStringKeyWrap::InitPtpl();
	v8::Local<v8::Value> argv[1] =
		{ Nan::New(vtkNodeJsNoWrap) };
	v8::Local<v8::Function> cons =
		Nan::New<v8::FunctionTemplate>(VtkInformationStringKeyWrap::ptpl)->GetFunction();
	v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
	VtkInformationStringKeyWrap *w = new VtkInformationStringKeyWrap();
	w->native = r;
	w->Wrap(wo);
	info.GetReturnValue().Set(wo);
}

void VtkDataObjectWrap::FIELD_NUMBER_OF_COMPONENTS(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkDataObjectWrap *wrapper = ObjectWrap::Unwrap<VtkDataObjectWrap>(info.Holder());
	vtkDataObject *native = (vtkDataObject *)wrapper->native.GetPointer();
	vtkInformationIntegerKey * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->FIELD_NUMBER_OF_COMPONENTS();
	VtkInformationIntegerKeyWrap::InitPtpl();
	v8::Local<v8::Value> argv[1] =
		{ Nan::New(vtkNodeJsNoWrap) };
	v8::Local<v8::Function> cons =
		Nan::New<v8::FunctionTemplate>(VtkInformationIntegerKeyWrap::ptpl)->GetFunction();
	v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
	VtkInformationIntegerKeyWrap *w = new VtkInformationIntegerKeyWrap();
	w->native = r;
	w->Wrap(wo);
	info.GetReturnValue().Set(wo);
}

void VtkDataObjectWrap::FIELD_NUMBER_OF_TUPLES(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkDataObjectWrap *wrapper = ObjectWrap::Unwrap<VtkDataObjectWrap>(info.Holder());
	vtkDataObject *native = (vtkDataObject *)wrapper->native.GetPointer();
	vtkInformationIntegerKey * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->FIELD_NUMBER_OF_TUPLES();
	VtkInformationIntegerKeyWrap::InitPtpl();
	v8::Local<v8::Value> argv[1] =
		{ Nan::New(vtkNodeJsNoWrap) };
	v8::Local<v8::Function> cons =
		Nan::New<v8::FunctionTemplate>(VtkInformationIntegerKeyWrap::ptpl)->GetFunction();
	v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
	VtkInformationIntegerKeyWrap *w = new VtkInformationIntegerKeyWrap();
	w->native = r;
	w->Wrap(wo);
	info.GetReturnValue().Set(wo);
}

void VtkDataObjectWrap::FIELD_OPERATION(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkDataObjectWrap *wrapper = ObjectWrap::Unwrap<VtkDataObjectWrap>(info.Holder());
	vtkDataObject *native = (vtkDataObject *)wrapper->native.GetPointer();
	vtkInformationIntegerKey * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->FIELD_OPERATION();
	VtkInformationIntegerKeyWrap::InitPtpl();
	v8::Local<v8::Value> argv[1] =
		{ Nan::New(vtkNodeJsNoWrap) };
	v8::Local<v8::Function> cons =
		Nan::New<v8::FunctionTemplate>(VtkInformationIntegerKeyWrap::ptpl)->GetFunction();
	v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
	VtkInformationIntegerKeyWrap *w = new VtkInformationIntegerKeyWrap();
	w->native = r;
	w->Wrap(wo);
	info.GetReturnValue().Set(wo);
}

void VtkDataObjectWrap::FIELD_RANGE(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkDataObjectWrap *wrapper = ObjectWrap::Unwrap<VtkDataObjectWrap>(info.Holder());
	vtkDataObject *native = (vtkDataObject *)wrapper->native.GetPointer();
	vtkInformationDoubleVectorKey * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->FIELD_RANGE();
	VtkInformationDoubleVectorKeyWrap::InitPtpl();
	v8::Local<v8::Value> argv[1] =
		{ Nan::New(vtkNodeJsNoWrap) };
	v8::Local<v8::Function> cons =
		Nan::New<v8::FunctionTemplate>(VtkInformationDoubleVectorKeyWrap::ptpl)->GetFunction();
	v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
	VtkInformationDoubleVectorKeyWrap *w = new VtkInformationDoubleVectorKeyWrap();
	w->native = r;
	w->Wrap(wo);
	info.GetReturnValue().Set(wo);
}

void VtkDataObjectWrap::GetActiveFieldInformation(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkDataObjectWrap *wrapper = ObjectWrap::Unwrap<VtkDataObjectWrap>(info.Holder());
	vtkDataObject *native = (vtkDataObject *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkInformationWrap::ptpl))->HasInstance(info[0]))
	{
		VtkInformationWrap *a0 = ObjectWrap::Unwrap<VtkInformationWrap>(info[0]->ToObject());
		if(info.Length() > 1 && info[1]->IsInt32())
		{
			if(info.Length() > 2 && info[2]->IsInt32())
			{
				vtkInformation * r;
				if(info.Length() != 3)
				{
					Nan::ThrowError("Too many parameters.");
					return;
				}
				r = native->GetActiveFieldInformation(
					(vtkInformation *) a0->native.GetPointer(),
					info[1]->Int32Value(),
					info[2]->Int32Value()
				);
				VtkInformationWrap::InitPtpl();
				v8::Local<v8::Value> argv[1] =
					{ Nan::New(vtkNodeJsNoWrap) };
				v8::Local<v8::Function> cons =
					Nan::New<v8::FunctionTemplate>(VtkInformationWrap::ptpl)->GetFunction();
				v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
				VtkInformationWrap *w = new VtkInformationWrap();
				w->native = r;
				w->Wrap(wo);
				info.GetReturnValue().Set(wo);
				return;
			}
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkDataObjectWrap::GetActualMemorySize(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkDataObjectWrap *wrapper = ObjectWrap::Unwrap<VtkDataObjectWrap>(info.Holder());
	vtkDataObject *native = (vtkDataObject *)wrapper->native.GetPointer();
	unsigned int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetActualMemorySize();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkDataObjectWrap::GetAssociationTypeAsString(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkDataObjectWrap *wrapper = ObjectWrap::Unwrap<VtkDataObjectWrap>(info.Holder());
	vtkDataObject *native = (vtkDataObject *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		char const * r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetAssociationTypeAsString(
			info[0]->Int32Value()
		);
		info.GetReturnValue().Set(Nan::New(r).ToLocalChecked());
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkDataObjectWrap::GetAssociationTypeFromString(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkDataObjectWrap *wrapper = ObjectWrap::Unwrap<VtkDataObjectWrap>(info.Holder());
	vtkDataObject *native = (vtkDataObject *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
		int r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetAssociationTypeFromString(
			*a0
		);
		info.GetReturnValue().Set(Nan::New(r));
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkDataObjectWrap::GetAttributeTypeForArray(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkDataObjectWrap *wrapper = ObjectWrap::Unwrap<VtkDataObjectWrap>(info.Holder());
	vtkDataObject *native = (vtkDataObject *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkAbstractArrayWrap::ptpl))->HasInstance(info[0]))
	{
		VtkAbstractArrayWrap *a0 = ObjectWrap::Unwrap<VtkAbstractArrayWrap>(info[0]->ToObject());
		int r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetAttributeTypeForArray(
			(vtkAbstractArray *) a0->native.GetPointer()
		);
		info.GetReturnValue().Set(Nan::New(r));
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkDataObjectWrap::GetAttributes(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkDataObjectWrap *wrapper = ObjectWrap::Unwrap<VtkDataObjectWrap>(info.Holder());
	vtkDataObject *native = (vtkDataObject *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		vtkDataSetAttributes * r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetAttributes(
			info[0]->Int32Value()
		);
		VtkDataSetAttributesWrap::InitPtpl();
		v8::Local<v8::Value> argv[1] =
			{ Nan::New(vtkNodeJsNoWrap) };
		v8::Local<v8::Function> cons =
			Nan::New<v8::FunctionTemplate>(VtkDataSetAttributesWrap::ptpl)->GetFunction();
		v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
		VtkDataSetAttributesWrap *w = new VtkDataSetAttributesWrap();
		w->native = r;
		w->Wrap(wo);
		info.GetReturnValue().Set(wo);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkDataObjectWrap::GetAttributesAsFieldData(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkDataObjectWrap *wrapper = ObjectWrap::Unwrap<VtkDataObjectWrap>(info.Holder());
	vtkDataObject *native = (vtkDataObject *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		vtkFieldData * r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetAttributesAsFieldData(
			info[0]->Int32Value()
		);
		VtkFieldDataWrap::InitPtpl();
		v8::Local<v8::Value> argv[1] =
			{ Nan::New(vtkNodeJsNoWrap) };
		v8::Local<v8::Function> cons =
			Nan::New<v8::FunctionTemplate>(VtkFieldDataWrap::ptpl)->GetFunction();
		v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
		VtkFieldDataWrap *w = new VtkFieldDataWrap();
		w->native = r;
		w->Wrap(wo);
		info.GetReturnValue().Set(wo);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkDataObjectWrap::GetData(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkDataObjectWrap *wrapper = ObjectWrap::Unwrap<VtkDataObjectWrap>(info.Holder());
	vtkDataObject *native = (vtkDataObject *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkInformationVectorWrap::ptpl))->HasInstance(info[0]))
	{
		VtkInformationVectorWrap *a0 = ObjectWrap::Unwrap<VtkInformationVectorWrap>(info[0]->ToObject());
		if(info.Length() > 1 && info[1]->IsInt32())
		{
			vtkDataObject * r;
			if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			r = native->GetData(
				(vtkInformationVector *) a0->native.GetPointer(),
				info[1]->Int32Value()
			);
			VtkDataObjectWrap::InitPtpl();
			v8::Local<v8::Value> argv[1] =
				{ Nan::New(vtkNodeJsNoWrap) };
			v8::Local<v8::Function> cons =
				Nan::New<v8::FunctionTemplate>(VtkDataObjectWrap::ptpl)->GetFunction();
			v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
			VtkDataObjectWrap *w = new VtkDataObjectWrap();
			w->native = r;
			w->Wrap(wo);
			info.GetReturnValue().Set(wo);
			return;
		}
	}
	else if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkInformationWrap::ptpl))->HasInstance(info[0]))
	{
		VtkInformationWrap *a0 = ObjectWrap::Unwrap<VtkInformationWrap>(info[0]->ToObject());
		vtkDataObject * r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetData(
			(vtkInformation *) a0->native.GetPointer()
		);
		VtkDataObjectWrap::InitPtpl();
		v8::Local<v8::Value> argv[1] =
			{ Nan::New(vtkNodeJsNoWrap) };
		v8::Local<v8::Function> cons =
			Nan::New<v8::FunctionTemplate>(VtkDataObjectWrap::ptpl)->GetFunction();
		v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
		VtkDataObjectWrap *w = new VtkDataObjectWrap();
		w->native = r;
		w->Wrap(wo);
		info.GetReturnValue().Set(wo);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkDataObjectWrap::GetDataObjectType(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkDataObjectWrap *wrapper = ObjectWrap::Unwrap<VtkDataObjectWrap>(info.Holder());
	vtkDataObject *native = (vtkDataObject *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetDataObjectType();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkDataObjectWrap::GetDataReleased(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkDataObjectWrap *wrapper = ObjectWrap::Unwrap<VtkDataObjectWrap>(info.Holder());
	vtkDataObject *native = (vtkDataObject *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetDataReleased();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkDataObjectWrap::GetExtentType(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkDataObjectWrap *wrapper = ObjectWrap::Unwrap<VtkDataObjectWrap>(info.Holder());
	vtkDataObject *native = (vtkDataObject *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetExtentType();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkDataObjectWrap::GetFieldData(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkDataObjectWrap *wrapper = ObjectWrap::Unwrap<VtkDataObjectWrap>(info.Holder());
	vtkDataObject *native = (vtkDataObject *)wrapper->native.GetPointer();
	vtkFieldData * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetFieldData();
	VtkFieldDataWrap::InitPtpl();
	v8::Local<v8::Value> argv[1] =
		{ Nan::New(vtkNodeJsNoWrap) };
	v8::Local<v8::Function> cons =
		Nan::New<v8::FunctionTemplate>(VtkFieldDataWrap::ptpl)->GetFunction();
	v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
	VtkFieldDataWrap *w = new VtkFieldDataWrap();
	w->native = r;
	w->Wrap(wo);
	info.GetReturnValue().Set(wo);
}

void VtkDataObjectWrap::GetGlobalReleaseDataFlag(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkDataObjectWrap *wrapper = ObjectWrap::Unwrap<VtkDataObjectWrap>(info.Holder());
	vtkDataObject *native = (vtkDataObject *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetGlobalReleaseDataFlag();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkDataObjectWrap::GetInformation(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkDataObjectWrap *wrapper = ObjectWrap::Unwrap<VtkDataObjectWrap>(info.Holder());
	vtkDataObject *native = (vtkDataObject *)wrapper->native.GetPointer();
	vtkInformation * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetInformation();
	VtkInformationWrap::InitPtpl();
	v8::Local<v8::Value> argv[1] =
		{ Nan::New(vtkNodeJsNoWrap) };
	v8::Local<v8::Function> cons =
		Nan::New<v8::FunctionTemplate>(VtkInformationWrap::ptpl)->GetFunction();
	v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
	VtkInformationWrap *w = new VtkInformationWrap();
	w->native = r;
	w->Wrap(wo);
	info.GetReturnValue().Set(wo);
}

void VtkDataObjectWrap::GetNamedFieldInformation(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkDataObjectWrap *wrapper = ObjectWrap::Unwrap<VtkDataObjectWrap>(info.Holder());
	vtkDataObject *native = (vtkDataObject *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkInformationWrap::ptpl))->HasInstance(info[0]))
	{
		VtkInformationWrap *a0 = ObjectWrap::Unwrap<VtkInformationWrap>(info[0]->ToObject());
		if(info.Length() > 1 && info[1]->IsInt32())
		{
			if(info.Length() > 2 && info[2]->IsString())
			{
				Nan::Utf8String a2(info[2]);
				vtkInformation * r;
				if(info.Length() != 3)
				{
					Nan::ThrowError("Too many parameters.");
					return;
				}
				r = native->GetNamedFieldInformation(
					(vtkInformation *) a0->native.GetPointer(),
					info[1]->Int32Value(),
					*a2
				);
				VtkInformationWrap::InitPtpl();
				v8::Local<v8::Value> argv[1] =
					{ Nan::New(vtkNodeJsNoWrap) };
				v8::Local<v8::Function> cons =
					Nan::New<v8::FunctionTemplate>(VtkInformationWrap::ptpl)->GetFunction();
				v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
				VtkInformationWrap *w = new VtkInformationWrap();
				w->native = r;
				w->Wrap(wo);
				info.GetReturnValue().Set(wo);
				return;
			}
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkDataObjectWrap::GlobalReleaseDataFlagOff(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkDataObjectWrap *wrapper = ObjectWrap::Unwrap<VtkDataObjectWrap>(info.Holder());
	vtkDataObject *native = (vtkDataObject *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->GlobalReleaseDataFlagOff();
}

void VtkDataObjectWrap::GlobalReleaseDataFlagOn(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkDataObjectWrap *wrapper = ObjectWrap::Unwrap<VtkDataObjectWrap>(info.Holder());
	vtkDataObject *native = (vtkDataObject *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->GlobalReleaseDataFlagOn();
}

void VtkDataObjectWrap::Initialize(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkDataObjectWrap *wrapper = ObjectWrap::Unwrap<VtkDataObjectWrap>(info.Holder());
	vtkDataObject *native = (vtkDataObject *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->Initialize();
}

void VtkDataObjectWrap::NewInstance(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkDataObjectWrap *wrapper = ObjectWrap::Unwrap<VtkDataObjectWrap>(info.Holder());
	vtkDataObject *native = (vtkDataObject *)wrapper->native.GetPointer();
	vtkDataObject * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->NewInstance();
	VtkDataObjectWrap::InitPtpl();
	v8::Local<v8::Value> argv[1] =
		{ Nan::New(vtkNodeJsNoWrap) };
	v8::Local<v8::Function> cons =
		Nan::New<v8::FunctionTemplate>(VtkDataObjectWrap::ptpl)->GetFunction();
	v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
	VtkDataObjectWrap *w = new VtkDataObjectWrap();
	w->native = r;
	w->Wrap(wo);
	info.GetReturnValue().Set(wo);
}

void VtkDataObjectWrap::ORIGIN(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkDataObjectWrap *wrapper = ObjectWrap::Unwrap<VtkDataObjectWrap>(info.Holder());
	vtkDataObject *native = (vtkDataObject *)wrapper->native.GetPointer();
	vtkInformationDoubleVectorKey * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->ORIGIN();
	VtkInformationDoubleVectorKeyWrap::InitPtpl();
	v8::Local<v8::Value> argv[1] =
		{ Nan::New(vtkNodeJsNoWrap) };
	v8::Local<v8::Function> cons =
		Nan::New<v8::FunctionTemplate>(VtkInformationDoubleVectorKeyWrap::ptpl)->GetFunction();
	v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
	VtkInformationDoubleVectorKeyWrap *w = new VtkInformationDoubleVectorKeyWrap();
	w->native = r;
	w->Wrap(wo);
	info.GetReturnValue().Set(wo);
}

void VtkDataObjectWrap::PIECE_EXTENT(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkDataObjectWrap *wrapper = ObjectWrap::Unwrap<VtkDataObjectWrap>(info.Holder());
	vtkDataObject *native = (vtkDataObject *)wrapper->native.GetPointer();
	vtkInformationIntegerVectorKey * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->PIECE_EXTENT();
	VtkInformationIntegerVectorKeyWrap::InitPtpl();
	v8::Local<v8::Value> argv[1] =
		{ Nan::New(vtkNodeJsNoWrap) };
	v8::Local<v8::Function> cons =
		Nan::New<v8::FunctionTemplate>(VtkInformationIntegerVectorKeyWrap::ptpl)->GetFunction();
	v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
	VtkInformationIntegerVectorKeyWrap *w = new VtkInformationIntegerVectorKeyWrap();
	w->native = r;
	w->Wrap(wo);
	info.GetReturnValue().Set(wo);
}

void VtkDataObjectWrap::POINT_DATA_VECTOR(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkDataObjectWrap *wrapper = ObjectWrap::Unwrap<VtkDataObjectWrap>(info.Holder());
	vtkDataObject *native = (vtkDataObject *)wrapper->native.GetPointer();
	vtkInformationInformationVectorKey * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->POINT_DATA_VECTOR();
	VtkInformationInformationVectorKeyWrap::InitPtpl();
	v8::Local<v8::Value> argv[1] =
		{ Nan::New(vtkNodeJsNoWrap) };
	v8::Local<v8::Function> cons =
		Nan::New<v8::FunctionTemplate>(VtkInformationInformationVectorKeyWrap::ptpl)->GetFunction();
	v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
	VtkInformationInformationVectorKeyWrap *w = new VtkInformationInformationVectorKeyWrap();
	w->native = r;
	w->Wrap(wo);
	info.GetReturnValue().Set(wo);
}

void VtkDataObjectWrap::PrepareForNewData(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkDataObjectWrap *wrapper = ObjectWrap::Unwrap<VtkDataObjectWrap>(info.Holder());
	vtkDataObject *native = (vtkDataObject *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->PrepareForNewData();
}

void VtkDataObjectWrap::ReleaseData(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkDataObjectWrap *wrapper = ObjectWrap::Unwrap<VtkDataObjectWrap>(info.Holder());
	vtkDataObject *native = (vtkDataObject *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->ReleaseData();
}

void VtkDataObjectWrap::RemoveNamedFieldInformation(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkDataObjectWrap *wrapper = ObjectWrap::Unwrap<VtkDataObjectWrap>(info.Holder());
	vtkDataObject *native = (vtkDataObject *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkInformationWrap::ptpl))->HasInstance(info[0]))
	{
		VtkInformationWrap *a0 = ObjectWrap::Unwrap<VtkInformationWrap>(info[0]->ToObject());
		if(info.Length() > 1 && info[1]->IsInt32())
		{
			if(info.Length() > 2 && info[2]->IsString())
			{
				Nan::Utf8String a2(info[2]);
								if(info.Length() != 3)
				{
					Nan::ThrowError("Too many parameters.");
					return;
				}
				native->RemoveNamedFieldInformation(
					(vtkInformation *) a0->native.GetPointer(),
					info[1]->Int32Value(),
					*a2
				);
				return;
			}
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkDataObjectWrap::SIL(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkDataObjectWrap *wrapper = ObjectWrap::Unwrap<VtkDataObjectWrap>(info.Holder());
	vtkDataObject *native = (vtkDataObject *)wrapper->native.GetPointer();
	vtkInformationDataObjectKey * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->SIL();
	VtkInformationDataObjectKeyWrap::InitPtpl();
	v8::Local<v8::Value> argv[1] =
		{ Nan::New(vtkNodeJsNoWrap) };
	v8::Local<v8::Function> cons =
		Nan::New<v8::FunctionTemplate>(VtkInformationDataObjectKeyWrap::ptpl)->GetFunction();
	v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
	VtkInformationDataObjectKeyWrap *w = new VtkInformationDataObjectKeyWrap();
	w->native = r;
	w->Wrap(wo);
	info.GetReturnValue().Set(wo);
}

void VtkDataObjectWrap::SPACING(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkDataObjectWrap *wrapper = ObjectWrap::Unwrap<VtkDataObjectWrap>(info.Holder());
	vtkDataObject *native = (vtkDataObject *)wrapper->native.GetPointer();
	vtkInformationDoubleVectorKey * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->SPACING();
	VtkInformationDoubleVectorKeyWrap::InitPtpl();
	v8::Local<v8::Value> argv[1] =
		{ Nan::New(vtkNodeJsNoWrap) };
	v8::Local<v8::Function> cons =
		Nan::New<v8::FunctionTemplate>(VtkInformationDoubleVectorKeyWrap::ptpl)->GetFunction();
	v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
	VtkInformationDoubleVectorKeyWrap *w = new VtkInformationDoubleVectorKeyWrap();
	w->native = r;
	w->Wrap(wo);
	info.GetReturnValue().Set(wo);
}

void VtkDataObjectWrap::SafeDownCast(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkDataObjectWrap *wrapper = ObjectWrap::Unwrap<VtkDataObjectWrap>(info.Holder());
	vtkDataObject *native = (vtkDataObject *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkObjectBaseWrap::ptpl))->HasInstance(info[0]))
	{
		VtkObjectBaseWrap *a0 = ObjectWrap::Unwrap<VtkObjectBaseWrap>(info[0]->ToObject());
		vtkDataObject * r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->SafeDownCast(
			(vtkObjectBase *) a0->native.GetPointer()
		);
		VtkDataObjectWrap::InitPtpl();
		v8::Local<v8::Value> argv[1] =
			{ Nan::New(vtkNodeJsNoWrap) };
		v8::Local<v8::Function> cons =
			Nan::New<v8::FunctionTemplate>(VtkDataObjectWrap::ptpl)->GetFunction();
		v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
		VtkDataObjectWrap *w = new VtkDataObjectWrap();
		w->native = r;
		w->Wrap(wo);
		info.GetReturnValue().Set(wo);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkDataObjectWrap::SetActiveAttribute(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkDataObjectWrap *wrapper = ObjectWrap::Unwrap<VtkDataObjectWrap>(info.Holder());
	vtkDataObject *native = (vtkDataObject *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkInformationWrap::ptpl))->HasInstance(info[0]))
	{
		VtkInformationWrap *a0 = ObjectWrap::Unwrap<VtkInformationWrap>(info[0]->ToObject());
		if(info.Length() > 1 && info[1]->IsInt32())
		{
			if(info.Length() > 2 && info[2]->IsString())
			{
				Nan::Utf8String a2(info[2]);
				if(info.Length() > 3 && info[3]->IsInt32())
				{
					vtkInformation * r;
					if(info.Length() != 4)
					{
						Nan::ThrowError("Too many parameters.");
						return;
					}
					r = native->SetActiveAttribute(
						(vtkInformation *) a0->native.GetPointer(),
						info[1]->Int32Value(),
						*a2,
						info[3]->Int32Value()
					);
					VtkInformationWrap::InitPtpl();
					v8::Local<v8::Value> argv[1] =
						{ Nan::New(vtkNodeJsNoWrap) };
					v8::Local<v8::Function> cons =
						Nan::New<v8::FunctionTemplate>(VtkInformationWrap::ptpl)->GetFunction();
					v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
					VtkInformationWrap *w = new VtkInformationWrap();
					w->native = r;
					w->Wrap(wo);
					info.GetReturnValue().Set(wo);
					return;
				}
			}
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkDataObjectWrap::SetActiveAttributeInfo(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkDataObjectWrap *wrapper = ObjectWrap::Unwrap<VtkDataObjectWrap>(info.Holder());
	vtkDataObject *native = (vtkDataObject *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkInformationWrap::ptpl))->HasInstance(info[0]))
	{
		VtkInformationWrap *a0 = ObjectWrap::Unwrap<VtkInformationWrap>(info[0]->ToObject());
		if(info.Length() > 1 && info[1]->IsInt32())
		{
			if(info.Length() > 2 && info[2]->IsInt32())
			{
				if(info.Length() > 3 && info[3]->IsString())
				{
					Nan::Utf8String a3(info[3]);
					if(info.Length() > 4 && info[4]->IsInt32())
					{
						if(info.Length() > 5 && info[5]->IsInt32())
						{
							if(info.Length() > 6 && info[6]->IsInt32())
							{
																if(info.Length() != 7)
								{
									Nan::ThrowError("Too many parameters.");
									return;
								}
								native->SetActiveAttributeInfo(
									(vtkInformation *) a0->native.GetPointer(),
									info[1]->Int32Value(),
									info[2]->Int32Value(),
									*a3,
									info[4]->Int32Value(),
									info[5]->Int32Value(),
									info[6]->Int32Value()
								);
								return;
							}
						}
					}
				}
			}
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkDataObjectWrap::SetFieldData(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkDataObjectWrap *wrapper = ObjectWrap::Unwrap<VtkDataObjectWrap>(info.Holder());
	vtkDataObject *native = (vtkDataObject *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkFieldDataWrap::ptpl))->HasInstance(info[0]))
	{
		VtkFieldDataWrap *a0 = ObjectWrap::Unwrap<VtkFieldDataWrap>(info[0]->ToObject());
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetFieldData(
			(vtkFieldData *) a0->native.GetPointer()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkDataObjectWrap::SetGlobalReleaseDataFlag(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkDataObjectWrap *wrapper = ObjectWrap::Unwrap<VtkDataObjectWrap>(info.Holder());
	vtkDataObject *native = (vtkDataObject *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetGlobalReleaseDataFlag(
			info[0]->Int32Value()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkDataObjectWrap::SetInformation(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkDataObjectWrap *wrapper = ObjectWrap::Unwrap<VtkDataObjectWrap>(info.Holder());
	vtkDataObject *native = (vtkDataObject *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkInformationWrap::ptpl))->HasInstance(info[0]))
	{
		VtkInformationWrap *a0 = ObjectWrap::Unwrap<VtkInformationWrap>(info[0]->ToObject());
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetInformation(
			(vtkInformation *) a0->native.GetPointer()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkDataObjectWrap::SetPointDataActiveScalarInfo(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkDataObjectWrap *wrapper = ObjectWrap::Unwrap<VtkDataObjectWrap>(info.Holder());
	vtkDataObject *native = (vtkDataObject *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkInformationWrap::ptpl))->HasInstance(info[0]))
	{
		VtkInformationWrap *a0 = ObjectWrap::Unwrap<VtkInformationWrap>(info[0]->ToObject());
		if(info.Length() > 1 && info[1]->IsInt32())
		{
			if(info.Length() > 2 && info[2]->IsInt32())
			{
								if(info.Length() != 3)
				{
					Nan::ThrowError("Too many parameters.");
					return;
				}
				native->SetPointDataActiveScalarInfo(
					(vtkInformation *) a0->native.GetPointer(),
					info[1]->Int32Value(),
					info[2]->Int32Value()
				);
				return;
			}
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkDataObjectWrap::ShallowCopy(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkDataObjectWrap *wrapper = ObjectWrap::Unwrap<VtkDataObjectWrap>(info.Holder());
	vtkDataObject *native = (vtkDataObject *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkDataObjectWrap::ptpl))->HasInstance(info[0]))
	{
		VtkDataObjectWrap *a0 = ObjectWrap::Unwrap<VtkDataObjectWrap>(info[0]->ToObject());
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->ShallowCopy(
			(vtkDataObject *) a0->native.GetPointer()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkDataObjectWrap::VERTEX_DATA_VECTOR(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkDataObjectWrap *wrapper = ObjectWrap::Unwrap<VtkDataObjectWrap>(info.Holder());
	vtkDataObject *native = (vtkDataObject *)wrapper->native.GetPointer();
	vtkInformationInformationVectorKey * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->VERTEX_DATA_VECTOR();
	VtkInformationInformationVectorKeyWrap::InitPtpl();
	v8::Local<v8::Value> argv[1] =
		{ Nan::New(vtkNodeJsNoWrap) };
	v8::Local<v8::Function> cons =
		Nan::New<v8::FunctionTemplate>(VtkInformationInformationVectorKeyWrap::ptpl)->GetFunction();
	v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
	VtkInformationInformationVectorKeyWrap *w = new VtkInformationInformationVectorKeyWrap();
	w->native = r;
	w->Wrap(wo);
	info.GetReturnValue().Set(wo);
}