/*
 *	server/zone/objects/intangible/VehicleControlDevice.cpp generated by engine3 IDL compiler 0.60
 */

#include "VehicleControlDevice.h"

#include "server/zone/objects/intangible/IntangibleObject.h"

#include "server/zone/objects/creature/VehicleObject.h"

#include "server/zone/objects/creature/CreatureObject.h"

#include "server/zone/objects/tangible/TangibleObject.h"

#include "server/zone/objects/scene/SceneObject.h"

#include "server/zone/Zone.h"

#include "server/zone/objects/creature/CreatureObject.h"

#include "server/zone/objects/intangible/VehicleControlObserver.h"

/*
 *	VehicleControlDeviceStub
 */

enum {RPC_STOREOBJECT__CREATUREOBJECT_ = 6,RPC_GENERATEOBJECT__CREATUREOBJECT_,RPC_SPAWNOBJECT__CREATUREOBJECT_,RPC_CANCELSPAWNOBJECT__CREATUREOBJECT_,RPC_HANDLEOBJECTMENUSELECT__CREATUREOBJECT_BYTE_,RPC_DESTROYOBJECTFROMDATABASE__BOOL_,RPC_CANBEDESTROYED__CREATUREOBJECT_};

VehicleControlDevice::VehicleControlDevice() : ControlDevice(DummyConstructorParameter::instance()) {
	VehicleControlDeviceImplementation* _implementation = new VehicleControlDeviceImplementation();
	_impl = _implementation;
	_impl->_setStub(this);
	_setClassName("VehicleControlDevice");
}

VehicleControlDevice::VehicleControlDevice(DummyConstructorParameter* param) : ControlDevice(param) {
	_setClassName("VehicleControlDevice");
}

VehicleControlDevice::~VehicleControlDevice() {
}



void VehicleControlDevice::storeObject(CreatureObject* player) {
	VehicleControlDeviceImplementation* _implementation = static_cast<VehicleControlDeviceImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_STOREOBJECT__CREATUREOBJECT_);
		method.addObjectParameter(player);

		method.executeWithVoidReturn();
	} else
		_implementation->storeObject(player);
}

void VehicleControlDevice::generateObject(CreatureObject* player) {
	VehicleControlDeviceImplementation* _implementation = static_cast<VehicleControlDeviceImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_GENERATEOBJECT__CREATUREOBJECT_);
		method.addObjectParameter(player);

		method.executeWithVoidReturn();
	} else
		_implementation->generateObject(player);
}

void VehicleControlDevice::spawnObject(CreatureObject* player) {
	VehicleControlDeviceImplementation* _implementation = static_cast<VehicleControlDeviceImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_SPAWNOBJECT__CREATUREOBJECT_);
		method.addObjectParameter(player);

		method.executeWithVoidReturn();
	} else
		_implementation->spawnObject(player);
}

void VehicleControlDevice::cancelSpawnObject(CreatureObject* player) {
	VehicleControlDeviceImplementation* _implementation = static_cast<VehicleControlDeviceImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_CANCELSPAWNOBJECT__CREATUREOBJECT_);
		method.addObjectParameter(player);

		method.executeWithVoidReturn();
	} else
		_implementation->cancelSpawnObject(player);
}

int VehicleControlDevice::handleObjectMenuSelect(CreatureObject* player, byte selectedID) {
	VehicleControlDeviceImplementation* _implementation = static_cast<VehicleControlDeviceImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_HANDLEOBJECTMENUSELECT__CREATUREOBJECT_BYTE_);
		method.addObjectParameter(player);
		method.addByteParameter(selectedID);

		return method.executeWithSignedIntReturn();
	} else
		return _implementation->handleObjectMenuSelect(player, selectedID);
}

void VehicleControlDevice::destroyObjectFromDatabase(bool destroyContainedObjects) {
	VehicleControlDeviceImplementation* _implementation = static_cast<VehicleControlDeviceImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_DESTROYOBJECTFROMDATABASE__BOOL_);
		method.addBooleanParameter(destroyContainedObjects);

		method.executeWithVoidReturn();
	} else
		_implementation->destroyObjectFromDatabase(destroyContainedObjects);
}

int VehicleControlDevice::canBeDestroyed(CreatureObject* player) {
	VehicleControlDeviceImplementation* _implementation = static_cast<VehicleControlDeviceImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_CANBEDESTROYED__CREATUREOBJECT_);
		method.addObjectParameter(player);

		return method.executeWithSignedIntReturn();
	} else
		return _implementation->canBeDestroyed(player);
}

DistributedObjectServant* VehicleControlDevice::_getImplementation() {

	 if (!_updated) _updated = true;
	return _impl;
}

DistributedObjectServant* VehicleControlDevice::_getImplementationForRead() {
	return _impl;
}

void VehicleControlDevice::_setImplementation(DistributedObjectServant* servant) {
	_impl = servant;
}

/*
 *	VehicleControlDeviceImplementation
 */

VehicleControlDeviceImplementation::VehicleControlDeviceImplementation(DummyConstructorParameter* param) : ControlDeviceImplementation(param) {
	_initializeImplementation();
}


VehicleControlDeviceImplementation::~VehicleControlDeviceImplementation() {
}


void VehicleControlDeviceImplementation::finalize() {
}

void VehicleControlDeviceImplementation::_initializeImplementation() {
	_setClassHelper(VehicleControlDeviceHelper::instance());

	_this = NULL;

	_serializationHelperMethod();
}

void VehicleControlDeviceImplementation::_setStub(DistributedObjectStub* stub) {
	_this = static_cast<VehicleControlDevice*>(stub);
	ControlDeviceImplementation::_setStub(stub);
}

DistributedObjectStub* VehicleControlDeviceImplementation::_getStub() {
	return _this.get();
}

VehicleControlDeviceImplementation::operator const VehicleControlDevice*() {
	return _this.get();
}

void VehicleControlDeviceImplementation::lock(bool doLock) {
	_this.getReferenceUnsafeStaticCast()->lock(doLock);
}

void VehicleControlDeviceImplementation::lock(ManagedObject* obj) {
	_this.getReferenceUnsafeStaticCast()->lock(obj);
}

void VehicleControlDeviceImplementation::rlock(bool doLock) {
	_this.getReferenceUnsafeStaticCast()->rlock(doLock);
}

void VehicleControlDeviceImplementation::wlock(bool doLock) {
	_this.getReferenceUnsafeStaticCast()->wlock(doLock);
}

void VehicleControlDeviceImplementation::wlock(ManagedObject* obj) {
	_this.getReferenceUnsafeStaticCast()->wlock(obj);
}

void VehicleControlDeviceImplementation::unlock(bool doLock) {
	_this.getReferenceUnsafeStaticCast()->unlock(doLock);
}

void VehicleControlDeviceImplementation::runlock(bool doLock) {
	_this.getReferenceUnsafeStaticCast()->runlock(doLock);
}

void VehicleControlDeviceImplementation::_serializationHelperMethod() {
	ControlDeviceImplementation::_serializationHelperMethod();

	_setClassName("VehicleControlDevice");

}

void VehicleControlDeviceImplementation::readObject(ObjectInputStream* stream) {
	uint16 _varCount = stream->readShort();
	for (int i = 0; i < _varCount; ++i) {
		uint32 _nameHashCode;
		TypeInfo<uint32>::parseFromBinaryStream(&_nameHashCode, stream);

		uint32 _varSize = stream->readInt();

		int _currentOffset = stream->getOffset();

		if(VehicleControlDeviceImplementation::readObjectMember(stream, _nameHashCode)) {
		}

		stream->setOffset(_currentOffset + _varSize);
	}

	initializeTransientMembers();
}

bool VehicleControlDeviceImplementation::readObjectMember(ObjectInputStream* stream, const uint32& nameHashCode) {
	if (ControlDeviceImplementation::readObjectMember(stream, nameHashCode))
		return true;

	switch(nameHashCode) {
	case 0xe8dcfb36: //VehicleControlDevice.vehicleControlObserver
		TypeInfo<ManagedReference<VehicleControlObserver* > >::parseFromBinaryStream(&vehicleControlObserver, stream);
		return true;

	}

	return false;
}

void VehicleControlDeviceImplementation::writeObject(ObjectOutputStream* stream) {
	int _currentOffset = stream->getOffset();
	stream->writeShort(0);
	int _varCount = VehicleControlDeviceImplementation::writeObjectMembers(stream);
	stream->writeShort(_currentOffset, _varCount);
}

int VehicleControlDeviceImplementation::writeObjectMembers(ObjectOutputStream* stream) {
	int _count = ControlDeviceImplementation::writeObjectMembers(stream);

	uint32 _nameHashCode;
	int _offset;
	uint32 _totalSize;
	_nameHashCode = 0xe8dcfb36; //VehicleControlDevice.vehicleControlObserver
	TypeInfo<uint32>::toBinaryStream(&_nameHashCode, stream);
	_offset = stream->getOffset();
	stream->writeInt(0);
	TypeInfo<ManagedReference<VehicleControlObserver* > >::toBinaryStream(&vehicleControlObserver, stream);
	_totalSize = (uint32) (stream->getOffset() - (_offset + 4));
	stream->writeInt(_offset, _totalSize);


	return _count + 1;
}

VehicleControlDeviceImplementation::VehicleControlDeviceImplementation() {
	_initializeImplementation();
	// server/zone/objects/intangible/VehicleControlDevice.idl():  		Logger.setLoggingName("VehicleControlDevice");
	Logger::setLoggingName("VehicleControlDevice");
	// server/zone/objects/intangible/VehicleControlDevice.idl():  		Logger.setLogging(false);
	Logger::setLogging(false);
	// server/zone/objects/intangible/VehicleControlDevice.idl():  		Logger.setGlobalLogging(true);
	Logger::setGlobalLogging(true);
}

int VehicleControlDeviceImplementation::handleObjectMenuSelect(CreatureObject* player, byte selectedID) {
	// server/zone/objects/intangible/VehicleControlDevice.idl():  		Logger.info("selected call");
	Logger::info("selected call");
	// server/zone/objects/intangible/VehicleControlDevice.idl():  		TangibleObject controlledObject = super.controlledObject;
	ManagedReference<TangibleObject* > controlledObject = ControlDeviceImplementation::controlledObject.getForUpdate();
	// server/zone/objects/intangible/VehicleControlDevice.idl():  		return 
	if (selectedID == RadialOptions::VEHICLE_GENERATE){
	// server/zone/objects/intangible/VehicleControlDevice.idl():  			}
	if (controlledObject == NULL){
	// server/zone/objects/intangible/VehicleControlDevice.idl():  				Logger.error("null controlled object in vehicle control device");
	Logger::error("null controlled object in vehicle control device");
	// server/zone/objects/intangible/VehicleControlDevice.idl():  				return 1;
	return 1;
}

	else {
	// server/zone/objects/intangible/VehicleControlDevice.idl():  				this.generateObject(player);
	_this.get()->generateObject(player);
}
}

	else 	// server/zone/objects/intangible/VehicleControlDevice.idl():  		return 
	if (selectedID == RadialOptions::VEHICLE_STORE){
	// server/zone/objects/intangible/VehicleControlDevice.idl():  			}
	if (controlledObject == NULL){
	// server/zone/objects/intangible/VehicleControlDevice.idl():  				Logger.error("null controlled object in vehicle control device");
	Logger::error("null controlled object in vehicle control device");
	// server/zone/objects/intangible/VehicleControlDevice.idl():  				return 1;
	return 1;
}

	else {
	// server/zone/objects/intangible/VehicleControlDevice.idl():  				}
	if (ControlDeviceImplementation::status == 1 && !controlledObject->isInQuadTree()){
	// server/zone/objects/intangible/VehicleControlDevice.idl():  					this.generateObject(player);
	_this.get()->generateObject(player);
}

	else {
	// server/zone/objects/intangible/VehicleControlDevice.idl():  					this.storeObject(player);
	_this.get()->storeObject(player);
}
}
}
	// server/zone/objects/intangible/VehicleControlDevice.idl():  		return 0;
	return 0;
}

/*
 *	VehicleControlDeviceAdapter
 */


#include "engine/orb/messages/InvokeMethodMessage.h"


VehicleControlDeviceAdapter::VehicleControlDeviceAdapter(VehicleControlDevice* obj) : ControlDeviceAdapter(obj) {
}

void VehicleControlDeviceAdapter::invokeMethod(uint32 methid, DistributedMethod* inv) {
	DOBMessage* resp = inv->getInvocationMessage();

	switch (methid) {
	case RPC_STOREOBJECT__CREATUREOBJECT_:
		{
			storeObject(static_cast<CreatureObject*>(inv->getObjectParameter()));
		}
		break;
	case RPC_GENERATEOBJECT__CREATUREOBJECT_:
		{
			generateObject(static_cast<CreatureObject*>(inv->getObjectParameter()));
		}
		break;
	case RPC_SPAWNOBJECT__CREATUREOBJECT_:
		{
			spawnObject(static_cast<CreatureObject*>(inv->getObjectParameter()));
		}
		break;
	case RPC_CANCELSPAWNOBJECT__CREATUREOBJECT_:
		{
			cancelSpawnObject(static_cast<CreatureObject*>(inv->getObjectParameter()));
		}
		break;
	case RPC_HANDLEOBJECTMENUSELECT__CREATUREOBJECT_BYTE_:
		{
			resp->insertSignedInt(handleObjectMenuSelect(static_cast<CreatureObject*>(inv->getObjectParameter()), inv->getByteParameter()));
		}
		break;
	case RPC_DESTROYOBJECTFROMDATABASE__BOOL_:
		{
			destroyObjectFromDatabase(inv->getBooleanParameter());
		}
		break;
	case RPC_CANBEDESTROYED__CREATUREOBJECT_:
		{
			resp->insertSignedInt(canBeDestroyed(static_cast<CreatureObject*>(inv->getObjectParameter())));
		}
		break;
	default:
		throw Exception("Method does not exists");
	}
}

void VehicleControlDeviceAdapter::storeObject(CreatureObject* player) {
	(static_cast<VehicleControlDevice*>(stub))->storeObject(player);
}

void VehicleControlDeviceAdapter::generateObject(CreatureObject* player) {
	(static_cast<VehicleControlDevice*>(stub))->generateObject(player);
}

void VehicleControlDeviceAdapter::spawnObject(CreatureObject* player) {
	(static_cast<VehicleControlDevice*>(stub))->spawnObject(player);
}

void VehicleControlDeviceAdapter::cancelSpawnObject(CreatureObject* player) {
	(static_cast<VehicleControlDevice*>(stub))->cancelSpawnObject(player);
}

int VehicleControlDeviceAdapter::handleObjectMenuSelect(CreatureObject* player, byte selectedID) {
	return (static_cast<VehicleControlDevice*>(stub))->handleObjectMenuSelect(player, selectedID);
}

void VehicleControlDeviceAdapter::destroyObjectFromDatabase(bool destroyContainedObjects) {
	(static_cast<VehicleControlDevice*>(stub))->destroyObjectFromDatabase(destroyContainedObjects);
}

int VehicleControlDeviceAdapter::canBeDestroyed(CreatureObject* player) {
	return (static_cast<VehicleControlDevice*>(stub))->canBeDestroyed(player);
}

/*
 *	VehicleControlDeviceHelper
 */

VehicleControlDeviceHelper* VehicleControlDeviceHelper::staticInitializer = VehicleControlDeviceHelper::instance();

VehicleControlDeviceHelper::VehicleControlDeviceHelper() {
	className = "VehicleControlDevice";

	Core::getObjectBroker()->registerClass(className, this);
}

void VehicleControlDeviceHelper::finalizeHelper() {
	VehicleControlDeviceHelper::finalize();
}

DistributedObject* VehicleControlDeviceHelper::instantiateObject() {
	return new VehicleControlDevice(DummyConstructorParameter::instance());
}

DistributedObjectServant* VehicleControlDeviceHelper::instantiateServant() {
	return new VehicleControlDeviceImplementation();
}

DistributedObjectAdapter* VehicleControlDeviceHelper::createAdapter(DistributedObjectStub* obj) {
	DistributedObjectAdapter* adapter = new VehicleControlDeviceAdapter(static_cast<VehicleControlDevice*>(obj));

	obj->_setClassName(className);
	obj->_setClassHelper(this);

	adapter->setStub(obj);

	return adapter;
}