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

#include "akodearts.h"

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

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

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

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

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

	return _fromString(object._toString());
}

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

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

void *akodePlayObject_base::_cast(unsigned long iid)
{
	if(iid == akodePlayObject_base::_IID) return (akodePlayObject_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;
}

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

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

std::string akodePlayObject_skel::_interfaceName()
{
	return "akodePlayObject";
}

bool akodePlayObject_skel::_isCompatibleWith(const std::string& interfacename)
{
	if (interfacename == "akodePlayObject") 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 akodePlayObject_skel::_interfaceNameSkel()
{
	return "akodePlayObject";
}

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

akodePlayObject_skel::akodePlayObject_skel()
{
	_initStream("indata",&indata,41);
	_initStream("left",&left,10);
	_initStream("right",&right,10);
}

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

Arts::Object_base* akodePlayObject::_Creator() {
	return akodePlayObject_base::_create();
}

unsigned long akodePlayObject_base::_IID = Arts::MCOPUtils::makeIID("akodePlayObject");

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

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

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

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

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

	return _fromString(object._toString());
}

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

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

void *akodeMPCPlayObject_base::_cast(unsigned long iid)
{
	if(iid == akodeMPCPlayObject_base::_IID) return (akodeMPCPlayObject_base *)this;
	if(iid == akodePlayObject_base::_IID) return (akodePlayObject_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;
}

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

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

std::string akodeMPCPlayObject_skel::_interfaceName()
{
	return "akodeMPCPlayObject";
}

bool akodeMPCPlayObject_skel::_isCompatibleWith(const std::string& interfacename)
{
	if (interfacename == "akodeMPCPlayObject") return true;
	if (interfacename == "akodePlayObject") 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 akodeMPCPlayObject_skel::_interfaceNameSkel()
{
	return "akodeMPCPlayObject";
}

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

akodeMPCPlayObject_skel::akodeMPCPlayObject_skel()
{
}

Arts::Object_base* akodeMPCPlayObject::_Creator() {
	return akodeMPCPlayObject_base::_create();
}

unsigned long akodeMPCPlayObject_base::_IID = Arts::MCOPUtils::makeIID("akodeMPCPlayObject");

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

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

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

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

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

	return _fromString(object._toString());
}

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

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

void *akodeMPEGPlayObject_base::_cast(unsigned long iid)
{
	if(iid == akodeMPEGPlayObject_base::_IID) return (akodeMPEGPlayObject_base *)this;
	if(iid == akodePlayObject_base::_IID) return (akodePlayObject_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;
}

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

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

std::string akodeMPEGPlayObject_skel::_interfaceName()
{
	return "akodeMPEGPlayObject";
}

bool akodeMPEGPlayObject_skel::_isCompatibleWith(const std::string& interfacename)
{
	if (interfacename == "akodeMPEGPlayObject") return true;
	if (interfacename == "akodePlayObject") 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 akodeMPEGPlayObject_skel::_interfaceNameSkel()
{
	return "akodeMPEGPlayObject";
}

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

akodeMPEGPlayObject_skel::akodeMPEGPlayObject_skel()
{
}

Arts::Object_base* akodeMPEGPlayObject::_Creator() {
	return akodeMPEGPlayObject_base::_create();
}

unsigned long akodeMPEGPlayObject_base::_IID = Arts::MCOPUtils::makeIID("akodeMPEGPlayObject");

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

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

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

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

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

	return _fromString(object._toString());
}

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

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

void *akodeFFMPEGPlayObject_base::_cast(unsigned long iid)
{
	if(iid == akodeFFMPEGPlayObject_base::_IID) return (akodeFFMPEGPlayObject_base *)this;
	if(iid == akodePlayObject_base::_IID) return (akodePlayObject_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;
}

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

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

std::string akodeFFMPEGPlayObject_skel::_interfaceName()
{
	return "akodeFFMPEGPlayObject";
}

bool akodeFFMPEGPlayObject_skel::_isCompatibleWith(const std::string& interfacename)
{
	if (interfacename == "akodeFFMPEGPlayObject") return true;
	if (interfacename == "akodePlayObject") 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 akodeFFMPEGPlayObject_skel::_interfaceNameSkel()
{
	return "akodeFFMPEGPlayObject";
}

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

akodeFFMPEGPlayObject_skel::akodeFFMPEGPlayObject_skel()
{
}

Arts::Object_base* akodeFFMPEGPlayObject::_Creator() {
	return akodeFFMPEGPlayObject_base::_create();
}

unsigned long akodeFFMPEGPlayObject_base::_IID = Arts::MCOPUtils::makeIID("akodeFFMPEGPlayObject");

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

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

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

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

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

	return _fromString(object._toString());
}

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

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

void *akodeXiphPlayObject_base::_cast(unsigned long iid)
{
	if(iid == akodeXiphPlayObject_base::_IID) return (akodeXiphPlayObject_base *)this;
	if(iid == akodePlayObject_base::_IID) return (akodePlayObject_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;
}

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

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

std::string akodeXiphPlayObject_skel::_interfaceName()
{
	return "akodeXiphPlayObject";
}

bool akodeXiphPlayObject_skel::_isCompatibleWith(const std::string& interfacename)
{
	if (interfacename == "akodeXiphPlayObject") return true;
	if (interfacename == "akodePlayObject") 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 akodeXiphPlayObject_skel::_interfaceNameSkel()
{
	return "akodeXiphPlayObject";
}

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

akodeXiphPlayObject_skel::akodeXiphPlayObject_skel()
{
}

Arts::Object_base* akodeXiphPlayObject::_Creator() {
	return akodeXiphPlayObject_base::_create();
}

unsigned long akodeXiphPlayObject_base::_IID = Arts::MCOPUtils::makeIID("akodeXiphPlayObject");

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

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

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

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

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

	return _fromString(object._toString());
}

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

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

void *akodeFAADPlayObject_base::_cast(unsigned long iid)
{
	if(iid == akodeFAADPlayObject_base::_IID) return (akodeFAADPlayObject_base *)this;
	if(iid == akodePlayObject_base::_IID) return (akodePlayObject_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;
}

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

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

std::string akodeFAADPlayObject_skel::_interfaceName()
{
	return "akodeFAADPlayObject";
}

bool akodeFAADPlayObject_skel::_isCompatibleWith(const std::string& interfacename)
{
	if (interfacename == "akodeFAADPlayObject") return true;
	if (interfacename == "akodePlayObject") 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 akodeFAADPlayObject_skel::_interfaceNameSkel()
{
	return "akodeFAADPlayObject";
}

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

akodeFAADPlayObject_skel::akodeFAADPlayObject_skel()
{
}

Arts::Object_base* akodeFAADPlayObject::_Creator() {
	return akodeFAADPlayObject_base::_create();
}

unsigned long akodeFAADPlayObject_base::_IID = Arts::MCOPUtils::makeIID("akodeFAADPlayObject");

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

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

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

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

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

	return _fromString(object._toString());
}

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

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

void *akodeVorbisStreamPlayObject_base::_cast(unsigned long iid)
{
	if(iid == akodeVorbisStreamPlayObject_base::_IID) return (akodeVorbisStreamPlayObject_base *)this;
	if(iid == akodePlayObject_base::_IID) return (akodePlayObject_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;
}

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

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

std::string akodeVorbisStreamPlayObject_skel::_interfaceName()
{
	return "akodeVorbisStreamPlayObject";
}

bool akodeVorbisStreamPlayObject_skel::_isCompatibleWith(const std::string& interfacename)
{
	if (interfacename == "akodeVorbisStreamPlayObject") return true;
	if (interfacename == "akodePlayObject") 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 akodeVorbisStreamPlayObject_skel::_interfaceNameSkel()
{
	return "akodeVorbisStreamPlayObject";
}

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

akodeVorbisStreamPlayObject_skel::akodeVorbisStreamPlayObject_skel()
{
}

Arts::Object_base* akodeVorbisStreamPlayObject::_Creator() {
	return akodeVorbisStreamPlayObject_base::_create();
}

unsigned long akodeVorbisStreamPlayObject_base::_IID = Arts::MCOPUtils::makeIID("akodeVorbisStreamPlayObject");

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

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

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

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

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

	return _fromString(object._toString());
}

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

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

void *akodeSpeexStreamPlayObject_base::_cast(unsigned long iid)
{
	if(iid == akodeSpeexStreamPlayObject_base::_IID) return (akodeSpeexStreamPlayObject_base *)this;
	if(iid == akodePlayObject_base::_IID) return (akodePlayObject_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;
}

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

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

std::string akodeSpeexStreamPlayObject_skel::_interfaceName()
{
	return "akodeSpeexStreamPlayObject";
}

bool akodeSpeexStreamPlayObject_skel::_isCompatibleWith(const std::string& interfacename)
{
	if (interfacename == "akodeSpeexStreamPlayObject") return true;
	if (interfacename == "akodePlayObject") 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 akodeSpeexStreamPlayObject_skel::_interfaceNameSkel()
{
	return "akodeSpeexStreamPlayObject";
}

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

akodeSpeexStreamPlayObject_skel::akodeSpeexStreamPlayObject_skel()
{
}

Arts::Object_base* akodeSpeexStreamPlayObject::_Creator() {
	return akodeSpeexStreamPlayObject_base::_create();
}

unsigned long akodeSpeexStreamPlayObject_base::_IID = Arts::MCOPUtils::makeIID("akodeSpeexStreamPlayObject");

static Arts::IDLFileReg IDLFileReg_akodearts("akodearts",
    "IDLFile:000000010000000000000000000000000800000010616b6f6465506c61794f"
    "626a656374000000000300000017417274733a3a53747265616d506c61794f626a6563"
    "740000000012417274733a3a53796e74684d6f64756c65000000001a417274733a3a50"
    "6974636861626c65506c61794f626a65637400000000000000000300000007696e6461"
    "7461000000000562797465000000002900000000000000056c6566740000000006666c"
    "6f6174000000000a000000000000000672696768740000000006666c6f617400000000"
    "0a00000000000000000000000000000013616b6f64654d5043506c61794f626a656374"
    "000000000100000010616b6f6465506c61794f626a6563740000000000000000000000"
    "00000000000000000014616b6f64654d504547506c61794f626a656374000000000100"
    "000010616b6f6465506c61794f626a6563740000000000000000000000000000000000"
    "00000016616b6f646546464d504547506c61794f626a65637400000000010000001061"
    "6b6f6465506c61794f626a656374000000000000000000000000000000000000000014"
    "616b6f646558697068506c61794f626a656374000000000100000010616b6f6465506c"
    "61794f626a656374000000000000000000000000000000000000000014616b6f646546"
    "414144506c61794f626a656374000000000100000010616b6f6465506c61794f626a65"
    "637400000000000000000000000000000000000000001c616b6f6465566f7262697353"
    "747265616d506c61794f626a656374000000000100000010616b6f6465506c61794f62"
    "6a65637400000000000000000000000000000000000000001b616b6f64655370656578"
    "53747265616d506c61794f626a656374000000000100000010616b6f6465506c61794f"
    "626a656374000000000000000000000000000000000000000000"
);
