/* this file was generated by the MCOP idl compiler - DO NOT EDIT */

#include "artsmodulessynth.h"

// Implementation
Arts::Synth_DIV_base *Arts::Synth_DIV_base::_create(const std::string& subClass)
{
	Arts::Object_skel *skel = Arts::ObjectManager::the()->create(subClass);
	assert(skel);
	Arts::Synth_DIV_base *castedObject = (Arts::Synth_DIV_base *)skel->_cast(Arts::Synth_DIV_base::_IID);
	assert(castedObject);
	return castedObject;
}

Arts::Synth_DIV_base *Arts::Synth_DIV_base::_fromString(const std::string& objectref)
{
	Arts::ObjectReference r;

	if(Arts::Dispatcher::the()->stringToObjectReference(r,objectref))
		return Arts::Synth_DIV_base::_fromReference(r,true);
	return 0;
}

Arts::Synth_DIV_base *Arts::Synth_DIV_base::_fromDynamicCast(const Arts::Object& object)
{
	if(object.isNull()) return 0;

	Arts::Synth_DIV_base *castedObject = (Arts::Synth_DIV_base *)object._base()->_cast(Arts::Synth_DIV_base::_IID);
	if(castedObject) return castedObject->_copy();

	return _fromString(object._toString());
}

Arts::Synth_DIV_base *Arts::Synth_DIV_base::_fromReference(Arts::ObjectReference r, bool needcopy)
{
	Arts::Synth_DIV_base *result;
	result = (Arts::Synth_DIV_base *)Arts::Dispatcher::the()->connectObjectLocal(r,"Arts::Synth_DIV");
	if(result)
	{
		if(!needcopy)
			result->_cancelCopyRemote();
	}
	else
	{
		Arts::Connection *conn = Arts::Dispatcher::the()->connectObjectRemote(r);
		if(conn)
		{
			result = new Arts::Synth_DIV_stub(conn,r.objectID);
			if(needcopy) result->_copyRemote();
			result->_useRemote();
			if (!result->_isCompatibleWith("Arts::Synth_DIV")) {
				result->_release();
				return 0;
			}
		}
	}
	return result;
}

std::vector<std::string> Arts::Synth_DIV_base::_defaultPortsIn() const {
	std::vector<std::string> ret;
	ret.push_back("invalue2");
	ret.push_back("invalue1");
	return ret;
}
std::vector<std::string> Arts::Synth_DIV_base::_defaultPortsOut() const {
	std::vector<std::string> ret;
	ret.push_back("outvalue");
	return ret;
}

void *Arts::Synth_DIV_base::_cast(unsigned long iid)
{
	if(iid == Arts::Synth_DIV_base::_IID) return (Arts::Synth_DIV_base *)this;
	if(iid == Arts::SynthModule_base::_IID) return (Arts::SynthModule_base *)this;
	if(iid == Arts::Object_base::_IID) return (Arts::Object_base *)this;
	return 0;
}

Arts::Synth_DIV_stub::Synth_DIV_stub()
{
	// constructor for subclasses (don't use directly)
}

Arts::Synth_DIV_stub::Synth_DIV_stub(Arts::Connection *connection, long objectID)
	: Arts::Object_stub(connection, objectID)
{
	// constructor to create a stub for an object
}

std::string Arts::Synth_DIV_skel::_interfaceName()
{
	return "Arts::Synth_DIV";
}

bool Arts::Synth_DIV_skel::_isCompatibleWith(const std::string& interfacename)
{
	if (interfacename == "Arts::Synth_DIV") return true;
	if (interfacename == "Arts::SynthModule") return true;
	if (interfacename == "Arts::Object") return true;
	return false;
}

std::string Arts::Synth_DIV_skel::_interfaceNameSkel()
{
	return "Arts::Synth_DIV";
}

void Arts::Synth_DIV_skel::_buildMethodTable()
{
	Arts::Buffer m;
	m.fromString(
        "MethodTable:",
		"MethodTable"
	);
	Arts::SynthModule_skel::_buildMethodTable();
}

Arts::Synth_DIV_skel::Synth_DIV_skel()
{
	_initStream("invalue1",&invalue1,9);
	_initStream("invalue2",&invalue2,9);
	_initStream("outvalue",&outvalue,10);
}

Arts::Object_base* Arts::Synth_DIV::_Creator() {
	return Arts::Synth_DIV_base::_create();
}

unsigned long Arts::Synth_DIV_base::_IID = Arts::MCOPUtils::makeIID("Arts::Synth_DIV");

Arts::Synth_XFADE_base *Arts::Synth_XFADE_base::_create(const std::string& subClass)
{
	Arts::Object_skel *skel = Arts::ObjectManager::the()->create(subClass);
	assert(skel);
	Arts::Synth_XFADE_base *castedObject = (Arts::Synth_XFADE_base *)skel->_cast(Arts::Synth_XFADE_base::_IID);
	assert(castedObject);
	return castedObject;
}

Arts::Synth_XFADE_base *Arts::Synth_XFADE_base::_fromString(const std::string& objectref)
{
	Arts::ObjectReference r;

	if(Arts::Dispatcher::the()->stringToObjectReference(r,objectref))
		return Arts::Synth_XFADE_base::_fromReference(r,true);
	return 0;
}

Arts::Synth_XFADE_base *Arts::Synth_XFADE_base::_fromDynamicCast(const Arts::Object& object)
{
	if(object.isNull()) return 0;

	Arts::Synth_XFADE_base *castedObject = (Arts::Synth_XFADE_base *)object._base()->_cast(Arts::Synth_XFADE_base::_IID);
	if(castedObject) return castedObject->_copy();

	return _fromString(object._toString());
}

Arts::Synth_XFADE_base *Arts::Synth_XFADE_base::_fromReference(Arts::ObjectReference r, bool needcopy)
{
	Arts::Synth_XFADE_base *result;
	result = (Arts::Synth_XFADE_base *)Arts::Dispatcher::the()->connectObjectLocal(r,"Arts::Synth_XFADE");
	if(result)
	{
		if(!needcopy)
			result->_cancelCopyRemote();
	}
	else
	{
		Arts::Connection *conn = Arts::Dispatcher::the()->connectObjectRemote(r);
		if(conn)
		{
			result = new Arts::Synth_XFADE_stub(conn,r.objectID);
			if(needcopy) result->_copyRemote();
			result->_useRemote();
			if (!result->_isCompatibleWith("Arts::Synth_XFADE")) {
				result->_release();
				return 0;
			}
		}
	}
	return result;
}

std::vector<std::string> Arts::Synth_XFADE_base::_defaultPortsIn() const {
	std::vector<std::string> ret;
	return ret;
}
std::vector<std::string> Arts::Synth_XFADE_base::_defaultPortsOut() const {
	std::vector<std::string> ret;
	ret.push_back("outvalue");
	return ret;
}

void *Arts::Synth_XFADE_base::_cast(unsigned long iid)
{
	if(iid == Arts::Synth_XFADE_base::_IID) return (Arts::Synth_XFADE_base *)this;
	if(iid == Arts::SynthModule_base::_IID) return (Arts::SynthModule_base *)this;
	if(iid == Arts::Object_base::_IID) return (Arts::Object_base *)this;
	return 0;
}

Arts::Synth_XFADE_stub::Synth_XFADE_stub()
{
	// constructor for subclasses (don't use directly)
}

Arts::Synth_XFADE_stub::Synth_XFADE_stub(Arts::Connection *connection, long objectID)
	: Arts::Object_stub(connection, objectID)
{
	// constructor to create a stub for an object
}

std::string Arts::Synth_XFADE_skel::_interfaceName()
{
	return "Arts::Synth_XFADE";
}

bool Arts::Synth_XFADE_skel::_isCompatibleWith(const std::string& interfacename)
{
	if (interfacename == "Arts::Synth_XFADE") return true;
	if (interfacename == "Arts::SynthModule") return true;
	if (interfacename == "Arts::Object") return true;
	return false;
}

std::string Arts::Synth_XFADE_skel::_interfaceNameSkel()
{
	return "Arts::Synth_XFADE";
}

void Arts::Synth_XFADE_skel::_buildMethodTable()
{
	Arts::Buffer m;
	m.fromString(
        "MethodTable:",
		"MethodTable"
	);
	Arts::SynthModule_skel::_buildMethodTable();
}

Arts::Synth_XFADE_skel::Synth_XFADE_skel()
{
	_initStream("invalue1",&invalue1,9);
	_initStream("invalue2",&invalue2,9);
	_initStream("percentage",&percentage,9);
	_initStream("outvalue",&outvalue,10);
}

Arts::Object_base* Arts::Synth_XFADE::_Creator() {
	return Arts::Synth_XFADE_base::_create();
}

unsigned long Arts::Synth_XFADE_base::_IID = Arts::MCOPUtils::makeIID("Arts::Synth_XFADE");

Arts::Synth_AUTOPANNER_base *Arts::Synth_AUTOPANNER_base::_create(const std::string& subClass)
{
	Arts::Object_skel *skel = Arts::ObjectManager::the()->create(subClass);
	assert(skel);
	Arts::Synth_AUTOPANNER_base *castedObject = (Arts::Synth_AUTOPANNER_base *)skel->_cast(Arts::Synth_AUTOPANNER_base::_IID);
	assert(castedObject);
	return castedObject;
}

Arts::Synth_AUTOPANNER_base *Arts::Synth_AUTOPANNER_base::_fromString(const std::string& objectref)
{
	Arts::ObjectReference r;

	if(Arts::Dispatcher::the()->stringToObjectReference(r,objectref))
		return Arts::Synth_AUTOPANNER_base::_fromReference(r,true);
	return 0;
}

Arts::Synth_AUTOPANNER_base *Arts::Synth_AUTOPANNER_base::_fromDynamicCast(const Arts::Object& object)
{
	if(object.isNull()) return 0;

	Arts::Synth_AUTOPANNER_base *castedObject = (Arts::Synth_AUTOPANNER_base *)object._base()->_cast(Arts::Synth_AUTOPANNER_base::_IID);
	if(castedObject) return castedObject->_copy();

	return _fromString(object._toString());
}

Arts::Synth_AUTOPANNER_base *Arts::Synth_AUTOPANNER_base::_fromReference(Arts::ObjectReference r, bool needcopy)
{
	Arts::Synth_AUTOPANNER_base *result;
	result = (Arts::Synth_AUTOPANNER_base *)Arts::Dispatcher::the()->connectObjectLocal(r,"Arts::Synth_AUTOPANNER");
	if(result)
	{
		if(!needcopy)
			result->_cancelCopyRemote();
	}
	else
	{
		Arts::Connection *conn = Arts::Dispatcher::the()->connectObjectRemote(r);
		if(conn)
		{
			result = new Arts::Synth_AUTOPANNER_stub(conn,r.objectID);
			if(needcopy) result->_copyRemote();
			result->_useRemote();
			if (!result->_isCompatibleWith("Arts::Synth_AUTOPANNER")) {
				result->_release();
				return 0;
			}
		}
	}
	return result;
}

std::vector<std::string> Arts::Synth_AUTOPANNER_base::_defaultPortsIn() const {
	std::vector<std::string> ret;
	return ret;
}
std::vector<std::string> Arts::Synth_AUTOPANNER_base::_defaultPortsOut() const {
	std::vector<std::string> ret;
	return ret;
}

void *Arts::Synth_AUTOPANNER_base::_cast(unsigned long iid)
{
	if(iid == Arts::Synth_AUTOPANNER_base::_IID) return (Arts::Synth_AUTOPANNER_base *)this;
	if(iid == Arts::SynthModule_base::_IID) return (Arts::SynthModule_base *)this;
	if(iid == Arts::Object_base::_IID) return (Arts::Object_base *)this;
	return 0;
}

Arts::Synth_AUTOPANNER_stub::Synth_AUTOPANNER_stub()
{
	// constructor for subclasses (don't use directly)
}

Arts::Synth_AUTOPANNER_stub::Synth_AUTOPANNER_stub(Arts::Connection *connection, long objectID)
	: Arts::Object_stub(connection, objectID)
{
	// constructor to create a stub for an object
}

std::string Arts::Synth_AUTOPANNER_skel::_interfaceName()
{
	return "Arts::Synth_AUTOPANNER";
}

bool Arts::Synth_AUTOPANNER_skel::_isCompatibleWith(const std::string& interfacename)
{
	if (interfacename == "Arts::Synth_AUTOPANNER") return true;
	if (interfacename == "Arts::SynthModule") return true;
	if (interfacename == "Arts::Object") return true;
	return false;
}

std::string Arts::Synth_AUTOPANNER_skel::_interfaceNameSkel()
{
	return "Arts::Synth_AUTOPANNER";
}

void Arts::Synth_AUTOPANNER_skel::_buildMethodTable()
{
	Arts::Buffer m;
	m.fromString(
        "MethodTable:",
		"MethodTable"
	);
	Arts::SynthModule_skel::_buildMethodTable();
}

Arts::Synth_AUTOPANNER_skel::Synth_AUTOPANNER_skel()
{
	_initStream("invalue",&invalue,9);
	_initStream("inlfo",&inlfo,9);
	_initStream("outvalue1",&outvalue1,10);
	_initStream("outvalue2",&outvalue2,10);
}

Arts::Object_base* Arts::Synth_AUTOPANNER::_Creator() {
	return Arts::Synth_AUTOPANNER_base::_create();
}

unsigned long Arts::Synth_AUTOPANNER_base::_IID = Arts::MCOPUtils::makeIID("Arts::Synth_AUTOPANNER");

Arts::Synth_DELAY_base *Arts::Synth_DELAY_base::_create(const std::string& subClass)
{
	Arts::Object_skel *skel = Arts::ObjectManager::the()->create(subClass);
	assert(skel);
	Arts::Synth_DELAY_base *castedObject = (Arts::Synth_DELAY_base *)skel->_cast(Arts::Synth_DELAY_base::_IID);
	assert(castedObject);
	return castedObject;
}

Arts::Synth_DELAY_base *Arts::Synth_DELAY_base::_fromString(const std::string& objectref)
{
	Arts::ObjectReference r;

	if(Arts::Dispatcher::the()->stringToObjectReference(r,objectref))
		return Arts::Synth_DELAY_base::_fromReference(r,true);
	return 0;
}

Arts::Synth_DELAY_base *Arts::Synth_DELAY_base::_fromDynamicCast(const Arts::Object& object)
{
	if(object.isNull()) return 0;

	Arts::Synth_DELAY_base *castedObject = (Arts::Synth_DELAY_base *)object._base()->_cast(Arts::Synth_DELAY_base::_IID);
	if(castedObject) return castedObject->_copy();

	return _fromString(object._toString());
}

Arts::Synth_DELAY_base *Arts::Synth_DELAY_base::_fromReference(Arts::ObjectReference r, bool needcopy)
{
	Arts::Synth_DELAY_base *result;
	result = (Arts::Synth_DELAY_base *)Arts::Dispatcher::the()->connectObjectLocal(r,"Arts::Synth_DELAY");
	if(result)
	{
		if(!needcopy)
			result->_cancelCopyRemote();
	}
	else
	{
		Arts::Connection *conn = Arts::Dispatcher::the()->connectObjectRemote(r);
		if(conn)
		{
			result = new Arts::Synth_DELAY_stub(conn,r.objectID);
			if(needcopy) result->_copyRemote();
			result->_useRemote();
			if (!result->_isCompatibleWith("Arts::Synth_DELAY")) {
				result->_release();
				return 0;
			}
		}
	}
	return result;
}

std::vector<std::string> Arts::Synth_DELAY_base::_defaultPortsIn() const {
	std::vector<std::string> ret;
	return ret;
}
std::vector<std::string> Arts::Synth_DELAY_base::_defaultPortsOut() const {
	std::vector<std::string> ret;
	ret.push_back("outvalue");
	return ret;
}

void *Arts::Synth_DELAY_base::_cast(unsigned long iid)
{
	if(iid == Arts::Synth_DELAY_base::_IID) return (Arts::Synth_DELAY_base *)this;
	if(iid == Arts::SynthModule_base::_IID) return (Arts::SynthModule_base *)this;
	if(iid == Arts::Object_base::_IID) return (Arts::Object_base *)this;
	return 0;
}

Arts::Synth_DELAY_stub::Synth_DELAY_stub()
{
	// constructor for subclasses (don't use directly)
}

Arts::Synth_DELAY_stub::Synth_DELAY_stub(Arts::Connection *connection, long objectID)
	: Arts::Object_stub(connection, objectID)
{
	// constructor to create a stub for an object
}

float Arts::Synth_DELAY_stub::maxdelay()
{
	long methodID = _lookupMethodFast("method:0000000e5f6765745f6d617864656c61790000000006666c6f617400000000020000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(!result) return 0.0; // error occurred
	float returnCode = result->readFloat();
	delete result;
	return returnCode;
}

void Arts::Synth_DELAY_stub::maxdelay(float newValue)
{
	long methodID = _lookupMethodFast("method:0000000e5f7365745f6d617864656c61790000000005766f696400000000020000000100000006666c6f617400000000096e657756616c7565000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->writeFloat(newValue);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(result) delete result;
}

std::string Arts::Synth_DELAY_skel::_interfaceName()
{
	return "Arts::Synth_DELAY";
}

bool Arts::Synth_DELAY_skel::_isCompatibleWith(const std::string& interfacename)
{
	if (interfacename == "Arts::Synth_DELAY") return true;
	if (interfacename == "Arts::SynthModule") return true;
	if (interfacename == "Arts::Object") return true;
	return false;
}

std::string Arts::Synth_DELAY_skel::_interfaceNameSkel()
{
	return "Arts::Synth_DELAY";
}

// _get_maxdelay
static void _dispatch_Arts_Synth_DELAY_00(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeFloat(((Arts::Synth_DELAY_skel *)object)->maxdelay());
}

// _set_maxdelay
static void _dispatch_Arts_Synth_DELAY_01(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	float newValue = request->readFloat();
	((Arts::Synth_DELAY_skel *)object)->maxdelay(newValue);
}

void Arts::Synth_DELAY_skel::_buildMethodTable()
{
	Arts::Buffer m;
	m.fromString(
        "MethodTable:0000000e5f6765745f6d617864656c61790000000006666c6f6174"
        "000000000200000000000000000000000e5f7365745f6d617864656c6179000000"
        "0005766f696400000000020000000100000006666c6f617400000000096e657756"
        "616c7565000000000000000000",
		"MethodTable"
	);
	_addMethod(_dispatch_Arts_Synth_DELAY_00,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_DELAY_01,this,Arts::MethodDef(m));
	Arts::SynthModule_skel::_buildMethodTable();
}

Arts::Synth_DELAY_skel::Synth_DELAY_skel()
{
	_initStream("invalue",&invalue,9);
	_initStream("time",&time,9);
	_initStream("outvalue",&outvalue,10);
}

Arts::Object_base* Arts::Synth_DELAY::_Creator() {
	return Arts::Synth_DELAY_base::_create();
}

unsigned long Arts::Synth_DELAY_base::_IID = Arts::MCOPUtils::makeIID("Arts::Synth_DELAY");

Arts::Synth_CDELAY_base *Arts::Synth_CDELAY_base::_create(const std::string& subClass)
{
	Arts::Object_skel *skel = Arts::ObjectManager::the()->create(subClass);
	assert(skel);
	Arts::Synth_CDELAY_base *castedObject = (Arts::Synth_CDELAY_base *)skel->_cast(Arts::Synth_CDELAY_base::_IID);
	assert(castedObject);
	return castedObject;
}

Arts::Synth_CDELAY_base *Arts::Synth_CDELAY_base::_fromString(const std::string& objectref)
{
	Arts::ObjectReference r;

	if(Arts::Dispatcher::the()->stringToObjectReference(r,objectref))
		return Arts::Synth_CDELAY_base::_fromReference(r,true);
	return 0;
}

Arts::Synth_CDELAY_base *Arts::Synth_CDELAY_base::_fromDynamicCast(const Arts::Object& object)
{
	if(object.isNull()) return 0;

	Arts::Synth_CDELAY_base *castedObject = (Arts::Synth_CDELAY_base *)object._base()->_cast(Arts::Synth_CDELAY_base::_IID);
	if(castedObject) return castedObject->_copy();

	return _fromString(object._toString());
}

Arts::Synth_CDELAY_base *Arts::Synth_CDELAY_base::_fromReference(Arts::ObjectReference r, bool needcopy)
{
	Arts::Synth_CDELAY_base *result;
	result = (Arts::Synth_CDELAY_base *)Arts::Dispatcher::the()->connectObjectLocal(r,"Arts::Synth_CDELAY");
	if(result)
	{
		if(!needcopy)
			result->_cancelCopyRemote();
	}
	else
	{
		Arts::Connection *conn = Arts::Dispatcher::the()->connectObjectRemote(r);
		if(conn)
		{
			result = new Arts::Synth_CDELAY_stub(conn,r.objectID);
			if(needcopy) result->_copyRemote();
			result->_useRemote();
			if (!result->_isCompatibleWith("Arts::Synth_CDELAY")) {
				result->_release();
				return 0;
			}
		}
	}
	return result;
}

std::vector<std::string> Arts::Synth_CDELAY_base::_defaultPortsIn() const {
	std::vector<std::string> ret;
	ret.push_back("invalue");
	return ret;
}
std::vector<std::string> Arts::Synth_CDELAY_base::_defaultPortsOut() const {
	std::vector<std::string> ret;
	ret.push_back("outvalue");
	return ret;
}

void *Arts::Synth_CDELAY_base::_cast(unsigned long iid)
{
	if(iid == Arts::Synth_CDELAY_base::_IID) return (Arts::Synth_CDELAY_base *)this;
	if(iid == Arts::SynthModule_base::_IID) return (Arts::SynthModule_base *)this;
	if(iid == Arts::Object_base::_IID) return (Arts::Object_base *)this;
	return 0;
}

Arts::Synth_CDELAY_stub::Synth_CDELAY_stub()
{
	// constructor for subclasses (don't use directly)
}

Arts::Synth_CDELAY_stub::Synth_CDELAY_stub(Arts::Connection *connection, long objectID)
	: Arts::Object_stub(connection, objectID)
{
	// constructor to create a stub for an object
}

float Arts::Synth_CDELAY_stub::time()
{
	long methodID = _lookupMethodFast("method:0000000a5f6765745f74696d650000000006666c6f617400000000020000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(!result) return 0.0; // error occurred
	float returnCode = result->readFloat();
	delete result;
	return returnCode;
}

void Arts::Synth_CDELAY_stub::time(float newValue)
{
	long methodID = _lookupMethodFast("method:0000000a5f7365745f74696d650000000005766f696400000000020000000100000006666c6f617400000000096e657756616c7565000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->writeFloat(newValue);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(result) delete result;
}

std::string Arts::Synth_CDELAY_skel::_interfaceName()
{
	return "Arts::Synth_CDELAY";
}

bool Arts::Synth_CDELAY_skel::_isCompatibleWith(const std::string& interfacename)
{
	if (interfacename == "Arts::Synth_CDELAY") return true;
	if (interfacename == "Arts::SynthModule") return true;
	if (interfacename == "Arts::Object") return true;
	return false;
}

std::string Arts::Synth_CDELAY_skel::_interfaceNameSkel()
{
	return "Arts::Synth_CDELAY";
}

// _get_time
static void _dispatch_Arts_Synth_CDELAY_00(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeFloat(((Arts::Synth_CDELAY_skel *)object)->time());
}

// _set_time
static void _dispatch_Arts_Synth_CDELAY_01(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	float newValue = request->readFloat();
	((Arts::Synth_CDELAY_skel *)object)->time(newValue);
}

void Arts::Synth_CDELAY_skel::_buildMethodTable()
{
	Arts::Buffer m;
	m.fromString(
        "MethodTable:0000000a5f6765745f74696d650000000006666c6f617400000000"
        "0200000000000000000000000a5f7365745f74696d650000000005766f69640000"
        "0000020000000100000006666c6f617400000000096e657756616c756500000000"
        "0000000000",
		"MethodTable"
	);
	_addMethod(_dispatch_Arts_Synth_CDELAY_00,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_CDELAY_01,this,Arts::MethodDef(m));
	Arts::SynthModule_skel::_buildMethodTable();
}

Arts::Synth_CDELAY_skel::Synth_CDELAY_skel()
{
	_initStream("invalue",&invalue,9);
	_initStream("outvalue",&outvalue,10);
}

Arts::Object_base* Arts::Synth_CDELAY::_Creator() {
	return Arts::Synth_CDELAY_base::_create();
}

unsigned long Arts::Synth_CDELAY_base::_IID = Arts::MCOPUtils::makeIID("Arts::Synth_CDELAY");

Arts::Synth_ENVELOPE_ADSR_base *Arts::Synth_ENVELOPE_ADSR_base::_create(const std::string& subClass)
{
	Arts::Object_skel *skel = Arts::ObjectManager::the()->create(subClass);
	assert(skel);
	Arts::Synth_ENVELOPE_ADSR_base *castedObject = (Arts::Synth_ENVELOPE_ADSR_base *)skel->_cast(Arts::Synth_ENVELOPE_ADSR_base::_IID);
	assert(castedObject);
	return castedObject;
}

Arts::Synth_ENVELOPE_ADSR_base *Arts::Synth_ENVELOPE_ADSR_base::_fromString(const std::string& objectref)
{
	Arts::ObjectReference r;

	if(Arts::Dispatcher::the()->stringToObjectReference(r,objectref))
		return Arts::Synth_ENVELOPE_ADSR_base::_fromReference(r,true);
	return 0;
}

Arts::Synth_ENVELOPE_ADSR_base *Arts::Synth_ENVELOPE_ADSR_base::_fromDynamicCast(const Arts::Object& object)
{
	if(object.isNull()) return 0;

	Arts::Synth_ENVELOPE_ADSR_base *castedObject = (Arts::Synth_ENVELOPE_ADSR_base *)object._base()->_cast(Arts::Synth_ENVELOPE_ADSR_base::_IID);
	if(castedObject) return castedObject->_copy();

	return _fromString(object._toString());
}

Arts::Synth_ENVELOPE_ADSR_base *Arts::Synth_ENVELOPE_ADSR_base::_fromReference(Arts::ObjectReference r, bool needcopy)
{
	Arts::Synth_ENVELOPE_ADSR_base *result;
	result = (Arts::Synth_ENVELOPE_ADSR_base *)Arts::Dispatcher::the()->connectObjectLocal(r,"Arts::Synth_ENVELOPE_ADSR");
	if(result)
	{
		if(!needcopy)
			result->_cancelCopyRemote();
	}
	else
	{
		Arts::Connection *conn = Arts::Dispatcher::the()->connectObjectRemote(r);
		if(conn)
		{
			result = new Arts::Synth_ENVELOPE_ADSR_stub(conn,r.objectID);
			if(needcopy) result->_copyRemote();
			result->_useRemote();
			if (!result->_isCompatibleWith("Arts::Synth_ENVELOPE_ADSR")) {
				result->_release();
				return 0;
			}
		}
	}
	return result;
}

std::vector<std::string> Arts::Synth_ENVELOPE_ADSR_base::_defaultPortsIn() const {
	std::vector<std::string> ret;
	return ret;
}
std::vector<std::string> Arts::Synth_ENVELOPE_ADSR_base::_defaultPortsOut() const {
	std::vector<std::string> ret;
	return ret;
}

void *Arts::Synth_ENVELOPE_ADSR_base::_cast(unsigned long iid)
{
	if(iid == Arts::Synth_ENVELOPE_ADSR_base::_IID) return (Arts::Synth_ENVELOPE_ADSR_base *)this;
	if(iid == Arts::SynthModule_base::_IID) return (Arts::SynthModule_base *)this;
	if(iid == Arts::Object_base::_IID) return (Arts::Object_base *)this;
	return 0;
}

Arts::Synth_ENVELOPE_ADSR_stub::Synth_ENVELOPE_ADSR_stub()
{
	// constructor for subclasses (don't use directly)
}

Arts::Synth_ENVELOPE_ADSR_stub::Synth_ENVELOPE_ADSR_stub(Arts::Connection *connection, long objectID)
	: Arts::Object_stub(connection, objectID)
{
	// constructor to create a stub for an object
}

std::string Arts::Synth_ENVELOPE_ADSR_skel::_interfaceName()
{
	return "Arts::Synth_ENVELOPE_ADSR";
}

bool Arts::Synth_ENVELOPE_ADSR_skel::_isCompatibleWith(const std::string& interfacename)
{
	if (interfacename == "Arts::Synth_ENVELOPE_ADSR") return true;
	if (interfacename == "Arts::SynthModule") return true;
	if (interfacename == "Arts::Object") return true;
	return false;
}

std::string Arts::Synth_ENVELOPE_ADSR_skel::_interfaceNameSkel()
{
	return "Arts::Synth_ENVELOPE_ADSR";
}

void Arts::Synth_ENVELOPE_ADSR_skel::_buildMethodTable()
{
	Arts::Buffer m;
	m.fromString(
        "MethodTable:",
		"MethodTable"
	);
	Arts::SynthModule_skel::_buildMethodTable();
}

Arts::Synth_ENVELOPE_ADSR_skel::Synth_ENVELOPE_ADSR_skel()
{
	_initStream("active",&active,9);
	_initStream("invalue",&invalue,9);
	_initStream("attack",&attack,9);
	_initStream("decay",&decay,9);
	_initStream("sustain",&sustain,9);
	_initStream("release",&release,9);
	_initStream("outvalue",&outvalue,10);
	_initStream("done",&done,10);
}

Arts::Object_base* Arts::Synth_ENVELOPE_ADSR::_Creator() {
	return Arts::Synth_ENVELOPE_ADSR_base::_create();
}

unsigned long Arts::Synth_ENVELOPE_ADSR_base::_IID = Arts::MCOPUtils::makeIID("Arts::Synth_ENVELOPE_ADSR");

Arts::Synth_PSCALE_base *Arts::Synth_PSCALE_base::_create(const std::string& subClass)
{
	Arts::Object_skel *skel = Arts::ObjectManager::the()->create(subClass);
	assert(skel);
	Arts::Synth_PSCALE_base *castedObject = (Arts::Synth_PSCALE_base *)skel->_cast(Arts::Synth_PSCALE_base::_IID);
	assert(castedObject);
	return castedObject;
}

Arts::Synth_PSCALE_base *Arts::Synth_PSCALE_base::_fromString(const std::string& objectref)
{
	Arts::ObjectReference r;

	if(Arts::Dispatcher::the()->stringToObjectReference(r,objectref))
		return Arts::Synth_PSCALE_base::_fromReference(r,true);
	return 0;
}

Arts::Synth_PSCALE_base *Arts::Synth_PSCALE_base::_fromDynamicCast(const Arts::Object& object)
{
	if(object.isNull()) return 0;

	Arts::Synth_PSCALE_base *castedObject = (Arts::Synth_PSCALE_base *)object._base()->_cast(Arts::Synth_PSCALE_base::_IID);
	if(castedObject) return castedObject->_copy();

	return _fromString(object._toString());
}

Arts::Synth_PSCALE_base *Arts::Synth_PSCALE_base::_fromReference(Arts::ObjectReference r, bool needcopy)
{
	Arts::Synth_PSCALE_base *result;
	result = (Arts::Synth_PSCALE_base *)Arts::Dispatcher::the()->connectObjectLocal(r,"Arts::Synth_PSCALE");
	if(result)
	{
		if(!needcopy)
			result->_cancelCopyRemote();
	}
	else
	{
		Arts::Connection *conn = Arts::Dispatcher::the()->connectObjectRemote(r);
		if(conn)
		{
			result = new Arts::Synth_PSCALE_stub(conn,r.objectID);
			if(needcopy) result->_copyRemote();
			result->_useRemote();
			if (!result->_isCompatibleWith("Arts::Synth_PSCALE")) {
				result->_release();
				return 0;
			}
		}
	}
	return result;
}

std::vector<std::string> Arts::Synth_PSCALE_base::_defaultPortsIn() const {
	std::vector<std::string> ret;
	return ret;
}
std::vector<std::string> Arts::Synth_PSCALE_base::_defaultPortsOut() const {
	std::vector<std::string> ret;
	ret.push_back("outvalue");
	return ret;
}

void *Arts::Synth_PSCALE_base::_cast(unsigned long iid)
{
	if(iid == Arts::Synth_PSCALE_base::_IID) return (Arts::Synth_PSCALE_base *)this;
	if(iid == Arts::SynthModule_base::_IID) return (Arts::SynthModule_base *)this;
	if(iid == Arts::Object_base::_IID) return (Arts::Object_base *)this;
	return 0;
}

Arts::Synth_PSCALE_stub::Synth_PSCALE_stub()
{
	// constructor for subclasses (don't use directly)
}

Arts::Synth_PSCALE_stub::Synth_PSCALE_stub(Arts::Connection *connection, long objectID)
	: Arts::Object_stub(connection, objectID)
{
	// constructor to create a stub for an object
}

float Arts::Synth_PSCALE_stub::top()
{
	long methodID = _lookupMethodFast("method:000000095f6765745f746f700000000006666c6f617400000000020000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(!result) return 0.0; // error occurred
	float returnCode = result->readFloat();
	delete result;
	return returnCode;
}

void Arts::Synth_PSCALE_stub::top(float newValue)
{
	long methodID = _lookupMethodFast("method:000000095f7365745f746f700000000005766f696400000000020000000100000006666c6f617400000000096e657756616c7565000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->writeFloat(newValue);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(result) delete result;
}

std::string Arts::Synth_PSCALE_skel::_interfaceName()
{
	return "Arts::Synth_PSCALE";
}

bool Arts::Synth_PSCALE_skel::_isCompatibleWith(const std::string& interfacename)
{
	if (interfacename == "Arts::Synth_PSCALE") return true;
	if (interfacename == "Arts::SynthModule") return true;
	if (interfacename == "Arts::Object") return true;
	return false;
}

std::string Arts::Synth_PSCALE_skel::_interfaceNameSkel()
{
	return "Arts::Synth_PSCALE";
}

// _get_top
static void _dispatch_Arts_Synth_PSCALE_00(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeFloat(((Arts::Synth_PSCALE_skel *)object)->top());
}

// _set_top
static void _dispatch_Arts_Synth_PSCALE_01(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	float newValue = request->readFloat();
	((Arts::Synth_PSCALE_skel *)object)->top(newValue);
}

void Arts::Synth_PSCALE_skel::_buildMethodTable()
{
	Arts::Buffer m;
	m.fromString(
        "MethodTable:000000095f6765745f746f700000000006666c6f61740000000002"
        "0000000000000000000000095f7365745f746f700000000005766f696400000000"
        "020000000100000006666c6f617400000000096e657756616c7565000000000000"
        "000000",
		"MethodTable"
	);
	_addMethod(_dispatch_Arts_Synth_PSCALE_00,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_PSCALE_01,this,Arts::MethodDef(m));
	Arts::SynthModule_skel::_buildMethodTable();
}

Arts::Synth_PSCALE_skel::Synth_PSCALE_skel()
{
	_initStream("invalue",&invalue,9);
	_initStream("pos",&pos,9);
	_initStream("outvalue",&outvalue,10);
}

Arts::Object_base* Arts::Synth_PSCALE::_Creator() {
	return Arts::Synth_PSCALE_base::_create();
}

unsigned long Arts::Synth_PSCALE_base::_IID = Arts::MCOPUtils::makeIID("Arts::Synth_PSCALE");

Arts::Synth_TREMOLO_base *Arts::Synth_TREMOLO_base::_create(const std::string& subClass)
{
	Arts::Object_skel *skel = Arts::ObjectManager::the()->create(subClass);
	assert(skel);
	Arts::Synth_TREMOLO_base *castedObject = (Arts::Synth_TREMOLO_base *)skel->_cast(Arts::Synth_TREMOLO_base::_IID);
	assert(castedObject);
	return castedObject;
}

Arts::Synth_TREMOLO_base *Arts::Synth_TREMOLO_base::_fromString(const std::string& objectref)
{
	Arts::ObjectReference r;

	if(Arts::Dispatcher::the()->stringToObjectReference(r,objectref))
		return Arts::Synth_TREMOLO_base::_fromReference(r,true);
	return 0;
}

Arts::Synth_TREMOLO_base *Arts::Synth_TREMOLO_base::_fromDynamicCast(const Arts::Object& object)
{
	if(object.isNull()) return 0;

	Arts::Synth_TREMOLO_base *castedObject = (Arts::Synth_TREMOLO_base *)object._base()->_cast(Arts::Synth_TREMOLO_base::_IID);
	if(castedObject) return castedObject->_copy();

	return _fromString(object._toString());
}

Arts::Synth_TREMOLO_base *Arts::Synth_TREMOLO_base::_fromReference(Arts::ObjectReference r, bool needcopy)
{
	Arts::Synth_TREMOLO_base *result;
	result = (Arts::Synth_TREMOLO_base *)Arts::Dispatcher::the()->connectObjectLocal(r,"Arts::Synth_TREMOLO");
	if(result)
	{
		if(!needcopy)
			result->_cancelCopyRemote();
	}
	else
	{
		Arts::Connection *conn = Arts::Dispatcher::the()->connectObjectRemote(r);
		if(conn)
		{
			result = new Arts::Synth_TREMOLO_stub(conn,r.objectID);
			if(needcopy) result->_copyRemote();
			result->_useRemote();
			if (!result->_isCompatibleWith("Arts::Synth_TREMOLO")) {
				result->_release();
				return 0;
			}
		}
	}
	return result;
}

std::vector<std::string> Arts::Synth_TREMOLO_base::_defaultPortsIn() const {
	std::vector<std::string> ret;
	return ret;
}
std::vector<std::string> Arts::Synth_TREMOLO_base::_defaultPortsOut() const {
	std::vector<std::string> ret;
	ret.push_back("outvalue");
	return ret;
}

void *Arts::Synth_TREMOLO_base::_cast(unsigned long iid)
{
	if(iid == Arts::Synth_TREMOLO_base::_IID) return (Arts::Synth_TREMOLO_base *)this;
	if(iid == Arts::SynthModule_base::_IID) return (Arts::SynthModule_base *)this;
	if(iid == Arts::Object_base::_IID) return (Arts::Object_base *)this;
	return 0;
}

Arts::Synth_TREMOLO_stub::Synth_TREMOLO_stub()
{
	// constructor for subclasses (don't use directly)
}

Arts::Synth_TREMOLO_stub::Synth_TREMOLO_stub(Arts::Connection *connection, long objectID)
	: Arts::Object_stub(connection, objectID)
{
	// constructor to create a stub for an object
}

std::string Arts::Synth_TREMOLO_skel::_interfaceName()
{
	return "Arts::Synth_TREMOLO";
}

bool Arts::Synth_TREMOLO_skel::_isCompatibleWith(const std::string& interfacename)
{
	if (interfacename == "Arts::Synth_TREMOLO") return true;
	if (interfacename == "Arts::SynthModule") return true;
	if (interfacename == "Arts::Object") return true;
	return false;
}

std::string Arts::Synth_TREMOLO_skel::_interfaceNameSkel()
{
	return "Arts::Synth_TREMOLO";
}

void Arts::Synth_TREMOLO_skel::_buildMethodTable()
{
	Arts::Buffer m;
	m.fromString(
        "MethodTable:",
		"MethodTable"
	);
	Arts::SynthModule_skel::_buildMethodTable();
}

Arts::Synth_TREMOLO_skel::Synth_TREMOLO_skel()
{
	_initStream("invalue",&invalue,9);
	_initStream("inlfo",&inlfo,9);
	_initStream("outvalue",&outvalue,10);
}

Arts::Object_base* Arts::Synth_TREMOLO::_Creator() {
	return Arts::Synth_TREMOLO_base::_create();
}

unsigned long Arts::Synth_TREMOLO_base::_IID = Arts::MCOPUtils::makeIID("Arts::Synth_TREMOLO");

Arts::Synth_FX_CFLANGER_base *Arts::Synth_FX_CFLANGER_base::_create(const std::string& subClass)
{
	Arts::Object_skel *skel = Arts::ObjectManager::the()->create(subClass);
	assert(skel);
	Arts::Synth_FX_CFLANGER_base *castedObject = (Arts::Synth_FX_CFLANGER_base *)skel->_cast(Arts::Synth_FX_CFLANGER_base::_IID);
	assert(castedObject);
	return castedObject;
}

Arts::Synth_FX_CFLANGER_base *Arts::Synth_FX_CFLANGER_base::_fromString(const std::string& objectref)
{
	Arts::ObjectReference r;

	if(Arts::Dispatcher::the()->stringToObjectReference(r,objectref))
		return Arts::Synth_FX_CFLANGER_base::_fromReference(r,true);
	return 0;
}

Arts::Synth_FX_CFLANGER_base *Arts::Synth_FX_CFLANGER_base::_fromDynamicCast(const Arts::Object& object)
{
	if(object.isNull()) return 0;

	Arts::Synth_FX_CFLANGER_base *castedObject = (Arts::Synth_FX_CFLANGER_base *)object._base()->_cast(Arts::Synth_FX_CFLANGER_base::_IID);
	if(castedObject) return castedObject->_copy();

	return _fromString(object._toString());
}

Arts::Synth_FX_CFLANGER_base *Arts::Synth_FX_CFLANGER_base::_fromReference(Arts::ObjectReference r, bool needcopy)
{
	Arts::Synth_FX_CFLANGER_base *result;
	result = (Arts::Synth_FX_CFLANGER_base *)Arts::Dispatcher::the()->connectObjectLocal(r,"Arts::Synth_FX_CFLANGER");
	if(result)
	{
		if(!needcopy)
			result->_cancelCopyRemote();
	}
	else
	{
		Arts::Connection *conn = Arts::Dispatcher::the()->connectObjectRemote(r);
		if(conn)
		{
			result = new Arts::Synth_FX_CFLANGER_stub(conn,r.objectID);
			if(needcopy) result->_copyRemote();
			result->_useRemote();
			if (!result->_isCompatibleWith("Arts::Synth_FX_CFLANGER")) {
				result->_release();
				return 0;
			}
		}
	}
	return result;
}

std::vector<std::string> Arts::Synth_FX_CFLANGER_base::_defaultPortsIn() const {
	std::vector<std::string> ret;
	return ret;
}
std::vector<std::string> Arts::Synth_FX_CFLANGER_base::_defaultPortsOut() const {
	std::vector<std::string> ret;
	ret.push_back("outvalue");
	return ret;
}

void *Arts::Synth_FX_CFLANGER_base::_cast(unsigned long iid)
{
	if(iid == Arts::Synth_FX_CFLANGER_base::_IID) return (Arts::Synth_FX_CFLANGER_base *)this;
	if(iid == Arts::SynthModule_base::_IID) return (Arts::SynthModule_base *)this;
	if(iid == Arts::Object_base::_IID) return (Arts::Object_base *)this;
	return 0;
}

Arts::Synth_FX_CFLANGER_stub::Synth_FX_CFLANGER_stub()
{
	// constructor for subclasses (don't use directly)
}

Arts::Synth_FX_CFLANGER_stub::Synth_FX_CFLANGER_stub(Arts::Connection *connection, long objectID)
	: Arts::Object_stub(connection, objectID)
{
	// constructor to create a stub for an object
}

float Arts::Synth_FX_CFLANGER_stub::mintime()
{
	long methodID = _lookupMethodFast("method:0000000d5f6765745f6d696e74696d650000000006666c6f617400000000020000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(!result) return 0.0; // error occurred
	float returnCode = result->readFloat();
	delete result;
	return returnCode;
}

void Arts::Synth_FX_CFLANGER_stub::mintime(float newValue)
{
	long methodID = _lookupMethodFast("method:0000000d5f7365745f6d696e74696d650000000005766f696400000000020000000100000006666c6f617400000000096e657756616c7565000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->writeFloat(newValue);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(result) delete result;
}

float Arts::Synth_FX_CFLANGER_stub::maxtime()
{
	long methodID = _lookupMethodFast("method:0000000d5f6765745f6d617874696d650000000006666c6f617400000000020000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(!result) return 0.0; // error occurred
	float returnCode = result->readFloat();
	delete result;
	return returnCode;
}

void Arts::Synth_FX_CFLANGER_stub::maxtime(float newValue)
{
	long methodID = _lookupMethodFast("method:0000000d5f7365745f6d617874696d650000000005766f696400000000020000000100000006666c6f617400000000096e657756616c7565000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->writeFloat(newValue);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(result) delete result;
}

std::string Arts::Synth_FX_CFLANGER_skel::_interfaceName()
{
	return "Arts::Synth_FX_CFLANGER";
}

bool Arts::Synth_FX_CFLANGER_skel::_isCompatibleWith(const std::string& interfacename)
{
	if (interfacename == "Arts::Synth_FX_CFLANGER") return true;
	if (interfacename == "Arts::SynthModule") return true;
	if (interfacename == "Arts::Object") return true;
	return false;
}

std::string Arts::Synth_FX_CFLANGER_skel::_interfaceNameSkel()
{
	return "Arts::Synth_FX_CFLANGER";
}

// _get_mintime
static void _dispatch_Arts_Synth_FX_CFLANGER_00(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeFloat(((Arts::Synth_FX_CFLANGER_skel *)object)->mintime());
}

// _set_mintime
static void _dispatch_Arts_Synth_FX_CFLANGER_01(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	float newValue = request->readFloat();
	((Arts::Synth_FX_CFLANGER_skel *)object)->mintime(newValue);
}

// _get_maxtime
static void _dispatch_Arts_Synth_FX_CFLANGER_02(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeFloat(((Arts::Synth_FX_CFLANGER_skel *)object)->maxtime());
}

// _set_maxtime
static void _dispatch_Arts_Synth_FX_CFLANGER_03(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	float newValue = request->readFloat();
	((Arts::Synth_FX_CFLANGER_skel *)object)->maxtime(newValue);
}

void Arts::Synth_FX_CFLANGER_skel::_buildMethodTable()
{
	Arts::Buffer m;
	m.fromString(
        "MethodTable:0000000d5f6765745f6d696e74696d650000000006666c6f617400"
        "0000000200000000000000000000000d5f7365745f6d696e74696d650000000005"
        "766f696400000000020000000100000006666c6f617400000000096e657756616c"
        "75650000000000000000000000000d5f6765745f6d617874696d65000000000666"
        "6c6f6174000000000200000000000000000000000d5f7365745f6d617874696d65"
        "0000000005766f696400000000020000000100000006666c6f617400000000096e"
        "657756616c7565000000000000000000",
		"MethodTable"
	);
	_addMethod(_dispatch_Arts_Synth_FX_CFLANGER_00,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_FX_CFLANGER_01,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_FX_CFLANGER_02,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_FX_CFLANGER_03,this,Arts::MethodDef(m));
	Arts::SynthModule_skel::_buildMethodTable();
}

Arts::Synth_FX_CFLANGER_skel::Synth_FX_CFLANGER_skel()
{
	_initStream("invalue",&invalue,9);
	_initStream("lfo",&lfo,9);
	_initStream("outvalue",&outvalue,10);
}

Arts::Object_base* Arts::Synth_FX_CFLANGER::_Creator() {
	return Arts::Synth_FX_CFLANGER_base::_create();
}

unsigned long Arts::Synth_FX_CFLANGER_base::_IID = Arts::MCOPUtils::makeIID("Arts::Synth_FX_CFLANGER");

Arts::Synth_COMPRESSOR_base *Arts::Synth_COMPRESSOR_base::_create(const std::string& subClass)
{
	Arts::Object_skel *skel = Arts::ObjectManager::the()->create(subClass);
	assert(skel);
	Arts::Synth_COMPRESSOR_base *castedObject = (Arts::Synth_COMPRESSOR_base *)skel->_cast(Arts::Synth_COMPRESSOR_base::_IID);
	assert(castedObject);
	return castedObject;
}

Arts::Synth_COMPRESSOR_base *Arts::Synth_COMPRESSOR_base::_fromString(const std::string& objectref)
{
	Arts::ObjectReference r;

	if(Arts::Dispatcher::the()->stringToObjectReference(r,objectref))
		return Arts::Synth_COMPRESSOR_base::_fromReference(r,true);
	return 0;
}

Arts::Synth_COMPRESSOR_base *Arts::Synth_COMPRESSOR_base::_fromDynamicCast(const Arts::Object& object)
{
	if(object.isNull()) return 0;

	Arts::Synth_COMPRESSOR_base *castedObject = (Arts::Synth_COMPRESSOR_base *)object._base()->_cast(Arts::Synth_COMPRESSOR_base::_IID);
	if(castedObject) return castedObject->_copy();

	return _fromString(object._toString());
}

Arts::Synth_COMPRESSOR_base *Arts::Synth_COMPRESSOR_base::_fromReference(Arts::ObjectReference r, bool needcopy)
{
	Arts::Synth_COMPRESSOR_base *result;
	result = (Arts::Synth_COMPRESSOR_base *)Arts::Dispatcher::the()->connectObjectLocal(r,"Arts::Synth_COMPRESSOR");
	if(result)
	{
		if(!needcopy)
			result->_cancelCopyRemote();
	}
	else
	{
		Arts::Connection *conn = Arts::Dispatcher::the()->connectObjectRemote(r);
		if(conn)
		{
			result = new Arts::Synth_COMPRESSOR_stub(conn,r.objectID);
			if(needcopy) result->_copyRemote();
			result->_useRemote();
			if (!result->_isCompatibleWith("Arts::Synth_COMPRESSOR")) {
				result->_release();
				return 0;
			}
		}
	}
	return result;
}

std::vector<std::string> Arts::Synth_COMPRESSOR_base::_defaultPortsIn() const {
	std::vector<std::string> ret;
	ret.push_back("invalue");
	return ret;
}
std::vector<std::string> Arts::Synth_COMPRESSOR_base::_defaultPortsOut() const {
	std::vector<std::string> ret;
	ret.push_back("outvalue");
	return ret;
}

void *Arts::Synth_COMPRESSOR_base::_cast(unsigned long iid)
{
	if(iid == Arts::Synth_COMPRESSOR_base::_IID) return (Arts::Synth_COMPRESSOR_base *)this;
	if(iid == Arts::SynthModule_base::_IID) return (Arts::SynthModule_base *)this;
	if(iid == Arts::Object_base::_IID) return (Arts::Object_base *)this;
	return 0;
}

Arts::Synth_COMPRESSOR_stub::Synth_COMPRESSOR_stub()
{
	// constructor for subclasses (don't use directly)
}

Arts::Synth_COMPRESSOR_stub::Synth_COMPRESSOR_stub(Arts::Connection *connection, long objectID)
	: Arts::Object_stub(connection, objectID)
{
	// constructor to create a stub for an object
}

float Arts::Synth_COMPRESSOR_stub::attack()
{
	long methodID = _lookupMethodFast("method:0000000c5f6765745f61747461636b0000000006666c6f617400000000020000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(!result) return 0.0; // error occurred
	float returnCode = result->readFloat();
	delete result;
	return returnCode;
}

void Arts::Synth_COMPRESSOR_stub::attack(float newValue)
{
	long methodID = _lookupMethodFast("method:0000000c5f7365745f61747461636b0000000005766f696400000000020000000100000006666c6f617400000000096e657756616c7565000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->writeFloat(newValue);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(result) delete result;
}

float Arts::Synth_COMPRESSOR_stub::release()
{
	long methodID = _lookupMethodFast("method:0000000d5f6765745f72656c656173650000000006666c6f617400000000020000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(!result) return 0.0; // error occurred
	float returnCode = result->readFloat();
	delete result;
	return returnCode;
}

void Arts::Synth_COMPRESSOR_stub::release(float newValue)
{
	long methodID = _lookupMethodFast("method:0000000d5f7365745f72656c656173650000000005766f696400000000020000000100000006666c6f617400000000096e657756616c7565000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->writeFloat(newValue);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(result) delete result;
}

float Arts::Synth_COMPRESSOR_stub::threshold()
{
	long methodID = _lookupMethodFast("method:0000000f5f6765745f7468726573686f6c640000000006666c6f617400000000020000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(!result) return 0.0; // error occurred
	float returnCode = result->readFloat();
	delete result;
	return returnCode;
}

void Arts::Synth_COMPRESSOR_stub::threshold(float newValue)
{
	long methodID = _lookupMethodFast("method:0000000f5f7365745f7468726573686f6c640000000005766f696400000000020000000100000006666c6f617400000000096e657756616c7565000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->writeFloat(newValue);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(result) delete result;
}

float Arts::Synth_COMPRESSOR_stub::ratio()
{
	long methodID = _lookupMethodFast("method:0000000b5f6765745f726174696f0000000006666c6f617400000000020000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(!result) return 0.0; // error occurred
	float returnCode = result->readFloat();
	delete result;
	return returnCode;
}

void Arts::Synth_COMPRESSOR_stub::ratio(float newValue)
{
	long methodID = _lookupMethodFast("method:0000000b5f7365745f726174696f0000000005766f696400000000020000000100000006666c6f617400000000096e657756616c7565000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->writeFloat(newValue);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(result) delete result;
}

float Arts::Synth_COMPRESSOR_stub::output()
{
	long methodID = _lookupMethodFast("method:0000000c5f6765745f6f75747075740000000006666c6f617400000000020000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(!result) return 0.0; // error occurred
	float returnCode = result->readFloat();
	delete result;
	return returnCode;
}

void Arts::Synth_COMPRESSOR_stub::output(float newValue)
{
	long methodID = _lookupMethodFast("method:0000000c5f7365745f6f75747075740000000005766f696400000000020000000100000006666c6f617400000000096e657756616c7565000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->writeFloat(newValue);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(result) delete result;
}

std::string Arts::Synth_COMPRESSOR_skel::_interfaceName()
{
	return "Arts::Synth_COMPRESSOR";
}

bool Arts::Synth_COMPRESSOR_skel::_isCompatibleWith(const std::string& interfacename)
{
	if (interfacename == "Arts::Synth_COMPRESSOR") return true;
	if (interfacename == "Arts::SynthModule") return true;
	if (interfacename == "Arts::Object") return true;
	return false;
}

std::string Arts::Synth_COMPRESSOR_skel::_interfaceNameSkel()
{
	return "Arts::Synth_COMPRESSOR";
}

// _get_attack
static void _dispatch_Arts_Synth_COMPRESSOR_00(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeFloat(((Arts::Synth_COMPRESSOR_skel *)object)->attack());
}

// _set_attack
static void _dispatch_Arts_Synth_COMPRESSOR_01(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	float newValue = request->readFloat();
	((Arts::Synth_COMPRESSOR_skel *)object)->attack(newValue);
}

// _get_release
static void _dispatch_Arts_Synth_COMPRESSOR_02(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeFloat(((Arts::Synth_COMPRESSOR_skel *)object)->release());
}

// _set_release
static void _dispatch_Arts_Synth_COMPRESSOR_03(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	float newValue = request->readFloat();
	((Arts::Synth_COMPRESSOR_skel *)object)->release(newValue);
}

// _get_threshold
static void _dispatch_Arts_Synth_COMPRESSOR_04(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeFloat(((Arts::Synth_COMPRESSOR_skel *)object)->threshold());
}

// _set_threshold
static void _dispatch_Arts_Synth_COMPRESSOR_05(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	float newValue = request->readFloat();
	((Arts::Synth_COMPRESSOR_skel *)object)->threshold(newValue);
}

// _get_ratio
static void _dispatch_Arts_Synth_COMPRESSOR_06(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeFloat(((Arts::Synth_COMPRESSOR_skel *)object)->ratio());
}

// _set_ratio
static void _dispatch_Arts_Synth_COMPRESSOR_07(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	float newValue = request->readFloat();
	((Arts::Synth_COMPRESSOR_skel *)object)->ratio(newValue);
}

// _get_output
static void _dispatch_Arts_Synth_COMPRESSOR_08(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeFloat(((Arts::Synth_COMPRESSOR_skel *)object)->output());
}

// _set_output
static void _dispatch_Arts_Synth_COMPRESSOR_09(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	float newValue = request->readFloat();
	((Arts::Synth_COMPRESSOR_skel *)object)->output(newValue);
}

void Arts::Synth_COMPRESSOR_skel::_buildMethodTable()
{
	Arts::Buffer m;
	m.fromString(
        "MethodTable:0000000c5f6765745f61747461636b0000000006666c6f61740000"
        "00000200000000000000000000000c5f7365745f61747461636b0000000005766f"
        "696400000000020000000100000006666c6f617400000000096e657756616c7565"
        "0000000000000000000000000d5f6765745f72656c656173650000000006666c6f"
        "6174000000000200000000000000000000000d5f7365745f72656c656173650000"
        "000005766f696400000000020000000100000006666c6f617400000000096e6577"
        "56616c75650000000000000000000000000f5f6765745f7468726573686f6c6400"
        "00000006666c6f6174000000000200000000000000000000000f5f7365745f7468"
        "726573686f6c640000000005766f696400000000020000000100000006666c6f61"
        "7400000000096e657756616c75650000000000000000000000000b5f6765745f72"
        "6174696f0000000006666c6f6174000000000200000000000000000000000b5f73"
        "65745f726174696f0000000005766f696400000000020000000100000006666c6f"
        "617400000000096e657756616c75650000000000000000000000000c5f6765745f"
        "6f75747075740000000006666c6f6174000000000200000000000000000000000c"
        "5f7365745f6f75747075740000000005766f696400000000020000000100000006"
        "666c6f617400000000096e657756616c7565000000000000000000",
		"MethodTable"
	);
	_addMethod(_dispatch_Arts_Synth_COMPRESSOR_00,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_COMPRESSOR_01,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_COMPRESSOR_02,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_COMPRESSOR_03,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_COMPRESSOR_04,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_COMPRESSOR_05,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_COMPRESSOR_06,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_COMPRESSOR_07,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_COMPRESSOR_08,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_COMPRESSOR_09,this,Arts::MethodDef(m));
	Arts::SynthModule_skel::_buildMethodTable();
}

Arts::Synth_COMPRESSOR_skel::Synth_COMPRESSOR_skel()
{
	_initStream("invalue",&invalue,9);
	_initStream("outvalue",&outvalue,10);
}

Arts::Object_base* Arts::Synth_COMPRESSOR::_Creator() {
	return Arts::Synth_COMPRESSOR_base::_create();
}

unsigned long Arts::Synth_COMPRESSOR_base::_IID = Arts::MCOPUtils::makeIID("Arts::Synth_COMPRESSOR");

Arts::Synth_PITCH_SHIFT_base *Arts::Synth_PITCH_SHIFT_base::_create(const std::string& subClass)
{
	Arts::Object_skel *skel = Arts::ObjectManager::the()->create(subClass);
	assert(skel);
	Arts::Synth_PITCH_SHIFT_base *castedObject = (Arts::Synth_PITCH_SHIFT_base *)skel->_cast(Arts::Synth_PITCH_SHIFT_base::_IID);
	assert(castedObject);
	return castedObject;
}

Arts::Synth_PITCH_SHIFT_base *Arts::Synth_PITCH_SHIFT_base::_fromString(const std::string& objectref)
{
	Arts::ObjectReference r;

	if(Arts::Dispatcher::the()->stringToObjectReference(r,objectref))
		return Arts::Synth_PITCH_SHIFT_base::_fromReference(r,true);
	return 0;
}

Arts::Synth_PITCH_SHIFT_base *Arts::Synth_PITCH_SHIFT_base::_fromDynamicCast(const Arts::Object& object)
{
	if(object.isNull()) return 0;

	Arts::Synth_PITCH_SHIFT_base *castedObject = (Arts::Synth_PITCH_SHIFT_base *)object._base()->_cast(Arts::Synth_PITCH_SHIFT_base::_IID);
	if(castedObject) return castedObject->_copy();

	return _fromString(object._toString());
}

Arts::Synth_PITCH_SHIFT_base *Arts::Synth_PITCH_SHIFT_base::_fromReference(Arts::ObjectReference r, bool needcopy)
{
	Arts::Synth_PITCH_SHIFT_base *result;
	result = (Arts::Synth_PITCH_SHIFT_base *)Arts::Dispatcher::the()->connectObjectLocal(r,"Arts::Synth_PITCH_SHIFT");
	if(result)
	{
		if(!needcopy)
			result->_cancelCopyRemote();
	}
	else
	{
		Arts::Connection *conn = Arts::Dispatcher::the()->connectObjectRemote(r);
		if(conn)
		{
			result = new Arts::Synth_PITCH_SHIFT_stub(conn,r.objectID);
			if(needcopy) result->_copyRemote();
			result->_useRemote();
			if (!result->_isCompatibleWith("Arts::Synth_PITCH_SHIFT")) {
				result->_release();
				return 0;
			}
		}
	}
	return result;
}

std::vector<std::string> Arts::Synth_PITCH_SHIFT_base::_defaultPortsIn() const {
	std::vector<std::string> ret;
	ret.push_back("invalue");
	return ret;
}
std::vector<std::string> Arts::Synth_PITCH_SHIFT_base::_defaultPortsOut() const {
	std::vector<std::string> ret;
	ret.push_back("outvalue");
	return ret;
}

void *Arts::Synth_PITCH_SHIFT_base::_cast(unsigned long iid)
{
	if(iid == Arts::Synth_PITCH_SHIFT_base::_IID) return (Arts::Synth_PITCH_SHIFT_base *)this;
	if(iid == Arts::SynthModule_base::_IID) return (Arts::SynthModule_base *)this;
	if(iid == Arts::Object_base::_IID) return (Arts::Object_base *)this;
	return 0;
}

Arts::Synth_PITCH_SHIFT_stub::Synth_PITCH_SHIFT_stub()
{
	// constructor for subclasses (don't use directly)
}

Arts::Synth_PITCH_SHIFT_stub::Synth_PITCH_SHIFT_stub(Arts::Connection *connection, long objectID)
	: Arts::Object_stub(connection, objectID)
{
	// constructor to create a stub for an object
}

float Arts::Synth_PITCH_SHIFT_stub::speed()
{
	long methodID = _lookupMethodFast("method:0000000b5f6765745f73706565640000000006666c6f617400000000020000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(!result) return 0.0; // error occurred
	float returnCode = result->readFloat();
	delete result;
	return returnCode;
}

void Arts::Synth_PITCH_SHIFT_stub::speed(float newValue)
{
	long methodID = _lookupMethodFast("method:0000000b5f7365745f73706565640000000005766f696400000000020000000100000006666c6f617400000000096e657756616c7565000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->writeFloat(newValue);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(result) delete result;
}

float Arts::Synth_PITCH_SHIFT_stub::frequency()
{
	long methodID = _lookupMethodFast("method:0000000f5f6765745f6672657175656e63790000000006666c6f617400000000020000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(!result) return 0.0; // error occurred
	float returnCode = result->readFloat();
	delete result;
	return returnCode;
}

void Arts::Synth_PITCH_SHIFT_stub::frequency(float newValue)
{
	long methodID = _lookupMethodFast("method:0000000f5f7365745f6672657175656e63790000000005766f696400000000020000000100000006666c6f617400000000096e657756616c7565000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->writeFloat(newValue);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(result) delete result;
}

std::string Arts::Synth_PITCH_SHIFT_skel::_interfaceName()
{
	return "Arts::Synth_PITCH_SHIFT";
}

bool Arts::Synth_PITCH_SHIFT_skel::_isCompatibleWith(const std::string& interfacename)
{
	if (interfacename == "Arts::Synth_PITCH_SHIFT") return true;
	if (interfacename == "Arts::SynthModule") return true;
	if (interfacename == "Arts::Object") return true;
	return false;
}

std::string Arts::Synth_PITCH_SHIFT_skel::_interfaceNameSkel()
{
	return "Arts::Synth_PITCH_SHIFT";
}

// _get_speed
static void _dispatch_Arts_Synth_PITCH_SHIFT_00(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeFloat(((Arts::Synth_PITCH_SHIFT_skel *)object)->speed());
}

// _set_speed
static void _dispatch_Arts_Synth_PITCH_SHIFT_01(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	float newValue = request->readFloat();
	((Arts::Synth_PITCH_SHIFT_skel *)object)->speed(newValue);
}

// _get_frequency
static void _dispatch_Arts_Synth_PITCH_SHIFT_02(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeFloat(((Arts::Synth_PITCH_SHIFT_skel *)object)->frequency());
}

// _set_frequency
static void _dispatch_Arts_Synth_PITCH_SHIFT_03(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	float newValue = request->readFloat();
	((Arts::Synth_PITCH_SHIFT_skel *)object)->frequency(newValue);
}

void Arts::Synth_PITCH_SHIFT_skel::_buildMethodTable()
{
	Arts::Buffer m;
	m.fromString(
        "MethodTable:0000000b5f6765745f73706565640000000006666c6f6174000000"
        "000200000000000000000000000b5f7365745f73706565640000000005766f6964"
        "00000000020000000100000006666c6f617400000000096e657756616c75650000"
        "000000000000000000000f5f6765745f6672657175656e63790000000006666c6f"
        "6174000000000200000000000000000000000f5f7365745f6672657175656e6379"
        "0000000005766f696400000000020000000100000006666c6f617400000000096e"
        "657756616c7565000000000000000000",
		"MethodTable"
	);
	_addMethod(_dispatch_Arts_Synth_PITCH_SHIFT_00,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_PITCH_SHIFT_01,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_PITCH_SHIFT_02,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_PITCH_SHIFT_03,this,Arts::MethodDef(m));
	Arts::SynthModule_skel::_buildMethodTable();
}

Arts::Synth_PITCH_SHIFT_skel::Synth_PITCH_SHIFT_skel()
{
	_initStream("invalue",&invalue,9);
	_initStream("outvalue",&outvalue,10);
}

Arts::Object_base* Arts::Synth_PITCH_SHIFT::_Creator() {
	return Arts::Synth_PITCH_SHIFT_base::_create();
}

unsigned long Arts::Synth_PITCH_SHIFT_base::_IID = Arts::MCOPUtils::makeIID("Arts::Synth_PITCH_SHIFT");

Arts::Synth_PITCH_SHIFT_FFT_base *Arts::Synth_PITCH_SHIFT_FFT_base::_create(const std::string& subClass)
{
	Arts::Object_skel *skel = Arts::ObjectManager::the()->create(subClass);
	assert(skel);
	Arts::Synth_PITCH_SHIFT_FFT_base *castedObject = (Arts::Synth_PITCH_SHIFT_FFT_base *)skel->_cast(Arts::Synth_PITCH_SHIFT_FFT_base::_IID);
	assert(castedObject);
	return castedObject;
}

Arts::Synth_PITCH_SHIFT_FFT_base *Arts::Synth_PITCH_SHIFT_FFT_base::_fromString(const std::string& objectref)
{
	Arts::ObjectReference r;

	if(Arts::Dispatcher::the()->stringToObjectReference(r,objectref))
		return Arts::Synth_PITCH_SHIFT_FFT_base::_fromReference(r,true);
	return 0;
}

Arts::Synth_PITCH_SHIFT_FFT_base *Arts::Synth_PITCH_SHIFT_FFT_base::_fromDynamicCast(const Arts::Object& object)
{
	if(object.isNull()) return 0;

	Arts::Synth_PITCH_SHIFT_FFT_base *castedObject = (Arts::Synth_PITCH_SHIFT_FFT_base *)object._base()->_cast(Arts::Synth_PITCH_SHIFT_FFT_base::_IID);
	if(castedObject) return castedObject->_copy();

	return _fromString(object._toString());
}

Arts::Synth_PITCH_SHIFT_FFT_base *Arts::Synth_PITCH_SHIFT_FFT_base::_fromReference(Arts::ObjectReference r, bool needcopy)
{
	Arts::Synth_PITCH_SHIFT_FFT_base *result;
	result = (Arts::Synth_PITCH_SHIFT_FFT_base *)Arts::Dispatcher::the()->connectObjectLocal(r,"Arts::Synth_PITCH_SHIFT_FFT");
	if(result)
	{
		if(!needcopy)
			result->_cancelCopyRemote();
	}
	else
	{
		Arts::Connection *conn = Arts::Dispatcher::the()->connectObjectRemote(r);
		if(conn)
		{
			result = new Arts::Synth_PITCH_SHIFT_FFT_stub(conn,r.objectID);
			if(needcopy) result->_copyRemote();
			result->_useRemote();
			if (!result->_isCompatibleWith("Arts::Synth_PITCH_SHIFT_FFT")) {
				result->_release();
				return 0;
			}
		}
	}
	return result;
}

std::vector<std::string> Arts::Synth_PITCH_SHIFT_FFT_base::_defaultPortsIn() const {
	std::vector<std::string> ret;
	ret.push_back("inStream");
	return ret;
}
std::vector<std::string> Arts::Synth_PITCH_SHIFT_FFT_base::_defaultPortsOut() const {
	std::vector<std::string> ret;
	ret.push_back("outStream");
	return ret;
}

void *Arts::Synth_PITCH_SHIFT_FFT_base::_cast(unsigned long iid)
{
	if(iid == Arts::Synth_PITCH_SHIFT_FFT_base::_IID) return (Arts::Synth_PITCH_SHIFT_FFT_base *)this;
	if(iid == Arts::SynthModule_base::_IID) return (Arts::SynthModule_base *)this;
	if(iid == Arts::Object_base::_IID) return (Arts::Object_base *)this;
	return 0;
}

Arts::Synth_PITCH_SHIFT_FFT_stub::Synth_PITCH_SHIFT_FFT_stub()
{
	// constructor for subclasses (don't use directly)
}

Arts::Synth_PITCH_SHIFT_FFT_stub::Synth_PITCH_SHIFT_FFT_stub(Arts::Connection *connection, long objectID)
	: Arts::Object_stub(connection, objectID)
{
	// constructor to create a stub for an object
}

float Arts::Synth_PITCH_SHIFT_FFT_stub::speed()
{
	long methodID = _lookupMethodFast("method:0000000b5f6765745f73706565640000000006666c6f617400000000020000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(!result) return 0.0; // error occurred
	float returnCode = result->readFloat();
	delete result;
	return returnCode;
}

void Arts::Synth_PITCH_SHIFT_FFT_stub::speed(float newValue)
{
	long methodID = _lookupMethodFast("method:0000000b5f7365745f73706565640000000005766f696400000000020000000100000006666c6f617400000000096e657756616c7565000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->writeFloat(newValue);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(result) delete result;
}

float Arts::Synth_PITCH_SHIFT_FFT_stub::scaleFactor()
{
	long methodID = _lookupMethodFast("method:000000115f6765745f7363616c65466163746f720000000006666c6f617400000000020000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(!result) return 0.0; // error occurred
	float returnCode = result->readFloat();
	delete result;
	return returnCode;
}

void Arts::Synth_PITCH_SHIFT_FFT_stub::scaleFactor(float newValue)
{
	long methodID = _lookupMethodFast("method:000000115f7365745f7363616c65466163746f720000000005766f696400000000020000000100000006666c6f617400000000096e657756616c7565000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->writeFloat(newValue);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(result) delete result;
}

long Arts::Synth_PITCH_SHIFT_FFT_stub::frameSize()
{
	long methodID = _lookupMethodFast("method:0000000f5f6765745f6672616d6553697a6500000000056c6f6e6700000000020000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(!result) return 0; // error occurred
	long returnCode = result->readLong();
	delete result;
	return returnCode;
}

void Arts::Synth_PITCH_SHIFT_FFT_stub::frameSize(long newValue)
{
	long methodID = _lookupMethodFast("method:0000000f5f7365745f6672616d6553697a650000000005766f6964000000000200000001000000056c6f6e6700000000096e657756616c7565000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->writeLong(newValue);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(result) delete result;
}

long Arts::Synth_PITCH_SHIFT_FFT_stub::oversample()
{
	long methodID = _lookupMethodFast("method:000000105f6765745f6f76657273616d706c6500000000056c6f6e6700000000020000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(!result) return 0; // error occurred
	long returnCode = result->readLong();
	delete result;
	return returnCode;
}

void Arts::Synth_PITCH_SHIFT_FFT_stub::oversample(long newValue)
{
	long methodID = _lookupMethodFast("method:000000105f7365745f6f76657273616d706c650000000005766f6964000000000200000001000000056c6f6e6700000000096e657756616c7565000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->writeLong(newValue);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(result) delete result;
}

std::string Arts::Synth_PITCH_SHIFT_FFT_skel::_interfaceName()
{
	return "Arts::Synth_PITCH_SHIFT_FFT";
}

bool Arts::Synth_PITCH_SHIFT_FFT_skel::_isCompatibleWith(const std::string& interfacename)
{
	if (interfacename == "Arts::Synth_PITCH_SHIFT_FFT") return true;
	if (interfacename == "Arts::SynthModule") return true;
	if (interfacename == "Arts::Object") return true;
	return false;
}

std::string Arts::Synth_PITCH_SHIFT_FFT_skel::_interfaceNameSkel()
{
	return "Arts::Synth_PITCH_SHIFT_FFT";
}

// _get_speed
static void _dispatch_Arts_Synth_PITCH_SHIFT_FFT_00(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeFloat(((Arts::Synth_PITCH_SHIFT_FFT_skel *)object)->speed());
}

// _set_speed
static void _dispatch_Arts_Synth_PITCH_SHIFT_FFT_01(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	float newValue = request->readFloat();
	((Arts::Synth_PITCH_SHIFT_FFT_skel *)object)->speed(newValue);
}

// _get_scaleFactor
static void _dispatch_Arts_Synth_PITCH_SHIFT_FFT_02(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeFloat(((Arts::Synth_PITCH_SHIFT_FFT_skel *)object)->scaleFactor());
}

// _set_scaleFactor
static void _dispatch_Arts_Synth_PITCH_SHIFT_FFT_03(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	float newValue = request->readFloat();
	((Arts::Synth_PITCH_SHIFT_FFT_skel *)object)->scaleFactor(newValue);
}

// _get_frameSize
static void _dispatch_Arts_Synth_PITCH_SHIFT_FFT_04(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeLong(((Arts::Synth_PITCH_SHIFT_FFT_skel *)object)->frameSize());
}

// _set_frameSize
static void _dispatch_Arts_Synth_PITCH_SHIFT_FFT_05(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	long newValue = request->readLong();
	((Arts::Synth_PITCH_SHIFT_FFT_skel *)object)->frameSize(newValue);
}

// _get_oversample
static void _dispatch_Arts_Synth_PITCH_SHIFT_FFT_06(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeLong(((Arts::Synth_PITCH_SHIFT_FFT_skel *)object)->oversample());
}

// _set_oversample
static void _dispatch_Arts_Synth_PITCH_SHIFT_FFT_07(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	long newValue = request->readLong();
	((Arts::Synth_PITCH_SHIFT_FFT_skel *)object)->oversample(newValue);
}

void Arts::Synth_PITCH_SHIFT_FFT_skel::_buildMethodTable()
{
	Arts::Buffer m;
	m.fromString(
        "MethodTable:0000000b5f6765745f73706565640000000006666c6f6174000000"
        "000200000000000000000000000b5f7365745f73706565640000000005766f6964"
        "00000000020000000100000006666c6f617400000000096e657756616c75650000"
        "00000000000000000000115f6765745f7363616c65466163746f72000000000666"
        "6c6f617400000000020000000000000000000000115f7365745f7363616c654661"
        "63746f720000000005766f696400000000020000000100000006666c6f61740000"
        "0000096e657756616c75650000000000000000000000000f5f6765745f6672616d"
        "6553697a6500000000056c6f6e67000000000200000000000000000000000f5f73"
        "65745f6672616d6553697a650000000005766f6964000000000200000001000000"
        "056c6f6e6700000000096e657756616c7565000000000000000000000000105f67"
        "65745f6f76657273616d706c6500000000056c6f6e670000000002000000000000"
        "0000000000105f7365745f6f76657273616d706c650000000005766f6964000000"
        "000200000001000000056c6f6e6700000000096e657756616c7565000000000000"
        "000000",
		"MethodTable"
	);
	_addMethod(_dispatch_Arts_Synth_PITCH_SHIFT_FFT_00,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_PITCH_SHIFT_FFT_01,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_PITCH_SHIFT_FFT_02,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_PITCH_SHIFT_FFT_03,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_PITCH_SHIFT_FFT_04,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_PITCH_SHIFT_FFT_05,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_PITCH_SHIFT_FFT_06,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_PITCH_SHIFT_FFT_07,this,Arts::MethodDef(m));
	Arts::SynthModule_skel::_buildMethodTable();
}

Arts::Synth_PITCH_SHIFT_FFT_skel::Synth_PITCH_SHIFT_FFT_skel()
{
	_initStream("inStream",&inStream,9);
	_initStream("outStream",&outStream,10);
}

Arts::Object_base* Arts::Synth_PITCH_SHIFT_FFT::_Creator() {
	return Arts::Synth_PITCH_SHIFT_FFT_base::_create();
}

unsigned long Arts::Synth_PITCH_SHIFT_FFT_base::_IID = Arts::MCOPUtils::makeIID("Arts::Synth_PITCH_SHIFT_FFT");

Arts::Synth_SHELVE_CUTOFF_base *Arts::Synth_SHELVE_CUTOFF_base::_create(const std::string& subClass)
{
	Arts::Object_skel *skel = Arts::ObjectManager::the()->create(subClass);
	assert(skel);
	Arts::Synth_SHELVE_CUTOFF_base *castedObject = (Arts::Synth_SHELVE_CUTOFF_base *)skel->_cast(Arts::Synth_SHELVE_CUTOFF_base::_IID);
	assert(castedObject);
	return castedObject;
}

Arts::Synth_SHELVE_CUTOFF_base *Arts::Synth_SHELVE_CUTOFF_base::_fromString(const std::string& objectref)
{
	Arts::ObjectReference r;

	if(Arts::Dispatcher::the()->stringToObjectReference(r,objectref))
		return Arts::Synth_SHELVE_CUTOFF_base::_fromReference(r,true);
	return 0;
}

Arts::Synth_SHELVE_CUTOFF_base *Arts::Synth_SHELVE_CUTOFF_base::_fromDynamicCast(const Arts::Object& object)
{
	if(object.isNull()) return 0;

	Arts::Synth_SHELVE_CUTOFF_base *castedObject = (Arts::Synth_SHELVE_CUTOFF_base *)object._base()->_cast(Arts::Synth_SHELVE_CUTOFF_base::_IID);
	if(castedObject) return castedObject->_copy();

	return _fromString(object._toString());
}

Arts::Synth_SHELVE_CUTOFF_base *Arts::Synth_SHELVE_CUTOFF_base::_fromReference(Arts::ObjectReference r, bool needcopy)
{
	Arts::Synth_SHELVE_CUTOFF_base *result;
	result = (Arts::Synth_SHELVE_CUTOFF_base *)Arts::Dispatcher::the()->connectObjectLocal(r,"Arts::Synth_SHELVE_CUTOFF");
	if(result)
	{
		if(!needcopy)
			result->_cancelCopyRemote();
	}
	else
	{
		Arts::Connection *conn = Arts::Dispatcher::the()->connectObjectRemote(r);
		if(conn)
		{
			result = new Arts::Synth_SHELVE_CUTOFF_stub(conn,r.objectID);
			if(needcopy) result->_copyRemote();
			result->_useRemote();
			if (!result->_isCompatibleWith("Arts::Synth_SHELVE_CUTOFF")) {
				result->_release();
				return 0;
			}
		}
	}
	return result;
}

std::vector<std::string> Arts::Synth_SHELVE_CUTOFF_base::_defaultPortsIn() const {
	std::vector<std::string> ret;
	return ret;
}
std::vector<std::string> Arts::Synth_SHELVE_CUTOFF_base::_defaultPortsOut() const {
	std::vector<std::string> ret;
	ret.push_back("outvalue");
	return ret;
}

void *Arts::Synth_SHELVE_CUTOFF_base::_cast(unsigned long iid)
{
	if(iid == Arts::Synth_SHELVE_CUTOFF_base::_IID) return (Arts::Synth_SHELVE_CUTOFF_base *)this;
	if(iid == Arts::SynthModule_base::_IID) return (Arts::SynthModule_base *)this;
	if(iid == Arts::Object_base::_IID) return (Arts::Object_base *)this;
	return 0;
}

Arts::Synth_SHELVE_CUTOFF_stub::Synth_SHELVE_CUTOFF_stub()
{
	// constructor for subclasses (don't use directly)
}

Arts::Synth_SHELVE_CUTOFF_stub::Synth_SHELVE_CUTOFF_stub(Arts::Connection *connection, long objectID)
	: Arts::Object_stub(connection, objectID)
{
	// constructor to create a stub for an object
}

std::string Arts::Synth_SHELVE_CUTOFF_skel::_interfaceName()
{
	return "Arts::Synth_SHELVE_CUTOFF";
}

bool Arts::Synth_SHELVE_CUTOFF_skel::_isCompatibleWith(const std::string& interfacename)
{
	if (interfacename == "Arts::Synth_SHELVE_CUTOFF") return true;
	if (interfacename == "Arts::SynthModule") return true;
	if (interfacename == "Arts::Object") return true;
	return false;
}

std::string Arts::Synth_SHELVE_CUTOFF_skel::_interfaceNameSkel()
{
	return "Arts::Synth_SHELVE_CUTOFF";
}

void Arts::Synth_SHELVE_CUTOFF_skel::_buildMethodTable()
{
	Arts::Buffer m;
	m.fromString(
        "MethodTable:",
		"MethodTable"
	);
	Arts::SynthModule_skel::_buildMethodTable();
}

Arts::Synth_SHELVE_CUTOFF_skel::Synth_SHELVE_CUTOFF_skel()
{
	_initStream("invalue",&invalue,9);
	_initStream("frequency",&frequency,9);
	_initStream("outvalue",&outvalue,10);
}

Arts::Object_base* Arts::Synth_SHELVE_CUTOFF::_Creator() {
	return Arts::Synth_SHELVE_CUTOFF_base::_create();
}

unsigned long Arts::Synth_SHELVE_CUTOFF_base::_IID = Arts::MCOPUtils::makeIID("Arts::Synth_SHELVE_CUTOFF");

Arts::Synth_BRICKWALL_LIMITER_base *Arts::Synth_BRICKWALL_LIMITER_base::_create(const std::string& subClass)
{
	Arts::Object_skel *skel = Arts::ObjectManager::the()->create(subClass);
	assert(skel);
	Arts::Synth_BRICKWALL_LIMITER_base *castedObject = (Arts::Synth_BRICKWALL_LIMITER_base *)skel->_cast(Arts::Synth_BRICKWALL_LIMITER_base::_IID);
	assert(castedObject);
	return castedObject;
}

Arts::Synth_BRICKWALL_LIMITER_base *Arts::Synth_BRICKWALL_LIMITER_base::_fromString(const std::string& objectref)
{
	Arts::ObjectReference r;

	if(Arts::Dispatcher::the()->stringToObjectReference(r,objectref))
		return Arts::Synth_BRICKWALL_LIMITER_base::_fromReference(r,true);
	return 0;
}

Arts::Synth_BRICKWALL_LIMITER_base *Arts::Synth_BRICKWALL_LIMITER_base::_fromDynamicCast(const Arts::Object& object)
{
	if(object.isNull()) return 0;

	Arts::Synth_BRICKWALL_LIMITER_base *castedObject = (Arts::Synth_BRICKWALL_LIMITER_base *)object._base()->_cast(Arts::Synth_BRICKWALL_LIMITER_base::_IID);
	if(castedObject) return castedObject->_copy();

	return _fromString(object._toString());
}

Arts::Synth_BRICKWALL_LIMITER_base *Arts::Synth_BRICKWALL_LIMITER_base::_fromReference(Arts::ObjectReference r, bool needcopy)
{
	Arts::Synth_BRICKWALL_LIMITER_base *result;
	result = (Arts::Synth_BRICKWALL_LIMITER_base *)Arts::Dispatcher::the()->connectObjectLocal(r,"Arts::Synth_BRICKWALL_LIMITER");
	if(result)
	{
		if(!needcopy)
			result->_cancelCopyRemote();
	}
	else
	{
		Arts::Connection *conn = Arts::Dispatcher::the()->connectObjectRemote(r);
		if(conn)
		{
			result = new Arts::Synth_BRICKWALL_LIMITER_stub(conn,r.objectID);
			if(needcopy) result->_copyRemote();
			result->_useRemote();
			if (!result->_isCompatibleWith("Arts::Synth_BRICKWALL_LIMITER")) {
				result->_release();
				return 0;
			}
		}
	}
	return result;
}

std::vector<std::string> Arts::Synth_BRICKWALL_LIMITER_base::_defaultPortsIn() const {
	std::vector<std::string> ret;
	ret.push_back("invalue");
	return ret;
}
std::vector<std::string> Arts::Synth_BRICKWALL_LIMITER_base::_defaultPortsOut() const {
	std::vector<std::string> ret;
	ret.push_back("outvalue");
	return ret;
}

void *Arts::Synth_BRICKWALL_LIMITER_base::_cast(unsigned long iid)
{
	if(iid == Arts::Synth_BRICKWALL_LIMITER_base::_IID) return (Arts::Synth_BRICKWALL_LIMITER_base *)this;
	if(iid == Arts::SynthModule_base::_IID) return (Arts::SynthModule_base *)this;
	if(iid == Arts::Object_base::_IID) return (Arts::Object_base *)this;
	return 0;
}

Arts::Synth_BRICKWALL_LIMITER_stub::Synth_BRICKWALL_LIMITER_stub()
{
	// constructor for subclasses (don't use directly)
}

Arts::Synth_BRICKWALL_LIMITER_stub::Synth_BRICKWALL_LIMITER_stub(Arts::Connection *connection, long objectID)
	: Arts::Object_stub(connection, objectID)
{
	// constructor to create a stub for an object
}

std::string Arts::Synth_BRICKWALL_LIMITER_skel::_interfaceName()
{
	return "Arts::Synth_BRICKWALL_LIMITER";
}

bool Arts::Synth_BRICKWALL_LIMITER_skel::_isCompatibleWith(const std::string& interfacename)
{
	if (interfacename == "Arts::Synth_BRICKWALL_LIMITER") return true;
	if (interfacename == "Arts::SynthModule") return true;
	if (interfacename == "Arts::Object") return true;
	return false;
}

std::string Arts::Synth_BRICKWALL_LIMITER_skel::_interfaceNameSkel()
{
	return "Arts::Synth_BRICKWALL_LIMITER";
}

void Arts::Synth_BRICKWALL_LIMITER_skel::_buildMethodTable()
{
	Arts::Buffer m;
	m.fromString(
        "MethodTable:",
		"MethodTable"
	);
	Arts::SynthModule_skel::_buildMethodTable();
}

Arts::Synth_BRICKWALL_LIMITER_skel::Synth_BRICKWALL_LIMITER_skel()
{
	_initStream("invalue",&invalue,9);
	_initStream("outvalue",&outvalue,10);
}

Arts::Object_base* Arts::Synth_BRICKWALL_LIMITER::_Creator() {
	return Arts::Synth_BRICKWALL_LIMITER_base::_create();
}

unsigned long Arts::Synth_BRICKWALL_LIMITER_base::_IID = Arts::MCOPUtils::makeIID("Arts::Synth_BRICKWALL_LIMITER");

Arts::Synth_STD_EQUALIZER_base *Arts::Synth_STD_EQUALIZER_base::_create(const std::string& subClass)
{
	Arts::Object_skel *skel = Arts::ObjectManager::the()->create(subClass);
	assert(skel);
	Arts::Synth_STD_EQUALIZER_base *castedObject = (Arts::Synth_STD_EQUALIZER_base *)skel->_cast(Arts::Synth_STD_EQUALIZER_base::_IID);
	assert(castedObject);
	return castedObject;
}

Arts::Synth_STD_EQUALIZER_base *Arts::Synth_STD_EQUALIZER_base::_fromString(const std::string& objectref)
{
	Arts::ObjectReference r;

	if(Arts::Dispatcher::the()->stringToObjectReference(r,objectref))
		return Arts::Synth_STD_EQUALIZER_base::_fromReference(r,true);
	return 0;
}

Arts::Synth_STD_EQUALIZER_base *Arts::Synth_STD_EQUALIZER_base::_fromDynamicCast(const Arts::Object& object)
{
	if(object.isNull()) return 0;

	Arts::Synth_STD_EQUALIZER_base *castedObject = (Arts::Synth_STD_EQUALIZER_base *)object._base()->_cast(Arts::Synth_STD_EQUALIZER_base::_IID);
	if(castedObject) return castedObject->_copy();

	return _fromString(object._toString());
}

Arts::Synth_STD_EQUALIZER_base *Arts::Synth_STD_EQUALIZER_base::_fromReference(Arts::ObjectReference r, bool needcopy)
{
	Arts::Synth_STD_EQUALIZER_base *result;
	result = (Arts::Synth_STD_EQUALIZER_base *)Arts::Dispatcher::the()->connectObjectLocal(r,"Arts::Synth_STD_EQUALIZER");
	if(result)
	{
		if(!needcopy)
			result->_cancelCopyRemote();
	}
	else
	{
		Arts::Connection *conn = Arts::Dispatcher::the()->connectObjectRemote(r);
		if(conn)
		{
			result = new Arts::Synth_STD_EQUALIZER_stub(conn,r.objectID);
			if(needcopy) result->_copyRemote();
			result->_useRemote();
			if (!result->_isCompatibleWith("Arts::Synth_STD_EQUALIZER")) {
				result->_release();
				return 0;
			}
		}
	}
	return result;
}

std::vector<std::string> Arts::Synth_STD_EQUALIZER_base::_defaultPortsIn() const {
	std::vector<std::string> ret;
	ret.push_back("invalue");
	return ret;
}
std::vector<std::string> Arts::Synth_STD_EQUALIZER_base::_defaultPortsOut() const {
	std::vector<std::string> ret;
	ret.push_back("outvalue");
	return ret;
}

void *Arts::Synth_STD_EQUALIZER_base::_cast(unsigned long iid)
{
	if(iid == Arts::Synth_STD_EQUALIZER_base::_IID) return (Arts::Synth_STD_EQUALIZER_base *)this;
	if(iid == Arts::SynthModule_base::_IID) return (Arts::SynthModule_base *)this;
	if(iid == Arts::Object_base::_IID) return (Arts::Object_base *)this;
	return 0;
}

Arts::Synth_STD_EQUALIZER_stub::Synth_STD_EQUALIZER_stub()
{
	// constructor for subclasses (don't use directly)
}

Arts::Synth_STD_EQUALIZER_stub::Synth_STD_EQUALIZER_stub(Arts::Connection *connection, long objectID)
	: Arts::Object_stub(connection, objectID)
{
	// constructor to create a stub for an object
}

float Arts::Synth_STD_EQUALIZER_stub::low()
{
	long methodID = _lookupMethodFast("method:000000095f6765745f6c6f770000000006666c6f617400000000020000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(!result) return 0.0; // error occurred
	float returnCode = result->readFloat();
	delete result;
	return returnCode;
}

void Arts::Synth_STD_EQUALIZER_stub::low(float newValue)
{
	long methodID = _lookupMethodFast("method:000000095f7365745f6c6f770000000005766f696400000000020000000100000006666c6f617400000000096e657756616c7565000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->writeFloat(newValue);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(result) delete result;
}

float Arts::Synth_STD_EQUALIZER_stub::mid()
{
	long methodID = _lookupMethodFast("method:000000095f6765745f6d69640000000006666c6f617400000000020000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(!result) return 0.0; // error occurred
	float returnCode = result->readFloat();
	delete result;
	return returnCode;
}

void Arts::Synth_STD_EQUALIZER_stub::mid(float newValue)
{
	long methodID = _lookupMethodFast("method:000000095f7365745f6d69640000000005766f696400000000020000000100000006666c6f617400000000096e657756616c7565000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->writeFloat(newValue);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(result) delete result;
}

float Arts::Synth_STD_EQUALIZER_stub::high()
{
	long methodID = _lookupMethodFast("method:0000000a5f6765745f686967680000000006666c6f617400000000020000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(!result) return 0.0; // error occurred
	float returnCode = result->readFloat();
	delete result;
	return returnCode;
}

void Arts::Synth_STD_EQUALIZER_stub::high(float newValue)
{
	long methodID = _lookupMethodFast("method:0000000a5f7365745f686967680000000005766f696400000000020000000100000006666c6f617400000000096e657756616c7565000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->writeFloat(newValue);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(result) delete result;
}

float Arts::Synth_STD_EQUALIZER_stub::frequency()
{
	long methodID = _lookupMethodFast("method:0000000f5f6765745f6672657175656e63790000000006666c6f617400000000020000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(!result) return 0.0; // error occurred
	float returnCode = result->readFloat();
	delete result;
	return returnCode;
}

void Arts::Synth_STD_EQUALIZER_stub::frequency(float newValue)
{
	long methodID = _lookupMethodFast("method:0000000f5f7365745f6672657175656e63790000000005766f696400000000020000000100000006666c6f617400000000096e657756616c7565000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->writeFloat(newValue);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(result) delete result;
}

float Arts::Synth_STD_EQUALIZER_stub::q()
{
	long methodID = _lookupMethodFast("method:000000075f6765745f710000000006666c6f617400000000020000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(!result) return 0.0; // error occurred
	float returnCode = result->readFloat();
	delete result;
	return returnCode;
}

void Arts::Synth_STD_EQUALIZER_stub::q(float newValue)
{
	long methodID = _lookupMethodFast("method:000000075f7365745f710000000005766f696400000000020000000100000006666c6f617400000000096e657756616c7565000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->writeFloat(newValue);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(result) delete result;
}

std::string Arts::Synth_STD_EQUALIZER_skel::_interfaceName()
{
	return "Arts::Synth_STD_EQUALIZER";
}

bool Arts::Synth_STD_EQUALIZER_skel::_isCompatibleWith(const std::string& interfacename)
{
	if (interfacename == "Arts::Synth_STD_EQUALIZER") return true;
	if (interfacename == "Arts::SynthModule") return true;
	if (interfacename == "Arts::Object") return true;
	return false;
}

std::string Arts::Synth_STD_EQUALIZER_skel::_interfaceNameSkel()
{
	return "Arts::Synth_STD_EQUALIZER";
}

// _get_low
static void _dispatch_Arts_Synth_STD_EQUALIZER_00(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeFloat(((Arts::Synth_STD_EQUALIZER_skel *)object)->low());
}

// _set_low
static void _dispatch_Arts_Synth_STD_EQUALIZER_01(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	float newValue = request->readFloat();
	((Arts::Synth_STD_EQUALIZER_skel *)object)->low(newValue);
}

// _get_mid
static void _dispatch_Arts_Synth_STD_EQUALIZER_02(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeFloat(((Arts::Synth_STD_EQUALIZER_skel *)object)->mid());
}

// _set_mid
static void _dispatch_Arts_Synth_STD_EQUALIZER_03(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	float newValue = request->readFloat();
	((Arts::Synth_STD_EQUALIZER_skel *)object)->mid(newValue);
}

// _get_high
static void _dispatch_Arts_Synth_STD_EQUALIZER_04(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeFloat(((Arts::Synth_STD_EQUALIZER_skel *)object)->high());
}

// _set_high
static void _dispatch_Arts_Synth_STD_EQUALIZER_05(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	float newValue = request->readFloat();
	((Arts::Synth_STD_EQUALIZER_skel *)object)->high(newValue);
}

// _get_frequency
static void _dispatch_Arts_Synth_STD_EQUALIZER_06(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeFloat(((Arts::Synth_STD_EQUALIZER_skel *)object)->frequency());
}

// _set_frequency
static void _dispatch_Arts_Synth_STD_EQUALIZER_07(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	float newValue = request->readFloat();
	((Arts::Synth_STD_EQUALIZER_skel *)object)->frequency(newValue);
}

// _get_q
static void _dispatch_Arts_Synth_STD_EQUALIZER_08(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeFloat(((Arts::Synth_STD_EQUALIZER_skel *)object)->q());
}

// _set_q
static void _dispatch_Arts_Synth_STD_EQUALIZER_09(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	float newValue = request->readFloat();
	((Arts::Synth_STD_EQUALIZER_skel *)object)->q(newValue);
}

void Arts::Synth_STD_EQUALIZER_skel::_buildMethodTable()
{
	Arts::Buffer m;
	m.fromString(
        "MethodTable:000000095f6765745f6c6f770000000006666c6f61740000000002"
        "0000000000000000000000095f7365745f6c6f770000000005766f696400000000"
        "020000000100000006666c6f617400000000096e657756616c7565000000000000"
        "000000000000095f6765745f6d69640000000006666c6f61740000000002000000"
        "0000000000000000095f7365745f6d69640000000005766f696400000000020000"
        "000100000006666c6f617400000000096e657756616c7565000000000000000000"
        "0000000a5f6765745f686967680000000006666c6f617400000000020000000000"
        "0000000000000a5f7365745f686967680000000005766f69640000000002000000"
        "0100000006666c6f617400000000096e657756616c756500000000000000000000"
        "00000f5f6765745f6672657175656e63790000000006666c6f6174000000000200"
        "000000000000000000000f5f7365745f6672657175656e63790000000005766f69"
        "6400000000020000000100000006666c6f617400000000096e657756616c756500"
        "0000000000000000000000075f6765745f710000000006666c6f61740000000002"
        "0000000000000000000000075f7365745f710000000005766f6964000000000200"
        "00000100000006666c6f617400000000096e657756616c75650000000000000000"
        "00",
		"MethodTable"
	);
	_addMethod(_dispatch_Arts_Synth_STD_EQUALIZER_00,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_STD_EQUALIZER_01,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_STD_EQUALIZER_02,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_STD_EQUALIZER_03,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_STD_EQUALIZER_04,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_STD_EQUALIZER_05,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_STD_EQUALIZER_06,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_STD_EQUALIZER_07,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_STD_EQUALIZER_08,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_STD_EQUALIZER_09,this,Arts::MethodDef(m));
	Arts::SynthModule_skel::_buildMethodTable();
}

Arts::Synth_STD_EQUALIZER_skel::Synth_STD_EQUALIZER_skel()
{
	_initStream("invalue",&invalue,9);
	_initStream("outvalue",&outvalue,10);
}

Arts::Object_base* Arts::Synth_STD_EQUALIZER::_Creator() {
	return Arts::Synth_STD_EQUALIZER_base::_create();
}

unsigned long Arts::Synth_STD_EQUALIZER_base::_IID = Arts::MCOPUtils::makeIID("Arts::Synth_STD_EQUALIZER");

Arts::Synth_RC_base *Arts::Synth_RC_base::_create(const std::string& subClass)
{
	Arts::Object_skel *skel = Arts::ObjectManager::the()->create(subClass);
	assert(skel);
	Arts::Synth_RC_base *castedObject = (Arts::Synth_RC_base *)skel->_cast(Arts::Synth_RC_base::_IID);
	assert(castedObject);
	return castedObject;
}

Arts::Synth_RC_base *Arts::Synth_RC_base::_fromString(const std::string& objectref)
{
	Arts::ObjectReference r;

	if(Arts::Dispatcher::the()->stringToObjectReference(r,objectref))
		return Arts::Synth_RC_base::_fromReference(r,true);
	return 0;
}

Arts::Synth_RC_base *Arts::Synth_RC_base::_fromDynamicCast(const Arts::Object& object)
{
	if(object.isNull()) return 0;

	Arts::Synth_RC_base *castedObject = (Arts::Synth_RC_base *)object._base()->_cast(Arts::Synth_RC_base::_IID);
	if(castedObject) return castedObject->_copy();

	return _fromString(object._toString());
}

Arts::Synth_RC_base *Arts::Synth_RC_base::_fromReference(Arts::ObjectReference r, bool needcopy)
{
	Arts::Synth_RC_base *result;
	result = (Arts::Synth_RC_base *)Arts::Dispatcher::the()->connectObjectLocal(r,"Arts::Synth_RC");
	if(result)
	{
		if(!needcopy)
			result->_cancelCopyRemote();
	}
	else
	{
		Arts::Connection *conn = Arts::Dispatcher::the()->connectObjectRemote(r);
		if(conn)
		{
			result = new Arts::Synth_RC_stub(conn,r.objectID);
			if(needcopy) result->_copyRemote();
			result->_useRemote();
			if (!result->_isCompatibleWith("Arts::Synth_RC")) {
				result->_release();
				return 0;
			}
		}
	}
	return result;
}

std::vector<std::string> Arts::Synth_RC_base::_defaultPortsIn() const {
	std::vector<std::string> ret;
	ret.push_back("invalue");
	return ret;
}
std::vector<std::string> Arts::Synth_RC_base::_defaultPortsOut() const {
	std::vector<std::string> ret;
	ret.push_back("outvalue");
	return ret;
}

void *Arts::Synth_RC_base::_cast(unsigned long iid)
{
	if(iid == Arts::Synth_RC_base::_IID) return (Arts::Synth_RC_base *)this;
	if(iid == Arts::SynthModule_base::_IID) return (Arts::SynthModule_base *)this;
	if(iid == Arts::Object_base::_IID) return (Arts::Object_base *)this;
	return 0;
}

Arts::Synth_RC_stub::Synth_RC_stub()
{
	// constructor for subclasses (don't use directly)
}

Arts::Synth_RC_stub::Synth_RC_stub(Arts::Connection *connection, long objectID)
	: Arts::Object_stub(connection, objectID)
{
	// constructor to create a stub for an object
}

float Arts::Synth_RC_stub::b()
{
	long methodID = _lookupMethodFast("method:000000075f6765745f620000000006666c6f617400000000020000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(!result) return 0.0; // error occurred
	float returnCode = result->readFloat();
	delete result;
	return returnCode;
}

void Arts::Synth_RC_stub::b(float newValue)
{
	long methodID = _lookupMethodFast("method:000000075f7365745f620000000005766f696400000000020000000100000006666c6f617400000000096e657756616c7565000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->writeFloat(newValue);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(result) delete result;
}

float Arts::Synth_RC_stub::f()
{
	long methodID = _lookupMethodFast("method:000000075f6765745f660000000006666c6f617400000000020000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(!result) return 0.0; // error occurred
	float returnCode = result->readFloat();
	delete result;
	return returnCode;
}

void Arts::Synth_RC_stub::f(float newValue)
{
	long methodID = _lookupMethodFast("method:000000075f7365745f660000000005766f696400000000020000000100000006666c6f617400000000096e657756616c7565000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->writeFloat(newValue);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(result) delete result;
}

std::string Arts::Synth_RC_skel::_interfaceName()
{
	return "Arts::Synth_RC";
}

bool Arts::Synth_RC_skel::_isCompatibleWith(const std::string& interfacename)
{
	if (interfacename == "Arts::Synth_RC") return true;
	if (interfacename == "Arts::SynthModule") return true;
	if (interfacename == "Arts::Object") return true;
	return false;
}

std::string Arts::Synth_RC_skel::_interfaceNameSkel()
{
	return "Arts::Synth_RC";
}

// _get_b
static void _dispatch_Arts_Synth_RC_00(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeFloat(((Arts::Synth_RC_skel *)object)->b());
}

// _set_b
static void _dispatch_Arts_Synth_RC_01(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	float newValue = request->readFloat();
	((Arts::Synth_RC_skel *)object)->b(newValue);
}

// _get_f
static void _dispatch_Arts_Synth_RC_02(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeFloat(((Arts::Synth_RC_skel *)object)->f());
}

// _set_f
static void _dispatch_Arts_Synth_RC_03(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	float newValue = request->readFloat();
	((Arts::Synth_RC_skel *)object)->f(newValue);
}

void Arts::Synth_RC_skel::_buildMethodTable()
{
	Arts::Buffer m;
	m.fromString(
        "MethodTable:000000075f6765745f620000000006666c6f617400000000020000"
        "000000000000000000075f7365745f620000000005766f69640000000002000000"
        "0100000006666c6f617400000000096e657756616c756500000000000000000000"
        "0000075f6765745f660000000006666c6f61740000000002000000000000000000"
        "0000075f7365745f660000000005766f696400000000020000000100000006666c"
        "6f617400000000096e657756616c7565000000000000000000",
		"MethodTable"
	);
	_addMethod(_dispatch_Arts_Synth_RC_00,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_RC_01,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_RC_02,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_RC_03,this,Arts::MethodDef(m));
	Arts::SynthModule_skel::_buildMethodTable();
}

Arts::Synth_RC_skel::Synth_RC_skel()
{
	_initStream("invalue",&invalue,9);
	_initStream("outvalue",&outvalue,10);
}

Arts::Object_base* Arts::Synth_RC::_Creator() {
	return Arts::Synth_RC_base::_create();
}

unsigned long Arts::Synth_RC_base::_IID = Arts::MCOPUtils::makeIID("Arts::Synth_RC");

Arts::Synth_MOOG_VCF_base *Arts::Synth_MOOG_VCF_base::_create(const std::string& subClass)
{
	Arts::Object_skel *skel = Arts::ObjectManager::the()->create(subClass);
	assert(skel);
	Arts::Synth_MOOG_VCF_base *castedObject = (Arts::Synth_MOOG_VCF_base *)skel->_cast(Arts::Synth_MOOG_VCF_base::_IID);
	assert(castedObject);
	return castedObject;
}

Arts::Synth_MOOG_VCF_base *Arts::Synth_MOOG_VCF_base::_fromString(const std::string& objectref)
{
	Arts::ObjectReference r;

	if(Arts::Dispatcher::the()->stringToObjectReference(r,objectref))
		return Arts::Synth_MOOG_VCF_base::_fromReference(r,true);
	return 0;
}

Arts::Synth_MOOG_VCF_base *Arts::Synth_MOOG_VCF_base::_fromDynamicCast(const Arts::Object& object)
{
	if(object.isNull()) return 0;

	Arts::Synth_MOOG_VCF_base *castedObject = (Arts::Synth_MOOG_VCF_base *)object._base()->_cast(Arts::Synth_MOOG_VCF_base::_IID);
	if(castedObject) return castedObject->_copy();

	return _fromString(object._toString());
}

Arts::Synth_MOOG_VCF_base *Arts::Synth_MOOG_VCF_base::_fromReference(Arts::ObjectReference r, bool needcopy)
{
	Arts::Synth_MOOG_VCF_base *result;
	result = (Arts::Synth_MOOG_VCF_base *)Arts::Dispatcher::the()->connectObjectLocal(r,"Arts::Synth_MOOG_VCF");
	if(result)
	{
		if(!needcopy)
			result->_cancelCopyRemote();
	}
	else
	{
		Arts::Connection *conn = Arts::Dispatcher::the()->connectObjectRemote(r);
		if(conn)
		{
			result = new Arts::Synth_MOOG_VCF_stub(conn,r.objectID);
			if(needcopy) result->_copyRemote();
			result->_useRemote();
			if (!result->_isCompatibleWith("Arts::Synth_MOOG_VCF")) {
				result->_release();
				return 0;
			}
		}
	}
	return result;
}

std::vector<std::string> Arts::Synth_MOOG_VCF_base::_defaultPortsIn() const {
	std::vector<std::string> ret;
	ret.push_back("invalue");
	return ret;
}
std::vector<std::string> Arts::Synth_MOOG_VCF_base::_defaultPortsOut() const {
	std::vector<std::string> ret;
	ret.push_back("outvalue");
	return ret;
}

void *Arts::Synth_MOOG_VCF_base::_cast(unsigned long iid)
{
	if(iid == Arts::Synth_MOOG_VCF_base::_IID) return (Arts::Synth_MOOG_VCF_base *)this;
	if(iid == Arts::SynthModule_base::_IID) return (Arts::SynthModule_base *)this;
	if(iid == Arts::Object_base::_IID) return (Arts::Object_base *)this;
	return 0;
}

Arts::Synth_MOOG_VCF_stub::Synth_MOOG_VCF_stub()
{
	// constructor for subclasses (don't use directly)
}

Arts::Synth_MOOG_VCF_stub::Synth_MOOG_VCF_stub(Arts::Connection *connection, long objectID)
	: Arts::Object_stub(connection, objectID)
{
	// constructor to create a stub for an object
}

float Arts::Synth_MOOG_VCF_stub::frequency()
{
	long methodID = _lookupMethodFast("method:0000000f5f6765745f6672657175656e63790000000006666c6f617400000000020000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(!result) return 0.0; // error occurred
	float returnCode = result->readFloat();
	delete result;
	return returnCode;
}

void Arts::Synth_MOOG_VCF_stub::frequency(float newValue)
{
	long methodID = _lookupMethodFast("method:0000000f5f7365745f6672657175656e63790000000005766f696400000000020000000100000006666c6f617400000000096e657756616c7565000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->writeFloat(newValue);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(result) delete result;
}

float Arts::Synth_MOOG_VCF_stub::resonance()
{
	long methodID = _lookupMethodFast("method:0000000f5f6765745f7265736f6e616e63650000000006666c6f617400000000020000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(!result) return 0.0; // error occurred
	float returnCode = result->readFloat();
	delete result;
	return returnCode;
}

void Arts::Synth_MOOG_VCF_stub::resonance(float newValue)
{
	long methodID = _lookupMethodFast("method:0000000f5f7365745f7265736f6e616e63650000000005766f696400000000020000000100000006666c6f617400000000096e657756616c7565000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->writeFloat(newValue);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(result) delete result;
}

std::string Arts::Synth_MOOG_VCF_skel::_interfaceName()
{
	return "Arts::Synth_MOOG_VCF";
}

bool Arts::Synth_MOOG_VCF_skel::_isCompatibleWith(const std::string& interfacename)
{
	if (interfacename == "Arts::Synth_MOOG_VCF") return true;
	if (interfacename == "Arts::SynthModule") return true;
	if (interfacename == "Arts::Object") return true;
	return false;
}

std::string Arts::Synth_MOOG_VCF_skel::_interfaceNameSkel()
{
	return "Arts::Synth_MOOG_VCF";
}

// _get_frequency
static void _dispatch_Arts_Synth_MOOG_VCF_00(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeFloat(((Arts::Synth_MOOG_VCF_skel *)object)->frequency());
}

// _set_frequency
static void _dispatch_Arts_Synth_MOOG_VCF_01(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	float newValue = request->readFloat();
	((Arts::Synth_MOOG_VCF_skel *)object)->frequency(newValue);
}

// _get_resonance
static void _dispatch_Arts_Synth_MOOG_VCF_02(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeFloat(((Arts::Synth_MOOG_VCF_skel *)object)->resonance());
}

// _set_resonance
static void _dispatch_Arts_Synth_MOOG_VCF_03(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	float newValue = request->readFloat();
	((Arts::Synth_MOOG_VCF_skel *)object)->resonance(newValue);
}

void Arts::Synth_MOOG_VCF_skel::_buildMethodTable()
{
	Arts::Buffer m;
	m.fromString(
        "MethodTable:0000000f5f6765745f6672657175656e63790000000006666c6f61"
        "74000000000200000000000000000000000f5f7365745f6672657175656e637900"
        "00000005766f696400000000020000000100000006666c6f617400000000096e65"
        "7756616c75650000000000000000000000000f5f6765745f7265736f6e616e6365"
        "0000000006666c6f6174000000000200000000000000000000000f5f7365745f72"
        "65736f6e616e63650000000005766f696400000000020000000100000006666c6f"
        "617400000000096e657756616c7565000000000000000000",
		"MethodTable"
	);
	_addMethod(_dispatch_Arts_Synth_MOOG_VCF_00,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_MOOG_VCF_01,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_MOOG_VCF_02,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_MOOG_VCF_03,this,Arts::MethodDef(m));
	Arts::SynthModule_skel::_buildMethodTable();
}

Arts::Synth_MOOG_VCF_skel::Synth_MOOG_VCF_skel()
{
	_initStream("invalue",&invalue,9);
	_initStream("outvalue",&outvalue,10);
}

Arts::Object_base* Arts::Synth_MOOG_VCF::_Creator() {
	return Arts::Synth_MOOG_VCF_base::_create();
}

unsigned long Arts::Synth_MOOG_VCF_base::_IID = Arts::MCOPUtils::makeIID("Arts::Synth_MOOG_VCF");

Arts::Synth_ATAN_SATURATE_base *Arts::Synth_ATAN_SATURATE_base::_create(const std::string& subClass)
{
	Arts::Object_skel *skel = Arts::ObjectManager::the()->create(subClass);
	assert(skel);
	Arts::Synth_ATAN_SATURATE_base *castedObject = (Arts::Synth_ATAN_SATURATE_base *)skel->_cast(Arts::Synth_ATAN_SATURATE_base::_IID);
	assert(castedObject);
	return castedObject;
}

Arts::Synth_ATAN_SATURATE_base *Arts::Synth_ATAN_SATURATE_base::_fromString(const std::string& objectref)
{
	Arts::ObjectReference r;

	if(Arts::Dispatcher::the()->stringToObjectReference(r,objectref))
		return Arts::Synth_ATAN_SATURATE_base::_fromReference(r,true);
	return 0;
}

Arts::Synth_ATAN_SATURATE_base *Arts::Synth_ATAN_SATURATE_base::_fromDynamicCast(const Arts::Object& object)
{
	if(object.isNull()) return 0;

	Arts::Synth_ATAN_SATURATE_base *castedObject = (Arts::Synth_ATAN_SATURATE_base *)object._base()->_cast(Arts::Synth_ATAN_SATURATE_base::_IID);
	if(castedObject) return castedObject->_copy();

	return _fromString(object._toString());
}

Arts::Synth_ATAN_SATURATE_base *Arts::Synth_ATAN_SATURATE_base::_fromReference(Arts::ObjectReference r, bool needcopy)
{
	Arts::Synth_ATAN_SATURATE_base *result;
	result = (Arts::Synth_ATAN_SATURATE_base *)Arts::Dispatcher::the()->connectObjectLocal(r,"Arts::Synth_ATAN_SATURATE");
	if(result)
	{
		if(!needcopy)
			result->_cancelCopyRemote();
	}
	else
	{
		Arts::Connection *conn = Arts::Dispatcher::the()->connectObjectRemote(r);
		if(conn)
		{
			result = new Arts::Synth_ATAN_SATURATE_stub(conn,r.objectID);
			if(needcopy) result->_copyRemote();
			result->_useRemote();
			if (!result->_isCompatibleWith("Arts::Synth_ATAN_SATURATE")) {
				result->_release();
				return 0;
			}
		}
	}
	return result;
}

std::vector<std::string> Arts::Synth_ATAN_SATURATE_base::_defaultPortsIn() const {
	std::vector<std::string> ret;
	ret.push_back("invalue");
	return ret;
}
std::vector<std::string> Arts::Synth_ATAN_SATURATE_base::_defaultPortsOut() const {
	std::vector<std::string> ret;
	ret.push_back("outvalue");
	return ret;
}

void *Arts::Synth_ATAN_SATURATE_base::_cast(unsigned long iid)
{
	if(iid == Arts::Synth_ATAN_SATURATE_base::_IID) return (Arts::Synth_ATAN_SATURATE_base *)this;
	if(iid == Arts::SynthModule_base::_IID) return (Arts::SynthModule_base *)this;
	if(iid == Arts::Object_base::_IID) return (Arts::Object_base *)this;
	return 0;
}

Arts::Synth_ATAN_SATURATE_stub::Synth_ATAN_SATURATE_stub()
{
	// constructor for subclasses (don't use directly)
}

Arts::Synth_ATAN_SATURATE_stub::Synth_ATAN_SATURATE_stub(Arts::Connection *connection, long objectID)
	: Arts::Object_stub(connection, objectID)
{
	// constructor to create a stub for an object
}

float Arts::Synth_ATAN_SATURATE_stub::inscale()
{
	long methodID = _lookupMethodFast("method:0000000d5f6765745f696e7363616c650000000006666c6f617400000000020000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(!result) return 0.0; // error occurred
	float returnCode = result->readFloat();
	delete result;
	return returnCode;
}

void Arts::Synth_ATAN_SATURATE_stub::inscale(float newValue)
{
	long methodID = _lookupMethodFast("method:0000000d5f7365745f696e7363616c650000000005766f696400000000020000000100000006666c6f617400000000096e657756616c7565000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->writeFloat(newValue);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(result) delete result;
}

std::string Arts::Synth_ATAN_SATURATE_skel::_interfaceName()
{
	return "Arts::Synth_ATAN_SATURATE";
}

bool Arts::Synth_ATAN_SATURATE_skel::_isCompatibleWith(const std::string& interfacename)
{
	if (interfacename == "Arts::Synth_ATAN_SATURATE") return true;
	if (interfacename == "Arts::SynthModule") return true;
	if (interfacename == "Arts::Object") return true;
	return false;
}

std::string Arts::Synth_ATAN_SATURATE_skel::_interfaceNameSkel()
{
	return "Arts::Synth_ATAN_SATURATE";
}

// _get_inscale
static void _dispatch_Arts_Synth_ATAN_SATURATE_00(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeFloat(((Arts::Synth_ATAN_SATURATE_skel *)object)->inscale());
}

// _set_inscale
static void _dispatch_Arts_Synth_ATAN_SATURATE_01(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	float newValue = request->readFloat();
	((Arts::Synth_ATAN_SATURATE_skel *)object)->inscale(newValue);
}

void Arts::Synth_ATAN_SATURATE_skel::_buildMethodTable()
{
	Arts::Buffer m;
	m.fromString(
        "MethodTable:0000000d5f6765745f696e7363616c650000000006666c6f617400"
        "0000000200000000000000000000000d5f7365745f696e7363616c650000000005"
        "766f696400000000020000000100000006666c6f617400000000096e657756616c"
        "7565000000000000000000",
		"MethodTable"
	);
	_addMethod(_dispatch_Arts_Synth_ATAN_SATURATE_00,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_ATAN_SATURATE_01,this,Arts::MethodDef(m));
	Arts::SynthModule_skel::_buildMethodTable();
}

Arts::Synth_ATAN_SATURATE_skel::Synth_ATAN_SATURATE_skel()
{
	_initStream("invalue",&invalue,9);
	_initStream("outvalue",&outvalue,10);
}

Arts::Object_base* Arts::Synth_ATAN_SATURATE::_Creator() {
	return Arts::Synth_ATAN_SATURATE_base::_create();
}

unsigned long Arts::Synth_ATAN_SATURATE_base::_IID = Arts::MCOPUtils::makeIID("Arts::Synth_ATAN_SATURATE");

Arts::Synth_MIDI_TEST_base *Arts::Synth_MIDI_TEST_base::_create(const std::string& subClass)
{
	Arts::Object_skel *skel = Arts::ObjectManager::the()->create(subClass);
	assert(skel);
	Arts::Synth_MIDI_TEST_base *castedObject = (Arts::Synth_MIDI_TEST_base *)skel->_cast(Arts::Synth_MIDI_TEST_base::_IID);
	assert(castedObject);
	return castedObject;
}

Arts::Synth_MIDI_TEST_base *Arts::Synth_MIDI_TEST_base::_fromString(const std::string& objectref)
{
	Arts::ObjectReference r;

	if(Arts::Dispatcher::the()->stringToObjectReference(r,objectref))
		return Arts::Synth_MIDI_TEST_base::_fromReference(r,true);
	return 0;
}

Arts::Synth_MIDI_TEST_base *Arts::Synth_MIDI_TEST_base::_fromDynamicCast(const Arts::Object& object)
{
	if(object.isNull()) return 0;

	Arts::Synth_MIDI_TEST_base *castedObject = (Arts::Synth_MIDI_TEST_base *)object._base()->_cast(Arts::Synth_MIDI_TEST_base::_IID);
	if(castedObject) return castedObject->_copy();

	return _fromString(object._toString());
}

Arts::Synth_MIDI_TEST_base *Arts::Synth_MIDI_TEST_base::_fromReference(Arts::ObjectReference r, bool needcopy)
{
	Arts::Synth_MIDI_TEST_base *result;
	result = (Arts::Synth_MIDI_TEST_base *)Arts::Dispatcher::the()->connectObjectLocal(r,"Arts::Synth_MIDI_TEST");
	if(result)
	{
		if(!needcopy)
			result->_cancelCopyRemote();
	}
	else
	{
		Arts::Connection *conn = Arts::Dispatcher::the()->connectObjectRemote(r);
		if(conn)
		{
			result = new Arts::Synth_MIDI_TEST_stub(conn,r.objectID);
			if(needcopy) result->_copyRemote();
			result->_useRemote();
			if (!result->_isCompatibleWith("Arts::Synth_MIDI_TEST")) {
				result->_release();
				return 0;
			}
		}
	}
	return result;
}

std::vector<std::string> Arts::Synth_MIDI_TEST_base::_defaultPortsIn() const {
	std::vector<std::string> ret;
	return ret;
}
std::vector<std::string> Arts::Synth_MIDI_TEST_base::_defaultPortsOut() const {
	std::vector<std::string> ret;
	return ret;
}

void *Arts::Synth_MIDI_TEST_base::_cast(unsigned long iid)
{
	if(iid == Arts::Synth_MIDI_TEST_base::_IID) return (Arts::Synth_MIDI_TEST_base *)this;
	if(iid == Arts::SynthModule_base::_IID) return (Arts::SynthModule_base *)this;
	if(iid == Arts::MidiPort_base::_IID) return (Arts::MidiPort_base *)this;
	if(iid == Arts::Object_base::_IID) return (Arts::Object_base *)this;
	return 0;
}

Arts::Synth_MIDI_TEST_stub::Synth_MIDI_TEST_stub()
{
	// constructor for subclasses (don't use directly)
}

Arts::Synth_MIDI_TEST_stub::Synth_MIDI_TEST_stub(Arts::Connection *connection, long objectID)
	: Arts::Object_stub(connection, objectID)
{
	// constructor to create a stub for an object
}

std::string Arts::Synth_MIDI_TEST_stub::filename()
{
	long methodID = _lookupMethodFast("method:0000000e5f6765745f66696c656e616d650000000007737472696e6700000000020000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(!result) return""; // error occurred
	std::string returnCode;
	result->readString(returnCode);
	delete result;
	return returnCode;
}

void Arts::Synth_MIDI_TEST_stub::filename(const std::string& newValue)
{
	long methodID = _lookupMethodFast("method:0000000e5f7365745f66696c656e616d650000000005766f696400000000020000000100000007737472696e6700000000096e657756616c7565000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->writeString(newValue);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(result) delete result;
}

std::string Arts::Synth_MIDI_TEST_stub::busname()
{
	long methodID = _lookupMethodFast("method:0000000d5f6765745f6275736e616d650000000007737472696e6700000000020000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(!result) return""; // error occurred
	std::string returnCode;
	result->readString(returnCode);
	delete result;
	return returnCode;
}

void Arts::Synth_MIDI_TEST_stub::busname(const std::string& newValue)
{
	long methodID = _lookupMethodFast("method:0000000d5f7365745f6275736e616d650000000005766f696400000000020000000100000007737472696e6700000000096e657756616c7565000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->writeString(newValue);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(result) delete result;
}

std::string Arts::Synth_MIDI_TEST_skel::_interfaceName()
{
	return "Arts::Synth_MIDI_TEST";
}

bool Arts::Synth_MIDI_TEST_skel::_isCompatibleWith(const std::string& interfacename)
{
	if (interfacename == "Arts::Synth_MIDI_TEST") return true;
	if (interfacename == "Arts::SynthModule") return true;
	if (interfacename == "Arts::MidiPort") return true;
	if (interfacename == "Arts::Object") return true;
	return false;
}

std::string Arts::Synth_MIDI_TEST_skel::_interfaceNameSkel()
{
	return "Arts::Synth_MIDI_TEST";
}

// _get_filename
static void _dispatch_Arts_Synth_MIDI_TEST_00(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeString(((Arts::Synth_MIDI_TEST_skel *)object)->filename());
}

// _set_filename
static void _dispatch_Arts_Synth_MIDI_TEST_01(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	std::string newValue;
	request->readString(newValue);
	((Arts::Synth_MIDI_TEST_skel *)object)->filename(newValue);
}

// _get_busname
static void _dispatch_Arts_Synth_MIDI_TEST_02(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeString(((Arts::Synth_MIDI_TEST_skel *)object)->busname());
}

// _set_busname
static void _dispatch_Arts_Synth_MIDI_TEST_03(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	std::string newValue;
	request->readString(newValue);
	((Arts::Synth_MIDI_TEST_skel *)object)->busname(newValue);
}

void Arts::Synth_MIDI_TEST_skel::_buildMethodTable()
{
	Arts::Buffer m;
	m.fromString(
        "MethodTable:0000000e5f6765745f66696c656e616d650000000007737472696e"
        "67000000000200000000000000000000000e5f7365745f66696c656e616d650000"
        "000005766f696400000000020000000100000007737472696e6700000000096e65"
        "7756616c75650000000000000000000000000d5f6765745f6275736e616d650000"
        "000007737472696e67000000000200000000000000000000000d5f7365745f6275"
        "736e616d650000000005766f696400000000020000000100000007737472696e67"
        "00000000096e657756616c7565000000000000000000",
		"MethodTable"
	);
	_addMethod(_dispatch_Arts_Synth_MIDI_TEST_00,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_MIDI_TEST_01,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_MIDI_TEST_02,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_MIDI_TEST_03,this,Arts::MethodDef(m));
	Arts::SynthModule_skel::_buildMethodTable();
	Arts::MidiPort_skel::_buildMethodTable();
}

Arts::Synth_MIDI_TEST_skel::Synth_MIDI_TEST_skel()
{
}

Arts::Object_base* Arts::Synth_MIDI_TEST::_Creator() {
	return Arts::Synth_MIDI_TEST_base::_create();
}

unsigned long Arts::Synth_MIDI_TEST_base::_IID = Arts::MCOPUtils::makeIID("Arts::Synth_MIDI_TEST");

Arts::Synth_SEQUENCE_base *Arts::Synth_SEQUENCE_base::_create(const std::string& subClass)
{
	Arts::Object_skel *skel = Arts::ObjectManager::the()->create(subClass);
	assert(skel);
	Arts::Synth_SEQUENCE_base *castedObject = (Arts::Synth_SEQUENCE_base *)skel->_cast(Arts::Synth_SEQUENCE_base::_IID);
	assert(castedObject);
	return castedObject;
}

Arts::Synth_SEQUENCE_base *Arts::Synth_SEQUENCE_base::_fromString(const std::string& objectref)
{
	Arts::ObjectReference r;

	if(Arts::Dispatcher::the()->stringToObjectReference(r,objectref))
		return Arts::Synth_SEQUENCE_base::_fromReference(r,true);
	return 0;
}

Arts::Synth_SEQUENCE_base *Arts::Synth_SEQUENCE_base::_fromDynamicCast(const Arts::Object& object)
{
	if(object.isNull()) return 0;

	Arts::Synth_SEQUENCE_base *castedObject = (Arts::Synth_SEQUENCE_base *)object._base()->_cast(Arts::Synth_SEQUENCE_base::_IID);
	if(castedObject) return castedObject->_copy();

	return _fromString(object._toString());
}

Arts::Synth_SEQUENCE_base *Arts::Synth_SEQUENCE_base::_fromReference(Arts::ObjectReference r, bool needcopy)
{
	Arts::Synth_SEQUENCE_base *result;
	result = (Arts::Synth_SEQUENCE_base *)Arts::Dispatcher::the()->connectObjectLocal(r,"Arts::Synth_SEQUENCE");
	if(result)
	{
		if(!needcopy)
			result->_cancelCopyRemote();
	}
	else
	{
		Arts::Connection *conn = Arts::Dispatcher::the()->connectObjectRemote(r);
		if(conn)
		{
			result = new Arts::Synth_SEQUENCE_stub(conn,r.objectID);
			if(needcopy) result->_copyRemote();
			result->_useRemote();
			if (!result->_isCompatibleWith("Arts::Synth_SEQUENCE")) {
				result->_release();
				return 0;
			}
		}
	}
	return result;
}

std::vector<std::string> Arts::Synth_SEQUENCE_base::_defaultPortsIn() const {
	std::vector<std::string> ret;
	return ret;
}
std::vector<std::string> Arts::Synth_SEQUENCE_base::_defaultPortsOut() const {
	std::vector<std::string> ret;
	return ret;
}

void *Arts::Synth_SEQUENCE_base::_cast(unsigned long iid)
{
	if(iid == Arts::Synth_SEQUENCE_base::_IID) return (Arts::Synth_SEQUENCE_base *)this;
	if(iid == Arts::SynthModule_base::_IID) return (Arts::SynthModule_base *)this;
	if(iid == Arts::Object_base::_IID) return (Arts::Object_base *)this;
	return 0;
}

Arts::Synth_SEQUENCE_stub::Synth_SEQUENCE_stub()
{
	// constructor for subclasses (don't use directly)
}

Arts::Synth_SEQUENCE_stub::Synth_SEQUENCE_stub(Arts::Connection *connection, long objectID)
	: Arts::Object_stub(connection, objectID)
{
	// constructor to create a stub for an object
}

float Arts::Synth_SEQUENCE_stub::speed()
{
	long methodID = _lookupMethodFast("method:0000000b5f6765745f73706565640000000006666c6f617400000000020000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(!result) return 0.0; // error occurred
	float returnCode = result->readFloat();
	delete result;
	return returnCode;
}

void Arts::Synth_SEQUENCE_stub::speed(float newValue)
{
	long methodID = _lookupMethodFast("method:0000000b5f7365745f73706565640000000005766f696400000000020000000100000006666c6f617400000000096e657756616c7565000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->writeFloat(newValue);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(result) delete result;
}

std::string Arts::Synth_SEQUENCE_stub::seq()
{
	long methodID = _lookupMethodFast("method:000000095f6765745f7365710000000007737472696e6700000000020000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(!result) return""; // error occurred
	std::string returnCode;
	result->readString(returnCode);
	delete result;
	return returnCode;
}

void Arts::Synth_SEQUENCE_stub::seq(const std::string& newValue)
{
	long methodID = _lookupMethodFast("method:000000095f7365745f7365710000000005766f696400000000020000000100000007737472696e6700000000096e657756616c7565000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->writeString(newValue);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(result) delete result;
}

std::string Arts::Synth_SEQUENCE_skel::_interfaceName()
{
	return "Arts::Synth_SEQUENCE";
}

bool Arts::Synth_SEQUENCE_skel::_isCompatibleWith(const std::string& interfacename)
{
	if (interfacename == "Arts::Synth_SEQUENCE") return true;
	if (interfacename == "Arts::SynthModule") return true;
	if (interfacename == "Arts::Object") return true;
	return false;
}

std::string Arts::Synth_SEQUENCE_skel::_interfaceNameSkel()
{
	return "Arts::Synth_SEQUENCE";
}

// _get_speed
static void _dispatch_Arts_Synth_SEQUENCE_00(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeFloat(((Arts::Synth_SEQUENCE_skel *)object)->speed());
}

// _set_speed
static void _dispatch_Arts_Synth_SEQUENCE_01(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	float newValue = request->readFloat();
	((Arts::Synth_SEQUENCE_skel *)object)->speed(newValue);
}

// _get_seq
static void _dispatch_Arts_Synth_SEQUENCE_02(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeString(((Arts::Synth_SEQUENCE_skel *)object)->seq());
}

// _set_seq
static void _dispatch_Arts_Synth_SEQUENCE_03(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	std::string newValue;
	request->readString(newValue);
	((Arts::Synth_SEQUENCE_skel *)object)->seq(newValue);
}

void Arts::Synth_SEQUENCE_skel::_buildMethodTable()
{
	Arts::Buffer m;
	m.fromString(
        "MethodTable:0000000b5f6765745f73706565640000000006666c6f6174000000"
        "000200000000000000000000000b5f7365745f73706565640000000005766f6964"
        "00000000020000000100000006666c6f617400000000096e657756616c75650000"
        "00000000000000000000095f6765745f7365710000000007737472696e67000000"
        "00020000000000000000000000095f7365745f7365710000000005766f69640000"
        "0000020000000100000007737472696e6700000000096e657756616c7565000000"
        "000000000000",
		"MethodTable"
	);
	_addMethod(_dispatch_Arts_Synth_SEQUENCE_00,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_SEQUENCE_01,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_SEQUENCE_02,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_SEQUENCE_03,this,Arts::MethodDef(m));
	Arts::SynthModule_skel::_buildMethodTable();
}

Arts::Synth_SEQUENCE_skel::Synth_SEQUENCE_skel()
{
	_initStream("frequency",&frequency,10);
	_initStream("pos",&pos,10);
}

Arts::Object_base* Arts::Synth_SEQUENCE::_Creator() {
	return Arts::Synth_SEQUENCE_base::_create();
}

unsigned long Arts::Synth_SEQUENCE_base::_IID = Arts::MCOPUtils::makeIID("Arts::Synth_SEQUENCE");

Arts::Synth_SEQUENCE_FREQ_base *Arts::Synth_SEQUENCE_FREQ_base::_create(const std::string& subClass)
{
	Arts::Object_skel *skel = Arts::ObjectManager::the()->create(subClass);
	assert(skel);
	Arts::Synth_SEQUENCE_FREQ_base *castedObject = (Arts::Synth_SEQUENCE_FREQ_base *)skel->_cast(Arts::Synth_SEQUENCE_FREQ_base::_IID);
	assert(castedObject);
	return castedObject;
}

Arts::Synth_SEQUENCE_FREQ_base *Arts::Synth_SEQUENCE_FREQ_base::_fromString(const std::string& objectref)
{
	Arts::ObjectReference r;

	if(Arts::Dispatcher::the()->stringToObjectReference(r,objectref))
		return Arts::Synth_SEQUENCE_FREQ_base::_fromReference(r,true);
	return 0;
}

Arts::Synth_SEQUENCE_FREQ_base *Arts::Synth_SEQUENCE_FREQ_base::_fromDynamicCast(const Arts::Object& object)
{
	if(object.isNull()) return 0;

	Arts::Synth_SEQUENCE_FREQ_base *castedObject = (Arts::Synth_SEQUENCE_FREQ_base *)object._base()->_cast(Arts::Synth_SEQUENCE_FREQ_base::_IID);
	if(castedObject) return castedObject->_copy();

	return _fromString(object._toString());
}

Arts::Synth_SEQUENCE_FREQ_base *Arts::Synth_SEQUENCE_FREQ_base::_fromReference(Arts::ObjectReference r, bool needcopy)
{
	Arts::Synth_SEQUENCE_FREQ_base *result;
	result = (Arts::Synth_SEQUENCE_FREQ_base *)Arts::Dispatcher::the()->connectObjectLocal(r,"Arts::Synth_SEQUENCE_FREQ");
	if(result)
	{
		if(!needcopy)
			result->_cancelCopyRemote();
	}
	else
	{
		Arts::Connection *conn = Arts::Dispatcher::the()->connectObjectRemote(r);
		if(conn)
		{
			result = new Arts::Synth_SEQUENCE_FREQ_stub(conn,r.objectID);
			if(needcopy) result->_copyRemote();
			result->_useRemote();
			if (!result->_isCompatibleWith("Arts::Synth_SEQUENCE_FREQ")) {
				result->_release();
				return 0;
			}
		}
	}
	return result;
}

std::vector<std::string> Arts::Synth_SEQUENCE_FREQ_base::_defaultPortsIn() const {
	std::vector<std::string> ret;
	return ret;
}
std::vector<std::string> Arts::Synth_SEQUENCE_FREQ_base::_defaultPortsOut() const {
	std::vector<std::string> ret;
	return ret;
}

void *Arts::Synth_SEQUENCE_FREQ_base::_cast(unsigned long iid)
{
	if(iid == Arts::Synth_SEQUENCE_FREQ_base::_IID) return (Arts::Synth_SEQUENCE_FREQ_base *)this;
	if(iid == Arts::SynthModule_base::_IID) return (Arts::SynthModule_base *)this;
	if(iid == Arts::Object_base::_IID) return (Arts::Object_base *)this;
	return 0;
}

Arts::Synth_SEQUENCE_FREQ_stub::Synth_SEQUENCE_FREQ_stub()
{
	// constructor for subclasses (don't use directly)
}

Arts::Synth_SEQUENCE_FREQ_stub::Synth_SEQUENCE_FREQ_stub(Arts::Connection *connection, long objectID)
	: Arts::Object_stub(connection, objectID)
{
	// constructor to create a stub for an object
}

float Arts::Synth_SEQUENCE_FREQ_stub::speed()
{
	long methodID = _lookupMethodFast("method:0000000b5f6765745f73706565640000000006666c6f617400000000020000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(!result) return 0.0; // error occurred
	float returnCode = result->readFloat();
	delete result;
	return returnCode;
}

void Arts::Synth_SEQUENCE_FREQ_stub::speed(float newValue)
{
	long methodID = _lookupMethodFast("method:0000000b5f7365745f73706565640000000005766f696400000000020000000100000006666c6f617400000000096e657756616c7565000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->writeFloat(newValue);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(result) delete result;
}

std::string Arts::Synth_SEQUENCE_FREQ_stub::seq()
{
	long methodID = _lookupMethodFast("method:000000095f6765745f7365710000000007737472696e6700000000020000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(!result) return""; // error occurred
	std::string returnCode;
	result->readString(returnCode);
	delete result;
	return returnCode;
}

void Arts::Synth_SEQUENCE_FREQ_stub::seq(const std::string& newValue)
{
	long methodID = _lookupMethodFast("method:000000095f7365745f7365710000000005766f696400000000020000000100000007737472696e6700000000096e657756616c7565000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->writeString(newValue);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(result) delete result;
}

std::string Arts::Synth_SEQUENCE_FREQ_skel::_interfaceName()
{
	return "Arts::Synth_SEQUENCE_FREQ";
}

bool Arts::Synth_SEQUENCE_FREQ_skel::_isCompatibleWith(const std::string& interfacename)
{
	if (interfacename == "Arts::Synth_SEQUENCE_FREQ") return true;
	if (interfacename == "Arts::SynthModule") return true;
	if (interfacename == "Arts::Object") return true;
	return false;
}

std::string Arts::Synth_SEQUENCE_FREQ_skel::_interfaceNameSkel()
{
	return "Arts::Synth_SEQUENCE_FREQ";
}

// _get_speed
static void _dispatch_Arts_Synth_SEQUENCE_FREQ_00(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeFloat(((Arts::Synth_SEQUENCE_FREQ_skel *)object)->speed());
}

// _set_speed
static void _dispatch_Arts_Synth_SEQUENCE_FREQ_01(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	float newValue = request->readFloat();
	((Arts::Synth_SEQUENCE_FREQ_skel *)object)->speed(newValue);
}

// _get_seq
static void _dispatch_Arts_Synth_SEQUENCE_FREQ_02(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeString(((Arts::Synth_SEQUENCE_FREQ_skel *)object)->seq());
}

// _set_seq
static void _dispatch_Arts_Synth_SEQUENCE_FREQ_03(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	std::string newValue;
	request->readString(newValue);
	((Arts::Synth_SEQUENCE_FREQ_skel *)object)->seq(newValue);
}

void Arts::Synth_SEQUENCE_FREQ_skel::_buildMethodTable()
{
	Arts::Buffer m;
	m.fromString(
        "MethodTable:0000000b5f6765745f73706565640000000006666c6f6174000000"
        "000200000000000000000000000b5f7365745f73706565640000000005766f6964"
        "00000000020000000100000006666c6f617400000000096e657756616c75650000"
        "00000000000000000000095f6765745f7365710000000007737472696e67000000"
        "00020000000000000000000000095f7365745f7365710000000005766f69640000"
        "0000020000000100000007737472696e6700000000096e657756616c7565000000"
        "000000000000",
		"MethodTable"
	);
	_addMethod(_dispatch_Arts_Synth_SEQUENCE_FREQ_00,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_SEQUENCE_FREQ_01,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_SEQUENCE_FREQ_02,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_SEQUENCE_FREQ_03,this,Arts::MethodDef(m));
	Arts::SynthModule_skel::_buildMethodTable();
}

Arts::Synth_SEQUENCE_FREQ_skel::Synth_SEQUENCE_FREQ_skel()
{
	_initStream("frequency",&frequency,10);
	_initStream("pos",&pos,10);
}

Arts::Object_base* Arts::Synth_SEQUENCE_FREQ::_Creator() {
	return Arts::Synth_SEQUENCE_FREQ_base::_create();
}

unsigned long Arts::Synth_SEQUENCE_FREQ_base::_IID = Arts::MCOPUtils::makeIID("Arts::Synth_SEQUENCE_FREQ");

Arts::Synth_FM_SOURCE_base *Arts::Synth_FM_SOURCE_base::_create(const std::string& subClass)
{
	Arts::Object_skel *skel = Arts::ObjectManager::the()->create(subClass);
	assert(skel);
	Arts::Synth_FM_SOURCE_base *castedObject = (Arts::Synth_FM_SOURCE_base *)skel->_cast(Arts::Synth_FM_SOURCE_base::_IID);
	assert(castedObject);
	return castedObject;
}

Arts::Synth_FM_SOURCE_base *Arts::Synth_FM_SOURCE_base::_fromString(const std::string& objectref)
{
	Arts::ObjectReference r;

	if(Arts::Dispatcher::the()->stringToObjectReference(r,objectref))
		return Arts::Synth_FM_SOURCE_base::_fromReference(r,true);
	return 0;
}

Arts::Synth_FM_SOURCE_base *Arts::Synth_FM_SOURCE_base::_fromDynamicCast(const Arts::Object& object)
{
	if(object.isNull()) return 0;

	Arts::Synth_FM_SOURCE_base *castedObject = (Arts::Synth_FM_SOURCE_base *)object._base()->_cast(Arts::Synth_FM_SOURCE_base::_IID);
	if(castedObject) return castedObject->_copy();

	return _fromString(object._toString());
}

Arts::Synth_FM_SOURCE_base *Arts::Synth_FM_SOURCE_base::_fromReference(Arts::ObjectReference r, bool needcopy)
{
	Arts::Synth_FM_SOURCE_base *result;
	result = (Arts::Synth_FM_SOURCE_base *)Arts::Dispatcher::the()->connectObjectLocal(r,"Arts::Synth_FM_SOURCE");
	if(result)
	{
		if(!needcopy)
			result->_cancelCopyRemote();
	}
	else
	{
		Arts::Connection *conn = Arts::Dispatcher::the()->connectObjectRemote(r);
		if(conn)
		{
			result = new Arts::Synth_FM_SOURCE_stub(conn,r.objectID);
			if(needcopy) result->_copyRemote();
			result->_useRemote();
			if (!result->_isCompatibleWith("Arts::Synth_FM_SOURCE")) {
				result->_release();
				return 0;
			}
		}
	}
	return result;
}

std::vector<std::string> Arts::Synth_FM_SOURCE_base::_defaultPortsIn() const {
	std::vector<std::string> ret;
	return ret;
}
std::vector<std::string> Arts::Synth_FM_SOURCE_base::_defaultPortsOut() const {
	std::vector<std::string> ret;
	ret.push_back("pos");
	return ret;
}

void *Arts::Synth_FM_SOURCE_base::_cast(unsigned long iid)
{
	if(iid == Arts::Synth_FM_SOURCE_base::_IID) return (Arts::Synth_FM_SOURCE_base *)this;
	if(iid == Arts::SynthModule_base::_IID) return (Arts::SynthModule_base *)this;
	if(iid == Arts::Object_base::_IID) return (Arts::Object_base *)this;
	return 0;
}

Arts::Synth_FM_SOURCE_stub::Synth_FM_SOURCE_stub()
{
	// constructor for subclasses (don't use directly)
}

Arts::Synth_FM_SOURCE_stub::Synth_FM_SOURCE_stub(Arts::Connection *connection, long objectID)
	: Arts::Object_stub(connection, objectID)
{
	// constructor to create a stub for an object
}

std::string Arts::Synth_FM_SOURCE_skel::_interfaceName()
{
	return "Arts::Synth_FM_SOURCE";
}

bool Arts::Synth_FM_SOURCE_skel::_isCompatibleWith(const std::string& interfacename)
{
	if (interfacename == "Arts::Synth_FM_SOURCE") return true;
	if (interfacename == "Arts::SynthModule") return true;
	if (interfacename == "Arts::Object") return true;
	return false;
}

std::string Arts::Synth_FM_SOURCE_skel::_interfaceNameSkel()
{
	return "Arts::Synth_FM_SOURCE";
}

void Arts::Synth_FM_SOURCE_skel::_buildMethodTable()
{
	Arts::Buffer m;
	m.fromString(
        "MethodTable:",
		"MethodTable"
	);
	Arts::SynthModule_skel::_buildMethodTable();
}

Arts::Synth_FM_SOURCE_skel::Synth_FM_SOURCE_skel()
{
	_initStream("frequency",&frequency,9);
	_initStream("modulator",&modulator,9);
	_initStream("modlevel",&modlevel,9);
	_initStream("pos",&pos,10);
}

Arts::Object_base* Arts::Synth_FM_SOURCE::_Creator() {
	return Arts::Synth_FM_SOURCE_base::_create();
}

unsigned long Arts::Synth_FM_SOURCE_base::_IID = Arts::MCOPUtils::makeIID("Arts::Synth_FM_SOURCE");

Arts::Synth_WAVE_TRI_base *Arts::Synth_WAVE_TRI_base::_create(const std::string& subClass)
{
	Arts::Object_skel *skel = Arts::ObjectManager::the()->create(subClass);
	assert(skel);
	Arts::Synth_WAVE_TRI_base *castedObject = (Arts::Synth_WAVE_TRI_base *)skel->_cast(Arts::Synth_WAVE_TRI_base::_IID);
	assert(castedObject);
	return castedObject;
}

Arts::Synth_WAVE_TRI_base *Arts::Synth_WAVE_TRI_base::_fromString(const std::string& objectref)
{
	Arts::ObjectReference r;

	if(Arts::Dispatcher::the()->stringToObjectReference(r,objectref))
		return Arts::Synth_WAVE_TRI_base::_fromReference(r,true);
	return 0;
}

Arts::Synth_WAVE_TRI_base *Arts::Synth_WAVE_TRI_base::_fromDynamicCast(const Arts::Object& object)
{
	if(object.isNull()) return 0;

	Arts::Synth_WAVE_TRI_base *castedObject = (Arts::Synth_WAVE_TRI_base *)object._base()->_cast(Arts::Synth_WAVE_TRI_base::_IID);
	if(castedObject) return castedObject->_copy();

	return _fromString(object._toString());
}

Arts::Synth_WAVE_TRI_base *Arts::Synth_WAVE_TRI_base::_fromReference(Arts::ObjectReference r, bool needcopy)
{
	Arts::Synth_WAVE_TRI_base *result;
	result = (Arts::Synth_WAVE_TRI_base *)Arts::Dispatcher::the()->connectObjectLocal(r,"Arts::Synth_WAVE_TRI");
	if(result)
	{
		if(!needcopy)
			result->_cancelCopyRemote();
	}
	else
	{
		Arts::Connection *conn = Arts::Dispatcher::the()->connectObjectRemote(r);
		if(conn)
		{
			result = new Arts::Synth_WAVE_TRI_stub(conn,r.objectID);
			if(needcopy) result->_copyRemote();
			result->_useRemote();
			if (!result->_isCompatibleWith("Arts::Synth_WAVE_TRI")) {
				result->_release();
				return 0;
			}
		}
	}
	return result;
}

std::vector<std::string> Arts::Synth_WAVE_TRI_base::_defaultPortsIn() const {
	std::vector<std::string> ret;
	ret.push_back("pos");
	return ret;
}
std::vector<std::string> Arts::Synth_WAVE_TRI_base::_defaultPortsOut() const {
	std::vector<std::string> ret;
	ret.push_back("outvalue");
	return ret;
}

void *Arts::Synth_WAVE_TRI_base::_cast(unsigned long iid)
{
	if(iid == Arts::Synth_WAVE_TRI_base::_IID) return (Arts::Synth_WAVE_TRI_base *)this;
	if(iid == Arts::SynthModule_base::_IID) return (Arts::SynthModule_base *)this;
	if(iid == Arts::Object_base::_IID) return (Arts::Object_base *)this;
	return 0;
}

Arts::Synth_WAVE_TRI_stub::Synth_WAVE_TRI_stub()
{
	// constructor for subclasses (don't use directly)
}

Arts::Synth_WAVE_TRI_stub::Synth_WAVE_TRI_stub(Arts::Connection *connection, long objectID)
	: Arts::Object_stub(connection, objectID)
{
	// constructor to create a stub for an object
}

std::string Arts::Synth_WAVE_TRI_skel::_interfaceName()
{
	return "Arts::Synth_WAVE_TRI";
}

bool Arts::Synth_WAVE_TRI_skel::_isCompatibleWith(const std::string& interfacename)
{
	if (interfacename == "Arts::Synth_WAVE_TRI") return true;
	if (interfacename == "Arts::SynthModule") return true;
	if (interfacename == "Arts::Object") return true;
	return false;
}

std::string Arts::Synth_WAVE_TRI_skel::_interfaceNameSkel()
{
	return "Arts::Synth_WAVE_TRI";
}

void Arts::Synth_WAVE_TRI_skel::_buildMethodTable()
{
	Arts::Buffer m;
	m.fromString(
        "MethodTable:",
		"MethodTable"
	);
	Arts::SynthModule_skel::_buildMethodTable();
}

Arts::Synth_WAVE_TRI_skel::Synth_WAVE_TRI_skel()
{
	_initStream("pos",&pos,9);
	_initStream("outvalue",&outvalue,10);
}

Arts::Object_base* Arts::Synth_WAVE_TRI::_Creator() {
	return Arts::Synth_WAVE_TRI_base::_create();
}

unsigned long Arts::Synth_WAVE_TRI_base::_IID = Arts::MCOPUtils::makeIID("Arts::Synth_WAVE_TRI");

Arts::Synth_NOISE_base *Arts::Synth_NOISE_base::_create(const std::string& subClass)
{
	Arts::Object_skel *skel = Arts::ObjectManager::the()->create(subClass);
	assert(skel);
	Arts::Synth_NOISE_base *castedObject = (Arts::Synth_NOISE_base *)skel->_cast(Arts::Synth_NOISE_base::_IID);
	assert(castedObject);
	return castedObject;
}

Arts::Synth_NOISE_base *Arts::Synth_NOISE_base::_fromString(const std::string& objectref)
{
	Arts::ObjectReference r;

	if(Arts::Dispatcher::the()->stringToObjectReference(r,objectref))
		return Arts::Synth_NOISE_base::_fromReference(r,true);
	return 0;
}

Arts::Synth_NOISE_base *Arts::Synth_NOISE_base::_fromDynamicCast(const Arts::Object& object)
{
	if(object.isNull()) return 0;

	Arts::Synth_NOISE_base *castedObject = (Arts::Synth_NOISE_base *)object._base()->_cast(Arts::Synth_NOISE_base::_IID);
	if(castedObject) return castedObject->_copy();

	return _fromString(object._toString());
}

Arts::Synth_NOISE_base *Arts::Synth_NOISE_base::_fromReference(Arts::ObjectReference r, bool needcopy)
{
	Arts::Synth_NOISE_base *result;
	result = (Arts::Synth_NOISE_base *)Arts::Dispatcher::the()->connectObjectLocal(r,"Arts::Synth_NOISE");
	if(result)
	{
		if(!needcopy)
			result->_cancelCopyRemote();
	}
	else
	{
		Arts::Connection *conn = Arts::Dispatcher::the()->connectObjectRemote(r);
		if(conn)
		{
			result = new Arts::Synth_NOISE_stub(conn,r.objectID);
			if(needcopy) result->_copyRemote();
			result->_useRemote();
			if (!result->_isCompatibleWith("Arts::Synth_NOISE")) {
				result->_release();
				return 0;
			}
		}
	}
	return result;
}

std::vector<std::string> Arts::Synth_NOISE_base::_defaultPortsIn() const {
	std::vector<std::string> ret;
	return ret;
}
std::vector<std::string> Arts::Synth_NOISE_base::_defaultPortsOut() const {
	std::vector<std::string> ret;
	ret.push_back("outvalue");
	return ret;
}

void *Arts::Synth_NOISE_base::_cast(unsigned long iid)
{
	if(iid == Arts::Synth_NOISE_base::_IID) return (Arts::Synth_NOISE_base *)this;
	if(iid == Arts::SynthModule_base::_IID) return (Arts::SynthModule_base *)this;
	if(iid == Arts::Object_base::_IID) return (Arts::Object_base *)this;
	return 0;
}

Arts::Synth_NOISE_stub::Synth_NOISE_stub()
{
	// constructor for subclasses (don't use directly)
}

Arts::Synth_NOISE_stub::Synth_NOISE_stub(Arts::Connection *connection, long objectID)
	: Arts::Object_stub(connection, objectID)
{
	// constructor to create a stub for an object
}

std::string Arts::Synth_NOISE_skel::_interfaceName()
{
	return "Arts::Synth_NOISE";
}

bool Arts::Synth_NOISE_skel::_isCompatibleWith(const std::string& interfacename)
{
	if (interfacename == "Arts::Synth_NOISE") return true;
	if (interfacename == "Arts::SynthModule") return true;
	if (interfacename == "Arts::Object") return true;
	return false;
}

std::string Arts::Synth_NOISE_skel::_interfaceNameSkel()
{
	return "Arts::Synth_NOISE";
}

void Arts::Synth_NOISE_skel::_buildMethodTable()
{
	Arts::Buffer m;
	m.fromString(
        "MethodTable:",
		"MethodTable"
	);
	Arts::SynthModule_skel::_buildMethodTable();
}

Arts::Synth_NOISE_skel::Synth_NOISE_skel()
{
	_initStream("outvalue",&outvalue,10);
}

Arts::Object_base* Arts::Synth_NOISE::_Creator() {
	return Arts::Synth_NOISE_base::_create();
}

unsigned long Arts::Synth_NOISE_base::_IID = Arts::MCOPUtils::makeIID("Arts::Synth_NOISE");

Arts::Synth_WAVE_SQUARE_base *Arts::Synth_WAVE_SQUARE_base::_create(const std::string& subClass)
{
	Arts::Object_skel *skel = Arts::ObjectManager::the()->create(subClass);
	assert(skel);
	Arts::Synth_WAVE_SQUARE_base *castedObject = (Arts::Synth_WAVE_SQUARE_base *)skel->_cast(Arts::Synth_WAVE_SQUARE_base::_IID);
	assert(castedObject);
	return castedObject;
}

Arts::Synth_WAVE_SQUARE_base *Arts::Synth_WAVE_SQUARE_base::_fromString(const std::string& objectref)
{
	Arts::ObjectReference r;

	if(Arts::Dispatcher::the()->stringToObjectReference(r,objectref))
		return Arts::Synth_WAVE_SQUARE_base::_fromReference(r,true);
	return 0;
}

Arts::Synth_WAVE_SQUARE_base *Arts::Synth_WAVE_SQUARE_base::_fromDynamicCast(const Arts::Object& object)
{
	if(object.isNull()) return 0;

	Arts::Synth_WAVE_SQUARE_base *castedObject = (Arts::Synth_WAVE_SQUARE_base *)object._base()->_cast(Arts::Synth_WAVE_SQUARE_base::_IID);
	if(castedObject) return castedObject->_copy();

	return _fromString(object._toString());
}

Arts::Synth_WAVE_SQUARE_base *Arts::Synth_WAVE_SQUARE_base::_fromReference(Arts::ObjectReference r, bool needcopy)
{
	Arts::Synth_WAVE_SQUARE_base *result;
	result = (Arts::Synth_WAVE_SQUARE_base *)Arts::Dispatcher::the()->connectObjectLocal(r,"Arts::Synth_WAVE_SQUARE");
	if(result)
	{
		if(!needcopy)
			result->_cancelCopyRemote();
	}
	else
	{
		Arts::Connection *conn = Arts::Dispatcher::the()->connectObjectRemote(r);
		if(conn)
		{
			result = new Arts::Synth_WAVE_SQUARE_stub(conn,r.objectID);
			if(needcopy) result->_copyRemote();
			result->_useRemote();
			if (!result->_isCompatibleWith("Arts::Synth_WAVE_SQUARE")) {
				result->_release();
				return 0;
			}
		}
	}
	return result;
}

std::vector<std::string> Arts::Synth_WAVE_SQUARE_base::_defaultPortsIn() const {
	std::vector<std::string> ret;
	ret.push_back("pos");
	return ret;
}
std::vector<std::string> Arts::Synth_WAVE_SQUARE_base::_defaultPortsOut() const {
	std::vector<std::string> ret;
	ret.push_back("outvalue");
	return ret;
}

void *Arts::Synth_WAVE_SQUARE_base::_cast(unsigned long iid)
{
	if(iid == Arts::Synth_WAVE_SQUARE_base::_IID) return (Arts::Synth_WAVE_SQUARE_base *)this;
	if(iid == Arts::SynthModule_base::_IID) return (Arts::SynthModule_base *)this;
	if(iid == Arts::Object_base::_IID) return (Arts::Object_base *)this;
	return 0;
}

Arts::Synth_WAVE_SQUARE_stub::Synth_WAVE_SQUARE_stub()
{
	// constructor for subclasses (don't use directly)
}

Arts::Synth_WAVE_SQUARE_stub::Synth_WAVE_SQUARE_stub(Arts::Connection *connection, long objectID)
	: Arts::Object_stub(connection, objectID)
{
	// constructor to create a stub for an object
}

std::string Arts::Synth_WAVE_SQUARE_skel::_interfaceName()
{
	return "Arts::Synth_WAVE_SQUARE";
}

bool Arts::Synth_WAVE_SQUARE_skel::_isCompatibleWith(const std::string& interfacename)
{
	if (interfacename == "Arts::Synth_WAVE_SQUARE") return true;
	if (interfacename == "Arts::SynthModule") return true;
	if (interfacename == "Arts::Object") return true;
	return false;
}

std::string Arts::Synth_WAVE_SQUARE_skel::_interfaceNameSkel()
{
	return "Arts::Synth_WAVE_SQUARE";
}

void Arts::Synth_WAVE_SQUARE_skel::_buildMethodTable()
{
	Arts::Buffer m;
	m.fromString(
        "MethodTable:",
		"MethodTable"
	);
	Arts::SynthModule_skel::_buildMethodTable();
}

Arts::Synth_WAVE_SQUARE_skel::Synth_WAVE_SQUARE_skel()
{
	_initStream("pos",&pos,9);
	_initStream("outvalue",&outvalue,10);
}

Arts::Object_base* Arts::Synth_WAVE_SQUARE::_Creator() {
	return Arts::Synth_WAVE_SQUARE_base::_create();
}

unsigned long Arts::Synth_WAVE_SQUARE_base::_IID = Arts::MCOPUtils::makeIID("Arts::Synth_WAVE_SQUARE");

Arts::Synth_WAVE_SOFTSAW_base *Arts::Synth_WAVE_SOFTSAW_base::_create(const std::string& subClass)
{
	Arts::Object_skel *skel = Arts::ObjectManager::the()->create(subClass);
	assert(skel);
	Arts::Synth_WAVE_SOFTSAW_base *castedObject = (Arts::Synth_WAVE_SOFTSAW_base *)skel->_cast(Arts::Synth_WAVE_SOFTSAW_base::_IID);
	assert(castedObject);
	return castedObject;
}

Arts::Synth_WAVE_SOFTSAW_base *Arts::Synth_WAVE_SOFTSAW_base::_fromString(const std::string& objectref)
{
	Arts::ObjectReference r;

	if(Arts::Dispatcher::the()->stringToObjectReference(r,objectref))
		return Arts::Synth_WAVE_SOFTSAW_base::_fromReference(r,true);
	return 0;
}

Arts::Synth_WAVE_SOFTSAW_base *Arts::Synth_WAVE_SOFTSAW_base::_fromDynamicCast(const Arts::Object& object)
{
	if(object.isNull()) return 0;

	Arts::Synth_WAVE_SOFTSAW_base *castedObject = (Arts::Synth_WAVE_SOFTSAW_base *)object._base()->_cast(Arts::Synth_WAVE_SOFTSAW_base::_IID);
	if(castedObject) return castedObject->_copy();

	return _fromString(object._toString());
}

Arts::Synth_WAVE_SOFTSAW_base *Arts::Synth_WAVE_SOFTSAW_base::_fromReference(Arts::ObjectReference r, bool needcopy)
{
	Arts::Synth_WAVE_SOFTSAW_base *result;
	result = (Arts::Synth_WAVE_SOFTSAW_base *)Arts::Dispatcher::the()->connectObjectLocal(r,"Arts::Synth_WAVE_SOFTSAW");
	if(result)
	{
		if(!needcopy)
			result->_cancelCopyRemote();
	}
	else
	{
		Arts::Connection *conn = Arts::Dispatcher::the()->connectObjectRemote(r);
		if(conn)
		{
			result = new Arts::Synth_WAVE_SOFTSAW_stub(conn,r.objectID);
			if(needcopy) result->_copyRemote();
			result->_useRemote();
			if (!result->_isCompatibleWith("Arts::Synth_WAVE_SOFTSAW")) {
				result->_release();
				return 0;
			}
		}
	}
	return result;
}

std::vector<std::string> Arts::Synth_WAVE_SOFTSAW_base::_defaultPortsIn() const {
	std::vector<std::string> ret;
	ret.push_back("pos");
	return ret;
}
std::vector<std::string> Arts::Synth_WAVE_SOFTSAW_base::_defaultPortsOut() const {
	std::vector<std::string> ret;
	ret.push_back("outvalue");
	return ret;
}

void *Arts::Synth_WAVE_SOFTSAW_base::_cast(unsigned long iid)
{
	if(iid == Arts::Synth_WAVE_SOFTSAW_base::_IID) return (Arts::Synth_WAVE_SOFTSAW_base *)this;
	if(iid == Arts::SynthModule_base::_IID) return (Arts::SynthModule_base *)this;
	if(iid == Arts::Object_base::_IID) return (Arts::Object_base *)this;
	return 0;
}

Arts::Synth_WAVE_SOFTSAW_stub::Synth_WAVE_SOFTSAW_stub()
{
	// constructor for subclasses (don't use directly)
}

Arts::Synth_WAVE_SOFTSAW_stub::Synth_WAVE_SOFTSAW_stub(Arts::Connection *connection, long objectID)
	: Arts::Object_stub(connection, objectID)
{
	// constructor to create a stub for an object
}

std::string Arts::Synth_WAVE_SOFTSAW_skel::_interfaceName()
{
	return "Arts::Synth_WAVE_SOFTSAW";
}

bool Arts::Synth_WAVE_SOFTSAW_skel::_isCompatibleWith(const std::string& interfacename)
{
	if (interfacename == "Arts::Synth_WAVE_SOFTSAW") return true;
	if (interfacename == "Arts::SynthModule") return true;
	if (interfacename == "Arts::Object") return true;
	return false;
}

std::string Arts::Synth_WAVE_SOFTSAW_skel::_interfaceNameSkel()
{
	return "Arts::Synth_WAVE_SOFTSAW";
}

void Arts::Synth_WAVE_SOFTSAW_skel::_buildMethodTable()
{
	Arts::Buffer m;
	m.fromString(
        "MethodTable:",
		"MethodTable"
	);
	Arts::SynthModule_skel::_buildMethodTable();
}

Arts::Synth_WAVE_SOFTSAW_skel::Synth_WAVE_SOFTSAW_skel()
{
	_initStream("pos",&pos,9);
	_initStream("outvalue",&outvalue,10);
}

Arts::Object_base* Arts::Synth_WAVE_SOFTSAW::_Creator() {
	return Arts::Synth_WAVE_SOFTSAW_base::_create();
}

unsigned long Arts::Synth_WAVE_SOFTSAW_base::_IID = Arts::MCOPUtils::makeIID("Arts::Synth_WAVE_SOFTSAW");

Arts::Synth_WAVE_PULSE_base *Arts::Synth_WAVE_PULSE_base::_create(const std::string& subClass)
{
	Arts::Object_skel *skel = Arts::ObjectManager::the()->create(subClass);
	assert(skel);
	Arts::Synth_WAVE_PULSE_base *castedObject = (Arts::Synth_WAVE_PULSE_base *)skel->_cast(Arts::Synth_WAVE_PULSE_base::_IID);
	assert(castedObject);
	return castedObject;
}

Arts::Synth_WAVE_PULSE_base *Arts::Synth_WAVE_PULSE_base::_fromString(const std::string& objectref)
{
	Arts::ObjectReference r;

	if(Arts::Dispatcher::the()->stringToObjectReference(r,objectref))
		return Arts::Synth_WAVE_PULSE_base::_fromReference(r,true);
	return 0;
}

Arts::Synth_WAVE_PULSE_base *Arts::Synth_WAVE_PULSE_base::_fromDynamicCast(const Arts::Object& object)
{
	if(object.isNull()) return 0;

	Arts::Synth_WAVE_PULSE_base *castedObject = (Arts::Synth_WAVE_PULSE_base *)object._base()->_cast(Arts::Synth_WAVE_PULSE_base::_IID);
	if(castedObject) return castedObject->_copy();

	return _fromString(object._toString());
}

Arts::Synth_WAVE_PULSE_base *Arts::Synth_WAVE_PULSE_base::_fromReference(Arts::ObjectReference r, bool needcopy)
{
	Arts::Synth_WAVE_PULSE_base *result;
	result = (Arts::Synth_WAVE_PULSE_base *)Arts::Dispatcher::the()->connectObjectLocal(r,"Arts::Synth_WAVE_PULSE");
	if(result)
	{
		if(!needcopy)
			result->_cancelCopyRemote();
	}
	else
	{
		Arts::Connection *conn = Arts::Dispatcher::the()->connectObjectRemote(r);
		if(conn)
		{
			result = new Arts::Synth_WAVE_PULSE_stub(conn,r.objectID);
			if(needcopy) result->_copyRemote();
			result->_useRemote();
			if (!result->_isCompatibleWith("Arts::Synth_WAVE_PULSE")) {
				result->_release();
				return 0;
			}
		}
	}
	return result;
}

std::vector<std::string> Arts::Synth_WAVE_PULSE_base::_defaultPortsIn() const {
	std::vector<std::string> ret;
	ret.push_back("pos");
	return ret;
}
std::vector<std::string> Arts::Synth_WAVE_PULSE_base::_defaultPortsOut() const {
	std::vector<std::string> ret;
	ret.push_back("outvalue");
	return ret;
}

void *Arts::Synth_WAVE_PULSE_base::_cast(unsigned long iid)
{
	if(iid == Arts::Synth_WAVE_PULSE_base::_IID) return (Arts::Synth_WAVE_PULSE_base *)this;
	if(iid == Arts::SynthModule_base::_IID) return (Arts::SynthModule_base *)this;
	if(iid == Arts::Object_base::_IID) return (Arts::Object_base *)this;
	return 0;
}

Arts::Synth_WAVE_PULSE_stub::Synth_WAVE_PULSE_stub()
{
	// constructor for subclasses (don't use directly)
}

Arts::Synth_WAVE_PULSE_stub::Synth_WAVE_PULSE_stub(Arts::Connection *connection, long objectID)
	: Arts::Object_stub(connection, objectID)
{
	// constructor to create a stub for an object
}

float Arts::Synth_WAVE_PULSE_stub::dutycycle()
{
	long methodID = _lookupMethodFast("method:0000000f5f6765745f647574796379636c650000000006666c6f617400000000020000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(!result) return 0.0; // error occurred
	float returnCode = result->readFloat();
	delete result;
	return returnCode;
}

void Arts::Synth_WAVE_PULSE_stub::dutycycle(float newValue)
{
	long methodID = _lookupMethodFast("method:0000000f5f7365745f647574796379636c650000000005766f696400000000020000000100000006666c6f617400000000096e657756616c7565000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->writeFloat(newValue);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(result) delete result;
}

std::string Arts::Synth_WAVE_PULSE_skel::_interfaceName()
{
	return "Arts::Synth_WAVE_PULSE";
}

bool Arts::Synth_WAVE_PULSE_skel::_isCompatibleWith(const std::string& interfacename)
{
	if (interfacename == "Arts::Synth_WAVE_PULSE") return true;
	if (interfacename == "Arts::SynthModule") return true;
	if (interfacename == "Arts::Object") return true;
	return false;
}

std::string Arts::Synth_WAVE_PULSE_skel::_interfaceNameSkel()
{
	return "Arts::Synth_WAVE_PULSE";
}

// _get_dutycycle
static void _dispatch_Arts_Synth_WAVE_PULSE_00(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeFloat(((Arts::Synth_WAVE_PULSE_skel *)object)->dutycycle());
}

// _set_dutycycle
static void _dispatch_Arts_Synth_WAVE_PULSE_01(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	float newValue = request->readFloat();
	((Arts::Synth_WAVE_PULSE_skel *)object)->dutycycle(newValue);
}

void Arts::Synth_WAVE_PULSE_skel::_buildMethodTable()
{
	Arts::Buffer m;
	m.fromString(
        "MethodTable:0000000f5f6765745f647574796379636c650000000006666c6f61"
        "74000000000200000000000000000000000f5f7365745f647574796379636c6500"
        "00000005766f696400000000020000000100000006666c6f617400000000096e65"
        "7756616c7565000000000000000000",
		"MethodTable"
	);
	_addMethod(_dispatch_Arts_Synth_WAVE_PULSE_00,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_WAVE_PULSE_01,this,Arts::MethodDef(m));
	Arts::SynthModule_skel::_buildMethodTable();
}

Arts::Synth_WAVE_PULSE_skel::Synth_WAVE_PULSE_skel()
{
	_initStream("pos",&pos,9);
	_initStream("outvalue",&outvalue,10);
}

Arts::Object_base* Arts::Synth_WAVE_PULSE::_Creator() {
	return Arts::Synth_WAVE_PULSE_base::_create();
}

unsigned long Arts::Synth_WAVE_PULSE_base::_IID = Arts::MCOPUtils::makeIID("Arts::Synth_WAVE_PULSE");

Arts::Synth_OSC_base *Arts::Synth_OSC_base::_create(const std::string& subClass)
{
	Arts::Object_skel *skel = Arts::ObjectManager::the()->create(subClass);
	assert(skel);
	Arts::Synth_OSC_base *castedObject = (Arts::Synth_OSC_base *)skel->_cast(Arts::Synth_OSC_base::_IID);
	assert(castedObject);
	return castedObject;
}

Arts::Synth_OSC_base *Arts::Synth_OSC_base::_fromString(const std::string& objectref)
{
	Arts::ObjectReference r;

	if(Arts::Dispatcher::the()->stringToObjectReference(r,objectref))
		return Arts::Synth_OSC_base::_fromReference(r,true);
	return 0;
}

Arts::Synth_OSC_base *Arts::Synth_OSC_base::_fromDynamicCast(const Arts::Object& object)
{
	if(object.isNull()) return 0;

	Arts::Synth_OSC_base *castedObject = (Arts::Synth_OSC_base *)object._base()->_cast(Arts::Synth_OSC_base::_IID);
	if(castedObject) return castedObject->_copy();

	return _fromString(object._toString());
}

Arts::Synth_OSC_base *Arts::Synth_OSC_base::_fromReference(Arts::ObjectReference r, bool needcopy)
{
	Arts::Synth_OSC_base *result;
	result = (Arts::Synth_OSC_base *)Arts::Dispatcher::the()->connectObjectLocal(r,"Arts::Synth_OSC");
	if(result)
	{
		if(!needcopy)
			result->_cancelCopyRemote();
	}
	else
	{
		Arts::Connection *conn = Arts::Dispatcher::the()->connectObjectRemote(r);
		if(conn)
		{
			result = new Arts::Synth_OSC_stub(conn,r.objectID);
			if(needcopy) result->_copyRemote();
			result->_useRemote();
			if (!result->_isCompatibleWith("Arts::Synth_OSC")) {
				result->_release();
				return 0;
			}
		}
	}
	return result;
}

std::vector<std::string> Arts::Synth_OSC_base::_defaultPortsIn() const {
	std::vector<std::string> ret;
	return ret;
}
std::vector<std::string> Arts::Synth_OSC_base::_defaultPortsOut() const {
	std::vector<std::string> ret;
	return ret;
}

void *Arts::Synth_OSC_base::_cast(unsigned long iid)
{
	if(iid == Arts::Synth_OSC_base::_IID) return (Arts::Synth_OSC_base *)this;
	if(iid == Arts::SynthModule_base::_IID) return (Arts::SynthModule_base *)this;
	if(iid == Arts::Object_base::_IID) return (Arts::Object_base *)this;
	return 0;
}

Arts::Synth_OSC_stub::Synth_OSC_stub()
{
	// constructor for subclasses (don't use directly)
}

Arts::Synth_OSC_stub::Synth_OSC_stub(Arts::Connection *connection, long objectID)
	: Arts::Object_stub(connection, objectID)
{
	// constructor to create a stub for an object
}

Arts::SynthOscWaveForm Arts::Synth_OSC_stub::waveForm()
{
	long methodID = _lookupMethodFast("method:0000000e5f6765745f77617665466f726d0000000017417274733a3a53796e74684f736357617665466f726d00000000020000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(!result) return (Arts::SynthOscWaveForm)0; // error occurred
	Arts::SynthOscWaveForm returnCode = (Arts::SynthOscWaveForm)result->readLong();
	delete result;
	return returnCode;
}

void Arts::Synth_OSC_stub::waveForm(Arts::SynthOscWaveForm newValue)
{
	long methodID = _lookupMethodFast("method:0000000e5f7365745f77617665466f726d0000000005766f696400000000020000000100000017417274733a3a53796e74684f736357617665466f726d00000000096e657756616c7565000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->writeLong(newValue);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(result) delete result;
}

bool Arts::Synth_OSC_stub::fmExponential()
{
	long methodID = _lookupMethodFast("method:000000135f6765745f666d4578706f6e656e7469616c0000000008626f6f6c65616e00000000020000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(!result) return false; // error occurred
	bool returnCode = result->readBool();
	delete result;
	return returnCode;
}

void Arts::Synth_OSC_stub::fmExponential(bool newValue)
{
	long methodID = _lookupMethodFast("method:000000135f7365745f666d4578706f6e656e7469616c0000000005766f696400000000020000000100000008626f6f6c65616e00000000096e657756616c7565000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->writeBool(newValue);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(result) delete result;
}

float Arts::Synth_OSC_stub::fmStrength()
{
	long methodID = _lookupMethodFast("method:000000105f6765745f666d537472656e6774680000000006666c6f617400000000020000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(!result) return 0.0; // error occurred
	float returnCode = result->readFloat();
	delete result;
	return returnCode;
}

void Arts::Synth_OSC_stub::fmStrength(float newValue)
{
	long methodID = _lookupMethodFast("method:000000105f7365745f666d537472656e6774680000000005766f696400000000020000000100000006666c6f617400000000096e657756616c7565000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->writeFloat(newValue);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(result) delete result;
}

float Arts::Synth_OSC_stub::fmSelfStrength()
{
	long methodID = _lookupMethodFast("method:000000145f6765745f666d53656c66537472656e6774680000000006666c6f617400000000020000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(!result) return 0.0; // error occurred
	float returnCode = result->readFloat();
	delete result;
	return returnCode;
}

void Arts::Synth_OSC_stub::fmSelfStrength(float newValue)
{
	long methodID = _lookupMethodFast("method:000000145f7365745f666d53656c66537472656e6774680000000005766f696400000000020000000100000006666c6f617400000000096e657756616c7565000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->writeFloat(newValue);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(result) delete result;
}

float Arts::Synth_OSC_stub::phase()
{
	long methodID = _lookupMethodFast("method:0000000b5f6765745f70686173650000000006666c6f617400000000020000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(!result) return 0.0; // error occurred
	float returnCode = result->readFloat();
	delete result;
	return returnCode;
}

void Arts::Synth_OSC_stub::phase(float newValue)
{
	long methodID = _lookupMethodFast("method:0000000b5f7365745f70686173650000000005766f696400000000020000000100000006666c6f617400000000096e657756616c7565000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->writeFloat(newValue);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(result) delete result;
}

float Arts::Synth_OSC_stub::frequency()
{
	long methodID = _lookupMethodFast("method:0000000f5f6765745f6672657175656e63790000000006666c6f617400000000020000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(!result) return 0.0; // error occurred
	float returnCode = result->readFloat();
	delete result;
	return returnCode;
}

void Arts::Synth_OSC_stub::frequency(float newValue)
{
	long methodID = _lookupMethodFast("method:0000000f5f7365745f6672657175656e63790000000005766f696400000000020000000100000006666c6f617400000000096e657756616c7565000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->writeFloat(newValue);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(result) delete result;
}

long Arts::Synth_OSC_stub::fineTune()
{
	long methodID = _lookupMethodFast("method:0000000e5f6765745f66696e6554756e6500000000056c6f6e6700000000020000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(!result) return 0; // error occurred
	long returnCode = result->readLong();
	delete result;
	return returnCode;
}

void Arts::Synth_OSC_stub::fineTune(long newValue)
{
	long methodID = _lookupMethodFast("method:0000000e5f7365745f66696e6554756e650000000005766f6964000000000200000001000000056c6f6e6700000000096e657756616c7565000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->writeLong(newValue);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(result) delete result;
}

float Arts::Synth_OSC_stub::pulseWidth()
{
	long methodID = _lookupMethodFast("method:000000105f6765745f70756c736557696474680000000006666c6f617400000000020000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(!result) return 0.0; // error occurred
	float returnCode = result->readFloat();
	delete result;
	return returnCode;
}

void Arts::Synth_OSC_stub::pulseWidth(float newValue)
{
	long methodID = _lookupMethodFast("method:000000105f7365745f70756c736557696474680000000005766f696400000000020000000100000006666c6f617400000000096e657756616c7565000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->writeFloat(newValue);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(result) delete result;
}

float Arts::Synth_OSC_stub::pulseModStrength()
{
	long methodID = _lookupMethodFast("method:000000165f6765745f70756c73654d6f64537472656e6774680000000006666c6f617400000000020000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(!result) return 0.0; // error occurred
	float returnCode = result->readFloat();
	delete result;
	return returnCode;
}

void Arts::Synth_OSC_stub::pulseModStrength(float newValue)
{
	long methodID = _lookupMethodFast("method:000000165f7365745f70756c73654d6f64537472656e6774680000000005766f696400000000020000000100000006666c6f617400000000096e657756616c7565000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->writeFloat(newValue);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(result) delete result;
}

std::string Arts::Synth_OSC_skel::_interfaceName()
{
	return "Arts::Synth_OSC";
}

bool Arts::Synth_OSC_skel::_isCompatibleWith(const std::string& interfacename)
{
	if (interfacename == "Arts::Synth_OSC") return true;
	if (interfacename == "Arts::SynthModule") return true;
	if (interfacename == "Arts::Object") return true;
	return false;
}

std::string Arts::Synth_OSC_skel::_interfaceNameSkel()
{
	return "Arts::Synth_OSC";
}

// _get_waveForm
static void _dispatch_Arts_Synth_OSC_00(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeLong(((Arts::Synth_OSC_skel *)object)->waveForm());
}

// _set_waveForm
static void _dispatch_Arts_Synth_OSC_01(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	Arts::SynthOscWaveForm newValue = (Arts::SynthOscWaveForm)request->readLong();
	((Arts::Synth_OSC_skel *)object)->waveForm(newValue);
}

// _get_fmExponential
static void _dispatch_Arts_Synth_OSC_02(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeBool(((Arts::Synth_OSC_skel *)object)->fmExponential());
}

// _set_fmExponential
static void _dispatch_Arts_Synth_OSC_03(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	bool newValue = request->readBool();
	((Arts::Synth_OSC_skel *)object)->fmExponential(newValue);
}

// _get_fmStrength
static void _dispatch_Arts_Synth_OSC_04(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeFloat(((Arts::Synth_OSC_skel *)object)->fmStrength());
}

// _set_fmStrength
static void _dispatch_Arts_Synth_OSC_05(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	float newValue = request->readFloat();
	((Arts::Synth_OSC_skel *)object)->fmStrength(newValue);
}

// _get_fmSelfStrength
static void _dispatch_Arts_Synth_OSC_06(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeFloat(((Arts::Synth_OSC_skel *)object)->fmSelfStrength());
}

// _set_fmSelfStrength
static void _dispatch_Arts_Synth_OSC_07(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	float newValue = request->readFloat();
	((Arts::Synth_OSC_skel *)object)->fmSelfStrength(newValue);
}

// _get_phase
static void _dispatch_Arts_Synth_OSC_08(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeFloat(((Arts::Synth_OSC_skel *)object)->phase());
}

// _set_phase
static void _dispatch_Arts_Synth_OSC_09(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	float newValue = request->readFloat();
	((Arts::Synth_OSC_skel *)object)->phase(newValue);
}

// _get_frequency
static void _dispatch_Arts_Synth_OSC_10(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeFloat(((Arts::Synth_OSC_skel *)object)->frequency());
}

// _set_frequency
static void _dispatch_Arts_Synth_OSC_11(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	float newValue = request->readFloat();
	((Arts::Synth_OSC_skel *)object)->frequency(newValue);
}

// _get_fineTune
static void _dispatch_Arts_Synth_OSC_12(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeLong(((Arts::Synth_OSC_skel *)object)->fineTune());
}

// _set_fineTune
static void _dispatch_Arts_Synth_OSC_13(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	long newValue = request->readLong();
	((Arts::Synth_OSC_skel *)object)->fineTune(newValue);
}

// _get_pulseWidth
static void _dispatch_Arts_Synth_OSC_14(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeFloat(((Arts::Synth_OSC_skel *)object)->pulseWidth());
}

// _set_pulseWidth
static void _dispatch_Arts_Synth_OSC_15(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	float newValue = request->readFloat();
	((Arts::Synth_OSC_skel *)object)->pulseWidth(newValue);
}

// _get_pulseModStrength
static void _dispatch_Arts_Synth_OSC_16(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeFloat(((Arts::Synth_OSC_skel *)object)->pulseModStrength());
}

// _set_pulseModStrength
static void _dispatch_Arts_Synth_OSC_17(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	float newValue = request->readFloat();
	((Arts::Synth_OSC_skel *)object)->pulseModStrength(newValue);
}

void Arts::Synth_OSC_skel::_buildMethodTable()
{
	Arts::Buffer m;
	m.fromString(
        "MethodTable:0000000e5f6765745f77617665466f726d0000000017417274733a"
        "3a53796e74684f736357617665466f726d00000000020000000000000000000000"
        "0e5f7365745f77617665466f726d0000000005766f696400000000020000000100"
        "000017417274733a3a53796e74684f736357617665466f726d00000000096e6577"
        "56616c7565000000000000000000000000135f6765745f666d4578706f6e656e74"
        "69616c0000000008626f6f6c65616e00000000020000000000000000000000135f"
        "7365745f666d4578706f6e656e7469616c0000000005766f696400000000020000"
        "000100000008626f6f6c65616e00000000096e657756616c756500000000000000"
        "0000000000105f6765745f666d537472656e6774680000000006666c6f61740000"
        "0000020000000000000000000000105f7365745f666d537472656e677468000000"
        "0005766f696400000000020000000100000006666c6f617400000000096e657756"
        "616c7565000000000000000000000000145f6765745f666d53656c66537472656e"
        "6774680000000006666c6f617400000000020000000000000000000000145f7365"
        "745f666d53656c66537472656e6774680000000005766f69640000000002000000"
        "0100000006666c6f617400000000096e657756616c756500000000000000000000"
        "00000b5f6765745f70686173650000000006666c6f617400000000020000000000"
        "0000000000000b5f7365745f70686173650000000005766f696400000000020000"
        "000100000006666c6f617400000000096e657756616c7565000000000000000000"
        "0000000f5f6765745f6672657175656e63790000000006666c6f61740000000002"
        "00000000000000000000000f5f7365745f6672657175656e63790000000005766f"
        "696400000000020000000100000006666c6f617400000000096e657756616c7565"
        "0000000000000000000000000e5f6765745f66696e6554756e6500000000056c6f"
        "6e67000000000200000000000000000000000e5f7365745f66696e6554756e6500"
        "00000005766f6964000000000200000001000000056c6f6e6700000000096e6577"
        "56616c7565000000000000000000000000105f6765745f70756c73655769647468"
        "0000000006666c6f617400000000020000000000000000000000105f7365745f70"
        "756c736557696474680000000005766f696400000000020000000100000006666c"
        "6f617400000000096e657756616c7565000000000000000000000000165f676574"
        "5f70756c73654d6f64537472656e6774680000000006666c6f6174000000000200"
        "00000000000000000000165f7365745f70756c73654d6f64537472656e67746800"
        "00000005766f696400000000020000000100000006666c6f617400000000096e65"
        "7756616c7565000000000000000000",
		"MethodTable"
	);
	_addMethod(_dispatch_Arts_Synth_OSC_00,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_OSC_01,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_OSC_02,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_OSC_03,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_OSC_04,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_OSC_05,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_OSC_06,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_OSC_07,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_OSC_08,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_OSC_09,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_OSC_10,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_OSC_11,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_OSC_12,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_OSC_13,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_OSC_14,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_OSC_15,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_OSC_16,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_OSC_17,this,Arts::MethodDef(m));
	Arts::SynthModule_skel::_buildMethodTable();
}

Arts::Synth_OSC_skel::Synth_OSC_skel()
{
	_initStream("infrequency",&infrequency,9);
	_initStream("modulation",&modulation,9);
	_initStream("inpwm",&inpwm,9);
	_initStream("insync",&insync,9);
	_initStream("outvalue",&outvalue,10);
	_initStream("outsync",&outsync,10);
}

Arts::Object_base* Arts::Synth_OSC::_Creator() {
	return Arts::Synth_OSC_base::_create();
}

unsigned long Arts::Synth_OSC_base::_IID = Arts::MCOPUtils::makeIID("Arts::Synth_OSC");

Arts::Synth_PLAY_PAT_base *Arts::Synth_PLAY_PAT_base::_create(const std::string& subClass)
{
	Arts::Object_skel *skel = Arts::ObjectManager::the()->create(subClass);
	assert(skel);
	Arts::Synth_PLAY_PAT_base *castedObject = (Arts::Synth_PLAY_PAT_base *)skel->_cast(Arts::Synth_PLAY_PAT_base::_IID);
	assert(castedObject);
	return castedObject;
}

Arts::Synth_PLAY_PAT_base *Arts::Synth_PLAY_PAT_base::_fromString(const std::string& objectref)
{
	Arts::ObjectReference r;

	if(Arts::Dispatcher::the()->stringToObjectReference(r,objectref))
		return Arts::Synth_PLAY_PAT_base::_fromReference(r,true);
	return 0;
}

Arts::Synth_PLAY_PAT_base *Arts::Synth_PLAY_PAT_base::_fromDynamicCast(const Arts::Object& object)
{
	if(object.isNull()) return 0;

	Arts::Synth_PLAY_PAT_base *castedObject = (Arts::Synth_PLAY_PAT_base *)object._base()->_cast(Arts::Synth_PLAY_PAT_base::_IID);
	if(castedObject) return castedObject->_copy();

	return _fromString(object._toString());
}

Arts::Synth_PLAY_PAT_base *Arts::Synth_PLAY_PAT_base::_fromReference(Arts::ObjectReference r, bool needcopy)
{
	Arts::Synth_PLAY_PAT_base *result;
	result = (Arts::Synth_PLAY_PAT_base *)Arts::Dispatcher::the()->connectObjectLocal(r,"Arts::Synth_PLAY_PAT");
	if(result)
	{
		if(!needcopy)
			result->_cancelCopyRemote();
	}
	else
	{
		Arts::Connection *conn = Arts::Dispatcher::the()->connectObjectRemote(r);
		if(conn)
		{
			result = new Arts::Synth_PLAY_PAT_stub(conn,r.objectID);
			if(needcopy) result->_copyRemote();
			result->_useRemote();
			if (!result->_isCompatibleWith("Arts::Synth_PLAY_PAT")) {
				result->_release();
				return 0;
			}
		}
	}
	return result;
}

std::vector<std::string> Arts::Synth_PLAY_PAT_base::_defaultPortsIn() const {
	std::vector<std::string> ret;
	ret.push_back("frequency");
	return ret;
}
std::vector<std::string> Arts::Synth_PLAY_PAT_base::_defaultPortsOut() const {
	std::vector<std::string> ret;
	ret.push_back("outvalue");
	return ret;
}

void *Arts::Synth_PLAY_PAT_base::_cast(unsigned long iid)
{
	if(iid == Arts::Synth_PLAY_PAT_base::_IID) return (Arts::Synth_PLAY_PAT_base *)this;
	if(iid == Arts::SynthModule_base::_IID) return (Arts::SynthModule_base *)this;
	if(iid == Arts::Object_base::_IID) return (Arts::Object_base *)this;
	return 0;
}

Arts::Synth_PLAY_PAT_stub::Synth_PLAY_PAT_stub()
{
	// constructor for subclasses (don't use directly)
}

Arts::Synth_PLAY_PAT_stub::Synth_PLAY_PAT_stub(Arts::Connection *connection, long objectID)
	: Arts::Object_stub(connection, objectID)
{
	// constructor to create a stub for an object
}

std::string Arts::Synth_PLAY_PAT_stub::filename()
{
	long methodID = _lookupMethodFast("method:0000000e5f6765745f66696c656e616d650000000007737472696e6700000000020000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(!result) return""; // error occurred
	std::string returnCode;
	result->readString(returnCode);
	delete result;
	return returnCode;
}

void Arts::Synth_PLAY_PAT_stub::filename(const std::string& newValue)
{
	long methodID = _lookupMethodFast("method:0000000e5f7365745f66696c656e616d650000000005766f696400000000020000000100000007737472696e6700000000096e657756616c7565000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->writeString(newValue);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(result) delete result;
}

std::string Arts::Synth_PLAY_PAT_skel::_interfaceName()
{
	return "Arts::Synth_PLAY_PAT";
}

bool Arts::Synth_PLAY_PAT_skel::_isCompatibleWith(const std::string& interfacename)
{
	if (interfacename == "Arts::Synth_PLAY_PAT") return true;
	if (interfacename == "Arts::SynthModule") return true;
	if (interfacename == "Arts::Object") return true;
	return false;
}

std::string Arts::Synth_PLAY_PAT_skel::_interfaceNameSkel()
{
	return "Arts::Synth_PLAY_PAT";
}

// _get_filename
static void _dispatch_Arts_Synth_PLAY_PAT_00(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeString(((Arts::Synth_PLAY_PAT_skel *)object)->filename());
}

// _set_filename
static void _dispatch_Arts_Synth_PLAY_PAT_01(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	std::string newValue;
	request->readString(newValue);
	((Arts::Synth_PLAY_PAT_skel *)object)->filename(newValue);
}

void Arts::Synth_PLAY_PAT_skel::_buildMethodTable()
{
	Arts::Buffer m;
	m.fromString(
        "MethodTable:0000000e5f6765745f66696c656e616d650000000007737472696e"
        "67000000000200000000000000000000000e5f7365745f66696c656e616d650000"
        "000005766f696400000000020000000100000007737472696e6700000000096e65"
        "7756616c7565000000000000000000",
		"MethodTable"
	);
	_addMethod(_dispatch_Arts_Synth_PLAY_PAT_00,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_PLAY_PAT_01,this,Arts::MethodDef(m));
	Arts::SynthModule_skel::_buildMethodTable();
}

Arts::Synth_PLAY_PAT_skel::Synth_PLAY_PAT_skel()
{
	_initStream("frequency",&frequency,9);
	_initStream("outvalue",&outvalue,10);
}

Arts::Object_base* Arts::Synth_PLAY_PAT::_Creator() {
	return Arts::Synth_PLAY_PAT_base::_create();
}

unsigned long Arts::Synth_PLAY_PAT_base::_IID = Arts::MCOPUtils::makeIID("Arts::Synth_PLAY_PAT");

Arts::Synth_CAPTURE_WAV_base *Arts::Synth_CAPTURE_WAV_base::_create(const std::string& subClass)
{
	Arts::Object_skel *skel = Arts::ObjectManager::the()->create(subClass);
	assert(skel);
	Arts::Synth_CAPTURE_WAV_base *castedObject = (Arts::Synth_CAPTURE_WAV_base *)skel->_cast(Arts::Synth_CAPTURE_WAV_base::_IID);
	assert(castedObject);
	return castedObject;
}

Arts::Synth_CAPTURE_WAV_base *Arts::Synth_CAPTURE_WAV_base::_fromString(const std::string& objectref)
{
	Arts::ObjectReference r;

	if(Arts::Dispatcher::the()->stringToObjectReference(r,objectref))
		return Arts::Synth_CAPTURE_WAV_base::_fromReference(r,true);
	return 0;
}

Arts::Synth_CAPTURE_WAV_base *Arts::Synth_CAPTURE_WAV_base::_fromDynamicCast(const Arts::Object& object)
{
	if(object.isNull()) return 0;

	Arts::Synth_CAPTURE_WAV_base *castedObject = (Arts::Synth_CAPTURE_WAV_base *)object._base()->_cast(Arts::Synth_CAPTURE_WAV_base::_IID);
	if(castedObject) return castedObject->_copy();

	return _fromString(object._toString());
}

Arts::Synth_CAPTURE_WAV_base *Arts::Synth_CAPTURE_WAV_base::_fromReference(Arts::ObjectReference r, bool needcopy)
{
	Arts::Synth_CAPTURE_WAV_base *result;
	result = (Arts::Synth_CAPTURE_WAV_base *)Arts::Dispatcher::the()->connectObjectLocal(r,"Arts::Synth_CAPTURE_WAV");
	if(result)
	{
		if(!needcopy)
			result->_cancelCopyRemote();
	}
	else
	{
		Arts::Connection *conn = Arts::Dispatcher::the()->connectObjectRemote(r);
		if(conn)
		{
			result = new Arts::Synth_CAPTURE_WAV_stub(conn,r.objectID);
			if(needcopy) result->_copyRemote();
			result->_useRemote();
			if (!result->_isCompatibleWith("Arts::Synth_CAPTURE_WAV")) {
				result->_release();
				return 0;
			}
		}
	}
	return result;
}

std::vector<std::string> Arts::Synth_CAPTURE_WAV_base::_defaultPortsIn() const {
	std::vector<std::string> ret;
	ret.push_back("left");
	ret.push_back("right");
	return ret;
}
std::vector<std::string> Arts::Synth_CAPTURE_WAV_base::_defaultPortsOut() const {
	std::vector<std::string> ret;
	return ret;
}

void *Arts::Synth_CAPTURE_WAV_base::_cast(unsigned long iid)
{
	if(iid == Arts::Synth_CAPTURE_WAV_base::_IID) return (Arts::Synth_CAPTURE_WAV_base *)this;
	if(iid == Arts::SynthModule_base::_IID) return (Arts::SynthModule_base *)this;
	if(iid == Arts::Object_base::_IID) return (Arts::Object_base *)this;
	return 0;
}

Arts::Synth_CAPTURE_WAV_stub::Synth_CAPTURE_WAV_stub()
{
	// constructor for subclasses (don't use directly)
}

Arts::Synth_CAPTURE_WAV_stub::Synth_CAPTURE_WAV_stub(Arts::Connection *connection, long objectID)
	: Arts::Object_stub(connection, objectID)
{
	// constructor to create a stub for an object
}

std::string Arts::Synth_CAPTURE_WAV_stub::filename()
{
	long methodID = _lookupMethodFast("method:0000000e5f6765745f66696c656e616d650000000007737472696e6700000000020000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(!result) return""; // error occurred
	std::string returnCode;
	result->readString(returnCode);
	delete result;
	return returnCode;
}

void Arts::Synth_CAPTURE_WAV_stub::filename(const std::string& newValue)
{
	long methodID = _lookupMethodFast("method:0000000e5f7365745f66696c656e616d650000000005766f696400000000020000000100000007737472696e6700000000096e657756616c7565000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->writeString(newValue);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(result) delete result;
}

std::string Arts::Synth_CAPTURE_WAV_skel::_interfaceName()
{
	return "Arts::Synth_CAPTURE_WAV";
}

bool Arts::Synth_CAPTURE_WAV_skel::_isCompatibleWith(const std::string& interfacename)
{
	if (interfacename == "Arts::Synth_CAPTURE_WAV") return true;
	if (interfacename == "Arts::SynthModule") return true;
	if (interfacename == "Arts::Object") return true;
	return false;
}

std::string Arts::Synth_CAPTURE_WAV_skel::_interfaceNameSkel()
{
	return "Arts::Synth_CAPTURE_WAV";
}

// _get_filename
static void _dispatch_Arts_Synth_CAPTURE_WAV_00(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeString(((Arts::Synth_CAPTURE_WAV_skel *)object)->filename());
}

// _set_filename
static void _dispatch_Arts_Synth_CAPTURE_WAV_01(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	std::string newValue;
	request->readString(newValue);
	((Arts::Synth_CAPTURE_WAV_skel *)object)->filename(newValue);
}

void Arts::Synth_CAPTURE_WAV_skel::_buildMethodTable()
{
	Arts::Buffer m;
	m.fromString(
        "MethodTable:0000000e5f6765745f66696c656e616d650000000007737472696e"
        "67000000000200000000000000000000000e5f7365745f66696c656e616d650000"
        "000005766f696400000000020000000100000007737472696e6700000000096e65"
        "7756616c7565000000000000000000",
		"MethodTable"
	);
	_addMethod(_dispatch_Arts_Synth_CAPTURE_WAV_00,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_CAPTURE_WAV_01,this,Arts::MethodDef(m));
	Arts::SynthModule_skel::_buildMethodTable();
}

Arts::Synth_CAPTURE_WAV_skel::Synth_CAPTURE_WAV_skel()
{
	_initStream("left",&left,73);
	_initStream("right",&right,73);
}

Arts::Object_base* Arts::Synth_CAPTURE_WAV::_Creator() {
	return Arts::Synth_CAPTURE_WAV_base::_create();
}

unsigned long Arts::Synth_CAPTURE_WAV_base::_IID = Arts::MCOPUtils::makeIID("Arts::Synth_CAPTURE_WAV");

Arts::Synth_NIL_base *Arts::Synth_NIL_base::_create(const std::string& subClass)
{
	Arts::Object_skel *skel = Arts::ObjectManager::the()->create(subClass);
	assert(skel);
	Arts::Synth_NIL_base *castedObject = (Arts::Synth_NIL_base *)skel->_cast(Arts::Synth_NIL_base::_IID);
	assert(castedObject);
	return castedObject;
}

Arts::Synth_NIL_base *Arts::Synth_NIL_base::_fromString(const std::string& objectref)
{
	Arts::ObjectReference r;

	if(Arts::Dispatcher::the()->stringToObjectReference(r,objectref))
		return Arts::Synth_NIL_base::_fromReference(r,true);
	return 0;
}

Arts::Synth_NIL_base *Arts::Synth_NIL_base::_fromDynamicCast(const Arts::Object& object)
{
	if(object.isNull()) return 0;

	Arts::Synth_NIL_base *castedObject = (Arts::Synth_NIL_base *)object._base()->_cast(Arts::Synth_NIL_base::_IID);
	if(castedObject) return castedObject->_copy();

	return _fromString(object._toString());
}

Arts::Synth_NIL_base *Arts::Synth_NIL_base::_fromReference(Arts::ObjectReference r, bool needcopy)
{
	Arts::Synth_NIL_base *result;
	result = (Arts::Synth_NIL_base *)Arts::Dispatcher::the()->connectObjectLocal(r,"Arts::Synth_NIL");
	if(result)
	{
		if(!needcopy)
			result->_cancelCopyRemote();
	}
	else
	{
		Arts::Connection *conn = Arts::Dispatcher::the()->connectObjectRemote(r);
		if(conn)
		{
			result = new Arts::Synth_NIL_stub(conn,r.objectID);
			if(needcopy) result->_copyRemote();
			result->_useRemote();
			if (!result->_isCompatibleWith("Arts::Synth_NIL")) {
				result->_release();
				return 0;
			}
		}
	}
	return result;
}

std::vector<std::string> Arts::Synth_NIL_base::_defaultPortsIn() const {
	std::vector<std::string> ret;
	return ret;
}
std::vector<std::string> Arts::Synth_NIL_base::_defaultPortsOut() const {
	std::vector<std::string> ret;
	return ret;
}

void *Arts::Synth_NIL_base::_cast(unsigned long iid)
{
	if(iid == Arts::Synth_NIL_base::_IID) return (Arts::Synth_NIL_base *)this;
	if(iid == Arts::SynthModule_base::_IID) return (Arts::SynthModule_base *)this;
	if(iid == Arts::Object_base::_IID) return (Arts::Object_base *)this;
	return 0;
}

Arts::Synth_NIL_stub::Synth_NIL_stub()
{
	// constructor for subclasses (don't use directly)
}

Arts::Synth_NIL_stub::Synth_NIL_stub(Arts::Connection *connection, long objectID)
	: Arts::Object_stub(connection, objectID)
{
	// constructor to create a stub for an object
}

std::string Arts::Synth_NIL_skel::_interfaceName()
{
	return "Arts::Synth_NIL";
}

bool Arts::Synth_NIL_skel::_isCompatibleWith(const std::string& interfacename)
{
	if (interfacename == "Arts::Synth_NIL") return true;
	if (interfacename == "Arts::SynthModule") return true;
	if (interfacename == "Arts::Object") return true;
	return false;
}

std::string Arts::Synth_NIL_skel::_interfaceNameSkel()
{
	return "Arts::Synth_NIL";
}

void Arts::Synth_NIL_skel::_buildMethodTable()
{
	Arts::Buffer m;
	m.fromString(
        "MethodTable:",
		"MethodTable"
	);
	Arts::SynthModule_skel::_buildMethodTable();
}

Arts::Synth_NIL_skel::Synth_NIL_skel()
{
}

Arts::Object_base* Arts::Synth_NIL::_Creator() {
	return Arts::Synth_NIL_base::_create();
}

unsigned long Arts::Synth_NIL_base::_IID = Arts::MCOPUtils::makeIID("Arts::Synth_NIL");

Arts::Synth_DEBUG_base *Arts::Synth_DEBUG_base::_create(const std::string& subClass)
{
	Arts::Object_skel *skel = Arts::ObjectManager::the()->create(subClass);
	assert(skel);
	Arts::Synth_DEBUG_base *castedObject = (Arts::Synth_DEBUG_base *)skel->_cast(Arts::Synth_DEBUG_base::_IID);
	assert(castedObject);
	return castedObject;
}

Arts::Synth_DEBUG_base *Arts::Synth_DEBUG_base::_fromString(const std::string& objectref)
{
	Arts::ObjectReference r;

	if(Arts::Dispatcher::the()->stringToObjectReference(r,objectref))
		return Arts::Synth_DEBUG_base::_fromReference(r,true);
	return 0;
}

Arts::Synth_DEBUG_base *Arts::Synth_DEBUG_base::_fromDynamicCast(const Arts::Object& object)
{
	if(object.isNull()) return 0;

	Arts::Synth_DEBUG_base *castedObject = (Arts::Synth_DEBUG_base *)object._base()->_cast(Arts::Synth_DEBUG_base::_IID);
	if(castedObject) return castedObject->_copy();

	return _fromString(object._toString());
}

Arts::Synth_DEBUG_base *Arts::Synth_DEBUG_base::_fromReference(Arts::ObjectReference r, bool needcopy)
{
	Arts::Synth_DEBUG_base *result;
	result = (Arts::Synth_DEBUG_base *)Arts::Dispatcher::the()->connectObjectLocal(r,"Arts::Synth_DEBUG");
	if(result)
	{
		if(!needcopy)
			result->_cancelCopyRemote();
	}
	else
	{
		Arts::Connection *conn = Arts::Dispatcher::the()->connectObjectRemote(r);
		if(conn)
		{
			result = new Arts::Synth_DEBUG_stub(conn,r.objectID);
			if(needcopy) result->_copyRemote();
			result->_useRemote();
			if (!result->_isCompatibleWith("Arts::Synth_DEBUG")) {
				result->_release();
				return 0;
			}
		}
	}
	return result;
}

std::vector<std::string> Arts::Synth_DEBUG_base::_defaultPortsIn() const {
	std::vector<std::string> ret;
	ret.push_back("invalue");
	return ret;
}
std::vector<std::string> Arts::Synth_DEBUG_base::_defaultPortsOut() const {
	std::vector<std::string> ret;
	return ret;
}

void *Arts::Synth_DEBUG_base::_cast(unsigned long iid)
{
	if(iid == Arts::Synth_DEBUG_base::_IID) return (Arts::Synth_DEBUG_base *)this;
	if(iid == Arts::SynthModule_base::_IID) return (Arts::SynthModule_base *)this;
	if(iid == Arts::Object_base::_IID) return (Arts::Object_base *)this;
	return 0;
}

Arts::Synth_DEBUG_stub::Synth_DEBUG_stub()
{
	// constructor for subclasses (don't use directly)
}

Arts::Synth_DEBUG_stub::Synth_DEBUG_stub(Arts::Connection *connection, long objectID)
	: Arts::Object_stub(connection, objectID)
{
	// constructor to create a stub for an object
}

std::string Arts::Synth_DEBUG_stub::comment()
{
	long methodID = _lookupMethodFast("method:0000000d5f6765745f636f6d6d656e740000000007737472696e6700000000020000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(!result) return""; // error occurred
	std::string returnCode;
	result->readString(returnCode);
	delete result;
	return returnCode;
}

void Arts::Synth_DEBUG_stub::comment(const std::string& newValue)
{
	long methodID = _lookupMethodFast("method:0000000d5f7365745f636f6d6d656e740000000005766f696400000000020000000100000007737472696e6700000000096e657756616c7565000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->writeString(newValue);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(result) delete result;
}

std::string Arts::Synth_DEBUG_skel::_interfaceName()
{
	return "Arts::Synth_DEBUG";
}

bool Arts::Synth_DEBUG_skel::_isCompatibleWith(const std::string& interfacename)
{
	if (interfacename == "Arts::Synth_DEBUG") return true;
	if (interfacename == "Arts::SynthModule") return true;
	if (interfacename == "Arts::Object") return true;
	return false;
}

std::string Arts::Synth_DEBUG_skel::_interfaceNameSkel()
{
	return "Arts::Synth_DEBUG";
}

// _get_comment
static void _dispatch_Arts_Synth_DEBUG_00(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeString(((Arts::Synth_DEBUG_skel *)object)->comment());
}

// _set_comment
static void _dispatch_Arts_Synth_DEBUG_01(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	std::string newValue;
	request->readString(newValue);
	((Arts::Synth_DEBUG_skel *)object)->comment(newValue);
}

void Arts::Synth_DEBUG_skel::_buildMethodTable()
{
	Arts::Buffer m;
	m.fromString(
        "MethodTable:0000000d5f6765745f636f6d6d656e740000000007737472696e67"
        "000000000200000000000000000000000d5f7365745f636f6d6d656e7400000000"
        "05766f696400000000020000000100000007737472696e6700000000096e657756"
        "616c7565000000000000000000",
		"MethodTable"
	);
	_addMethod(_dispatch_Arts_Synth_DEBUG_00,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_DEBUG_01,this,Arts::MethodDef(m));
	Arts::SynthModule_skel::_buildMethodTable();
}

Arts::Synth_DEBUG_skel::Synth_DEBUG_skel()
{
	_initStream("invalue",&invalue,9);
}

Arts::Object_base* Arts::Synth_DEBUG::_Creator() {
	return Arts::Synth_DEBUG_base::_create();
}

unsigned long Arts::Synth_DEBUG_base::_IID = Arts::MCOPUtils::makeIID("Arts::Synth_DEBUG");

Arts::Synth_DATA_base *Arts::Synth_DATA_base::_create(const std::string& subClass)
{
	Arts::Object_skel *skel = Arts::ObjectManager::the()->create(subClass);
	assert(skel);
	Arts::Synth_DATA_base *castedObject = (Arts::Synth_DATA_base *)skel->_cast(Arts::Synth_DATA_base::_IID);
	assert(castedObject);
	return castedObject;
}

Arts::Synth_DATA_base *Arts::Synth_DATA_base::_fromString(const std::string& objectref)
{
	Arts::ObjectReference r;

	if(Arts::Dispatcher::the()->stringToObjectReference(r,objectref))
		return Arts::Synth_DATA_base::_fromReference(r,true);
	return 0;
}

Arts::Synth_DATA_base *Arts::Synth_DATA_base::_fromDynamicCast(const Arts::Object& object)
{
	if(object.isNull()) return 0;

	Arts::Synth_DATA_base *castedObject = (Arts::Synth_DATA_base *)object._base()->_cast(Arts::Synth_DATA_base::_IID);
	if(castedObject) return castedObject->_copy();

	return _fromString(object._toString());
}

Arts::Synth_DATA_base *Arts::Synth_DATA_base::_fromReference(Arts::ObjectReference r, bool needcopy)
{
	Arts::Synth_DATA_base *result;
	result = (Arts::Synth_DATA_base *)Arts::Dispatcher::the()->connectObjectLocal(r,"Arts::Synth_DATA");
	if(result)
	{
		if(!needcopy)
			result->_cancelCopyRemote();
	}
	else
	{
		Arts::Connection *conn = Arts::Dispatcher::the()->connectObjectRemote(r);
		if(conn)
		{
			result = new Arts::Synth_DATA_stub(conn,r.objectID);
			if(needcopy) result->_copyRemote();
			result->_useRemote();
			if (!result->_isCompatibleWith("Arts::Synth_DATA")) {
				result->_release();
				return 0;
			}
		}
	}
	return result;
}

std::vector<std::string> Arts::Synth_DATA_base::_defaultPortsIn() const {
	std::vector<std::string> ret;
	return ret;
}
std::vector<std::string> Arts::Synth_DATA_base::_defaultPortsOut() const {
	std::vector<std::string> ret;
	ret.push_back("outvalue");
	return ret;
}

void *Arts::Synth_DATA_base::_cast(unsigned long iid)
{
	if(iid == Arts::Synth_DATA_base::_IID) return (Arts::Synth_DATA_base *)this;
	if(iid == Arts::SynthModule_base::_IID) return (Arts::SynthModule_base *)this;
	if(iid == Arts::Object_base::_IID) return (Arts::Object_base *)this;
	return 0;
}

Arts::Synth_DATA_stub::Synth_DATA_stub()
{
	// constructor for subclasses (don't use directly)
}

Arts::Synth_DATA_stub::Synth_DATA_stub(Arts::Connection *connection, long objectID)
	: Arts::Object_stub(connection, objectID)
{
	// constructor to create a stub for an object
}

float Arts::Synth_DATA_stub::value()
{
	long methodID = _lookupMethodFast("method:0000000b5f6765745f76616c75650000000006666c6f617400000000020000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(!result) return 0.0; // error occurred
	float returnCode = result->readFloat();
	delete result;
	return returnCode;
}

void Arts::Synth_DATA_stub::value(float newValue)
{
	long methodID = _lookupMethodFast("method:0000000b5f7365745f76616c75650000000005766f696400000000020000000100000006666c6f617400000000096e657756616c7565000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->writeFloat(newValue);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(result) delete result;
}

std::string Arts::Synth_DATA_skel::_interfaceName()
{
	return "Arts::Synth_DATA";
}

bool Arts::Synth_DATA_skel::_isCompatibleWith(const std::string& interfacename)
{
	if (interfacename == "Arts::Synth_DATA") return true;
	if (interfacename == "Arts::SynthModule") return true;
	if (interfacename == "Arts::Object") return true;
	return false;
}

std::string Arts::Synth_DATA_skel::_interfaceNameSkel()
{
	return "Arts::Synth_DATA";
}

// _get_value
static void _dispatch_Arts_Synth_DATA_00(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeFloat(((Arts::Synth_DATA_skel *)object)->value());
}

// _set_value
static void _dispatch_Arts_Synth_DATA_01(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	float newValue = request->readFloat();
	((Arts::Synth_DATA_skel *)object)->value(newValue);
}

void Arts::Synth_DATA_skel::_buildMethodTable()
{
	Arts::Buffer m;
	m.fromString(
        "MethodTable:0000000b5f6765745f76616c75650000000006666c6f6174000000"
        "000200000000000000000000000b5f7365745f76616c75650000000005766f6964"
        "00000000020000000100000006666c6f617400000000096e657756616c75650000"
        "00000000000000",
		"MethodTable"
	);
	_addMethod(_dispatch_Arts_Synth_DATA_00,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_DATA_01,this,Arts::MethodDef(m));
	Arts::SynthModule_skel::_buildMethodTable();
}

Arts::Synth_DATA_skel::Synth_DATA_skel()
{
	_initStream("outvalue",&outvalue,10);
}

Arts::Object_base* Arts::Synth_DATA::_Creator() {
	return Arts::Synth_DATA_base::_create();
}

unsigned long Arts::Synth_DATA_base::_IID = Arts::MCOPUtils::makeIID("Arts::Synth_DATA");

Arts::Synth_MIDI_DEBUG_base *Arts::Synth_MIDI_DEBUG_base::_create(const std::string& subClass)
{
	Arts::Object_skel *skel = Arts::ObjectManager::the()->create(subClass);
	assert(skel);
	Arts::Synth_MIDI_DEBUG_base *castedObject = (Arts::Synth_MIDI_DEBUG_base *)skel->_cast(Arts::Synth_MIDI_DEBUG_base::_IID);
	assert(castedObject);
	return castedObject;
}

Arts::Synth_MIDI_DEBUG_base *Arts::Synth_MIDI_DEBUG_base::_fromString(const std::string& objectref)
{
	Arts::ObjectReference r;

	if(Arts::Dispatcher::the()->stringToObjectReference(r,objectref))
		return Arts::Synth_MIDI_DEBUG_base::_fromReference(r,true);
	return 0;
}

Arts::Synth_MIDI_DEBUG_base *Arts::Synth_MIDI_DEBUG_base::_fromDynamicCast(const Arts::Object& object)
{
	if(object.isNull()) return 0;

	Arts::Synth_MIDI_DEBUG_base *castedObject = (Arts::Synth_MIDI_DEBUG_base *)object._base()->_cast(Arts::Synth_MIDI_DEBUG_base::_IID);
	if(castedObject) return castedObject->_copy();

	return _fromString(object._toString());
}

Arts::Synth_MIDI_DEBUG_base *Arts::Synth_MIDI_DEBUG_base::_fromReference(Arts::ObjectReference r, bool needcopy)
{
	Arts::Synth_MIDI_DEBUG_base *result;
	result = (Arts::Synth_MIDI_DEBUG_base *)Arts::Dispatcher::the()->connectObjectLocal(r,"Arts::Synth_MIDI_DEBUG");
	if(result)
	{
		if(!needcopy)
			result->_cancelCopyRemote();
	}
	else
	{
		Arts::Connection *conn = Arts::Dispatcher::the()->connectObjectRemote(r);
		if(conn)
		{
			result = new Arts::Synth_MIDI_DEBUG_stub(conn,r.objectID);
			if(needcopy) result->_copyRemote();
			result->_useRemote();
			if (!result->_isCompatibleWith("Arts::Synth_MIDI_DEBUG")) {
				result->_release();
				return 0;
			}
		}
	}
	return result;
}

std::vector<std::string> Arts::Synth_MIDI_DEBUG_base::_defaultPortsIn() const {
	std::vector<std::string> ret;
	return ret;
}
std::vector<std::string> Arts::Synth_MIDI_DEBUG_base::_defaultPortsOut() const {
	std::vector<std::string> ret;
	return ret;
}

void *Arts::Synth_MIDI_DEBUG_base::_cast(unsigned long iid)
{
	if(iid == Arts::Synth_MIDI_DEBUG_base::_IID) return (Arts::Synth_MIDI_DEBUG_base *)this;
	if(iid == Arts::SynthModule_base::_IID) return (Arts::SynthModule_base *)this;
	if(iid == Arts::MidiPort_base::_IID) return (Arts::MidiPort_base *)this;
	if(iid == Arts::Object_base::_IID) return (Arts::Object_base *)this;
	return 0;
}

Arts::Synth_MIDI_DEBUG_stub::Synth_MIDI_DEBUG_stub()
{
	// constructor for subclasses (don't use directly)
}

Arts::Synth_MIDI_DEBUG_stub::Synth_MIDI_DEBUG_stub(Arts::Connection *connection, long objectID)
	: Arts::Object_stub(connection, objectID)
{
	// constructor to create a stub for an object
}

std::string Arts::Synth_MIDI_DEBUG_skel::_interfaceName()
{
	return "Arts::Synth_MIDI_DEBUG";
}

bool Arts::Synth_MIDI_DEBUG_skel::_isCompatibleWith(const std::string& interfacename)
{
	if (interfacename == "Arts::Synth_MIDI_DEBUG") return true;
	if (interfacename == "Arts::SynthModule") return true;
	if (interfacename == "Arts::MidiPort") return true;
	if (interfacename == "Arts::Object") return true;
	return false;
}

std::string Arts::Synth_MIDI_DEBUG_skel::_interfaceNameSkel()
{
	return "Arts::Synth_MIDI_DEBUG";
}

void Arts::Synth_MIDI_DEBUG_skel::_buildMethodTable()
{
	Arts::Buffer m;
	m.fromString(
        "MethodTable:",
		"MethodTable"
	);
	Arts::SynthModule_skel::_buildMethodTable();
	Arts::MidiPort_skel::_buildMethodTable();
}

Arts::Synth_MIDI_DEBUG_skel::Synth_MIDI_DEBUG_skel()
{
}

Arts::Object_base* Arts::Synth_MIDI_DEBUG::_Creator() {
	return Arts::Synth_MIDI_DEBUG_base::_create();
}

unsigned long Arts::Synth_MIDI_DEBUG_base::_IID = Arts::MCOPUtils::makeIID("Arts::Synth_MIDI_DEBUG");

Arts::ObjectCache_base *Arts::ObjectCache_base::_create(const std::string& subClass)
{
	Arts::Object_skel *skel = Arts::ObjectManager::the()->create(subClass);
	assert(skel);
	Arts::ObjectCache_base *castedObject = (Arts::ObjectCache_base *)skel->_cast(Arts::ObjectCache_base::_IID);
	assert(castedObject);
	return castedObject;
}

Arts::ObjectCache_base *Arts::ObjectCache_base::_fromString(const std::string& objectref)
{
	Arts::ObjectReference r;

	if(Arts::Dispatcher::the()->stringToObjectReference(r,objectref))
		return Arts::ObjectCache_base::_fromReference(r,true);
	return 0;
}

Arts::ObjectCache_base *Arts::ObjectCache_base::_fromDynamicCast(const Arts::Object& object)
{
	if(object.isNull()) return 0;

	Arts::ObjectCache_base *castedObject = (Arts::ObjectCache_base *)object._base()->_cast(Arts::ObjectCache_base::_IID);
	if(castedObject) return castedObject->_copy();

	return _fromString(object._toString());
}

Arts::ObjectCache_base *Arts::ObjectCache_base::_fromReference(Arts::ObjectReference r, bool needcopy)
{
	Arts::ObjectCache_base *result;
	result = (Arts::ObjectCache_base *)Arts::Dispatcher::the()->connectObjectLocal(r,"Arts::ObjectCache");
	if(result)
	{
		if(!needcopy)
			result->_cancelCopyRemote();
	}
	else
	{
		Arts::Connection *conn = Arts::Dispatcher::the()->connectObjectRemote(r);
		if(conn)
		{
			result = new Arts::ObjectCache_stub(conn,r.objectID);
			if(needcopy) result->_copyRemote();
			result->_useRemote();
			if (!result->_isCompatibleWith("Arts::ObjectCache")) {
				result->_release();
				return 0;
			}
		}
	}
	return result;
}

std::vector<std::string> Arts::ObjectCache_base::_defaultPortsIn() const {
	std::vector<std::string> ret;
	return ret;
}
std::vector<std::string> Arts::ObjectCache_base::_defaultPortsOut() const {
	std::vector<std::string> ret;
	return ret;
}

void *Arts::ObjectCache_base::_cast(unsigned long iid)
{
	if(iid == Arts::ObjectCache_base::_IID) return (Arts::ObjectCache_base *)this;
	if(iid == Arts::Object_base::_IID) return (Arts::Object_base *)this;
	return 0;
}

Arts::ObjectCache_stub::ObjectCache_stub()
{
	// constructor for subclasses (don't use directly)
}

Arts::ObjectCache_stub::ObjectCache_stub(Arts::Connection *connection, long objectID)
	: Arts::Object_stub(connection, objectID)
{
	// constructor to create a stub for an object
}

void Arts::ObjectCache_stub::put(Arts::Object obj, const std::string& name)
{
	long methodID = _lookupMethodFast("method:000000047075740000000005766f6964000000000200000002000000076f626a65637400000000046f626a000000000000000007737472696e6700000000056e616d65000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	Arts::writeObject(*request,obj._base());
	request->writeString(name);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(result) delete result;
}

Arts::Object Arts::ObjectCache_stub::get(const std::string& name)
{
	long methodID = _lookupMethodFast("method:0000000467657400000000076f626a65637400000000020000000100000007737472696e6700000000056e616d65000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->writeString(name);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if (!result) return Arts::Object::null();
	Arts::Object_base* returnCode;
	Arts::readObject(*result,returnCode);
	delete result;
	return Arts::Object::_from_base(returnCode);
}

std::string Arts::ObjectCache_skel::_interfaceName()
{
	return "Arts::ObjectCache";
}

bool Arts::ObjectCache_skel::_isCompatibleWith(const std::string& interfacename)
{
	if (interfacename == "Arts::ObjectCache") return true;
	if (interfacename == "Arts::Object") return true;
	return false;
}

std::string Arts::ObjectCache_skel::_interfaceNameSkel()
{
	return "Arts::ObjectCache";
}

// put
static void _dispatch_Arts_ObjectCache_00(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	Arts::Object_base* _temp_obj;
	Arts::readObject(*request,_temp_obj);
	Arts::Object obj = Arts::Object::_from_base(_temp_obj);
	std::string name;
	request->readString(name);
	((Arts::ObjectCache_skel *)object)->put(obj,name);
}

// get
static void _dispatch_Arts_ObjectCache_01(void *object, Arts::Buffer *request, Arts::Buffer *result)
{
	std::string name;
	request->readString(name);
	Arts::Object returnCode = ((Arts::ObjectCache_skel *)object)->get(name);
	Arts::writeObject(*result,returnCode._base());
}

void Arts::ObjectCache_skel::_buildMethodTable()
{
	Arts::Buffer m;
	m.fromString(
        "MethodTable:000000047075740000000005766f69640000000002000000020000"
        "00076f626a65637400000000046f626a000000000000000007737472696e670000"
        "0000056e616d650000000000000000000000000467657400000000076f626a6563"
        "7400000000020000000100000007737472696e6700000000056e616d6500000000"
        "0000000000",
		"MethodTable"
	);
	_addMethod(_dispatch_Arts_ObjectCache_00,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_ObjectCache_01,this,Arts::MethodDef(m));
}

Arts::ObjectCache_skel::ObjectCache_skel()
{
}

Arts::Object_base* Arts::ObjectCache::_Creator() {
	return Arts::ObjectCache_base::_create();
}

unsigned long Arts::ObjectCache_base::_IID = Arts::MCOPUtils::makeIID("Arts::ObjectCache");

Arts::MidiReleaseHelper_base *Arts::MidiReleaseHelper_base::_create(const std::string& subClass)
{
	Arts::Object_skel *skel = Arts::ObjectManager::the()->create(subClass);
	assert(skel);
	Arts::MidiReleaseHelper_base *castedObject = (Arts::MidiReleaseHelper_base *)skel->_cast(Arts::MidiReleaseHelper_base::_IID);
	assert(castedObject);
	return castedObject;
}

Arts::MidiReleaseHelper_base *Arts::MidiReleaseHelper_base::_fromString(const std::string& objectref)
{
	Arts::ObjectReference r;

	if(Arts::Dispatcher::the()->stringToObjectReference(r,objectref))
		return Arts::MidiReleaseHelper_base::_fromReference(r,true);
	return 0;
}

Arts::MidiReleaseHelper_base *Arts::MidiReleaseHelper_base::_fromDynamicCast(const Arts::Object& object)
{
	if(object.isNull()) return 0;

	Arts::MidiReleaseHelper_base *castedObject = (Arts::MidiReleaseHelper_base *)object._base()->_cast(Arts::MidiReleaseHelper_base::_IID);
	if(castedObject) return castedObject->_copy();

	return _fromString(object._toString());
}

Arts::MidiReleaseHelper_base *Arts::MidiReleaseHelper_base::_fromReference(Arts::ObjectReference r, bool needcopy)
{
	Arts::MidiReleaseHelper_base *result;
	result = (Arts::MidiReleaseHelper_base *)Arts::Dispatcher::the()->connectObjectLocal(r,"Arts::MidiReleaseHelper");
	if(result)
	{
		if(!needcopy)
			result->_cancelCopyRemote();
	}
	else
	{
		Arts::Connection *conn = Arts::Dispatcher::the()->connectObjectRemote(r);
		if(conn)
		{
			result = new Arts::MidiReleaseHelper_stub(conn,r.objectID);
			if(needcopy) result->_copyRemote();
			result->_useRemote();
			if (!result->_isCompatibleWith("Arts::MidiReleaseHelper")) {
				result->_release();
				return 0;
			}
		}
	}
	return result;
}

std::vector<std::string> Arts::MidiReleaseHelper_base::_defaultPortsIn() const {
	std::vector<std::string> ret;
	ret.push_back("done");
	return ret;
}
std::vector<std::string> Arts::MidiReleaseHelper_base::_defaultPortsOut() const {
	std::vector<std::string> ret;
	return ret;
}

void *Arts::MidiReleaseHelper_base::_cast(unsigned long iid)
{
	if(iid == Arts::MidiReleaseHelper_base::_IID) return (Arts::MidiReleaseHelper_base *)this;
	if(iid == Arts::SynthModule_base::_IID) return (Arts::SynthModule_base *)this;
	if(iid == Arts::Object_base::_IID) return (Arts::Object_base *)this;
	return 0;
}

Arts::MidiReleaseHelper_stub::MidiReleaseHelper_stub()
{
	// constructor for subclasses (don't use directly)
}

Arts::MidiReleaseHelper_stub::MidiReleaseHelper_stub(Arts::Connection *connection, long objectID)
	: Arts::Object_stub(connection, objectID)
{
	// constructor to create a stub for an object
}

bool Arts::MidiReleaseHelper_stub::terminate()
{
	long methodID = _lookupMethodFast("method:0000000a7465726d696e6174650000000008626f6f6c65616e00000000020000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(!result) return false; // error occurred
	bool returnCode = result->readBool();
	delete result;
	return returnCode;
}

Arts::SynthModule Arts::MidiReleaseHelper_stub::voice()
{
	long methodID = _lookupMethodFast("method:0000000b5f6765745f766f6963650000000012417274733a3a53796e74684d6f64756c6500000000020000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if (!result) return Arts::SynthModule::null();
	Arts::SynthModule_base* returnCode;
	Arts::readObject(*result,returnCode);
	delete result;
	return Arts::SynthModule::_from_base(returnCode);
}

void Arts::MidiReleaseHelper_stub::voice(Arts::SynthModule newValue)
{
	long methodID = _lookupMethodFast("method:0000000b5f7365745f766f6963650000000005766f696400000000020000000100000012417274733a3a53796e74684d6f64756c6500000000096e657756616c7565000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	Arts::writeObject(*request,newValue._base());
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(result) delete result;
}

std::string Arts::MidiReleaseHelper_stub::name()
{
	long methodID = _lookupMethodFast("method:0000000a5f6765745f6e616d650000000007737472696e6700000000020000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(!result) return""; // error occurred
	std::string returnCode;
	result->readString(returnCode);
	delete result;
	return returnCode;
}

void Arts::MidiReleaseHelper_stub::name(const std::string& newValue)
{
	long methodID = _lookupMethodFast("method:0000000a5f7365745f6e616d650000000005766f696400000000020000000100000007737472696e6700000000096e657756616c7565000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->writeString(newValue);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(result) delete result;
}

Arts::ObjectCache Arts::MidiReleaseHelper_stub::cache()
{
	long methodID = _lookupMethodFast("method:0000000b5f6765745f63616368650000000012417274733a3a4f626a656374436163686500000000020000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if (!result) return Arts::ObjectCache::null();
	Arts::ObjectCache_base* returnCode;
	Arts::readObject(*result,returnCode);
	delete result;
	return Arts::ObjectCache::_from_base(returnCode);
}

void Arts::MidiReleaseHelper_stub::cache(Arts::ObjectCache newValue)
{
	long methodID = _lookupMethodFast("method:0000000b5f7365745f63616368650000000005766f696400000000020000000100000012417274733a3a4f626a656374436163686500000000096e657756616c7565000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	Arts::writeObject(*request,newValue._base());
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(result) delete result;
}

std::string Arts::MidiReleaseHelper_skel::_interfaceName()
{
	return "Arts::MidiReleaseHelper";
}

bool Arts::MidiReleaseHelper_skel::_isCompatibleWith(const std::string& interfacename)
{
	if (interfacename == "Arts::MidiReleaseHelper") return true;
	if (interfacename == "Arts::SynthModule") return true;
	if (interfacename == "Arts::Object") return true;
	return false;
}

std::string Arts::MidiReleaseHelper_skel::_interfaceNameSkel()
{
	return "Arts::MidiReleaseHelper";
}

// terminate
static void _dispatch_Arts_MidiReleaseHelper_00(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeBool(((Arts::MidiReleaseHelper_skel *)object)->terminate());
}

// _get_voice
static void _dispatch_Arts_MidiReleaseHelper_01(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	Arts::SynthModule returnCode = ((Arts::MidiReleaseHelper_skel *)object)->voice();
	Arts::writeObject(*result,returnCode._base());
}

// _set_voice
static void _dispatch_Arts_MidiReleaseHelper_02(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	Arts::SynthModule_base* _temp_newValue;
	Arts::readObject(*request,_temp_newValue);
	Arts::SynthModule newValue = Arts::SynthModule::_from_base(_temp_newValue);
	((Arts::MidiReleaseHelper_skel *)object)->voice(newValue);
}

// _get_name
static void _dispatch_Arts_MidiReleaseHelper_03(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeString(((Arts::MidiReleaseHelper_skel *)object)->name());
}

// _set_name
static void _dispatch_Arts_MidiReleaseHelper_04(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	std::string newValue;
	request->readString(newValue);
	((Arts::MidiReleaseHelper_skel *)object)->name(newValue);
}

// _get_cache
static void _dispatch_Arts_MidiReleaseHelper_05(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	Arts::ObjectCache returnCode = ((Arts::MidiReleaseHelper_skel *)object)->cache();
	Arts::writeObject(*result,returnCode._base());
}

// _set_cache
static void _dispatch_Arts_MidiReleaseHelper_06(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	Arts::ObjectCache_base* _temp_newValue;
	Arts::readObject(*request,_temp_newValue);
	Arts::ObjectCache newValue = Arts::ObjectCache::_from_base(_temp_newValue);
	((Arts::MidiReleaseHelper_skel *)object)->cache(newValue);
}

void Arts::MidiReleaseHelper_skel::_buildMethodTable()
{
	Arts::Buffer m;
	m.fromString(
        "MethodTable:0000000a7465726d696e6174650000000008626f6f6c65616e0000"
        "00000200000000000000000000000b5f6765745f766f6963650000000012417274"
        "733a3a53796e74684d6f64756c65000000000200000000000000000000000b5f73"
        "65745f766f6963650000000005766f696400000000020000000100000012417274"
        "733a3a53796e74684d6f64756c6500000000096e657756616c7565000000000000"
        "0000000000000a5f6765745f6e616d650000000007737472696e67000000000200"
        "000000000000000000000a5f7365745f6e616d650000000005766f696400000000"
        "020000000100000007737472696e6700000000096e657756616c75650000000000"
        "000000000000000b5f6765745f63616368650000000012417274733a3a4f626a65"
        "63744361636865000000000200000000000000000000000b5f7365745f63616368"
        "650000000005766f696400000000020000000100000012417274733a3a4f626a65"
        "6374436163686500000000096e657756616c7565000000000000000000",
		"MethodTable"
	);
	_addMethod(_dispatch_Arts_MidiReleaseHelper_00,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_MidiReleaseHelper_01,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_MidiReleaseHelper_02,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_MidiReleaseHelper_03,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_MidiReleaseHelper_04,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_MidiReleaseHelper_05,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_MidiReleaseHelper_06,this,Arts::MethodDef(m));
	Arts::SynthModule_skel::_buildMethodTable();
}

Arts::MidiReleaseHelper_skel::MidiReleaseHelper_skel()
{
	_initStream("done",&done,9);
}

Arts::Object_base* Arts::MidiReleaseHelper::_Creator() {
	return Arts::MidiReleaseHelper_base::_create();
}

unsigned long Arts::MidiReleaseHelper_base::_IID = Arts::MCOPUtils::makeIID("Arts::MidiReleaseHelper");

static Arts::IDLFileReg IDLFileReg_artsmodulessynth("artsmodulessynth",
    "IDLFile:00000001000000000100000017417274733a3a53796e74684f736357617665"
    "466f726d00000000090000000b736f5761766553696e65000000000000000000000000"
    "0f736f57617665547269616e676c650000000001000000000000000e736f5761766553"
    "6177526973650000000002000000000000000e736f5761766553617746616c6c000000"
    "0003000000000000000f736f576176655065616b526973650000000004000000000000"
    "000f736f576176655065616b46616c6c0000000005000000000000000e736f57617665"
    "4d6f6f675361770000000006000000000000000d736f57617665537175617265000000"
    "0007000000000000000f736f5761766550756c73655361770000000008000000000000"
    "0000000000000000002400000010417274733a3a53796e74685f444956000000000100"
    "000012417274733a3a53796e74684d6f64756c6500000000000000000300000009696e"
    "76616c7565310000000006666c6f617400000000090000000000000009696e76616c75"
    "65320000000006666c6f6174000000000900000000000000096f757476616c75650000"
    "000006666c6f6174000000000a000000000000000200000009696e76616c7565320000"
    "000009696e76616c756531000000000000000012417274733a3a53796e74685f584641"
    "4445000000000100000012417274733a3a53796e74684d6f64756c6500000000000000"
    "000400000009696e76616c7565310000000006666c6f61740000000009000000000000"
    "0009696e76616c7565320000000006666c6f61740000000009000000000000000b7065"
    "7263656e746167650000000006666c6f6174000000000900000000000000096f757476"
    "616c75650000000006666c6f6174000000000a00000000000000000000000000000017"
    "417274733a3a53796e74685f4155544f50414e4e455200000000010000001241727473"
    "3a3a53796e74684d6f64756c6500000000000000000400000008696e76616c75650000"
    "000006666c6f617400000000090000000000000006696e6c666f0000000006666c6f61"
    "740000000009000000000000000a6f757476616c7565310000000006666c6f61740000"
    "00000a000000000000000a6f757476616c7565320000000006666c6f6174000000000a"
    "00000000000000000000000000000012417274733a3a53796e74685f44454c41590000"
    "00000100000012417274733a3a53796e74684d6f64756c650000000000000000040000"
    "00096d617864656c61790000000006666c6f617400000000130000000000000008696e"
    "76616c75650000000006666c6f61740000000009000000000000000574696d65000000"
    "0006666c6f6174000000000900000000000000096f757476616c75650000000006666c"
    "6f6174000000000a00000000000000000000000000000013417274733a3a53796e7468"
    "5f4344454c4159000000000100000012417274733a3a53796e74684d6f64756c650000"
    "000000000000030000000574696d650000000006666c6f617400000000130000000000"
    "000008696e76616c75650000000006666c6f6174000000000900000000000000096f75"
    "7476616c75650000000006666c6f6174000000000a0000000000000000000000000000"
    "001a417274733a3a53796e74685f454e56454c4f50455f414453520000000001000000"
    "12417274733a3a53796e74684d6f64756c650000000000000000080000000761637469"
    "76650000000006666c6f617400000000090000000000000008696e76616c7565000000"
    "0006666c6f61740000000009000000000000000761747461636b0000000006666c6f61"
    "740000000009000000000000000664656361790000000006666c6f6174000000000900"
    "000000000000087375737461696e0000000006666c6f61740000000009000000000000"
    "000872656c656173650000000006666c6f6174000000000900000000000000096f7574"
    "76616c75650000000006666c6f6174000000000a0000000000000005646f6e65000000"
    "0006666c6f6174000000000a00000000000000000000000000000013417274733a3a53"
    "796e74685f505343414c45000000000100000012417274733a3a53796e74684d6f6475"
    "6c6500000000000000000400000004746f700000000006666c6f617400000000130000"
    "000000000008696e76616c75650000000006666c6f6174000000000900000000000000"
    "04706f730000000006666c6f6174000000000900000000000000096f757476616c7565"
    "0000000006666c6f6174000000000a0000000000000000000000000000001441727473"
    "3a3a53796e74685f5452454d4f4c4f000000000100000012417274733a3a53796e7468"
    "4d6f64756c6500000000000000000300000008696e76616c75650000000006666c6f61"
    "7400000000090000000000000006696e6c666f0000000006666c6f6174000000000900"
    "000000000000096f757476616c75650000000006666c6f6174000000000a0000000000"
    "0000000000000000000018417274733a3a53796e74685f46585f43464c414e47455200"
    "0000000100000012417274733a3a53796e74684d6f64756c6500000000000000000500"
    "0000086d696e74696d650000000006666c6f6174000000001300000000000000086d61"
    "7874696d650000000006666c6f617400000000130000000000000008696e76616c7565"
    "0000000006666c6f6174000000000900000000000000046c666f0000000006666c6f61"
    "74000000000900000000000000096f757476616c75650000000006666c6f6174000000"
    "000a00000000000000000000000000000017417274733a3a53796e74685f434f4d5052"
    "4553534f52000000000100000012417274733a3a53796e74684d6f64756c6500000000"
    "00000000070000000761747461636b0000000006666c6f617400000000130000000000"
    "00000872656c656173650000000006666c6f61740000000013000000000000000a7468"
    "726573686f6c640000000006666c6f617400000000130000000000000006726174696f"
    "0000000006666c6f6174000000001300000000000000076f7574707574000000000666"
    "6c6f617400000000130000000000000008696e76616c75650000000006666c6f617400"
    "0000000900000000000000096f757476616c75650000000006666c6f6174000000000a"
    "00000000000000000000000000000018417274733a3a53796e74685f50495443485f53"
    "48494654000000000100000012417274733a3a53796e74684d6f64756c650000000000"
    "000000040000000673706565640000000006666c6f6174000000001300000000000000"
    "0a6672657175656e63790000000006666c6f617400000000130000000000000008696e"
    "76616c75650000000006666c6f6174000000000900000000000000096f757476616c75"
    "650000000006666c6f6174000000000a0000000000000000000000000000001c417274"
    "733a3a53796e74685f50495443485f53484946545f4646540000000001000000124172"
    "74733a3a53796e74684d6f64756c650000000000000000060000000673706565640000"
    "000006666c6f61740000000013000000000000000c7363616c65466163746f72000000"
    "0006666c6f61740000000013000000000000000a6672616d6553697a6500000000056c"
    "6f6e670000000013000000000000000b6f76657273616d706c6500000000056c6f6e67"
    "00000000130000000000000009696e53747265616d0000000006666c6f617400000000"
    "09000000000000000a6f757453747265616d0000000006666c6f6174000000000a0000"
    "000000000000000000000000001a417274733a3a53796e74685f5348454c56455f4355"
    "544f4646000000000100000012417274733a3a53796e74684d6f64756c650000000000"
    "0000000300000008696e76616c75650000000006666c6f617400000000090000000000"
    "00000a6672657175656e63790000000006666c6f617400000000090000000000000009"
    "6f757476616c75650000000006666c6f6174000000000a000000000000000000000000"
    "0000001e417274733a3a53796e74685f425249434b57414c4c5f4c494d495445520000"
    "00000100000012417274733a3a53796e74684d6f64756c650000000000000000020000"
    "0008696e76616c75650000000006666c6f6174000000000900000000000000096f7574"
    "76616c75650000000006666c6f6174000000000a000000000000000000000000000000"
    "1a417274733a3a53796e74685f5354445f455155414c495a4552000000000100000012"
    "417274733a3a53796e74684d6f64756c65000000000000000007000000046c6f770000"
    "000006666c6f6174000000001300000000000000046d69640000000006666c6f617400"
    "000000130000000000000005686967680000000006666c6f6174000000001300000000"
    "0000000a6672657175656e63790000000006666c6f6174000000001300000000000000"
    "02710000000006666c6f617400000000130000000000000008696e76616c7565000000"
    "0006666c6f6174000000000900000000000000096f757476616c75650000000006666c"
    "6f6174000000000a0000000000000000000000000000000f417274733a3a53796e7468"
    "5f5243000000000100000012417274733a3a53796e74684d6f64756c65000000000000"
    "00000400000002620000000006666c6f61740000000013000000000000000266000000"
    "0006666c6f617400000000130000000000000008696e76616c75650000000006666c6f"
    "6174000000000900000000000000096f757476616c75650000000006666c6f61740000"
    "00000a00000000000000000000000000000015417274733a3a53796e74685f4d4f4f47"
    "5f564346000000000100000012417274733a3a53796e74684d6f64756c650000000000"
    "000000040000000a6672657175656e63790000000006666c6f61740000000013000000"
    "000000000a7265736f6e616e63650000000006666c6f61740000000013000000000000"
    "0008696e76616c75650000000006666c6f6174000000000900000000000000096f7574"
    "76616c75650000000006666c6f6174000000000a000000000000000000000000000000"
    "1a417274733a3a53796e74685f4154414e5f5341545552415445000000000100000012"
    "417274733a3a53796e74684d6f64756c6500000000000000000300000008696e736361"
    "6c650000000006666c6f617400000000130000000000000008696e76616c7565000000"
    "0006666c6f6174000000000900000000000000096f757476616c75650000000006666c"
    "6f6174000000000a00000000000000000000000000000016417274733a3a53796e7468"
    "5f4d4944495f54455354000000000200000012417274733a3a53796e74684d6f64756c"
    "65000000000f417274733a3a4d696469506f7274000000000000000002000000096669"
    "6c656e616d650000000007737472696e67000000001300000000000000086275736e61"
    "6d650000000007737472696e6700000000130000000000000000000000000000001541"
    "7274733a3a53796e74685f53455155454e4345000000000100000012417274733a3a53"
    "796e74684d6f64756c650000000000000000040000000673706565640000000006666c"
    "6f6174000000001300000000000000047365710000000007737472696e670000000013"
    "000000000000000a6672657175656e63790000000006666c6f6174000000000a000000"
    "0000000004706f730000000006666c6f6174000000000a000000000000000000000000"
    "0000001a417274733a3a53796e74685f53455155454e43455f46524551000000000100"
    "000012417274733a3a53796e74684d6f64756c65000000000000000004000000067370"
    "6565640000000006666c6f617400000000130000000000000004736571000000000773"
    "7472696e670000000013000000000000000a6672657175656e63790000000006666c6f"
    "6174000000000a0000000000000004706f730000000006666c6f6174000000000a0000"
    "0000000000000000000000000016417274733a3a53796e74685f464d5f534f55524345"
    "000000000100000012417274733a3a53796e74684d6f64756c65000000000000000004"
    "0000000a6672657175656e63790000000006666c6f6174000000000900000000000000"
    "0a6d6f64756c61746f720000000006666c6f6174000000000900000000000000096d6f"
    "646c6576656c0000000006666c6f617400000000090000000000000004706f73000000"
    "0006666c6f6174000000000a00000000000000000000000000000015417274733a3a53"
    "796e74685f574156455f545249000000000100000012417274733a3a53796e74684d6f"
    "64756c6500000000000000000200000004706f730000000006666c6f61740000000009"
    "00000000000000096f757476616c75650000000006666c6f6174000000000a00000000"
    "000000000000000000000012417274733a3a53796e74685f4e4f495345000000000100"
    "000012417274733a3a53796e74684d6f64756c65000000000000000001000000096f75"
    "7476616c75650000000006666c6f6174000000000a0000000000000000000000000000"
    "0018417274733a3a53796e74685f574156455f53515541524500000000010000001241"
    "7274733a3a53796e74684d6f64756c6500000000000000000200000004706f73000000"
    "0006666c6f6174000000000900000000000000096f757476616c75650000000006666c"
    "6f6174000000000a00000000000000000000000000000019417274733a3a53796e7468"
    "5f574156455f534f4654534157000000000100000012417274733a3a53796e74684d6f"
    "64756c6500000000000000000200000004706f730000000006666c6f61740000000009"
    "00000000000000096f757476616c75650000000006666c6f6174000000000a00000000"
    "000000000000000000000017417274733a3a53796e74685f574156455f50554c534500"
    "0000000100000012417274733a3a53796e74684d6f64756c6500000000000000000300"
    "00000a647574796379636c650000000006666c6f617400000000130000000000000004"
    "706f730000000006666c6f6174000000000900000000000000096f757476616c756500"
    "00000006666c6f6174000000000a00000000000000000000000000000010417274733a"
    "3a53796e74685f4f5343000000000100000012417274733a3a53796e74684d6f64756c"
    "6500000000000000000f0000000c696e6672657175656e63790000000006666c6f6174"
    "0000000009000000000000000b6d6f64756c6174696f6e0000000006666c6f61740000"
    "0000090000000000000006696e70776d0000000006666c6f6174000000000900000000"
    "00000007696e73796e630000000006666c6f6174000000000900000000000000096f75"
    "7476616c75650000000006666c6f6174000000000a00000000000000086f757473796e"
    "630000000006666c6f6174000000000a000000000000000977617665466f726d000000"
    "0017417274733a3a53796e74684f736357617665466f726d0000000013000000000000"
    "000e666d4578706f6e656e7469616c0000000008626f6f6c65616e0000000013000000"
    "000000000b666d537472656e6774680000000006666c6f617400000000130000000000"
    "00000f666d53656c66537472656e6774680000000006666c6f61740000000013000000"
    "000000000670686173650000000006666c6f61740000000013000000000000000a6672"
    "657175656e63790000000006666c6f61740000000013000000000000000966696e6554"
    "756e6500000000056c6f6e670000000013000000000000000b70756c73655769647468"
    "0000000006666c6f61740000000013000000000000001170756c73654d6f6453747265"
    "6e6774680000000006666c6f6174000000001300000000000000000000000000000015"
    "417274733a3a53796e74685f504c41595f504154000000000100000012417274733a3a"
    "53796e74684d6f64756c650000000000000000030000000966696c656e616d65000000"
    "0007737472696e670000000013000000000000000a6672657175656e63790000000006"
    "666c6f6174000000000900000000000000096f757476616c75650000000006666c6f61"
    "74000000000a00000000000000000000000000000018417274733a3a53796e74685f43"
    "4150545552455f574156000000000100000012417274733a3a53796e74684d6f64756c"
    "650000000000000000030000000966696c656e616d650000000007737472696e670000"
    "00001300000000000000056c6566740000000006666c6f617400000000490000000000"
    "00000672696768740000000006666c6f61740000000049000000000000000200000005"
    "6c65667400000000067269676874000000000000000010417274733a3a53796e74685f"
    "4e494c000000000100000012417274733a3a53796e74684d6f64756c65000000000000"
    "000000000000000000000000000012417274733a3a53796e74685f4445425547000000"
    "000100000012417274733a3a53796e74684d6f64756c65000000000000000002000000"
    "08636f6d6d656e740000000007737472696e6700000000130000000000000008696e76"
    "616c75650000000006666c6f6174000000000900000000000000000000000000000011"
    "417274733a3a53796e74685f44415441000000000100000012417274733a3a53796e74"
    "684d6f64756c650000000000000000020000000676616c75650000000006666c6f6174"
    "000000001300000000000000096f757476616c75650000000006666c6f617400000000"
    "0a00000000000000000000000000000017417274733a3a53796e74685f4d4944495f44"
    "45425547000000000200000012417274733a3a53796e74684d6f64756c65000000000f"
    "417274733a3a4d696469506f7274000000000000000000000000000000000000000012"
    "417274733a3a4f626a6563744361636865000000000000000002000000047075740000"
    "000005766f6964000000000200000002000000076f626a65637400000000046f626a00"
    "0000000000000007737472696e6700000000056e616d65000000000000000000000000"
    "0467657400000000076f626a65637400000000020000000100000007737472696e6700"
    "000000056e616d65000000000000000000000000000000000000000000000000184172"
    "74733a3a4d69646952656c6561736548656c706572000000000100000012417274733a"
    "3a53796e74684d6f64756c6500000000010000000a7465726d696e6174650000000008"
    "626f6f6c65616e000000000200000000000000000000000400000006766f6963650000"
    "000012417274733a3a53796e74684d6f64756c65000000001300000000000000056e61"
    "6d650000000007737472696e6700000000130000000000000006636163686500000000"
    "12417274733a3a4f626a656374436163686500000000130000000000000005646f6e65"
    "0000000006666c6f6174000000000900000000000000000000000000000000"
);
