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

#include "decoderBaseObject.h"

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

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

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

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

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

	return _fromString(object._toString());
}

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

std::vector<std::string> DecoderBaseObject_base::_defaultPortsIn() const {
	std::vector<std::string> ret;
	ret.push_back("indata");
	return ret;
}
std::vector<std::string> DecoderBaseObject_base::_defaultPortsOut() const {
	std::vector<std::string> ret;
	return ret;
}

void *DecoderBaseObject_base::_cast(unsigned long iid)
{
	if(iid == DecoderBaseObject_base::_IID) return (DecoderBaseObject_base *)this;
	if(iid == Arts::StreamPlayObject_base::_IID) return (Arts::StreamPlayObject_base *)this;
	if(iid == Arts::PlayObject_base::_IID) return (Arts::PlayObject_base *)this;
	if(iid == Arts::PlayObject_private_base::_IID) return (Arts::PlayObject_private_base *)this;
	if(iid == Arts::SynthModule_base::_IID) return (Arts::SynthModule_base *)this;
	if(iid == Arts::PitchablePlayObject_base::_IID) return (Arts::PitchablePlayObject_base *)this;
	if(iid == Arts::Object_base::_IID) return (Arts::Object_base *)this;
	return 0;
}

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

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

bool DecoderBaseObject_stub::blocking()
{
	long methodID = _lookupMethodFast("method:0000000e5f6765745f626c6f636b696e670000000008626f6f6c65616e00000000020000000000000000");
	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 DecoderBaseObject_stub::blocking(bool newValue)
{
	long methodID = _lookupMethodFast("method:0000000e5f7365745f626c6f636b696e670000000005766f696400000000020000000100000008626f6f6c65616e00000000096e657756616c7565000000000000000000");
	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;
}

std::string DecoderBaseObject_skel::_interfaceName()
{
	return "DecoderBaseObject";
}

bool DecoderBaseObject_skel::_isCompatibleWith(const std::string& interfacename)
{
	if (interfacename == "DecoderBaseObject") return true;
	if (interfacename == "Arts::StreamPlayObject") return true;
	if (interfacename == "Arts::PlayObject") return true;
	if (interfacename == "Arts::PlayObject_private") return true;
	if (interfacename == "Arts::SynthModule") return true;
	if (interfacename == "Arts::PitchablePlayObject") return true;
	if (interfacename == "Arts::Object") return true;
	return false;
}

std::string DecoderBaseObject_skel::_interfaceNameSkel()
{
	return "DecoderBaseObject";
}

// _get_blocking
static void _dispatch__DecoderBaseObject_00(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeBool(((DecoderBaseObject_skel *)object)->blocking());
}

// _set_blocking
static void _dispatch__DecoderBaseObject_01(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	bool newValue = request->readBool();
	((DecoderBaseObject_skel *)object)->blocking(newValue);
}

void DecoderBaseObject_skel::_buildMethodTable()
{
	Arts::Buffer m;
	m.fromString(
        "MethodTable:0000000e5f6765745f626c6f636b696e670000000008626f6f6c65"
        "616e000000000200000000000000000000000e5f7365745f626c6f636b696e6700"
        "00000005766f696400000000020000000100000008626f6f6c65616e0000000009"
        "6e657756616c7565000000000000000000",
		"MethodTable"
	);
	_addMethod(_dispatch__DecoderBaseObject_00,this,Arts::MethodDef(m));
	_addMethod(_dispatch__DecoderBaseObject_01,this,Arts::MethodDef(m));
	Arts::StreamPlayObject_skel::_buildMethodTable();
	Arts::SynthModule_skel::_buildMethodTable();
	Arts::PitchablePlayObject_skel::_buildMethodTable();
}

DecoderBaseObject_skel::DecoderBaseObject_skel()
{
	_initStream("indata",&indata,41);
}

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

Arts::Object_base* DecoderBaseObject::_Creator() {
	return DecoderBaseObject_base::_create();
}

unsigned long DecoderBaseObject_base::_IID = Arts::MCOPUtils::makeIID("DecoderBaseObject");

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

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

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

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

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

	return _fromString(object._toString());
}

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

std::vector<std::string> MP3PlayObject_base::_defaultPortsIn() const {
	std::vector<std::string> ret;
	ret.push_back("indata");
	return ret;
}
std::vector<std::string> MP3PlayObject_base::_defaultPortsOut() const {
	std::vector<std::string> ret;
	return ret;
}

void *MP3PlayObject_base::_cast(unsigned long iid)
{
	if(iid == MP3PlayObject_base::_IID) return (MP3PlayObject_base *)this;
	if(iid == DecoderBaseObject_base::_IID) return (DecoderBaseObject_base *)this;
	if(iid == Arts::StreamPlayObject_base::_IID) return (Arts::StreamPlayObject_base *)this;
	if(iid == Arts::PlayObject_base::_IID) return (Arts::PlayObject_base *)this;
	if(iid == Arts::PlayObject_private_base::_IID) return (Arts::PlayObject_private_base *)this;
	if(iid == Arts::SynthModule_base::_IID) return (Arts::SynthModule_base *)this;
	if(iid == Arts::PitchablePlayObject_base::_IID) return (Arts::PitchablePlayObject_base *)this;
	if(iid == Arts::Object_base::_IID) return (Arts::Object_base *)this;
	return 0;
}

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

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

std::string MP3PlayObject_skel::_interfaceName()
{
	return "MP3PlayObject";
}

bool MP3PlayObject_skel::_isCompatibleWith(const std::string& interfacename)
{
	if (interfacename == "MP3PlayObject") return true;
	if (interfacename == "DecoderBaseObject") return true;
	if (interfacename == "Arts::StreamPlayObject") return true;
	if (interfacename == "Arts::PlayObject") return true;
	if (interfacename == "Arts::PlayObject_private") return true;
	if (interfacename == "Arts::SynthModule") return true;
	if (interfacename == "Arts::PitchablePlayObject") return true;
	if (interfacename == "Arts::Object") return true;
	return false;
}

std::string MP3PlayObject_skel::_interfaceNameSkel()
{
	return "MP3PlayObject";
}

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

MP3PlayObject_skel::MP3PlayObject_skel()
{
	_initStream("left",&left,10);
	_initStream("right",&right,10);
}

Arts::Object_base* MP3PlayObject::_Creator() {
	return MP3PlayObject_base::_create();
}

unsigned long MP3PlayObject_base::_IID = Arts::MCOPUtils::makeIID("MP3PlayObject");

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

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

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

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

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

	return _fromString(object._toString());
}

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

std::vector<std::string> WAVPlayObject_base::_defaultPortsIn() const {
	std::vector<std::string> ret;
	ret.push_back("indata");
	return ret;
}
std::vector<std::string> WAVPlayObject_base::_defaultPortsOut() const {
	std::vector<std::string> ret;
	return ret;
}

void *WAVPlayObject_base::_cast(unsigned long iid)
{
	if(iid == WAVPlayObject_base::_IID) return (WAVPlayObject_base *)this;
	if(iid == DecoderBaseObject_base::_IID) return (DecoderBaseObject_base *)this;
	if(iid == Arts::StreamPlayObject_base::_IID) return (Arts::StreamPlayObject_base *)this;
	if(iid == Arts::PlayObject_base::_IID) return (Arts::PlayObject_base *)this;
	if(iid == Arts::PlayObject_private_base::_IID) return (Arts::PlayObject_private_base *)this;
	if(iid == Arts::SynthModule_base::_IID) return (Arts::SynthModule_base *)this;
	if(iid == Arts::PitchablePlayObject_base::_IID) return (Arts::PitchablePlayObject_base *)this;
	if(iid == Arts::Object_base::_IID) return (Arts::Object_base *)this;
	return 0;
}

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

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

std::string WAVPlayObject_skel::_interfaceName()
{
	return "WAVPlayObject";
}

bool WAVPlayObject_skel::_isCompatibleWith(const std::string& interfacename)
{
	if (interfacename == "WAVPlayObject") return true;
	if (interfacename == "DecoderBaseObject") return true;
	if (interfacename == "Arts::StreamPlayObject") return true;
	if (interfacename == "Arts::PlayObject") return true;
	if (interfacename == "Arts::PlayObject_private") return true;
	if (interfacename == "Arts::SynthModule") return true;
	if (interfacename == "Arts::PitchablePlayObject") return true;
	if (interfacename == "Arts::Object") return true;
	return false;
}

std::string WAVPlayObject_skel::_interfaceNameSkel()
{
	return "WAVPlayObject";
}

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

WAVPlayObject_skel::WAVPlayObject_skel()
{
	_initStream("left",&left,10);
	_initStream("right",&right,10);
}

Arts::Object_base* WAVPlayObject::_Creator() {
	return WAVPlayObject_base::_create();
}

unsigned long WAVPlayObject_base::_IID = Arts::MCOPUtils::makeIID("WAVPlayObject");

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

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

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

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

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

	return _fromString(object._toString());
}

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

std::vector<std::string> MPGPlayObject_base::_defaultPortsIn() const {
	std::vector<std::string> ret;
	ret.push_back("indata");
	return ret;
}
std::vector<std::string> MPGPlayObject_base::_defaultPortsOut() const {
	std::vector<std::string> ret;
	return ret;
}

void *MPGPlayObject_base::_cast(unsigned long iid)
{
	if(iid == MPGPlayObject_base::_IID) return (MPGPlayObject_base *)this;
	if(iid == DecoderBaseObject_base::_IID) return (DecoderBaseObject_base *)this;
	if(iid == Arts::StreamPlayObject_base::_IID) return (Arts::StreamPlayObject_base *)this;
	if(iid == Arts::PlayObject_base::_IID) return (Arts::PlayObject_base *)this;
	if(iid == Arts::PlayObject_private_base::_IID) return (Arts::PlayObject_private_base *)this;
	if(iid == Arts::SynthModule_base::_IID) return (Arts::SynthModule_base *)this;
	if(iid == Arts::PitchablePlayObject_base::_IID) return (Arts::PitchablePlayObject_base *)this;
	if(iid == Arts::Object_base::_IID) return (Arts::Object_base *)this;
	return 0;
}

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

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

std::string MPGPlayObject_skel::_interfaceName()
{
	return "MPGPlayObject";
}

bool MPGPlayObject_skel::_isCompatibleWith(const std::string& interfacename)
{
	if (interfacename == "MPGPlayObject") return true;
	if (interfacename == "DecoderBaseObject") return true;
	if (interfacename == "Arts::StreamPlayObject") return true;
	if (interfacename == "Arts::PlayObject") return true;
	if (interfacename == "Arts::PlayObject_private") return true;
	if (interfacename == "Arts::SynthModule") return true;
	if (interfacename == "Arts::PitchablePlayObject") return true;
	if (interfacename == "Arts::Object") return true;
	return false;
}

std::string MPGPlayObject_skel::_interfaceNameSkel()
{
	return "MPGPlayObject";
}

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

MPGPlayObject_skel::MPGPlayObject_skel()
{
	_initStream("left",&left,10);
	_initStream("right",&right,10);
}

Arts::Object_base* MPGPlayObject::_Creator() {
	return MPGPlayObject_base::_create();
}

unsigned long MPGPlayObject_base::_IID = Arts::MCOPUtils::makeIID("MPGPlayObject");

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

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

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

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

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

	return _fromString(object._toString());
}

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

std::vector<std::string> OGGPlayObject_base::_defaultPortsIn() const {
	std::vector<std::string> ret;
	ret.push_back("indata");
	return ret;
}
std::vector<std::string> OGGPlayObject_base::_defaultPortsOut() const {
	std::vector<std::string> ret;
	return ret;
}

void *OGGPlayObject_base::_cast(unsigned long iid)
{
	if(iid == OGGPlayObject_base::_IID) return (OGGPlayObject_base *)this;
	if(iid == DecoderBaseObject_base::_IID) return (DecoderBaseObject_base *)this;
	if(iid == Arts::StreamPlayObject_base::_IID) return (Arts::StreamPlayObject_base *)this;
	if(iid == Arts::PlayObject_base::_IID) return (Arts::PlayObject_base *)this;
	if(iid == Arts::PlayObject_private_base::_IID) return (Arts::PlayObject_private_base *)this;
	if(iid == Arts::SynthModule_base::_IID) return (Arts::SynthModule_base *)this;
	if(iid == Arts::PitchablePlayObject_base::_IID) return (Arts::PitchablePlayObject_base *)this;
	if(iid == Arts::Object_base::_IID) return (Arts::Object_base *)this;
	return 0;
}

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

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

std::string OGGPlayObject_skel::_interfaceName()
{
	return "OGGPlayObject";
}

bool OGGPlayObject_skel::_isCompatibleWith(const std::string& interfacename)
{
	if (interfacename == "OGGPlayObject") return true;
	if (interfacename == "DecoderBaseObject") return true;
	if (interfacename == "Arts::StreamPlayObject") return true;
	if (interfacename == "Arts::PlayObject") return true;
	if (interfacename == "Arts::PlayObject_private") return true;
	if (interfacename == "Arts::SynthModule") return true;
	if (interfacename == "Arts::PitchablePlayObject") return true;
	if (interfacename == "Arts::Object") return true;
	return false;
}

std::string OGGPlayObject_skel::_interfaceNameSkel()
{
	return "OGGPlayObject";
}

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

OGGPlayObject_skel::OGGPlayObject_skel()
{
	_initStream("left",&left,10);
	_initStream("right",&right,10);
}

Arts::Object_base* OGGPlayObject::_Creator() {
	return OGGPlayObject_base::_create();
}

unsigned long OGGPlayObject_base::_IID = Arts::MCOPUtils::makeIID("OGGPlayObject");

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

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

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

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

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

	return _fromString(object._toString());
}

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

std::vector<std::string> CDDAPlayObject_base::_defaultPortsIn() const {
	std::vector<std::string> ret;
	ret.push_back("indata");
	return ret;
}
std::vector<std::string> CDDAPlayObject_base::_defaultPortsOut() const {
	std::vector<std::string> ret;
	return ret;
}

void *CDDAPlayObject_base::_cast(unsigned long iid)
{
	if(iid == CDDAPlayObject_base::_IID) return (CDDAPlayObject_base *)this;
	if(iid == DecoderBaseObject_base::_IID) return (DecoderBaseObject_base *)this;
	if(iid == Arts::StreamPlayObject_base::_IID) return (Arts::StreamPlayObject_base *)this;
	if(iid == Arts::PlayObject_base::_IID) return (Arts::PlayObject_base *)this;
	if(iid == Arts::PlayObject_private_base::_IID) return (Arts::PlayObject_private_base *)this;
	if(iid == Arts::SynthModule_base::_IID) return (Arts::SynthModule_base *)this;
	if(iid == Arts::PitchablePlayObject_base::_IID) return (Arts::PitchablePlayObject_base *)this;
	if(iid == Arts::Object_base::_IID) return (Arts::Object_base *)this;
	return 0;
}

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

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

std::string CDDAPlayObject_skel::_interfaceName()
{
	return "CDDAPlayObject";
}

bool CDDAPlayObject_skel::_isCompatibleWith(const std::string& interfacename)
{
	if (interfacename == "CDDAPlayObject") return true;
	if (interfacename == "DecoderBaseObject") return true;
	if (interfacename == "Arts::StreamPlayObject") return true;
	if (interfacename == "Arts::PlayObject") return true;
	if (interfacename == "Arts::PlayObject_private") return true;
	if (interfacename == "Arts::SynthModule") return true;
	if (interfacename == "Arts::PitchablePlayObject") return true;
	if (interfacename == "Arts::Object") return true;
	return false;
}

std::string CDDAPlayObject_skel::_interfaceNameSkel()
{
	return "CDDAPlayObject";
}

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

CDDAPlayObject_skel::CDDAPlayObject_skel()
{
	_initStream("left",&left,10);
	_initStream("right",&right,10);
}

Arts::Object_base* CDDAPlayObject::_Creator() {
	return CDDAPlayObject_base::_create();
}

unsigned long CDDAPlayObject_base::_IID = Arts::MCOPUtils::makeIID("CDDAPlayObject");

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

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

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

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

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

	return _fromString(object._toString());
}

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

std::vector<std::string> VCDPlayObject_base::_defaultPortsIn() const {
	std::vector<std::string> ret;
	ret.push_back("indata");
	return ret;
}
std::vector<std::string> VCDPlayObject_base::_defaultPortsOut() const {
	std::vector<std::string> ret;
	return ret;
}

void *VCDPlayObject_base::_cast(unsigned long iid)
{
	if(iid == VCDPlayObject_base::_IID) return (VCDPlayObject_base *)this;
	if(iid == DecoderBaseObject_base::_IID) return (DecoderBaseObject_base *)this;
	if(iid == Arts::StreamPlayObject_base::_IID) return (Arts::StreamPlayObject_base *)this;
	if(iid == Arts::PlayObject_base::_IID) return (Arts::PlayObject_base *)this;
	if(iid == Arts::PlayObject_private_base::_IID) return (Arts::PlayObject_private_base *)this;
	if(iid == Arts::SynthModule_base::_IID) return (Arts::SynthModule_base *)this;
	if(iid == Arts::PitchablePlayObject_base::_IID) return (Arts::PitchablePlayObject_base *)this;
	if(iid == Arts::Object_base::_IID) return (Arts::Object_base *)this;
	return 0;
}

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

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

std::string VCDPlayObject_skel::_interfaceName()
{
	return "VCDPlayObject";
}

bool VCDPlayObject_skel::_isCompatibleWith(const std::string& interfacename)
{
	if (interfacename == "VCDPlayObject") return true;
	if (interfacename == "DecoderBaseObject") return true;
	if (interfacename == "Arts::StreamPlayObject") return true;
	if (interfacename == "Arts::PlayObject") return true;
	if (interfacename == "Arts::PlayObject_private") return true;
	if (interfacename == "Arts::SynthModule") return true;
	if (interfacename == "Arts::PitchablePlayObject") return true;
	if (interfacename == "Arts::Object") return true;
	return false;
}

std::string VCDPlayObject_skel::_interfaceNameSkel()
{
	return "VCDPlayObject";
}

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

VCDPlayObject_skel::VCDPlayObject_skel()
{
	_initStream("left",&left,10);
	_initStream("right",&right,10);
}

Arts::Object_base* VCDPlayObject::_Creator() {
	return VCDPlayObject_base::_create();
}

unsigned long VCDPlayObject_base::_IID = Arts::MCOPUtils::makeIID("VCDPlayObject");

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

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

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

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

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

	return _fromString(object._toString());
}

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

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

void *NULLPlayObject_base::_cast(unsigned long iid)
{
	if(iid == NULLPlayObject_base::_IID) return (NULLPlayObject_base *)this;
	if(iid == Arts::PlayObject_base::_IID) return (Arts::PlayObject_base *)this;
	if(iid == Arts::PlayObject_private_base::_IID) return (Arts::PlayObject_private_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;
}

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

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

std::string NULLPlayObject_skel::_interfaceName()
{
	return "NULLPlayObject";
}

bool NULLPlayObject_skel::_isCompatibleWith(const std::string& interfacename)
{
	if (interfacename == "NULLPlayObject") return true;
	if (interfacename == "Arts::PlayObject") return true;
	if (interfacename == "Arts::PlayObject_private") return true;
	if (interfacename == "Arts::SynthModule") return true;
	if (interfacename == "Arts::Object") return true;
	return false;
}

std::string NULLPlayObject_skel::_interfaceNameSkel()
{
	return "NULLPlayObject";
}

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

NULLPlayObject_skel::NULLPlayObject_skel()
{
	_initStream("left",&left,10);
	_initStream("right",&right,10);
}

Arts::Object_base* NULLPlayObject::_Creator() {
	return NULLPlayObject_base::_create();
}

unsigned long NULLPlayObject_base::_IID = Arts::MCOPUtils::makeIID("NULLPlayObject");

static Arts::IDLFileReg IDLFileReg_decoderBaseObject("decoderBaseObject",
    "IDLFile:0000000100000000000000000000000008000000124465636f646572426173"
    "654f626a656374000000000300000017417274733a3a53747265616d506c61794f626a"
    "6563740000000012417274733a3a53796e74684d6f64756c65000000001a417274733a"
    "3a506974636861626c65506c61794f626a65637400000000000000000200000007696e"
    "6461746100000000056279746500000000290000000000000009626c6f636b696e6700"
    "00000008626f6f6c65616e00000000130000000000000000000000000000000e4d5033"
    "506c61794f626a6563740000000001000000124465636f646572426173654f626a6563"
    "74000000000000000002000000056c6566740000000006666c6f6174000000000a0000"
    "00000000000672696768740000000006666c6f6174000000000a000000000000000000"
    "0000000000000e574156506c61794f626a6563740000000001000000124465636f6465"
    "72426173654f626a656374000000000000000002000000056c6566740000000006666c"
    "6f6174000000000a000000000000000672696768740000000006666c6f617400000000"
    "0a0000000000000000000000000000000e4d5047506c61794f626a6563740000000001"
    "000000124465636f646572426173654f626a656374000000000000000002000000056c"
    "6566740000000006666c6f6174000000000a0000000000000006726967687400000000"
    "06666c6f6174000000000a0000000000000000000000000000000e4f4747506c61794f"
    "626a6563740000000001000000124465636f646572426173654f626a65637400000000"
    "0000000002000000056c6566740000000006666c6f6174000000000a00000000000000"
    "0672696768740000000006666c6f6174000000000a0000000000000000000000000000"
    "000f43444441506c61794f626a6563740000000001000000124465636f646572426173"
    "654f626a656374000000000000000002000000056c6566740000000006666c6f617400"
    "0000000a000000000000000672696768740000000006666c6f6174000000000a000000"
    "0000000000000000000000000e564344506c61794f626a656374000000000100000012"
    "4465636f646572426173654f626a656374000000000000000002000000056c65667400"
    "00000006666c6f6174000000000a000000000000000672696768740000000006666c6f"
    "6174000000000a0000000000000000000000000000000f4e554c4c506c61794f626a65"
    "6374000000000200000011417274733a3a506c61794f626a6563740000000012417274"
    "733a3a53796e74684d6f64756c65000000000000000002000000056c65667400000000"
    "06666c6f6174000000000a000000000000000672696768740000000006666c6f617400"
    "0000000a00000000000000000000000000000000"
);
