/* 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 "vtkMultiBlockDataSetAlgorithmWrap.h"
#include "vtkMultiBlockPLOT3DReaderWrap.h"
#include "vtkObjectWrap.h"
#include "vtkMultiProcessControllerWrap.h"
#include "../../plus/plus.h"

using namespace v8;

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

VtkMultiBlockPLOT3DReaderWrap::VtkMultiBlockPLOT3DReaderWrap()
{ }

VtkMultiBlockPLOT3DReaderWrap::VtkMultiBlockPLOT3DReaderWrap(vtkSmartPointer<vtkMultiBlockPLOT3DReader> _native)
{ native = _native; }

VtkMultiBlockPLOT3DReaderWrap::~VtkMultiBlockPLOT3DReaderWrap()
{ }

void VtkMultiBlockPLOT3DReaderWrap::Init(v8::Local<v8::Object> exports)
{
	Nan::SetAccessor(exports, Nan::New("vtkMultiBlockPLOT3DReader").ToLocalChecked(), ConstructorGetter);
	Nan::SetAccessor(exports, Nan::New("MultiBlockPLOT3DReader").ToLocalChecked(), ConstructorGetter);
}

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

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

	Nan::SetPrototypeMethod(tpl, "AddFunction", AddFunction);
	Nan::SetPrototypeMethod(tpl, "addFunction", AddFunction);

	Nan::SetPrototypeMethod(tpl, "AutoDetectFormatOff", AutoDetectFormatOff);
	Nan::SetPrototypeMethod(tpl, "autoDetectFormatOff", AutoDetectFormatOff);

	Nan::SetPrototypeMethod(tpl, "AutoDetectFormatOn", AutoDetectFormatOn);
	Nan::SetPrototypeMethod(tpl, "autoDetectFormatOn", AutoDetectFormatOn);

	Nan::SetPrototypeMethod(tpl, "BinaryFileOff", BinaryFileOff);
	Nan::SetPrototypeMethod(tpl, "binaryFileOff", BinaryFileOff);

	Nan::SetPrototypeMethod(tpl, "BinaryFileOn", BinaryFileOn);
	Nan::SetPrototypeMethod(tpl, "binaryFileOn", BinaryFileOn);

	Nan::SetPrototypeMethod(tpl, "CanReadBinaryFile", CanReadBinaryFile);
	Nan::SetPrototypeMethod(tpl, "canReadBinaryFile", CanReadBinaryFile);

	Nan::SetPrototypeMethod(tpl, "DoublePrecisionOff", DoublePrecisionOff);
	Nan::SetPrototypeMethod(tpl, "doublePrecisionOff", DoublePrecisionOff);

	Nan::SetPrototypeMethod(tpl, "DoublePrecisionOn", DoublePrecisionOn);
	Nan::SetPrototypeMethod(tpl, "doublePrecisionOn", DoublePrecisionOn);

	Nan::SetPrototypeMethod(tpl, "ForceReadOff", ForceReadOff);
	Nan::SetPrototypeMethod(tpl, "forceReadOff", ForceReadOff);

	Nan::SetPrototypeMethod(tpl, "ForceReadOn", ForceReadOn);
	Nan::SetPrototypeMethod(tpl, "forceReadOn", ForceReadOn);

	Nan::SetPrototypeMethod(tpl, "GetAutoDetectFormat", GetAutoDetectFormat);
	Nan::SetPrototypeMethod(tpl, "getAutoDetectFormat", GetAutoDetectFormat);

	Nan::SetPrototypeMethod(tpl, "GetBinaryFile", GetBinaryFile);
	Nan::SetPrototypeMethod(tpl, "getBinaryFile", GetBinaryFile);

	Nan::SetPrototypeMethod(tpl, "GetByteOrder", GetByteOrder);
	Nan::SetPrototypeMethod(tpl, "getByteOrder", GetByteOrder);

	Nan::SetPrototypeMethod(tpl, "GetByteOrderAsString", GetByteOrderAsString);
	Nan::SetPrototypeMethod(tpl, "getByteOrderAsString", GetByteOrderAsString);

	Nan::SetPrototypeMethod(tpl, "GetClassName", GetClassName);
	Nan::SetPrototypeMethod(tpl, "getClassName", GetClassName);

	Nan::SetPrototypeMethod(tpl, "GetController", GetController);
	Nan::SetPrototypeMethod(tpl, "getController", GetController);

	Nan::SetPrototypeMethod(tpl, "GetDoublePrecision", GetDoublePrecision);
	Nan::SetPrototypeMethod(tpl, "getDoublePrecision", GetDoublePrecision);

	Nan::SetPrototypeMethod(tpl, "GetFileName", GetFileName);
	Nan::SetPrototypeMethod(tpl, "getFileName", GetFileName);

	Nan::SetPrototypeMethod(tpl, "GetForceRead", GetForceRead);
	Nan::SetPrototypeMethod(tpl, "getForceRead", GetForceRead);

	Nan::SetPrototypeMethod(tpl, "GetFunctionFileName", GetFunctionFileName);
	Nan::SetPrototypeMethod(tpl, "getFunctionFileName", GetFunctionFileName);

	Nan::SetPrototypeMethod(tpl, "GetGamma", GetGamma);
	Nan::SetPrototypeMethod(tpl, "getGamma", GetGamma);

	Nan::SetPrototypeMethod(tpl, "GetHasByteCount", GetHasByteCount);
	Nan::SetPrototypeMethod(tpl, "getHasByteCount", GetHasByteCount);

	Nan::SetPrototypeMethod(tpl, "GetIBlanking", GetIBlanking);
	Nan::SetPrototypeMethod(tpl, "getIBlanking", GetIBlanking);

	Nan::SetPrototypeMethod(tpl, "GetMultiGrid", GetMultiGrid);
	Nan::SetPrototypeMethod(tpl, "getMultiGrid", GetMultiGrid);

	Nan::SetPrototypeMethod(tpl, "GetQFileName", GetQFileName);
	Nan::SetPrototypeMethod(tpl, "getQFileName", GetQFileName);

	Nan::SetPrototypeMethod(tpl, "GetR", GetR);
	Nan::SetPrototypeMethod(tpl, "getR", GetR);

	Nan::SetPrototypeMethod(tpl, "GetScalarFunctionNumber", GetScalarFunctionNumber);
	Nan::SetPrototypeMethod(tpl, "getScalarFunctionNumber", GetScalarFunctionNumber);

	Nan::SetPrototypeMethod(tpl, "GetTwoDimensionalGeometry", GetTwoDimensionalGeometry);
	Nan::SetPrototypeMethod(tpl, "getTwoDimensionalGeometry", GetTwoDimensionalGeometry);

	Nan::SetPrototypeMethod(tpl, "GetVectorFunctionNumber", GetVectorFunctionNumber);
	Nan::SetPrototypeMethod(tpl, "getVectorFunctionNumber", GetVectorFunctionNumber);

	Nan::SetPrototypeMethod(tpl, "GetXYZFileName", GetXYZFileName);
	Nan::SetPrototypeMethod(tpl, "getXYZFileName", GetXYZFileName);

	Nan::SetPrototypeMethod(tpl, "HasByteCountOff", HasByteCountOff);
	Nan::SetPrototypeMethod(tpl, "hasByteCountOff", HasByteCountOff);

	Nan::SetPrototypeMethod(tpl, "HasByteCountOn", HasByteCountOn);
	Nan::SetPrototypeMethod(tpl, "hasByteCountOn", HasByteCountOn);

	Nan::SetPrototypeMethod(tpl, "IBlankingOff", IBlankingOff);
	Nan::SetPrototypeMethod(tpl, "iBlankingOff", IBlankingOff);

	Nan::SetPrototypeMethod(tpl, "IBlankingOn", IBlankingOn);
	Nan::SetPrototypeMethod(tpl, "iBlankingOn", IBlankingOn);

	Nan::SetPrototypeMethod(tpl, "IsA", IsA);
	Nan::SetPrototypeMethod(tpl, "isA", IsA);

	Nan::SetPrototypeMethod(tpl, "MultiGridOff", MultiGridOff);
	Nan::SetPrototypeMethod(tpl, "multiGridOff", MultiGridOff);

	Nan::SetPrototypeMethod(tpl, "MultiGridOn", MultiGridOn);
	Nan::SetPrototypeMethod(tpl, "multiGridOn", MultiGridOn);

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

	Nan::SetPrototypeMethod(tpl, "RemoveAllFunctions", RemoveAllFunctions);
	Nan::SetPrototypeMethod(tpl, "removeAllFunctions", RemoveAllFunctions);

	Nan::SetPrototypeMethod(tpl, "RemoveFunction", RemoveFunction);
	Nan::SetPrototypeMethod(tpl, "removeFunction", RemoveFunction);

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

	Nan::SetPrototypeMethod(tpl, "SetAutoDetectFormat", SetAutoDetectFormat);
	Nan::SetPrototypeMethod(tpl, "setAutoDetectFormat", SetAutoDetectFormat);

	Nan::SetPrototypeMethod(tpl, "SetBinaryFile", SetBinaryFile);
	Nan::SetPrototypeMethod(tpl, "setBinaryFile", SetBinaryFile);

	Nan::SetPrototypeMethod(tpl, "SetByteOrder", SetByteOrder);
	Nan::SetPrototypeMethod(tpl, "setByteOrder", SetByteOrder);

	Nan::SetPrototypeMethod(tpl, "SetByteOrderToBigEndian", SetByteOrderToBigEndian);
	Nan::SetPrototypeMethod(tpl, "setByteOrderToBigEndian", SetByteOrderToBigEndian);

	Nan::SetPrototypeMethod(tpl, "SetByteOrderToLittleEndian", SetByteOrderToLittleEndian);
	Nan::SetPrototypeMethod(tpl, "setByteOrderToLittleEndian", SetByteOrderToLittleEndian);

	Nan::SetPrototypeMethod(tpl, "SetController", SetController);
	Nan::SetPrototypeMethod(tpl, "setController", SetController);

	Nan::SetPrototypeMethod(tpl, "SetDoublePrecision", SetDoublePrecision);
	Nan::SetPrototypeMethod(tpl, "setDoublePrecision", SetDoublePrecision);

	Nan::SetPrototypeMethod(tpl, "SetFileName", SetFileName);
	Nan::SetPrototypeMethod(tpl, "setFileName", SetFileName);

	Nan::SetPrototypeMethod(tpl, "SetForceRead", SetForceRead);
	Nan::SetPrototypeMethod(tpl, "setForceRead", SetForceRead);

	Nan::SetPrototypeMethod(tpl, "SetFunctionFileName", SetFunctionFileName);
	Nan::SetPrototypeMethod(tpl, "setFunctionFileName", SetFunctionFileName);

	Nan::SetPrototypeMethod(tpl, "SetGamma", SetGamma);
	Nan::SetPrototypeMethod(tpl, "setGamma", SetGamma);

	Nan::SetPrototypeMethod(tpl, "SetHasByteCount", SetHasByteCount);
	Nan::SetPrototypeMethod(tpl, "setHasByteCount", SetHasByteCount);

	Nan::SetPrototypeMethod(tpl, "SetIBlanking", SetIBlanking);
	Nan::SetPrototypeMethod(tpl, "setIBlanking", SetIBlanking);

	Nan::SetPrototypeMethod(tpl, "SetMultiGrid", SetMultiGrid);
	Nan::SetPrototypeMethod(tpl, "setMultiGrid", SetMultiGrid);

	Nan::SetPrototypeMethod(tpl, "SetQFileName", SetQFileName);
	Nan::SetPrototypeMethod(tpl, "setQFileName", SetQFileName);

	Nan::SetPrototypeMethod(tpl, "SetR", SetR);
	Nan::SetPrototypeMethod(tpl, "setR", SetR);

	Nan::SetPrototypeMethod(tpl, "SetScalarFunctionNumber", SetScalarFunctionNumber);
	Nan::SetPrototypeMethod(tpl, "setScalarFunctionNumber", SetScalarFunctionNumber);

	Nan::SetPrototypeMethod(tpl, "SetTwoDimensionalGeometry", SetTwoDimensionalGeometry);
	Nan::SetPrototypeMethod(tpl, "setTwoDimensionalGeometry", SetTwoDimensionalGeometry);

	Nan::SetPrototypeMethod(tpl, "SetVectorFunctionNumber", SetVectorFunctionNumber);
	Nan::SetPrototypeMethod(tpl, "setVectorFunctionNumber", SetVectorFunctionNumber);

	Nan::SetPrototypeMethod(tpl, "SetXYZFileName", SetXYZFileName);
	Nan::SetPrototypeMethod(tpl, "setXYZFileName", SetXYZFileName);

	Nan::SetPrototypeMethod(tpl, "TwoDimensionalGeometryOff", TwoDimensionalGeometryOff);
	Nan::SetPrototypeMethod(tpl, "twoDimensionalGeometryOff", TwoDimensionalGeometryOff);

	Nan::SetPrototypeMethod(tpl, "TwoDimensionalGeometryOn", TwoDimensionalGeometryOn);
	Nan::SetPrototypeMethod(tpl, "twoDimensionalGeometryOn", TwoDimensionalGeometryOn);

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

void VtkMultiBlockPLOT3DReaderWrap::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<vtkMultiBlockPLOT3DReader> native = vtkSmartPointer<vtkMultiBlockPLOT3DReader>::New();
		VtkMultiBlockPLOT3DReaderWrap* obj = new VtkMultiBlockPLOT3DReaderWrap(native);
		obj->Wrap(info.This());
	}
	else
	{
		if(info[0]->ToObject() != vtkNodeJsNoWrap )
		{
			Nan::ThrowError("Parameter Error");
			return;
		}
	}

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

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

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

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

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

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

void VtkMultiBlockPLOT3DReaderWrap::CanReadBinaryFile(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkMultiBlockPLOT3DReaderWrap *wrapper = ObjectWrap::Unwrap<VtkMultiBlockPLOT3DReaderWrap>(info.Holder());
	vtkMultiBlockPLOT3DReader *native = (vtkMultiBlockPLOT3DReader *)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->CanReadBinaryFile(
			*a0
		);
		info.GetReturnValue().Set(Nan::New(r));
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void VtkMultiBlockPLOT3DReaderWrap::IsA(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkMultiBlockPLOT3DReaderWrap *wrapper = ObjectWrap::Unwrap<VtkMultiBlockPLOT3DReaderWrap>(info.Holder());
	vtkMultiBlockPLOT3DReader *native = (vtkMultiBlockPLOT3DReader *)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->IsA(
			*a0
		);
		info.GetReturnValue().Set(Nan::New(r));
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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