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

#include "artskde.h"

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

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

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

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

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

	return _fromString(object._toString());
}

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

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

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

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

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

float Arts::KFloatWatchProxy_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::KFloatWatchProxy_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::KFloatWatchProxy_skel::_interfaceName()
{
	return "Arts::KFloatWatchProxy";
}

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

std::string Arts::KFloatWatchProxy_skel::_interfaceNameSkel()
{
	return "Arts::KFloatWatchProxy";
}

// _get_value
static void _dispatch_Arts_KFloatWatchProxy_00(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeFloat(((Arts::KFloatWatchProxy_skel *)object)->value());
}

// _set_value
static void _dispatch_Arts_KFloatWatchProxy_01(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	float newValue = request->readFloat();
	((Arts::KFloatWatchProxy_skel *)object)->value(newValue);
}

void Arts::KFloatWatchProxy_skel::_buildMethodTable()
{
	Arts::Buffer m;
	m.fromString(
        "MethodTable:0000000b5f6765745f76616c75650000000006666c6f6174000000"
        "000200000000000000000000000b5f7365745f76616c75650000000005766f6964"
        "00000000020000000100000006666c6f617400000000096e657756616c75650000"
        "00000000000000",
		"MethodTable"
	);
	_addMethod(_dispatch_Arts_KFloatWatchProxy_00,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_KFloatWatchProxy_01,this,Arts::MethodDef(m));
}

Arts::KFloatWatchProxy_skel::KFloatWatchProxy_skel()
{
}

Arts::Object_base* Arts::KFloatWatchProxy::_Creator() {
	return Arts::KFloatWatchProxy_base::_create();
}

unsigned long Arts::KFloatWatchProxy_base::_IID = Arts::MCOPUtils::makeIID("Arts::KFloatWatchProxy");

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

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

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

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

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

	return _fromString(object._toString());
}

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

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

void *Arts::KIOInputStream_base::_cast(unsigned long iid)
{
	if(iid == Arts::KIOInputStream_base::_IID) return (Arts::KIOInputStream_base *)this;
	if(iid == Arts::InputStream_base::_IID) return (Arts::InputStream_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::KIOInputStream_stub::KIOInputStream_stub()
{
	// constructor for subclasses (don't use directly)
}

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

bool Arts::KIOInputStream_stub::openURL(const std::string& url)
{
	long methodID = _lookupMethodFast("method:000000086f70656e55524c0000000008626f6f6c65616e00000000020000000100000007737472696e67000000000475726c000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->writeString(url);
	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;
}

long Arts::KIOInputStream_stub::packetSize()
{
	long methodID = _lookupMethodFast("method:0000000b7061636b657453697a6500000000056c6f6e6700000000020000000000000000");
	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;
}

long Arts::KIOInputStream_stub::bufferPackets()
{
	long methodID = _lookupMethodFast("method:000000135f6765745f6275666665725061636b65747300000000056c6f6e6700000000020000000000000000");
	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::KIOInputStream_stub::bufferPackets(long newValue)
{
	long methodID = _lookupMethodFast("method:000000135f7365745f6275666665725061636b6574730000000005766f6964000000000200000001000000056c6f6e6700000000096e657756616c7565000000000000000000");
	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::KIOInputStream_skel::_interfaceName()
{
	return "Arts::KIOInputStream";
}

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

std::string Arts::KIOInputStream_skel::_interfaceNameSkel()
{
	return "Arts::KIOInputStream";
}

// openURL
static void _dispatch_Arts_KIOInputStream_00(void *object, Arts::Buffer *request, Arts::Buffer *result)
{
	std::string url;
	request->readString(url);
	result->writeBool(((Arts::KIOInputStream_skel *)object)->openURL(url));
}

// packetSize
static void _dispatch_Arts_KIOInputStream_01(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeLong(((Arts::KIOInputStream_skel *)object)->packetSize());
}

// _get_bufferPackets
static void _dispatch_Arts_KIOInputStream_02(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeLong(((Arts::KIOInputStream_skel *)object)->bufferPackets());
}

// _set_bufferPackets
static void _dispatch_Arts_KIOInputStream_03(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	long newValue = request->readLong();
	((Arts::KIOInputStream_skel *)object)->bufferPackets(newValue);
}

void Arts::KIOInputStream_skel::_buildMethodTable()
{
	Arts::Buffer m;
	m.fromString(
        "MethodTable:000000086f70656e55524c0000000008626f6f6c65616e00000000"
        "020000000100000007737472696e67000000000475726c00000000000000000000"
        "00000b7061636b657453697a6500000000056c6f6e670000000002000000000000"
        "0000000000135f6765745f6275666665725061636b65747300000000056c6f6e67"
        "00000000020000000000000000000000135f7365745f6275666665725061636b65"
        "74730000000005766f6964000000000200000001000000056c6f6e670000000009"
        "6e657756616c7565000000000000000000",
		"MethodTable"
	);
	_addMethod(_dispatch_Arts_KIOInputStream_00,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_KIOInputStream_01,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_KIOInputStream_02,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_KIOInputStream_03,this,Arts::MethodDef(m));
	Arts::InputStream_skel::_buildMethodTable();
}

Arts::KIOInputStream_skel::KIOInputStream_skel()
{
}

Arts::Object_base* Arts::KIOInputStream::_Creator() {
	return Arts::KIOInputStream_base::_create();
}

unsigned long Arts::KIOInputStream_base::_IID = Arts::MCOPUtils::makeIID("Arts::KIOInputStream");

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

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

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

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

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

	return _fromString(object._toString());
}

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

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

void *Arts::KDataRequest_base::_cast(unsigned long iid)
{
	if(iid == Arts::KDataRequest_base::_IID) return (Arts::KDataRequest_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::KDataRequest_stub::KDataRequest_stub()
{
	// constructor for subclasses (don't use directly)
}

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

void Arts::KDataRequest_stub::goOn()
{
	long methodID = _lookupMethodFast("method:00000005676f4f6e0000000005766f696400000000020000000000000000");
	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) delete result;
}

std::string Arts::KDataRequest_skel::_interfaceName()
{
	return "Arts::KDataRequest";
}

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

std::string Arts::KDataRequest_skel::_interfaceNameSkel()
{
	return "Arts::KDataRequest";
}

// goOn
static void _dispatch_Arts_KDataRequest_00(void *object, Arts::Buffer *, Arts::Buffer *)
{
	((Arts::KDataRequest_skel *)object)->goOn();
}

void Arts::KDataRequest_skel::_buildMethodTable()
{
	Arts::Buffer m;
	m.fromString(
        "MethodTable:00000005676f4f6e0000000005766f696400000000020000000000"
        "000000",
		"MethodTable"
	);
	_addMethod(_dispatch_Arts_KDataRequest_00,this,Arts::MethodDef(m));
	Arts::SynthModule_skel::_buildMethodTable();
}

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

Arts::Object_base* Arts::KDataRequest::_Creator() {
	return Arts::KDataRequest_base::_create();
}

unsigned long Arts::KDataRequest_base::_IID = Arts::MCOPUtils::makeIID("Arts::KDataRequest");

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

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

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

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

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

	return _fromString(object._toString());
}

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

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

void *Arts::KIOTestSlow_base::_cast(unsigned long iid)
{
	if(iid == Arts::KIOTestSlow_base::_IID) return (Arts::KIOTestSlow_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::KIOTestSlow_stub::KIOTestSlow_stub()
{
	// constructor for subclasses (don't use directly)
}

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

Arts::InputStream Arts::KIOTestSlow_stub::inputStream()
{
	long methodID = _lookupMethodFast("method:000000115f6765745f696e70757453747265616d0000000012417274733a3a496e70757453747265616d00000000020000000000000000");
	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::InputStream::null();
	Arts::InputStream_base* returnCode;
	Arts::readObject(*result,returnCode);
	delete result;
	return Arts::InputStream::_from_base(returnCode);
}

void Arts::KIOTestSlow_stub::inputStream(Arts::InputStream newValue)
{
	long methodID = _lookupMethodFast("method:000000115f7365745f696e70757453747265616d0000000005766f696400000000020000000100000012417274733a3a496e70757453747265616d00000000096e657756616c7565000000000000000000");
	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::KIOTestSlow_skel::_interfaceName()
{
	return "Arts::KIOTestSlow";
}

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

std::string Arts::KIOTestSlow_skel::_interfaceNameSkel()
{
	return "Arts::KIOTestSlow";
}

// _get_inputStream
static void _dispatch_Arts_KIOTestSlow_00(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	Arts::InputStream returnCode = ((Arts::KIOTestSlow_skel *)object)->inputStream();
	Arts::writeObject(*result,returnCode._base());
}

// _set_inputStream
static void _dispatch_Arts_KIOTestSlow_01(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	Arts::InputStream_base* _temp_newValue;
	Arts::readObject(*request,_temp_newValue);
	Arts::InputStream newValue = Arts::InputStream::_from_base(_temp_newValue);
	((Arts::KIOTestSlow_skel *)object)->inputStream(newValue);
}

void Arts::KIOTestSlow_skel::_buildMethodTable()
{
	Arts::Buffer m;
	m.fromString(
        "MethodTable:000000115f6765745f696e70757453747265616d00000000124172"
        "74733a3a496e70757453747265616d00000000020000000000000000000000115f"
        "7365745f696e70757453747265616d0000000005766f6964000000000200000001"
        "00000012417274733a3a496e70757453747265616d00000000096e657756616c75"
        "65000000000000000000",
		"MethodTable"
	);
	_addMethod(_dispatch_Arts_KIOTestSlow_00,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_KIOTestSlow_01,this,Arts::MethodDef(m));
	Arts::SynthModule_skel::_buildMethodTable();
}

Arts::KIOTestSlow_skel::KIOTestSlow_skel()
{
	_initStream("data",&data,41);
}

void Arts::KIOTestSlow_skel::notify(const Arts::Notification &notification)
{
	if(data.notifyID() == notification.ID)
		process_data((Arts::DataPacket<Arts::mcopbyte> *)notification.data);
}

Arts::Object_base* Arts::KIOTestSlow::_Creator() {
	return Arts::KIOTestSlow_base::_create();
}

unsigned long Arts::KIOTestSlow_base::_IID = Arts::MCOPUtils::makeIID("Arts::KIOTestSlow");

static Arts::IDLFileReg IDLFileReg_artskde("artskde",
    "IDLFile:000000010000000000000000000000000400000017417274733a3a4b466c6f"
    "6174576174636850726f7879000000000000000000000000010000000676616c756500"
    "00000006666c6f6174000000001300000000000000000000000000000015417274733a"
    "3a4b494f496e70757453747265616d000000000100000012417274733a3a496e707574"
    "53747265616d0000000002000000086f70656e55524c0000000008626f6f6c65616e00"
    "000000020000000100000007737472696e67000000000475726c000000000000000000"
    "0000000b7061636b657453697a6500000000056c6f6e67000000000200000000000000"
    "00000000010000000e6275666665725061636b65747300000000056c6f6e6700000000"
    "1300000000000000000000000000000013417274733a3a4b4461746152657175657374"
    "000000000100000012417274733a3a53796e74684d6f64756c65000000000100000005"
    "676f4f6e0000000005766f69640000000002000000000000000000000002000000056c"
    "6566740000000006666c6f617400000000490000000000000006726967687400000000"
    "06666c6f617400000000490000000000000002000000056c6566740000000006726967"
    "6874000000000000000012417274733a3a4b494f54657374536c6f7700000000010000"
    "0012417274733a3a53796e74684d6f64756c6500000000000000000200000005646174"
    "610000000005627974650000000029000000000000000c696e70757453747265616d00"
    "00000012417274733a3a496e70757453747265616d0000000013000000000000000000"
    "00000000000000"
);
