BeobotEvents.ice.C

// **********************************************************************
//
// Copyright (c) 2003-2009 ZeroC, Inc. All rights reserved.
//
// This copy of Ice is licensed to you under the terms described in the
// ICE_LICENSE file included in this distribution.
//
// **********************************************************************

// Ice version 3.3.1
// Generated from file `BeobotEvents.ice'

#include <BeobotEvents.ice.H>
#include <Ice/LocalException.h>
#include <Ice/ObjectFactory.h>
#include <Ice/BasicStream.h>
#include <IceUtil/Iterator.h>
#include <IceUtil/ScopedArray.h>

#ifndef ICE_IGNORE_VERSION
#   if ICE_INT_VERSION / 100 != 303
#       error Ice version mismatch!
#   endif
#   if ICE_INT_VERSION % 100 > 50
#       error Beta header file detected
#   endif
#   if ICE_INT_VERSION % 100 < 1
#       error Ice patch level mismatch!
#   endif
#endif

::Ice::Object* IceInternal::upCast(::BeobotEvents::MotorMessage* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::BeobotEvents::MotorMessage* p) { return p; }

::Ice::Object* IceInternal::upCast(::BeobotEvents::MotorRequest* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::BeobotEvents::MotorRequest* p) { return p; }

::Ice::Object* IceInternal::upCast(::BeobotEvents::CornerMotorRequest* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::BeobotEvents::CornerMotorRequest* p) { return p; }

::Ice::Object* IceInternal::upCast(::BeobotEvents::CornerLocationMessage* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::BeobotEvents::CornerLocationMessage* p) { return p; }

::Ice::Object* IceInternal::upCast(::BeobotEvents::SonarMessage* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::BeobotEvents::SonarMessage* p) { return p; }

::Ice::Object* IceInternal::upCast(::BeobotEvents::GPSMessage* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::BeobotEvents::GPSMessage* p) { return p; }

::Ice::Object* IceInternal::upCast(::BeobotEvents::LRFMessage* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::BeobotEvents::LRFMessage* p) { return p; }

::Ice::Object* IceInternal::upCast(::BeobotEvents::SLAMMessage* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::BeobotEvents::SLAMMessage* p) { return p; }

::Ice::Object* IceInternal::upCast(::BeobotEvents::IMUMessage* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::BeobotEvents::IMUMessage* p) { return p; }

::Ice::Object* IceInternal::upCast(::BeobotEvents::CameraMessage* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::BeobotEvents::CameraMessage* p) { return p; }

::Ice::Object* IceInternal::upCast(::BeobotEvents::GistSalMessage* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::BeobotEvents::GistSalMessage* p) { return p; }

::Ice::Object* IceInternal::upCast(::BeobotEvents::LandmarkSearchQueueMessage* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::BeobotEvents::LandmarkSearchQueueMessage* p) { return p; }

::Ice::Object* IceInternal::upCast(::BeobotEvents::LandmarkTrackMessage* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::BeobotEvents::LandmarkTrackMessage* p) { return p; }

::Ice::Object* IceInternal::upCast(::BeobotEvents::LandmarkSearchStatMessage* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::BeobotEvents::LandmarkSearchStatMessage* p) { return p; }

::Ice::Object* IceInternal::upCast(::BeobotEvents::LandmarkMatchResultMessage* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::BeobotEvents::LandmarkMatchResultMessage* p) { return p; }

::Ice::Object* IceInternal::upCast(::BeobotEvents::LandmarkDBSearchResultMessage* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::BeobotEvents::LandmarkDBSearchResultMessage* p) { return p; }

::Ice::Object* IceInternal::upCast(::BeobotEvents::CurrentLocationMessage* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::BeobotEvents::CurrentLocationMessage* p) { return p; }

::Ice::Object* IceInternal::upCast(::BeobotEvents::CancelSearchMessage* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::BeobotEvents::CancelSearchMessage* p) { return p; }

::Ice::Object* IceInternal::upCast(::BeobotEvents::SearchDoneMessage* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::BeobotEvents::SearchDoneMessage* p) { return p; }

::Ice::Object* IceInternal::upCast(::BeobotEvents::NextFrameMessage* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::BeobotEvents::NextFrameMessage* p) { return p; }

::Ice::Object* IceInternal::upCast(::BeobotEvents::AbortMessage* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::BeobotEvents::AbortMessage* p) { return p; }

::Ice::Object* IceInternal::upCast(::BeobotEvents::FacesMessage* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::BeobotEvents::FacesMessage* p) { return p; }

::Ice::Object* IceInternal::upCast(::BeobotEvents::GUISpeechMessage* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::BeobotEvents::GUISpeechMessage* p) { return p; }

void
BeobotEvents::__read(::IceInternal::BasicStream* __is, ::BeobotEvents::MotorMessagePrx& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::BeobotEvents::MotorMessage;
        v->__copyFrom(proxy);
    }
}

void
BeobotEvents::__read(::IceInternal::BasicStream* __is, ::BeobotEvents::MotorRequestPrx& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::BeobotEvents::MotorRequest;
        v->__copyFrom(proxy);
    }
}

void
BeobotEvents::__read(::IceInternal::BasicStream* __is, ::BeobotEvents::CornerMotorRequestPrx& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::BeobotEvents::CornerMotorRequest;
        v->__copyFrom(proxy);
    }
}

void
BeobotEvents::__read(::IceInternal::BasicStream* __is, ::BeobotEvents::CornerLocationMessagePrx& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::BeobotEvents::CornerLocationMessage;
        v->__copyFrom(proxy);
    }
}

void
BeobotEvents::__read(::IceInternal::BasicStream* __is, ::BeobotEvents::SonarMessagePrx& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::BeobotEvents::SonarMessage;
        v->__copyFrom(proxy);
    }
}

void
BeobotEvents::__read(::IceInternal::BasicStream* __is, ::BeobotEvents::GPSMessagePrx& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::BeobotEvents::GPSMessage;
        v->__copyFrom(proxy);
    }
}

void
BeobotEvents::__read(::IceInternal::BasicStream* __is, ::BeobotEvents::LRFMessagePrx& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::BeobotEvents::LRFMessage;
        v->__copyFrom(proxy);
    }
}

void
BeobotEvents::__read(::IceInternal::BasicStream* __is, ::BeobotEvents::SLAMMessagePrx& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::BeobotEvents::SLAMMessage;
        v->__copyFrom(proxy);
    }
}

void
BeobotEvents::__read(::IceInternal::BasicStream* __is, ::BeobotEvents::IMUMessagePrx& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::BeobotEvents::IMUMessage;
        v->__copyFrom(proxy);
    }
}

void
BeobotEvents::__read(::IceInternal::BasicStream* __is, ::BeobotEvents::CameraMessagePrx& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::BeobotEvents::CameraMessage;
        v->__copyFrom(proxy);
    }
}

void
BeobotEvents::__read(::IceInternal::BasicStream* __is, ::BeobotEvents::GistSalMessagePrx& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::BeobotEvents::GistSalMessage;
        v->__copyFrom(proxy);
    }
}

void
BeobotEvents::__read(::IceInternal::BasicStream* __is, ::BeobotEvents::LandmarkSearchQueueMessagePrx& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::BeobotEvents::LandmarkSearchQueueMessage;
        v->__copyFrom(proxy);
    }
}

void
BeobotEvents::__read(::IceInternal::BasicStream* __is, ::BeobotEvents::LandmarkTrackMessagePrx& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::BeobotEvents::LandmarkTrackMessage;
        v->__copyFrom(proxy);
    }
}

void
BeobotEvents::__read(::IceInternal::BasicStream* __is, ::BeobotEvents::LandmarkSearchStatMessagePrx& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::BeobotEvents::LandmarkSearchStatMessage;
        v->__copyFrom(proxy);
    }
}

void
BeobotEvents::__read(::IceInternal::BasicStream* __is, ::BeobotEvents::LandmarkMatchResultMessagePrx& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::BeobotEvents::LandmarkMatchResultMessage;
        v->__copyFrom(proxy);
    }
}

void
BeobotEvents::__read(::IceInternal::BasicStream* __is, ::BeobotEvents::LandmarkDBSearchResultMessagePrx& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::BeobotEvents::LandmarkDBSearchResultMessage;
        v->__copyFrom(proxy);
    }
}

void
BeobotEvents::__read(::IceInternal::BasicStream* __is, ::BeobotEvents::CurrentLocationMessagePrx& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::BeobotEvents::CurrentLocationMessage;
        v->__copyFrom(proxy);
    }
}

void
BeobotEvents::__read(::IceInternal::BasicStream* __is, ::BeobotEvents::CancelSearchMessagePrx& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::BeobotEvents::CancelSearchMessage;
        v->__copyFrom(proxy);
    }
}

void
BeobotEvents::__read(::IceInternal::BasicStream* __is, ::BeobotEvents::SearchDoneMessagePrx& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::BeobotEvents::SearchDoneMessage;
        v->__copyFrom(proxy);
    }
}

void
BeobotEvents::__read(::IceInternal::BasicStream* __is, ::BeobotEvents::NextFrameMessagePrx& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::BeobotEvents::NextFrameMessage;
        v->__copyFrom(proxy);
    }
}

void
BeobotEvents::__read(::IceInternal::BasicStream* __is, ::BeobotEvents::AbortMessagePrx& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::BeobotEvents::AbortMessage;
        v->__copyFrom(proxy);
    }
}

void
BeobotEvents::__read(::IceInternal::BasicStream* __is, ::BeobotEvents::FacesMessagePrx& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::BeobotEvents::FacesMessage;
        v->__copyFrom(proxy);
    }
}

void
BeobotEvents::__read(::IceInternal::BasicStream* __is, ::BeobotEvents::GUISpeechMessagePrx& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::BeobotEvents::GUISpeechMessage;
        v->__copyFrom(proxy);
    }
}

bool
BeobotEvents::SalientRegion::operator==(const SalientRegion& __rhs) const
{
    if(this == &__rhs)
    {
        return true;
    }
    if(salpt != __rhs.salpt)
    {
        return false;
    }
    if(objRect != __rhs.objRect)
    {
        return false;
    }
    if(salFeatures != __rhs.salFeatures)
    {
        return false;
    }
    return true;
}

bool
BeobotEvents::SalientRegion::operator<(const SalientRegion& __rhs) const
{
    if(this == &__rhs)
    {
        return false;
    }
    if(salpt < __rhs.salpt)
    {
        return true;
    }
    else if(__rhs.salpt < salpt)
    {
        return false;
    }
    if(objRect < __rhs.objRect)
    {
        return true;
    }
    else if(__rhs.objRect < objRect)
    {
        return false;
    }
    if(salFeatures < __rhs.salFeatures)
    {
        return true;
    }
    else if(__rhs.salFeatures < salFeatures)
    {
        return false;
    }
    return false;
}

void
BeobotEvents::SalientRegion::__write(::IceInternal::BasicStream* __os) const
{
    salpt.__write(__os);
    objRect.__write(__os);
    if(salFeatures.size() == 0)
    {
        __os->writeSize(0);
    }
    else
    {
        __os->write(&salFeatures[0], &salFeatures[0] + salFeatures.size());
    }
}

void
BeobotEvents::SalientRegion::__read(::IceInternal::BasicStream* __is)
{
    salpt.__read(__is);
    objRect.__read(__is);
    __is->read(salFeatures);
}

void
BeobotEvents::__writeSalientRegionSeq(::IceInternal::BasicStream* __os, const ::BeobotEvents::SalientRegion* begin, const ::BeobotEvents::SalientRegion* end)
{
    ::Ice::Int size = static_cast< ::Ice::Int>(end - begin);
    __os->writeSize(size);
    for(int i = 0; i < size; ++i)
    {
        begin[i].__write(__os);
    }
}

void
BeobotEvents::__readSalientRegionSeq(::IceInternal::BasicStream* __is, ::BeobotEvents::SalientRegionSeq& v)
{
    ::Ice::Int sz;
    __is->readSize(sz);
    __is->startSeq(sz, 25);
    v.resize(sz);
    for(int i = 0; i < sz; ++i)
    {
        v[i].__read(__is);
        __is->checkSeq();
        __is->endElement();
    }
    __is->endSeq(sz);
}

bool
BeobotEvents::LandmarkSearchJob::operator==(const LandmarkSearchJob& __rhs) const
{
    if(this == &__rhs)
    {
        return true;
    }
    if(inputSalRegID != __rhs.inputSalRegID)
    {
        return false;
    }
    if(dbSegNum != __rhs.dbSegNum)
    {
        return false;
    }
    if(dbLmkNum != __rhs.dbLmkNum)
    {
        return false;
    }
    if(dbVOStart != __rhs.dbVOStart)
    {
        return false;
    }
    if(dbVOEnd != __rhs.dbVOEnd)
    {
        return false;
    }
    return true;
}

bool
BeobotEvents::LandmarkSearchJob::operator<(const LandmarkSearchJob& __rhs) const
{
    if(this == &__rhs)
    {
        return false;
    }
    if(inputSalRegID < __rhs.inputSalRegID)
    {
        return true;
    }
    else if(__rhs.inputSalRegID < inputSalRegID)
    {
        return false;
    }
    if(dbSegNum < __rhs.dbSegNum)
    {
        return true;
    }
    else if(__rhs.dbSegNum < dbSegNum)
    {
        return false;
    }
    if(dbLmkNum < __rhs.dbLmkNum)
    {
        return true;
    }
    else if(__rhs.dbLmkNum < dbLmkNum)
    {
        return false;
    }
    if(dbVOStart < __rhs.dbVOStart)
    {
        return true;
    }
    else if(__rhs.dbVOStart < dbVOStart)
    {
        return false;
    }
    if(dbVOEnd < __rhs.dbVOEnd)
    {
        return true;
    }
    else if(__rhs.dbVOEnd < dbVOEnd)
    {
        return false;
    }
    return false;
}

void
BeobotEvents::LandmarkSearchJob::__write(::IceInternal::BasicStream* __os) const
{
    __os->write(inputSalRegID);
    __os->write(dbSegNum);
    __os->write(dbLmkNum);
    __os->write(dbVOStart);
    __os->write(dbVOEnd);
}

void
BeobotEvents::LandmarkSearchJob::__read(::IceInternal::BasicStream* __is)
{
    __is->read(inputSalRegID);
    __is->read(dbSegNum);
    __is->read(dbLmkNum);
    __is->read(dbVOStart);
    __is->read(dbVOEnd);
}

void
BeobotEvents::__writeLandmarkSearchJobSeq(::IceInternal::BasicStream* __os, const ::BeobotEvents::LandmarkSearchJob* begin, const ::BeobotEvents::LandmarkSearchJob* end)
{
    ::Ice::Int size = static_cast< ::Ice::Int>(end - begin);
    __os->writeSize(size);
    for(int i = 0; i < size; ++i)
    {
        begin[i].__write(__os);
    }
}

void
BeobotEvents::__readLandmarkSearchJobSeq(::IceInternal::BasicStream* __is, ::BeobotEvents::LandmarkSearchJobSeq& v)
{
    ::Ice::Int sz;
    __is->readSize(sz);
    __is->checkFixedSeq(sz, 20);
    v.resize(sz);
    for(int i = 0; i < sz; ++i)
    {
        v[i].__read(__is);
    }
}

void
BeobotEvents::__writeRectangleIceSeq(::IceInternal::BasicStream* __os, const ::ImageIceMod::RectangleIce* begin, const ::ImageIceMod::RectangleIce* end)
{
    ::Ice::Int size = static_cast< ::Ice::Int>(end - begin);
    __os->writeSize(size);
    for(int i = 0; i < size; ++i)
    {
        begin[i].__write(__os);
    }
}

void
BeobotEvents::__readRectangleIceSeq(::IceInternal::BasicStream* __is, ::BeobotEvents::RectangleIceSeq& v)
{
    ::Ice::Int sz;
    __is->readSize(sz);
    __is->checkFixedSeq(sz, 16);
    v.resize(sz);
    for(int i = 0; i < sz; ++i)
    {
        v[i].__read(__is);
    }
}

const ::std::string&
IceProxy::BeobotEvents::MotorMessage::ice_staticId()
{
    return ::BeobotEvents::MotorMessage::ice_staticId();
}

::IceInternal::Handle< ::IceDelegateM::Ice::Object>
IceProxy::BeobotEvents::MotorMessage::__createDelegateM()
{
    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::BeobotEvents::MotorMessage);
}

::IceInternal::Handle< ::IceDelegateD::Ice::Object>
IceProxy::BeobotEvents::MotorMessage::__createDelegateD()
{
    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::BeobotEvents::MotorMessage);
}

::IceProxy::Ice::Object*
IceProxy::BeobotEvents::MotorMessage::__newInstance() const
{
    return new MotorMessage;
}

const ::std::string&
IceProxy::BeobotEvents::MotorRequest::ice_staticId()
{
    return ::BeobotEvents::MotorRequest::ice_staticId();
}

::IceInternal::Handle< ::IceDelegateM::Ice::Object>
IceProxy::BeobotEvents::MotorRequest::__createDelegateM()
{
    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::BeobotEvents::MotorRequest);
}

::IceInternal::Handle< ::IceDelegateD::Ice::Object>
IceProxy::BeobotEvents::MotorRequest::__createDelegateD()
{
    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::BeobotEvents::MotorRequest);
}

::IceProxy::Ice::Object*
IceProxy::BeobotEvents::MotorRequest::__newInstance() const
{
    return new MotorRequest;
}

const ::std::string&
IceProxy::BeobotEvents::CornerMotorRequest::ice_staticId()
{
    return ::BeobotEvents::CornerMotorRequest::ice_staticId();
}

::IceInternal::Handle< ::IceDelegateM::Ice::Object>
IceProxy::BeobotEvents::CornerMotorRequest::__createDelegateM()
{
    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::BeobotEvents::CornerMotorRequest);
}

::IceInternal::Handle< ::IceDelegateD::Ice::Object>
IceProxy::BeobotEvents::CornerMotorRequest::__createDelegateD()
{
    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::BeobotEvents::CornerMotorRequest);
}

::IceProxy::Ice::Object*
IceProxy::BeobotEvents::CornerMotorRequest::__newInstance() const
{
    return new CornerMotorRequest;
}

const ::std::string&
IceProxy::BeobotEvents::CornerLocationMessage::ice_staticId()
{
    return ::BeobotEvents::CornerLocationMessage::ice_staticId();
}

::IceInternal::Handle< ::IceDelegateM::Ice::Object>
IceProxy::BeobotEvents::CornerLocationMessage::__createDelegateM()
{
    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::BeobotEvents::CornerLocationMessage);
}

::IceInternal::Handle< ::IceDelegateD::Ice::Object>
IceProxy::BeobotEvents::CornerLocationMessage::__createDelegateD()
{
    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::BeobotEvents::CornerLocationMessage);
}

::IceProxy::Ice::Object*
IceProxy::BeobotEvents::CornerLocationMessage::__newInstance() const
{
    return new CornerLocationMessage;
}

const ::std::string&
IceProxy::BeobotEvents::SonarMessage::ice_staticId()
{
    return ::BeobotEvents::SonarMessage::ice_staticId();
}

::IceInternal::Handle< ::IceDelegateM::Ice::Object>
IceProxy::BeobotEvents::SonarMessage::__createDelegateM()
{
    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::BeobotEvents::SonarMessage);
}

::IceInternal::Handle< ::IceDelegateD::Ice::Object>
IceProxy::BeobotEvents::SonarMessage::__createDelegateD()
{
    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::BeobotEvents::SonarMessage);
}

::IceProxy::Ice::Object*
IceProxy::BeobotEvents::SonarMessage::__newInstance() const
{
    return new SonarMessage;
}

const ::std::string&
IceProxy::BeobotEvents::GPSMessage::ice_staticId()
{
    return ::BeobotEvents::GPSMessage::ice_staticId();
}

::IceInternal::Handle< ::IceDelegateM::Ice::Object>
IceProxy::BeobotEvents::GPSMessage::__createDelegateM()
{
    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::BeobotEvents::GPSMessage);
}

::IceInternal::Handle< ::IceDelegateD::Ice::Object>
IceProxy::BeobotEvents::GPSMessage::__createDelegateD()
{
    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::BeobotEvents::GPSMessage);
}

::IceProxy::Ice::Object*
IceProxy::BeobotEvents::GPSMessage::__newInstance() const
{
    return new GPSMessage;
}

const ::std::string&
IceProxy::BeobotEvents::LRFMessage::ice_staticId()
{
    return ::BeobotEvents::LRFMessage::ice_staticId();
}

::IceInternal::Handle< ::IceDelegateM::Ice::Object>
IceProxy::BeobotEvents::LRFMessage::__createDelegateM()
{
    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::BeobotEvents::LRFMessage);
}

::IceInternal::Handle< ::IceDelegateD::Ice::Object>
IceProxy::BeobotEvents::LRFMessage::__createDelegateD()
{
    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::BeobotEvents::LRFMessage);
}

::IceProxy::Ice::Object*
IceProxy::BeobotEvents::LRFMessage::__newInstance() const
{
    return new LRFMessage;
}

const ::std::string&
IceProxy::BeobotEvents::SLAMMessage::ice_staticId()
{
    return ::BeobotEvents::SLAMMessage::ice_staticId();
}

::IceInternal::Handle< ::IceDelegateM::Ice::Object>
IceProxy::BeobotEvents::SLAMMessage::__createDelegateM()
{
    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::BeobotEvents::SLAMMessage);
}

::IceInternal::Handle< ::IceDelegateD::Ice::Object>
IceProxy::BeobotEvents::SLAMMessage::__createDelegateD()
{
    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::BeobotEvents::SLAMMessage);
}

::IceProxy::Ice::Object*
IceProxy::BeobotEvents::SLAMMessage::__newInstance() const
{
    return new SLAMMessage;
}

const ::std::string&
IceProxy::BeobotEvents::IMUMessage::ice_staticId()
{
    return ::BeobotEvents::IMUMessage::ice_staticId();
}

::IceInternal::Handle< ::IceDelegateM::Ice::Object>
IceProxy::BeobotEvents::IMUMessage::__createDelegateM()
{
    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::BeobotEvents::IMUMessage);
}

::IceInternal::Handle< ::IceDelegateD::Ice::Object>
IceProxy::BeobotEvents::IMUMessage::__createDelegateD()
{
    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::BeobotEvents::IMUMessage);
}

::IceProxy::Ice::Object*
IceProxy::BeobotEvents::IMUMessage::__newInstance() const
{
    return new IMUMessage;
}

const ::std::string&
IceProxy::BeobotEvents::CameraMessage::ice_staticId()
{
    return ::BeobotEvents::CameraMessage::ice_staticId();
}

::IceInternal::Handle< ::IceDelegateM::Ice::Object>
IceProxy::BeobotEvents::CameraMessage::__createDelegateM()
{
    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::BeobotEvents::CameraMessage);
}

::IceInternal::Handle< ::IceDelegateD::Ice::Object>
IceProxy::BeobotEvents::CameraMessage::__createDelegateD()
{
    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::BeobotEvents::CameraMessage);
}

::IceProxy::Ice::Object*
IceProxy::BeobotEvents::CameraMessage::__newInstance() const
{
    return new CameraMessage;
}

const ::std::string&
IceProxy::BeobotEvents::GistSalMessage::ice_staticId()
{
    return ::BeobotEvents::GistSalMessage::ice_staticId();
}

::IceInternal::Handle< ::IceDelegateM::Ice::Object>
IceProxy::BeobotEvents::GistSalMessage::__createDelegateM()
{
    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::BeobotEvents::GistSalMessage);
}

::IceInternal::Handle< ::IceDelegateD::Ice::Object>
IceProxy::BeobotEvents::GistSalMessage::__createDelegateD()
{
    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::BeobotEvents::GistSalMessage);
}

::IceProxy::Ice::Object*
IceProxy::BeobotEvents::GistSalMessage::__newInstance() const
{
    return new GistSalMessage;
}

const ::std::string&
IceProxy::BeobotEvents::LandmarkSearchQueueMessage::ice_staticId()
{
    return ::BeobotEvents::LandmarkSearchQueueMessage::ice_staticId();
}

::IceInternal::Handle< ::IceDelegateM::Ice::Object>
IceProxy::BeobotEvents::LandmarkSearchQueueMessage::__createDelegateM()
{
    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::BeobotEvents::LandmarkSearchQueueMessage);
}

::IceInternal::Handle< ::IceDelegateD::Ice::Object>
IceProxy::BeobotEvents::LandmarkSearchQueueMessage::__createDelegateD()
{
    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::BeobotEvents::LandmarkSearchQueueMessage);
}

::IceProxy::Ice::Object*
IceProxy::BeobotEvents::LandmarkSearchQueueMessage::__newInstance() const
{
    return new LandmarkSearchQueueMessage;
}

const ::std::string&
IceProxy::BeobotEvents::LandmarkTrackMessage::ice_staticId()
{
    return ::BeobotEvents::LandmarkTrackMessage::ice_staticId();
}

::IceInternal::Handle< ::IceDelegateM::Ice::Object>
IceProxy::BeobotEvents::LandmarkTrackMessage::__createDelegateM()
{
    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::BeobotEvents::LandmarkTrackMessage);
}

::IceInternal::Handle< ::IceDelegateD::Ice::Object>
IceProxy::BeobotEvents::LandmarkTrackMessage::__createDelegateD()
{
    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::BeobotEvents::LandmarkTrackMessage);
}

::IceProxy::Ice::Object*
IceProxy::BeobotEvents::LandmarkTrackMessage::__newInstance() const
{
    return new LandmarkTrackMessage;
}

const ::std::string&
IceProxy::BeobotEvents::LandmarkSearchStatMessage::ice_staticId()
{
    return ::BeobotEvents::LandmarkSearchStatMessage::ice_staticId();
}

::IceInternal::Handle< ::IceDelegateM::Ice::Object>
IceProxy::BeobotEvents::LandmarkSearchStatMessage::__createDelegateM()
{
    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::BeobotEvents::LandmarkSearchStatMessage);
}

::IceInternal::Handle< ::IceDelegateD::Ice::Object>
IceProxy::BeobotEvents::LandmarkSearchStatMessage::__createDelegateD()
{
    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::BeobotEvents::LandmarkSearchStatMessage);
}

::IceProxy::Ice::Object*
IceProxy::BeobotEvents::LandmarkSearchStatMessage::__newInstance() const
{
    return new LandmarkSearchStatMessage;
}

const ::std::string&
IceProxy::BeobotEvents::LandmarkMatchResultMessage::ice_staticId()
{
    return ::BeobotEvents::LandmarkMatchResultMessage::ice_staticId();
}

::IceInternal::Handle< ::IceDelegateM::Ice::Object>
IceProxy::BeobotEvents::LandmarkMatchResultMessage::__createDelegateM()
{
    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::BeobotEvents::LandmarkMatchResultMessage);
}

::IceInternal::Handle< ::IceDelegateD::Ice::Object>
IceProxy::BeobotEvents::LandmarkMatchResultMessage::__createDelegateD()
{
    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::BeobotEvents::LandmarkMatchResultMessage);
}

::IceProxy::Ice::Object*
IceProxy::BeobotEvents::LandmarkMatchResultMessage::__newInstance() const
{
    return new LandmarkMatchResultMessage;
}

const ::std::string&
IceProxy::BeobotEvents::LandmarkDBSearchResultMessage::ice_staticId()
{
    return ::BeobotEvents::LandmarkDBSearchResultMessage::ice_staticId();
}

::IceInternal::Handle< ::IceDelegateM::Ice::Object>
IceProxy::BeobotEvents::LandmarkDBSearchResultMessage::__createDelegateM()
{
    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::BeobotEvents::LandmarkDBSearchResultMessage);
}

::IceInternal::Handle< ::IceDelegateD::Ice::Object>
IceProxy::BeobotEvents::LandmarkDBSearchResultMessage::__createDelegateD()
{
    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::BeobotEvents::LandmarkDBSearchResultMessage);
}

::IceProxy::Ice::Object*
IceProxy::BeobotEvents::LandmarkDBSearchResultMessage::__newInstance() const
{
    return new LandmarkDBSearchResultMessage;
}

const ::std::string&
IceProxy::BeobotEvents::CurrentLocationMessage::ice_staticId()
{
    return ::BeobotEvents::CurrentLocationMessage::ice_staticId();
}

::IceInternal::Handle< ::IceDelegateM::Ice::Object>
IceProxy::BeobotEvents::CurrentLocationMessage::__createDelegateM()
{
    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::BeobotEvents::CurrentLocationMessage);
}

::IceInternal::Handle< ::IceDelegateD::Ice::Object>
IceProxy::BeobotEvents::CurrentLocationMessage::__createDelegateD()
{
    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::BeobotEvents::CurrentLocationMessage);
}

::IceProxy::Ice::Object*
IceProxy::BeobotEvents::CurrentLocationMessage::__newInstance() const
{
    return new CurrentLocationMessage;
}

const ::std::string&
IceProxy::BeobotEvents::CancelSearchMessage::ice_staticId()
{
    return ::BeobotEvents::CancelSearchMessage::ice_staticId();
}

::IceInternal::Handle< ::IceDelegateM::Ice::Object>
IceProxy::BeobotEvents::CancelSearchMessage::__createDelegateM()
{
    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::BeobotEvents::CancelSearchMessage);
}

::IceInternal::Handle< ::IceDelegateD::Ice::Object>
IceProxy::BeobotEvents::CancelSearchMessage::__createDelegateD()
{
    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::BeobotEvents::CancelSearchMessage);
}

::IceProxy::Ice::Object*
IceProxy::BeobotEvents::CancelSearchMessage::__newInstance() const
{
    return new CancelSearchMessage;
}

const ::std::string&
IceProxy::BeobotEvents::SearchDoneMessage::ice_staticId()
{
    return ::BeobotEvents::SearchDoneMessage::ice_staticId();
}

::IceInternal::Handle< ::IceDelegateM::Ice::Object>
IceProxy::BeobotEvents::SearchDoneMessage::__createDelegateM()
{
    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::BeobotEvents::SearchDoneMessage);
}

::IceInternal::Handle< ::IceDelegateD::Ice::Object>
IceProxy::BeobotEvents::SearchDoneMessage::__createDelegateD()
{
    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::BeobotEvents::SearchDoneMessage);
}

::IceProxy::Ice::Object*
IceProxy::BeobotEvents::SearchDoneMessage::__newInstance() const
{
    return new SearchDoneMessage;
}

const ::std::string&
IceProxy::BeobotEvents::NextFrameMessage::ice_staticId()
{
    return ::BeobotEvents::NextFrameMessage::ice_staticId();
}

::IceInternal::Handle< ::IceDelegateM::Ice::Object>
IceProxy::BeobotEvents::NextFrameMessage::__createDelegateM()
{
    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::BeobotEvents::NextFrameMessage);
}

::IceInternal::Handle< ::IceDelegateD::Ice::Object>
IceProxy::BeobotEvents::NextFrameMessage::__createDelegateD()
{
    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::BeobotEvents::NextFrameMessage);
}

::IceProxy::Ice::Object*
IceProxy::BeobotEvents::NextFrameMessage::__newInstance() const
{
    return new NextFrameMessage;
}

const ::std::string&
IceProxy::BeobotEvents::AbortMessage::ice_staticId()
{
    return ::BeobotEvents::AbortMessage::ice_staticId();
}

::IceInternal::Handle< ::IceDelegateM::Ice::Object>
IceProxy::BeobotEvents::AbortMessage::__createDelegateM()
{
    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::BeobotEvents::AbortMessage);
}

::IceInternal::Handle< ::IceDelegateD::Ice::Object>
IceProxy::BeobotEvents::AbortMessage::__createDelegateD()
{
    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::BeobotEvents::AbortMessage);
}

::IceProxy::Ice::Object*
IceProxy::BeobotEvents::AbortMessage::__newInstance() const
{
    return new AbortMessage;
}

const ::std::string&
IceProxy::BeobotEvents::FacesMessage::ice_staticId()
{
    return ::BeobotEvents::FacesMessage::ice_staticId();
}

::IceInternal::Handle< ::IceDelegateM::Ice::Object>
IceProxy::BeobotEvents::FacesMessage::__createDelegateM()
{
    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::BeobotEvents::FacesMessage);
}

::IceInternal::Handle< ::IceDelegateD::Ice::Object>
IceProxy::BeobotEvents::FacesMessage::__createDelegateD()
{
    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::BeobotEvents::FacesMessage);
}

::IceProxy::Ice::Object*
IceProxy::BeobotEvents::FacesMessage::__newInstance() const
{
    return new FacesMessage;
}

const ::std::string&
IceProxy::BeobotEvents::GUISpeechMessage::ice_staticId()
{
    return ::BeobotEvents::GUISpeechMessage::ice_staticId();
}

::IceInternal::Handle< ::IceDelegateM::Ice::Object>
IceProxy::BeobotEvents::GUISpeechMessage::__createDelegateM()
{
    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::BeobotEvents::GUISpeechMessage);
}

::IceInternal::Handle< ::IceDelegateD::Ice::Object>
IceProxy::BeobotEvents::GUISpeechMessage::__createDelegateD()
{
    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::BeobotEvents::GUISpeechMessage);
}

::IceProxy::Ice::Object*
IceProxy::BeobotEvents::GUISpeechMessage::__newInstance() const
{
    return new GUISpeechMessage;
}

BeobotEvents::MotorMessage::MotorMessage(::Ice::Int __ice_rcMode, ::Ice::Int __ice_motor1, ::Ice::Int __ice_motor2, ::Ice::Double __ice_transVel, ::Ice::Double __ice_rotVel, ::Ice::Double __ice_encoderX, ::Ice::Double __ice_encoderY, ::Ice::Double __ice_encoderOri, ::Ice::Double __ice_rcTransVel, ::Ice::Double __ice_rcRotVel, ::Ice::Int __ice_RequestID) :
    rcMode(__ice_rcMode),
    motor1(__ice_motor1),
    motor2(__ice_motor2),
    transVel(__ice_transVel),
    rotVel(__ice_rotVel),
    encoderX(__ice_encoderX),
    encoderY(__ice_encoderY),
    encoderOri(__ice_encoderOri),
    rcTransVel(__ice_rcTransVel),
    rcRotVel(__ice_rcRotVel),
    RequestID(__ice_RequestID)
{
}

::Ice::ObjectPtr
BeobotEvents::MotorMessage::ice_clone() const
{
    ::BeobotEvents::MotorMessagePtr __p = new ::BeobotEvents::MotorMessage(*this);
    return __p;
}

static const ::std::string __BeobotEvents__MotorMessage_ids[3] =
{
    "::BeobotEvents::MotorMessage",
    "::Ice::Object",
    "::RobotSimEvents::EventMessage"
};

bool
BeobotEvents::MotorMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__BeobotEvents__MotorMessage_ids, __BeobotEvents__MotorMessage_ids + 3, _s);
}

::std::vector< ::std::string>
BeobotEvents::MotorMessage::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__BeobotEvents__MotorMessage_ids[0], &__BeobotEvents__MotorMessage_ids[3]);
}

const ::std::string&
BeobotEvents::MotorMessage::ice_id(const ::Ice::Current&) const
{
    return __BeobotEvents__MotorMessage_ids[0];
}

const ::std::string&
BeobotEvents::MotorMessage::ice_staticId()
{
    return __BeobotEvents__MotorMessage_ids[0];
}

void
BeobotEvents::MotorMessage::__write(::IceInternal::BasicStream* __os) const
{
    __os->writeTypeId(ice_staticId());
    __os->startWriteSlice();
    __os->write(rcMode);
    __os->write(motor1);
    __os->write(motor2);
    __os->write(transVel);
    __os->write(rotVel);
    __os->write(encoderX);
    __os->write(encoderY);
    __os->write(encoderOri);
    __os->write(rcTransVel);
    __os->write(rcRotVel);
    __os->write(RequestID);
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__write(__os);
#else
    ::RobotSimEvents::EventMessage::__write(__os);
#endif
}

void
BeobotEvents::MotorMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    __is->read(rcMode);
    __is->read(motor1);
    __is->read(motor2);
    __is->read(transVel);
    __is->read(rotVel);
    __is->read(encoderX);
    __is->read(encoderY);
    __is->read(encoderOri);
    __is->read(rcTransVel);
    __is->read(rcRotVel);
    __is->read(RequestID);
    __is->endReadSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__read(__is, true);
#else
    ::RobotSimEvents::EventMessage::__read(__is, true);
#endif
}

void
BeobotEvents::MotorMessage::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type BeobotEvents::MotorMessage was not generated with stream support";
    throw ex;
}

void
BeobotEvents::MotorMessage::__read(const ::Ice::InputStreamPtr&, bool)
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type BeobotEvents::MotorMessage was not generated with stream support";
    throw ex;
}

class __F__BeobotEvents__MotorMessage : public ::Ice::ObjectFactory
{
public:

    virtual ::Ice::ObjectPtr
    create(const ::std::string& type)
    {
        assert(type == ::BeobotEvents::MotorMessage::ice_staticId());
        return new ::BeobotEvents::MotorMessage;
    }

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__BeobotEvents__MotorMessage_Ptr = new __F__BeobotEvents__MotorMessage;

const ::Ice::ObjectFactoryPtr&
BeobotEvents::MotorMessage::ice_factory()
{
    return __F__BeobotEvents__MotorMessage_Ptr;
}

class __F__BeobotEvents__MotorMessage__Init
{
public:

    __F__BeobotEvents__MotorMessage__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::BeobotEvents::MotorMessage::ice_staticId(), ::BeobotEvents::MotorMessage::ice_factory());
    }

    ~__F__BeobotEvents__MotorMessage__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::BeobotEvents::MotorMessage::ice_staticId());
    }
};

static __F__BeobotEvents__MotorMessage__Init __F__BeobotEvents__MotorMessage__i;

#ifdef __APPLE__
extern "C" { void __F__BeobotEvents__MotorMessage__initializer() {} }
#endif

void
BeobotEvents::__patch__MotorMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::BeobotEvents::MotorMessagePtr* p = static_cast< ::BeobotEvents::MotorMessagePtr*>(__addr);
    assert(p);
    *p = ::BeobotEvents::MotorMessagePtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::BeobotEvents::MotorMessage::ice_staticId(), v->ice_id());
    }
}

bool
BeobotEvents::operator==(const ::BeobotEvents::MotorMessage& l, const ::BeobotEvents::MotorMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

bool
BeobotEvents::operator<(const ::BeobotEvents::MotorMessage& l, const ::BeobotEvents::MotorMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}

BeobotEvents::MotorRequest::MotorRequest(::Ice::Double __ice_transVel, ::Ice::Double __ice_rotVel) :
    transVel(__ice_transVel),
    rotVel(__ice_rotVel)
{
}

::Ice::ObjectPtr
BeobotEvents::MotorRequest::ice_clone() const
{
    ::BeobotEvents::MotorRequestPtr __p = new ::BeobotEvents::MotorRequest(*this);
    return __p;
}

static const ::std::string __BeobotEvents__MotorRequest_ids[3] =
{
    "::BeobotEvents::MotorRequest",
    "::Ice::Object",
    "::RobotSimEvents::EventMessage"
};

bool
BeobotEvents::MotorRequest::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__BeobotEvents__MotorRequest_ids, __BeobotEvents__MotorRequest_ids + 3, _s);
}

::std::vector< ::std::string>
BeobotEvents::MotorRequest::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__BeobotEvents__MotorRequest_ids[0], &__BeobotEvents__MotorRequest_ids[3]);
}

const ::std::string&
BeobotEvents::MotorRequest::ice_id(const ::Ice::Current&) const
{
    return __BeobotEvents__MotorRequest_ids[0];
}

const ::std::string&
BeobotEvents::MotorRequest::ice_staticId()
{
    return __BeobotEvents__MotorRequest_ids[0];
}

void
BeobotEvents::MotorRequest::__write(::IceInternal::BasicStream* __os) const
{
    __os->writeTypeId(ice_staticId());
    __os->startWriteSlice();
    __os->write(transVel);
    __os->write(rotVel);
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__write(__os);
#else
    ::RobotSimEvents::EventMessage::__write(__os);
#endif
}

void
BeobotEvents::MotorRequest::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    __is->read(transVel);
    __is->read(rotVel);
    __is->endReadSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__read(__is, true);
#else
    ::RobotSimEvents::EventMessage::__read(__is, true);
#endif
}

void
BeobotEvents::MotorRequest::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type BeobotEvents::MotorRequest was not generated with stream support";
    throw ex;
}

void
BeobotEvents::MotorRequest::__read(const ::Ice::InputStreamPtr&, bool)
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type BeobotEvents::MotorRequest was not generated with stream support";
    throw ex;
}

class __F__BeobotEvents__MotorRequest : public ::Ice::ObjectFactory
{
public:

    virtual ::Ice::ObjectPtr
    create(const ::std::string& type)
    {
        assert(type == ::BeobotEvents::MotorRequest::ice_staticId());
        return new ::BeobotEvents::MotorRequest;
    }

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__BeobotEvents__MotorRequest_Ptr = new __F__BeobotEvents__MotorRequest;

const ::Ice::ObjectFactoryPtr&
BeobotEvents::MotorRequest::ice_factory()
{
    return __F__BeobotEvents__MotorRequest_Ptr;
}

class __F__BeobotEvents__MotorRequest__Init
{
public:

    __F__BeobotEvents__MotorRequest__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::BeobotEvents::MotorRequest::ice_staticId(), ::BeobotEvents::MotorRequest::ice_factory());
    }

    ~__F__BeobotEvents__MotorRequest__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::BeobotEvents::MotorRequest::ice_staticId());
    }
};

static __F__BeobotEvents__MotorRequest__Init __F__BeobotEvents__MotorRequest__i;

#ifdef __APPLE__
extern "C" { void __F__BeobotEvents__MotorRequest__initializer() {} }
#endif

void
BeobotEvents::__patch__MotorRequestPtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::BeobotEvents::MotorRequestPtr* p = static_cast< ::BeobotEvents::MotorRequestPtr*>(__addr);
    assert(p);
    *p = ::BeobotEvents::MotorRequestPtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::BeobotEvents::MotorRequest::ice_staticId(), v->ice_id());
    }
}

bool
BeobotEvents::operator==(const ::BeobotEvents::MotorRequest& l, const ::BeobotEvents::MotorRequest& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

bool
BeobotEvents::operator<(const ::BeobotEvents::MotorRequest& l, const ::BeobotEvents::MotorRequest& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}

BeobotEvents::CornerMotorRequest::CornerMotorRequest(::Ice::Double __ice_transVel, ::Ice::Double __ice_rotVel, ::Ice::Int __ice_status) :
    transVel(__ice_transVel),
    rotVel(__ice_rotVel),
    status(__ice_status)
{
}

::Ice::ObjectPtr
BeobotEvents::CornerMotorRequest::ice_clone() const
{
    ::BeobotEvents::CornerMotorRequestPtr __p = new ::BeobotEvents::CornerMotorRequest(*this);
    return __p;
}

static const ::std::string __BeobotEvents__CornerMotorRequest_ids[3] =
{
    "::BeobotEvents::CornerMotorRequest",
    "::Ice::Object",
    "::RobotSimEvents::EventMessage"
};

bool
BeobotEvents::CornerMotorRequest::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__BeobotEvents__CornerMotorRequest_ids, __BeobotEvents__CornerMotorRequest_ids + 3, _s);
}

::std::vector< ::std::string>
BeobotEvents::CornerMotorRequest::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__BeobotEvents__CornerMotorRequest_ids[0], &__BeobotEvents__CornerMotorRequest_ids[3]);
}

const ::std::string&
BeobotEvents::CornerMotorRequest::ice_id(const ::Ice::Current&) const
{
    return __BeobotEvents__CornerMotorRequest_ids[0];
}

const ::std::string&
BeobotEvents::CornerMotorRequest::ice_staticId()
{
    return __BeobotEvents__CornerMotorRequest_ids[0];
}

void
BeobotEvents::CornerMotorRequest::__write(::IceInternal::BasicStream* __os) const
{
    __os->writeTypeId(ice_staticId());
    __os->startWriteSlice();
    __os->write(transVel);
    __os->write(rotVel);
    __os->write(status);
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__write(__os);
#else
    ::RobotSimEvents::EventMessage::__write(__os);
#endif
}

void
BeobotEvents::CornerMotorRequest::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    __is->read(transVel);
    __is->read(rotVel);
    __is->read(status);
    __is->endReadSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__read(__is, true);
#else
    ::RobotSimEvents::EventMessage::__read(__is, true);
#endif
}

void
BeobotEvents::CornerMotorRequest::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type BeobotEvents::CornerMotorRequest was not generated with stream support";
    throw ex;
}

void
BeobotEvents::CornerMotorRequest::__read(const ::Ice::InputStreamPtr&, bool)
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type BeobotEvents::CornerMotorRequest was not generated with stream support";
    throw ex;
}

class __F__BeobotEvents__CornerMotorRequest : public ::Ice::ObjectFactory
{
public:

    virtual ::Ice::ObjectPtr
    create(const ::std::string& type)
    {
        assert(type == ::BeobotEvents::CornerMotorRequest::ice_staticId());
        return new ::BeobotEvents::CornerMotorRequest;
    }

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__BeobotEvents__CornerMotorRequest_Ptr = new __F__BeobotEvents__CornerMotorRequest;

const ::Ice::ObjectFactoryPtr&
BeobotEvents::CornerMotorRequest::ice_factory()
{
    return __F__BeobotEvents__CornerMotorRequest_Ptr;
}

class __F__BeobotEvents__CornerMotorRequest__Init
{
public:

    __F__BeobotEvents__CornerMotorRequest__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::BeobotEvents::CornerMotorRequest::ice_staticId(), ::BeobotEvents::CornerMotorRequest::ice_factory());
    }

    ~__F__BeobotEvents__CornerMotorRequest__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::BeobotEvents::CornerMotorRequest::ice_staticId());
    }
};

static __F__BeobotEvents__CornerMotorRequest__Init __F__BeobotEvents__CornerMotorRequest__i;

#ifdef __APPLE__
extern "C" { void __F__BeobotEvents__CornerMotorRequest__initializer() {} }
#endif

void
BeobotEvents::__patch__CornerMotorRequestPtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::BeobotEvents::CornerMotorRequestPtr* p = static_cast< ::BeobotEvents::CornerMotorRequestPtr*>(__addr);
    assert(p);
    *p = ::BeobotEvents::CornerMotorRequestPtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::BeobotEvents::CornerMotorRequest::ice_staticId(), v->ice_id());
    }
}

bool
BeobotEvents::operator==(const ::BeobotEvents::CornerMotorRequest& l, const ::BeobotEvents::CornerMotorRequest& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

bool
BeobotEvents::operator<(const ::BeobotEvents::CornerMotorRequest& l, const ::BeobotEvents::CornerMotorRequest& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}

BeobotEvents::CornerLocationMessage::CornerLocationMessage(::Ice::Int __ice_cornerLocation) :
    cornerLocation(__ice_cornerLocation)
{
}

::Ice::ObjectPtr
BeobotEvents::CornerLocationMessage::ice_clone() const
{
    ::BeobotEvents::CornerLocationMessagePtr __p = new ::BeobotEvents::CornerLocationMessage(*this);
    return __p;
}

static const ::std::string __BeobotEvents__CornerLocationMessage_ids[3] =
{
    "::BeobotEvents::CornerLocationMessage",
    "::Ice::Object",
    "::RobotSimEvents::EventMessage"
};

bool
BeobotEvents::CornerLocationMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__BeobotEvents__CornerLocationMessage_ids, __BeobotEvents__CornerLocationMessage_ids + 3, _s);
}

::std::vector< ::std::string>
BeobotEvents::CornerLocationMessage::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__BeobotEvents__CornerLocationMessage_ids[0], &__BeobotEvents__CornerLocationMessage_ids[3]);
}

const ::std::string&
BeobotEvents::CornerLocationMessage::ice_id(const ::Ice::Current&) const
{
    return __BeobotEvents__CornerLocationMessage_ids[0];
}

const ::std::string&
BeobotEvents::CornerLocationMessage::ice_staticId()
{
    return __BeobotEvents__CornerLocationMessage_ids[0];
}

void
BeobotEvents::CornerLocationMessage::__write(::IceInternal::BasicStream* __os) const
{
    __os->writeTypeId(ice_staticId());
    __os->startWriteSlice();
    __os->write(cornerLocation);
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__write(__os);
#else
    ::RobotSimEvents::EventMessage::__write(__os);
#endif
}

void
BeobotEvents::CornerLocationMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    __is->read(cornerLocation);
    __is->endReadSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__read(__is, true);
#else
    ::RobotSimEvents::EventMessage::__read(__is, true);
#endif
}

void
BeobotEvents::CornerLocationMessage::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type BeobotEvents::CornerLocationMessage was not generated with stream support";
    throw ex;
}

void
BeobotEvents::CornerLocationMessage::__read(const ::Ice::InputStreamPtr&, bool)
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type BeobotEvents::CornerLocationMessage was not generated with stream support";
    throw ex;
}

class __F__BeobotEvents__CornerLocationMessage : public ::Ice::ObjectFactory
{
public:

    virtual ::Ice::ObjectPtr
    create(const ::std::string& type)
    {
        assert(type == ::BeobotEvents::CornerLocationMessage::ice_staticId());
        return new ::BeobotEvents::CornerLocationMessage;
    }

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__BeobotEvents__CornerLocationMessage_Ptr = new __F__BeobotEvents__CornerLocationMessage;

const ::Ice::ObjectFactoryPtr&
BeobotEvents::CornerLocationMessage::ice_factory()
{
    return __F__BeobotEvents__CornerLocationMessage_Ptr;
}

class __F__BeobotEvents__CornerLocationMessage__Init
{
public:

    __F__BeobotEvents__CornerLocationMessage__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::BeobotEvents::CornerLocationMessage::ice_staticId(), ::BeobotEvents::CornerLocationMessage::ice_factory());
    }

    ~__F__BeobotEvents__CornerLocationMessage__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::BeobotEvents::CornerLocationMessage::ice_staticId());
    }
};

static __F__BeobotEvents__CornerLocationMessage__Init __F__BeobotEvents__CornerLocationMessage__i;

#ifdef __APPLE__
extern "C" { void __F__BeobotEvents__CornerLocationMessage__initializer() {} }
#endif

void
BeobotEvents::__patch__CornerLocationMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::BeobotEvents::CornerLocationMessagePtr* p = static_cast< ::BeobotEvents::CornerLocationMessagePtr*>(__addr);
    assert(p);
    *p = ::BeobotEvents::CornerLocationMessagePtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::BeobotEvents::CornerLocationMessage::ice_staticId(), v->ice_id());
    }
}

bool
BeobotEvents::operator==(const ::BeobotEvents::CornerLocationMessage& l, const ::BeobotEvents::CornerLocationMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

bool
BeobotEvents::operator<(const ::BeobotEvents::CornerLocationMessage& l, const ::BeobotEvents::CornerLocationMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}

BeobotEvents::SonarMessage::SonarMessage(const ::BeobotEvents::DoubleSeq& __ice_distances, const ::BeobotEvents::DoubleSeq& __ice_angles) :
    distances(__ice_distances),
    angles(__ice_angles)
{
}

::Ice::ObjectPtr
BeobotEvents::SonarMessage::ice_clone() const
{
    ::BeobotEvents::SonarMessagePtr __p = new ::BeobotEvents::SonarMessage(*this);
    return __p;
}

static const ::std::string __BeobotEvents__SonarMessage_ids[3] =
{
    "::BeobotEvents::SonarMessage",
    "::Ice::Object",
    "::RobotSimEvents::EventMessage"
};

bool
BeobotEvents::SonarMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__BeobotEvents__SonarMessage_ids, __BeobotEvents__SonarMessage_ids + 3, _s);
}

::std::vector< ::std::string>
BeobotEvents::SonarMessage::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__BeobotEvents__SonarMessage_ids[0], &__BeobotEvents__SonarMessage_ids[3]);
}

const ::std::string&
BeobotEvents::SonarMessage::ice_id(const ::Ice::Current&) const
{
    return __BeobotEvents__SonarMessage_ids[0];
}

const ::std::string&
BeobotEvents::SonarMessage::ice_staticId()
{
    return __BeobotEvents__SonarMessage_ids[0];
}

void
BeobotEvents::SonarMessage::__write(::IceInternal::BasicStream* __os) const
{
    __os->writeTypeId(ice_staticId());
    __os->startWriteSlice();
    if(distances.size() == 0)
    {
        __os->writeSize(0);
    }
    else
    {
        __os->write(&distances[0], &distances[0] + distances.size());
    }
    if(angles.size() == 0)
    {
        __os->writeSize(0);
    }
    else
    {
        __os->write(&angles[0], &angles[0] + angles.size());
    }
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__write(__os);
#else
    ::RobotSimEvents::EventMessage::__write(__os);
#endif
}

void
BeobotEvents::SonarMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    __is->read(distances);
    __is->read(angles);
    __is->endReadSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__read(__is, true);
#else
    ::RobotSimEvents::EventMessage::__read(__is, true);
#endif
}

void
BeobotEvents::SonarMessage::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type BeobotEvents::SonarMessage was not generated with stream support";
    throw ex;
}

void
BeobotEvents::SonarMessage::__read(const ::Ice::InputStreamPtr&, bool)
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type BeobotEvents::SonarMessage was not generated with stream support";
    throw ex;
}

class __F__BeobotEvents__SonarMessage : public ::Ice::ObjectFactory
{
public:

    virtual ::Ice::ObjectPtr
    create(const ::std::string& type)
    {
        assert(type == ::BeobotEvents::SonarMessage::ice_staticId());
        return new ::BeobotEvents::SonarMessage;
    }

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__BeobotEvents__SonarMessage_Ptr = new __F__BeobotEvents__SonarMessage;

const ::Ice::ObjectFactoryPtr&
BeobotEvents::SonarMessage::ice_factory()
{
    return __F__BeobotEvents__SonarMessage_Ptr;
}

class __F__BeobotEvents__SonarMessage__Init
{
public:

    __F__BeobotEvents__SonarMessage__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::BeobotEvents::SonarMessage::ice_staticId(), ::BeobotEvents::SonarMessage::ice_factory());
    }

    ~__F__BeobotEvents__SonarMessage__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::BeobotEvents::SonarMessage::ice_staticId());
    }
};

static __F__BeobotEvents__SonarMessage__Init __F__BeobotEvents__SonarMessage__i;

#ifdef __APPLE__
extern "C" { void __F__BeobotEvents__SonarMessage__initializer() {} }
#endif

void
BeobotEvents::__patch__SonarMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::BeobotEvents::SonarMessagePtr* p = static_cast< ::BeobotEvents::SonarMessagePtr*>(__addr);
    assert(p);
    *p = ::BeobotEvents::SonarMessagePtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::BeobotEvents::SonarMessage::ice_staticId(), v->ice_id());
    }
}

bool
BeobotEvents::operator==(const ::BeobotEvents::SonarMessage& l, const ::BeobotEvents::SonarMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

bool
BeobotEvents::operator<(const ::BeobotEvents::SonarMessage& l, const ::BeobotEvents::SonarMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}

BeobotEvents::GPSMessage::GPSMessage(::Ice::Double __ice_latitude, ::Ice::Double __ice_longitude, ::Ice::Int __ice_precision, ::Ice::Int __ice_satNum, ::Ice::Int __ice_RequestID) :
    latitude(__ice_latitude),
    longitude(__ice_longitude),
    precision(__ice_precision),
    satNum(__ice_satNum),
    RequestID(__ice_RequestID)
{
}

::Ice::ObjectPtr
BeobotEvents::GPSMessage::ice_clone() const
{
    ::BeobotEvents::GPSMessagePtr __p = new ::BeobotEvents::GPSMessage(*this);
    return __p;
}

static const ::std::string __BeobotEvents__GPSMessage_ids[3] =
{
    "::BeobotEvents::GPSMessage",
    "::Ice::Object",
    "::RobotSimEvents::EventMessage"
};

bool
BeobotEvents::GPSMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__BeobotEvents__GPSMessage_ids, __BeobotEvents__GPSMessage_ids + 3, _s);
}

::std::vector< ::std::string>
BeobotEvents::GPSMessage::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__BeobotEvents__GPSMessage_ids[0], &__BeobotEvents__GPSMessage_ids[3]);
}

const ::std::string&
BeobotEvents::GPSMessage::ice_id(const ::Ice::Current&) const
{
    return __BeobotEvents__GPSMessage_ids[0];
}

const ::std::string&
BeobotEvents::GPSMessage::ice_staticId()
{
    return __BeobotEvents__GPSMessage_ids[0];
}

void
BeobotEvents::GPSMessage::__write(::IceInternal::BasicStream* __os) const
{
    __os->writeTypeId(ice_staticId());
    __os->startWriteSlice();
    __os->write(latitude);
    __os->write(longitude);
    __os->write(precision);
    __os->write(satNum);
    __os->write(RequestID);
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__write(__os);
#else
    ::RobotSimEvents::EventMessage::__write(__os);
#endif
}

void
BeobotEvents::GPSMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    __is->read(latitude);
    __is->read(longitude);
    __is->read(precision);
    __is->read(satNum);
    __is->read(RequestID);
    __is->endReadSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__read(__is, true);
#else
    ::RobotSimEvents::EventMessage::__read(__is, true);
#endif
}

void
BeobotEvents::GPSMessage::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type BeobotEvents::GPSMessage was not generated with stream support";
    throw ex;
}

void
BeobotEvents::GPSMessage::__read(const ::Ice::InputStreamPtr&, bool)
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type BeobotEvents::GPSMessage was not generated with stream support";
    throw ex;
}

class __F__BeobotEvents__GPSMessage : public ::Ice::ObjectFactory
{
public:

    virtual ::Ice::ObjectPtr
    create(const ::std::string& type)
    {
        assert(type == ::BeobotEvents::GPSMessage::ice_staticId());
        return new ::BeobotEvents::GPSMessage;
    }

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__BeobotEvents__GPSMessage_Ptr = new __F__BeobotEvents__GPSMessage;

const ::Ice::ObjectFactoryPtr&
BeobotEvents::GPSMessage::ice_factory()
{
    return __F__BeobotEvents__GPSMessage_Ptr;
}

class __F__BeobotEvents__GPSMessage__Init
{
public:

    __F__BeobotEvents__GPSMessage__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::BeobotEvents::GPSMessage::ice_staticId(), ::BeobotEvents::GPSMessage::ice_factory());
    }

    ~__F__BeobotEvents__GPSMessage__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::BeobotEvents::GPSMessage::ice_staticId());
    }
};

static __F__BeobotEvents__GPSMessage__Init __F__BeobotEvents__GPSMessage__i;

#ifdef __APPLE__
extern "C" { void __F__BeobotEvents__GPSMessage__initializer() {} }
#endif

void
BeobotEvents::__patch__GPSMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::BeobotEvents::GPSMessagePtr* p = static_cast< ::BeobotEvents::GPSMessagePtr*>(__addr);
    assert(p);
    *p = ::BeobotEvents::GPSMessagePtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::BeobotEvents::GPSMessage::ice_staticId(), v->ice_id());
    }
}

bool
BeobotEvents::operator==(const ::BeobotEvents::GPSMessage& l, const ::BeobotEvents::GPSMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

bool
BeobotEvents::operator<(const ::BeobotEvents::GPSMessage& l, const ::BeobotEvents::GPSMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}

BeobotEvents::LRFMessage::LRFMessage(const ::BeobotEvents::DoubleSeq& __ice_distances, const ::BeobotEvents::DoubleSeq& __ice_angles, ::Ice::Int __ice_RequestID) :
    distances(__ice_distances),
    angles(__ice_angles),
    RequestID(__ice_RequestID)
{
}

::Ice::ObjectPtr
BeobotEvents::LRFMessage::ice_clone() const
{
    ::BeobotEvents::LRFMessagePtr __p = new ::BeobotEvents::LRFMessage(*this);
    return __p;
}

static const ::std::string __BeobotEvents__LRFMessage_ids[3] =
{
    "::BeobotEvents::LRFMessage",
    "::Ice::Object",
    "::RobotSimEvents::EventMessage"
};

bool
BeobotEvents::LRFMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__BeobotEvents__LRFMessage_ids, __BeobotEvents__LRFMessage_ids + 3, _s);
}

::std::vector< ::std::string>
BeobotEvents::LRFMessage::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__BeobotEvents__LRFMessage_ids[0], &__BeobotEvents__LRFMessage_ids[3]);
}

const ::std::string&
BeobotEvents::LRFMessage::ice_id(const ::Ice::Current&) const
{
    return __BeobotEvents__LRFMessage_ids[0];
}

const ::std::string&
BeobotEvents::LRFMessage::ice_staticId()
{
    return __BeobotEvents__LRFMessage_ids[0];
}

void
BeobotEvents::LRFMessage::__write(::IceInternal::BasicStream* __os) const
{
    __os->writeTypeId(ice_staticId());
    __os->startWriteSlice();
    if(distances.size() == 0)
    {
        __os->writeSize(0);
    }
    else
    {
        __os->write(&distances[0], &distances[0] + distances.size());
    }
    if(angles.size() == 0)
    {
        __os->writeSize(0);
    }
    else
    {
        __os->write(&angles[0], &angles[0] + angles.size());
    }
    __os->write(RequestID);
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__write(__os);
#else
    ::RobotSimEvents::EventMessage::__write(__os);
#endif
}

void
BeobotEvents::LRFMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    __is->read(distances);
    __is->read(angles);
    __is->read(RequestID);
    __is->endReadSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__read(__is, true);
#else
    ::RobotSimEvents::EventMessage::__read(__is, true);
#endif
}

void
BeobotEvents::LRFMessage::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type BeobotEvents::LRFMessage was not generated with stream support";
    throw ex;
}

void
BeobotEvents::LRFMessage::__read(const ::Ice::InputStreamPtr&, bool)
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type BeobotEvents::LRFMessage was not generated with stream support";
    throw ex;
}

class __F__BeobotEvents__LRFMessage : public ::Ice::ObjectFactory
{
public:

    virtual ::Ice::ObjectPtr
    create(const ::std::string& type)
    {
        assert(type == ::BeobotEvents::LRFMessage::ice_staticId());
        return new ::BeobotEvents::LRFMessage;
    }

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__BeobotEvents__LRFMessage_Ptr = new __F__BeobotEvents__LRFMessage;

const ::Ice::ObjectFactoryPtr&
BeobotEvents::LRFMessage::ice_factory()
{
    return __F__BeobotEvents__LRFMessage_Ptr;
}

class __F__BeobotEvents__LRFMessage__Init
{
public:

    __F__BeobotEvents__LRFMessage__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::BeobotEvents::LRFMessage::ice_staticId(), ::BeobotEvents::LRFMessage::ice_factory());
    }

    ~__F__BeobotEvents__LRFMessage__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::BeobotEvents::LRFMessage::ice_staticId());
    }
};

static __F__BeobotEvents__LRFMessage__Init __F__BeobotEvents__LRFMessage__i;

#ifdef __APPLE__
extern "C" { void __F__BeobotEvents__LRFMessage__initializer() {} }
#endif

void
BeobotEvents::__patch__LRFMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::BeobotEvents::LRFMessagePtr* p = static_cast< ::BeobotEvents::LRFMessagePtr*>(__addr);
    assert(p);
    *p = ::BeobotEvents::LRFMessagePtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::BeobotEvents::LRFMessage::ice_staticId(), v->ice_id());
    }
}

bool
BeobotEvents::operator==(const ::BeobotEvents::LRFMessage& l, const ::BeobotEvents::LRFMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

bool
BeobotEvents::operator<(const ::BeobotEvents::LRFMessage& l, const ::BeobotEvents::LRFMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}

BeobotEvents::SLAMMessage::SLAMMessage(::Ice::Double __ice_mapResolution, ::Ice::Double __ice_robotX, ::Ice::Double __ice_robotY, ::Ice::Double __ice_robotOri, ::Ice::Int __ice_RequestID) :
    mapResolution(__ice_mapResolution),
    robotX(__ice_robotX),
    robotY(__ice_robotY),
    robotOri(__ice_robotOri),
    RequestID(__ice_RequestID)
{
}

::Ice::ObjectPtr
BeobotEvents::SLAMMessage::ice_clone() const
{
    ::BeobotEvents::SLAMMessagePtr __p = new ::BeobotEvents::SLAMMessage(*this);
    return __p;
}

static const ::std::string __BeobotEvents__SLAMMessage_ids[3] =
{
    "::BeobotEvents::SLAMMessage",
    "::Ice::Object",
    "::RobotSimEvents::EventMessage"
};

bool
BeobotEvents::SLAMMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__BeobotEvents__SLAMMessage_ids, __BeobotEvents__SLAMMessage_ids + 3, _s);
}

::std::vector< ::std::string>
BeobotEvents::SLAMMessage::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__BeobotEvents__SLAMMessage_ids[0], &__BeobotEvents__SLAMMessage_ids[3]);
}

const ::std::string&
BeobotEvents::SLAMMessage::ice_id(const ::Ice::Current&) const
{
    return __BeobotEvents__SLAMMessage_ids[0];
}

const ::std::string&
BeobotEvents::SLAMMessage::ice_staticId()
{
    return __BeobotEvents__SLAMMessage_ids[0];
}

void
BeobotEvents::SLAMMessage::__write(::IceInternal::BasicStream* __os) const
{
    __os->writeTypeId(ice_staticId());
    __os->startWriteSlice();
    __os->write(mapResolution);
    __os->write(robotX);
    __os->write(robotY);
    __os->write(robotOri);
    __os->write(RequestID);
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__write(__os);
#else
    ::RobotSimEvents::EventMessage::__write(__os);
#endif
}

void
BeobotEvents::SLAMMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    __is->read(mapResolution);
    __is->read(robotX);
    __is->read(robotY);
    __is->read(robotOri);
    __is->read(RequestID);
    __is->endReadSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__read(__is, true);
#else
    ::RobotSimEvents::EventMessage::__read(__is, true);
#endif
}

void
BeobotEvents::SLAMMessage::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type BeobotEvents::SLAMMessage was not generated with stream support";
    throw ex;
}

void
BeobotEvents::SLAMMessage::__read(const ::Ice::InputStreamPtr&, bool)
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type BeobotEvents::SLAMMessage was not generated with stream support";
    throw ex;
}

class __F__BeobotEvents__SLAMMessage : public ::Ice::ObjectFactory
{
public:

    virtual ::Ice::ObjectPtr
    create(const ::std::string& type)
    {
        assert(type == ::BeobotEvents::SLAMMessage::ice_staticId());
        return new ::BeobotEvents::SLAMMessage;
    }

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__BeobotEvents__SLAMMessage_Ptr = new __F__BeobotEvents__SLAMMessage;

const ::Ice::ObjectFactoryPtr&
BeobotEvents::SLAMMessage::ice_factory()
{
    return __F__BeobotEvents__SLAMMessage_Ptr;
}

class __F__BeobotEvents__SLAMMessage__Init
{
public:

    __F__BeobotEvents__SLAMMessage__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::BeobotEvents::SLAMMessage::ice_staticId(), ::BeobotEvents::SLAMMessage::ice_factory());
    }

    ~__F__BeobotEvents__SLAMMessage__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::BeobotEvents::SLAMMessage::ice_staticId());
    }
};

static __F__BeobotEvents__SLAMMessage__Init __F__BeobotEvents__SLAMMessage__i;

#ifdef __APPLE__
extern "C" { void __F__BeobotEvents__SLAMMessage__initializer() {} }
#endif

void
BeobotEvents::__patch__SLAMMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::BeobotEvents::SLAMMessagePtr* p = static_cast< ::BeobotEvents::SLAMMessagePtr*>(__addr);
    assert(p);
    *p = ::BeobotEvents::SLAMMessagePtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::BeobotEvents::SLAMMessage::ice_staticId(), v->ice_id());
    }
}

bool
BeobotEvents::operator==(const ::BeobotEvents::SLAMMessage& l, const ::BeobotEvents::SLAMMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

bool
BeobotEvents::operator<(const ::BeobotEvents::SLAMMessage& l, const ::BeobotEvents::SLAMMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}

BeobotEvents::IMUMessage::IMUMessage(bool __ice_validAccAndAng, ::Ice::Float __ice_accelX, ::Ice::Float __ice_accelY, ::Ice::Float __ice_accelZ, ::Ice::Float __ice_angRateX, ::Ice::Float __ice_angRateY, ::Ice::Float __ice_angRateZ, bool __ice_validRollPitchYaw, ::Ice::Float __ice_roll, ::Ice::Float __ice_pitch, ::Ice::Float __ice_yaw, bool __ice_validMagnetometer, ::Ice::Float __ice_magX, ::Ice::Float __ice_magY, ::Ice::Float __ice_magZ, ::Ice::Int __ice_RequestID) :
    validAccAndAng(__ice_validAccAndAng),
    accelX(__ice_accelX),
    accelY(__ice_accelY),
    accelZ(__ice_accelZ),
    angRateX(__ice_angRateX),
    angRateY(__ice_angRateY),
    angRateZ(__ice_angRateZ),
    validRollPitchYaw(__ice_validRollPitchYaw),
    roll(__ice_roll),
    pitch(__ice_pitch),
    yaw(__ice_yaw),
    validMagnetometer(__ice_validMagnetometer),
    magX(__ice_magX),
    magY(__ice_magY),
    magZ(__ice_magZ),
    RequestID(__ice_RequestID)
{
}

::Ice::ObjectPtr
BeobotEvents::IMUMessage::ice_clone() const
{
    ::BeobotEvents::IMUMessagePtr __p = new ::BeobotEvents::IMUMessage(*this);
    return __p;
}

static const ::std::string __BeobotEvents__IMUMessage_ids[3] =
{
    "::BeobotEvents::IMUMessage",
    "::Ice::Object",
    "::RobotSimEvents::EventMessage"
};

bool
BeobotEvents::IMUMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__BeobotEvents__IMUMessage_ids, __BeobotEvents__IMUMessage_ids + 3, _s);
}

::std::vector< ::std::string>
BeobotEvents::IMUMessage::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__BeobotEvents__IMUMessage_ids[0], &__BeobotEvents__IMUMessage_ids[3]);
}

const ::std::string&
BeobotEvents::IMUMessage::ice_id(const ::Ice::Current&) const
{
    return __BeobotEvents__IMUMessage_ids[0];
}

const ::std::string&
BeobotEvents::IMUMessage::ice_staticId()
{
    return __BeobotEvents__IMUMessage_ids[0];
}

void
BeobotEvents::IMUMessage::__write(::IceInternal::BasicStream* __os) const
{
    __os->writeTypeId(ice_staticId());
    __os->startWriteSlice();
    __os->write(validAccAndAng);
    __os->write(accelX);
    __os->write(accelY);
    __os->write(accelZ);
    __os->write(angRateX);
    __os->write(angRateY);
    __os->write(angRateZ);
    __os->write(validRollPitchYaw);
    __os->write(roll);
    __os->write(pitch);
    __os->write(yaw);
    __os->write(validMagnetometer);
    __os->write(magX);
    __os->write(magY);
    __os->write(magZ);
    __os->write(RequestID);
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__write(__os);
#else
    ::RobotSimEvents::EventMessage::__write(__os);
#endif
}

void
BeobotEvents::IMUMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    __is->read(validAccAndAng);
    __is->read(accelX);
    __is->read(accelY);
    __is->read(accelZ);
    __is->read(angRateX);
    __is->read(angRateY);
    __is->read(angRateZ);
    __is->read(validRollPitchYaw);
    __is->read(roll);
    __is->read(pitch);
    __is->read(yaw);
    __is->read(validMagnetometer);
    __is->read(magX);
    __is->read(magY);
    __is->read(magZ);
    __is->read(RequestID);
    __is->endReadSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__read(__is, true);
#else
    ::RobotSimEvents::EventMessage::__read(__is, true);
#endif
}

void
BeobotEvents::IMUMessage::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type BeobotEvents::IMUMessage was not generated with stream support";
    throw ex;
}

void
BeobotEvents::IMUMessage::__read(const ::Ice::InputStreamPtr&, bool)
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type BeobotEvents::IMUMessage was not generated with stream support";
    throw ex;
}

class __F__BeobotEvents__IMUMessage : public ::Ice::ObjectFactory
{
public:

    virtual ::Ice::ObjectPtr
    create(const ::std::string& type)
    {
        assert(type == ::BeobotEvents::IMUMessage::ice_staticId());
        return new ::BeobotEvents::IMUMessage;
    }

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__BeobotEvents__IMUMessage_Ptr = new __F__BeobotEvents__IMUMessage;

const ::Ice::ObjectFactoryPtr&
BeobotEvents::IMUMessage::ice_factory()
{
    return __F__BeobotEvents__IMUMessage_Ptr;
}

class __F__BeobotEvents__IMUMessage__Init
{
public:

    __F__BeobotEvents__IMUMessage__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::BeobotEvents::IMUMessage::ice_staticId(), ::BeobotEvents::IMUMessage::ice_factory());
    }

    ~__F__BeobotEvents__IMUMessage__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::BeobotEvents::IMUMessage::ice_staticId());
    }
};

static __F__BeobotEvents__IMUMessage__Init __F__BeobotEvents__IMUMessage__i;

#ifdef __APPLE__
extern "C" { void __F__BeobotEvents__IMUMessage__initializer() {} }
#endif

void
BeobotEvents::__patch__IMUMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::BeobotEvents::IMUMessagePtr* p = static_cast< ::BeobotEvents::IMUMessagePtr*>(__addr);
    assert(p);
    *p = ::BeobotEvents::IMUMessagePtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::BeobotEvents::IMUMessage::ice_staticId(), v->ice_id());
    }
}

bool
BeobotEvents::operator==(const ::BeobotEvents::IMUMessage& l, const ::BeobotEvents::IMUMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

bool
BeobotEvents::operator<(const ::BeobotEvents::IMUMessage& l, const ::BeobotEvents::IMUMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}

BeobotEvents::CameraMessage::CameraMessage(const ::ImageIceMod::ImageIce& __ice_image, ::Ice::Int __ice_RequestID) :
    image(__ice_image),
    RequestID(__ice_RequestID)
{
}

::Ice::ObjectPtr
BeobotEvents::CameraMessage::ice_clone() const
{
    ::BeobotEvents::CameraMessagePtr __p = new ::BeobotEvents::CameraMessage(*this);
    return __p;
}

static const ::std::string __BeobotEvents__CameraMessage_ids[3] =
{
    "::BeobotEvents::CameraMessage",
    "::Ice::Object",
    "::RobotSimEvents::EventMessage"
};

bool
BeobotEvents::CameraMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__BeobotEvents__CameraMessage_ids, __BeobotEvents__CameraMessage_ids + 3, _s);
}

::std::vector< ::std::string>
BeobotEvents::CameraMessage::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__BeobotEvents__CameraMessage_ids[0], &__BeobotEvents__CameraMessage_ids[3]);
}

const ::std::string&
BeobotEvents::CameraMessage::ice_id(const ::Ice::Current&) const
{
    return __BeobotEvents__CameraMessage_ids[0];
}

const ::std::string&
BeobotEvents::CameraMessage::ice_staticId()
{
    return __BeobotEvents__CameraMessage_ids[0];
}

void
BeobotEvents::CameraMessage::__write(::IceInternal::BasicStream* __os) const
{
    __os->writeTypeId(ice_staticId());
    __os->startWriteSlice();
    image.__write(__os);
    __os->write(RequestID);
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__write(__os);
#else
    ::RobotSimEvents::EventMessage::__write(__os);
#endif
}

void
BeobotEvents::CameraMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    image.__read(__is);
    __is->read(RequestID);
    __is->endReadSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__read(__is, true);
#else
    ::RobotSimEvents::EventMessage::__read(__is, true);
#endif
}

void
BeobotEvents::CameraMessage::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type BeobotEvents::CameraMessage was not generated with stream support";
    throw ex;
}

void
BeobotEvents::CameraMessage::__read(const ::Ice::InputStreamPtr&, bool)
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type BeobotEvents::CameraMessage was not generated with stream support";
    throw ex;
}

class __F__BeobotEvents__CameraMessage : public ::Ice::ObjectFactory
{
public:

    virtual ::Ice::ObjectPtr
    create(const ::std::string& type)
    {
        assert(type == ::BeobotEvents::CameraMessage::ice_staticId());
        return new ::BeobotEvents::CameraMessage;
    }

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__BeobotEvents__CameraMessage_Ptr = new __F__BeobotEvents__CameraMessage;

const ::Ice::ObjectFactoryPtr&
BeobotEvents::CameraMessage::ice_factory()
{
    return __F__BeobotEvents__CameraMessage_Ptr;
}

class __F__BeobotEvents__CameraMessage__Init
{
public:

    __F__BeobotEvents__CameraMessage__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::BeobotEvents::CameraMessage::ice_staticId(), ::BeobotEvents::CameraMessage::ice_factory());
    }

    ~__F__BeobotEvents__CameraMessage__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::BeobotEvents::CameraMessage::ice_staticId());
    }
};

static __F__BeobotEvents__CameraMessage__Init __F__BeobotEvents__CameraMessage__i;

#ifdef __APPLE__
extern "C" { void __F__BeobotEvents__CameraMessage__initializer() {} }
#endif

void
BeobotEvents::__patch__CameraMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::BeobotEvents::CameraMessagePtr* p = static_cast< ::BeobotEvents::CameraMessagePtr*>(__addr);
    assert(p);
    *p = ::BeobotEvents::CameraMessagePtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::BeobotEvents::CameraMessage::ice_staticId(), v->ice_id());
    }
}

bool
BeobotEvents::operator==(const ::BeobotEvents::CameraMessage& l, const ::BeobotEvents::CameraMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

bool
BeobotEvents::operator<(const ::BeobotEvents::CameraMessage& l, const ::BeobotEvents::CameraMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}

BeobotEvents::GistSalMessage::GistSalMessage(const ::ImageIceMod::ImageIce& __ice_currIma, const ::BeobotEvents::DoubleSeq& __ice_gistFeatures, const ::BeobotEvents::SalientRegionSeq& __ice_salientRegions, const ::ImageIceMod::ImageIceSeq& __ice_conspicuityMaps, ::Ice::Int __ice_RequestID) :
    currIma(__ice_currIma),
    gistFeatures(__ice_gistFeatures),
    salientRegions(__ice_salientRegions),
    conspicuityMaps(__ice_conspicuityMaps),
    RequestID(__ice_RequestID)
{
}

::Ice::ObjectPtr
BeobotEvents::GistSalMessage::ice_clone() const
{
    ::BeobotEvents::GistSalMessagePtr __p = new ::BeobotEvents::GistSalMessage(*this);
    return __p;
}

static const ::std::string __BeobotEvents__GistSalMessage_ids[3] =
{
    "::BeobotEvents::GistSalMessage",
    "::Ice::Object",
    "::RobotSimEvents::EventMessage"
};

bool
BeobotEvents::GistSalMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__BeobotEvents__GistSalMessage_ids, __BeobotEvents__GistSalMessage_ids + 3, _s);
}

::std::vector< ::std::string>
BeobotEvents::GistSalMessage::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__BeobotEvents__GistSalMessage_ids[0], &__BeobotEvents__GistSalMessage_ids[3]);
}

const ::std::string&
BeobotEvents::GistSalMessage::ice_id(const ::Ice::Current&) const
{
    return __BeobotEvents__GistSalMessage_ids[0];
}

const ::std::string&
BeobotEvents::GistSalMessage::ice_staticId()
{
    return __BeobotEvents__GistSalMessage_ids[0];
}

void
BeobotEvents::GistSalMessage::__write(::IceInternal::BasicStream* __os) const
{
    __os->writeTypeId(ice_staticId());
    __os->startWriteSlice();
    currIma.__write(__os);
    if(gistFeatures.size() == 0)
    {
        __os->writeSize(0);
    }
    else
    {
        __os->write(&gistFeatures[0], &gistFeatures[0] + gistFeatures.size());
    }
    if(salientRegions.size() == 0)
    {
        __os->writeSize(0);
    }
    else
    {
        ::BeobotEvents::__writeSalientRegionSeq(__os, &salientRegions[0], &salientRegions[0] + salientRegions.size());
    }
    if(conspicuityMaps.size() == 0)
    {
        __os->writeSize(0);
    }
    else
    {
        ::ImageIceMod::__writeImageIceSeq(__os, &conspicuityMaps[0], &conspicuityMaps[0] + conspicuityMaps.size());
    }
    __os->write(RequestID);
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__write(__os);
#else
    ::RobotSimEvents::EventMessage::__write(__os);
#endif
}

void
BeobotEvents::GistSalMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    currIma.__read(__is);
    __is->read(gistFeatures);
    ::BeobotEvents::__readSalientRegionSeq(__is, salientRegions);
    ::ImageIceMod::__readImageIceSeq(__is, conspicuityMaps);
    __is->read(RequestID);
    __is->endReadSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__read(__is, true);
#else
    ::RobotSimEvents::EventMessage::__read(__is, true);
#endif
}

void
BeobotEvents::GistSalMessage::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type BeobotEvents::GistSalMessage was not generated with stream support";
    throw ex;
}

void
BeobotEvents::GistSalMessage::__read(const ::Ice::InputStreamPtr&, bool)
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type BeobotEvents::GistSalMessage was not generated with stream support";
    throw ex;
}

class __F__BeobotEvents__GistSalMessage : public ::Ice::ObjectFactory
{
public:

    virtual ::Ice::ObjectPtr
    create(const ::std::string& type)
    {
        assert(type == ::BeobotEvents::GistSalMessage::ice_staticId());
        return new ::BeobotEvents::GistSalMessage;
    }

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__BeobotEvents__GistSalMessage_Ptr = new __F__BeobotEvents__GistSalMessage;

const ::Ice::ObjectFactoryPtr&
BeobotEvents::GistSalMessage::ice_factory()
{
    return __F__BeobotEvents__GistSalMessage_Ptr;
}

class __F__BeobotEvents__GistSalMessage__Init
{
public:

    __F__BeobotEvents__GistSalMessage__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::BeobotEvents::GistSalMessage::ice_staticId(), ::BeobotEvents::GistSalMessage::ice_factory());
    }

    ~__F__BeobotEvents__GistSalMessage__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::BeobotEvents::GistSalMessage::ice_staticId());
    }
};

static __F__BeobotEvents__GistSalMessage__Init __F__BeobotEvents__GistSalMessage__i;

#ifdef __APPLE__
extern "C" { void __F__BeobotEvents__GistSalMessage__initializer() {} }
#endif

void
BeobotEvents::__patch__GistSalMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::BeobotEvents::GistSalMessagePtr* p = static_cast< ::BeobotEvents::GistSalMessagePtr*>(__addr);
    assert(p);
    *p = ::BeobotEvents::GistSalMessagePtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::BeobotEvents::GistSalMessage::ice_staticId(), v->ice_id());
    }
}

bool
BeobotEvents::operator==(const ::BeobotEvents::GistSalMessage& l, const ::BeobotEvents::GistSalMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

bool
BeobotEvents::operator<(const ::BeobotEvents::GistSalMessage& l, const ::BeobotEvents::GistSalMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}

BeobotEvents::LandmarkSearchQueueMessage::LandmarkSearchQueueMessage(const ::ImageIceMod::ImageIce& __ice_currIma, const ::BeobotEvents::SalientRegionSeq& __ice_salientRegions, const ::BeobotEvents::LandmarkSearchJobSeq& __ice_jobs, ::Ice::Int __ice_RequestID) :
    currIma(__ice_currIma),
    salientRegions(__ice_salientRegions),
    jobs(__ice_jobs),
    RequestID(__ice_RequestID)
{
}

::Ice::ObjectPtr
BeobotEvents::LandmarkSearchQueueMessage::ice_clone() const
{
    ::BeobotEvents::LandmarkSearchQueueMessagePtr __p = new ::BeobotEvents::LandmarkSearchQueueMessage(*this);
    return __p;
}

static const ::std::string __BeobotEvents__LandmarkSearchQueueMessage_ids[3] =
{
    "::BeobotEvents::LandmarkSearchQueueMessage",
    "::Ice::Object",
    "::RobotSimEvents::EventMessage"
};

bool
BeobotEvents::LandmarkSearchQueueMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__BeobotEvents__LandmarkSearchQueueMessage_ids, __BeobotEvents__LandmarkSearchQueueMessage_ids + 3, _s);
}

::std::vector< ::std::string>
BeobotEvents::LandmarkSearchQueueMessage::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__BeobotEvents__LandmarkSearchQueueMessage_ids[0], &__BeobotEvents__LandmarkSearchQueueMessage_ids[3]);
}

const ::std::string&
BeobotEvents::LandmarkSearchQueueMessage::ice_id(const ::Ice::Current&) const
{
    return __BeobotEvents__LandmarkSearchQueueMessage_ids[0];
}

const ::std::string&
BeobotEvents::LandmarkSearchQueueMessage::ice_staticId()
{
    return __BeobotEvents__LandmarkSearchQueueMessage_ids[0];
}

void
BeobotEvents::LandmarkSearchQueueMessage::__write(::IceInternal::BasicStream* __os) const
{
    __os->writeTypeId(ice_staticId());
    __os->startWriteSlice();
    currIma.__write(__os);
    if(salientRegions.size() == 0)
    {
        __os->writeSize(0);
    }
    else
    {
        ::BeobotEvents::__writeSalientRegionSeq(__os, &salientRegions[0], &salientRegions[0] + salientRegions.size());
    }
    if(jobs.size() == 0)
    {
        __os->writeSize(0);
    }
    else
    {
        ::BeobotEvents::__writeLandmarkSearchJobSeq(__os, &jobs[0], &jobs[0] + jobs.size());
    }
    __os->write(RequestID);
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__write(__os);
#else
    ::RobotSimEvents::EventMessage::__write(__os);
#endif
}

void
BeobotEvents::LandmarkSearchQueueMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    currIma.__read(__is);
    ::BeobotEvents::__readSalientRegionSeq(__is, salientRegions);
    ::BeobotEvents::__readLandmarkSearchJobSeq(__is, jobs);
    __is->read(RequestID);
    __is->endReadSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__read(__is, true);
#else
    ::RobotSimEvents::EventMessage::__read(__is, true);
#endif
}

void
BeobotEvents::LandmarkSearchQueueMessage::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type BeobotEvents::LandmarkSearchQueueMessage was not generated with stream support";
    throw ex;
}

void
BeobotEvents::LandmarkSearchQueueMessage::__read(const ::Ice::InputStreamPtr&, bool)
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type BeobotEvents::LandmarkSearchQueueMessage was not generated with stream support";
    throw ex;
}

class __F__BeobotEvents__LandmarkSearchQueueMessage : public ::Ice::ObjectFactory
{
public:

    virtual ::Ice::ObjectPtr
    create(const ::std::string& type)
    {
        assert(type == ::BeobotEvents::LandmarkSearchQueueMessage::ice_staticId());
        return new ::BeobotEvents::LandmarkSearchQueueMessage;
    }

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__BeobotEvents__LandmarkSearchQueueMessage_Ptr = new __F__BeobotEvents__LandmarkSearchQueueMessage;

const ::Ice::ObjectFactoryPtr&
BeobotEvents::LandmarkSearchQueueMessage::ice_factory()
{
    return __F__BeobotEvents__LandmarkSearchQueueMessage_Ptr;
}

class __F__BeobotEvents__LandmarkSearchQueueMessage__Init
{
public:

    __F__BeobotEvents__LandmarkSearchQueueMessage__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::BeobotEvents::LandmarkSearchQueueMessage::ice_staticId(), ::BeobotEvents::LandmarkSearchQueueMessage::ice_factory());
    }

    ~__F__BeobotEvents__LandmarkSearchQueueMessage__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::BeobotEvents::LandmarkSearchQueueMessage::ice_staticId());
    }
};

static __F__BeobotEvents__LandmarkSearchQueueMessage__Init __F__BeobotEvents__LandmarkSearchQueueMessage__i;

#ifdef __APPLE__
extern "C" { void __F__BeobotEvents__LandmarkSearchQueueMessage__initializer() {} }
#endif

void
BeobotEvents::__patch__LandmarkSearchQueueMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::BeobotEvents::LandmarkSearchQueueMessagePtr* p = static_cast< ::BeobotEvents::LandmarkSearchQueueMessagePtr*>(__addr);
    assert(p);
    *p = ::BeobotEvents::LandmarkSearchQueueMessagePtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::BeobotEvents::LandmarkSearchQueueMessage::ice_staticId(), v->ice_id());
    }
}

bool
BeobotEvents::operator==(const ::BeobotEvents::LandmarkSearchQueueMessage& l, const ::BeobotEvents::LandmarkSearchQueueMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

bool
BeobotEvents::operator<(const ::BeobotEvents::LandmarkSearchQueueMessage& l, const ::BeobotEvents::LandmarkSearchQueueMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}

BeobotEvents::LandmarkTrackMessage::LandmarkTrackMessage(const ::ImageIceMod::ImageIce& __ice_currIma, const ::BeobotEvents::DoubleSeq& __ice_gistFeatures, const ::BeobotEvents::SalientRegionSeq& __ice_salientRegions, const ::ImageIceMod::ImageIceSeq& __ice_conspicuityMaps, bool __ice_resetTracker, ::Ice::Int __ice_RequestID) :
    currIma(__ice_currIma),
    gistFeatures(__ice_gistFeatures),
    salientRegions(__ice_salientRegions),
    conspicuityMaps(__ice_conspicuityMaps),
    resetTracker(__ice_resetTracker),
    RequestID(__ice_RequestID)
{
}

::Ice::ObjectPtr
BeobotEvents::LandmarkTrackMessage::ice_clone() const
{
    ::BeobotEvents::LandmarkTrackMessagePtr __p = new ::BeobotEvents::LandmarkTrackMessage(*this);
    return __p;
}

static const ::std::string __BeobotEvents__LandmarkTrackMessage_ids[3] =
{
    "::BeobotEvents::LandmarkTrackMessage",
    "::Ice::Object",
    "::RobotSimEvents::EventMessage"
};

bool
BeobotEvents::LandmarkTrackMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__BeobotEvents__LandmarkTrackMessage_ids, __BeobotEvents__LandmarkTrackMessage_ids + 3, _s);
}

::std::vector< ::std::string>
BeobotEvents::LandmarkTrackMessage::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__BeobotEvents__LandmarkTrackMessage_ids[0], &__BeobotEvents__LandmarkTrackMessage_ids[3]);
}

const ::std::string&
BeobotEvents::LandmarkTrackMessage::ice_id(const ::Ice::Current&) const
{
    return __BeobotEvents__LandmarkTrackMessage_ids[0];
}

const ::std::string&
BeobotEvents::LandmarkTrackMessage::ice_staticId()
{
    return __BeobotEvents__LandmarkTrackMessage_ids[0];
}

void
BeobotEvents::LandmarkTrackMessage::__write(::IceInternal::BasicStream* __os) const
{
    __os->writeTypeId(ice_staticId());
    __os->startWriteSlice();
    currIma.__write(__os);
    if(gistFeatures.size() == 0)
    {
        __os->writeSize(0);
    }
    else
    {
        __os->write(&gistFeatures[0], &gistFeatures[0] + gistFeatures.size());
    }
    if(salientRegions.size() == 0)
    {
        __os->writeSize(0);
    }
    else
    {
        ::BeobotEvents::__writeSalientRegionSeq(__os, &salientRegions[0], &salientRegions[0] + salientRegions.size());
    }
    if(conspicuityMaps.size() == 0)
    {
        __os->writeSize(0);
    }
    else
    {
        ::ImageIceMod::__writeImageIceSeq(__os, &conspicuityMaps[0], &conspicuityMaps[0] + conspicuityMaps.size());
    }
    __os->write(resetTracker);
    __os->write(RequestID);
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__write(__os);
#else
    ::RobotSimEvents::EventMessage::__write(__os);
#endif
}

void
BeobotEvents::LandmarkTrackMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    currIma.__read(__is);
    __is->read(gistFeatures);
    ::BeobotEvents::__readSalientRegionSeq(__is, salientRegions);
    ::ImageIceMod::__readImageIceSeq(__is, conspicuityMaps);
    __is->read(resetTracker);
    __is->read(RequestID);
    __is->endReadSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__read(__is, true);
#else
    ::RobotSimEvents::EventMessage::__read(__is, true);
#endif
}

void
BeobotEvents::LandmarkTrackMessage::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type BeobotEvents::LandmarkTrackMessage was not generated with stream support";
    throw ex;
}

void
BeobotEvents::LandmarkTrackMessage::__read(const ::Ice::InputStreamPtr&, bool)
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type BeobotEvents::LandmarkTrackMessage was not generated with stream support";
    throw ex;
}

class __F__BeobotEvents__LandmarkTrackMessage : public ::Ice::ObjectFactory
{
public:

    virtual ::Ice::ObjectPtr
    create(const ::std::string& type)
    {
        assert(type == ::BeobotEvents::LandmarkTrackMessage::ice_staticId());
        return new ::BeobotEvents::LandmarkTrackMessage;
    }

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__BeobotEvents__LandmarkTrackMessage_Ptr = new __F__BeobotEvents__LandmarkTrackMessage;

const ::Ice::ObjectFactoryPtr&
BeobotEvents::LandmarkTrackMessage::ice_factory()
{
    return __F__BeobotEvents__LandmarkTrackMessage_Ptr;
}

class __F__BeobotEvents__LandmarkTrackMessage__Init
{
public:

    __F__BeobotEvents__LandmarkTrackMessage__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::BeobotEvents::LandmarkTrackMessage::ice_staticId(), ::BeobotEvents::LandmarkTrackMessage::ice_factory());
    }

    ~__F__BeobotEvents__LandmarkTrackMessage__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::BeobotEvents::LandmarkTrackMessage::ice_staticId());
    }
};

static __F__BeobotEvents__LandmarkTrackMessage__Init __F__BeobotEvents__LandmarkTrackMessage__i;

#ifdef __APPLE__
extern "C" { void __F__BeobotEvents__LandmarkTrackMessage__initializer() {} }
#endif

void
BeobotEvents::__patch__LandmarkTrackMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::BeobotEvents::LandmarkTrackMessagePtr* p = static_cast< ::BeobotEvents::LandmarkTrackMessagePtr*>(__addr);
    assert(p);
    *p = ::BeobotEvents::LandmarkTrackMessagePtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::BeobotEvents::LandmarkTrackMessage::ice_staticId(), v->ice_id());
    }
}

bool
BeobotEvents::operator==(const ::BeobotEvents::LandmarkTrackMessage& l, const ::BeobotEvents::LandmarkTrackMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

bool
BeobotEvents::operator<(const ::BeobotEvents::LandmarkTrackMessage& l, const ::BeobotEvents::LandmarkTrackMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}

BeobotEvents::LandmarkSearchStatMessage::LandmarkSearchStatMessage(::Ice::Int __ice_inputSalRegID, ::Ice::Int __ice_numObjSearch, bool __ice_found, ::Ice::Int __ice_RequestID) :
    inputSalRegID(__ice_inputSalRegID),
    numObjSearch(__ice_numObjSearch),
    found(__ice_found),
    RequestID(__ice_RequestID)
{
}

::Ice::ObjectPtr
BeobotEvents::LandmarkSearchStatMessage::ice_clone() const
{
    ::BeobotEvents::LandmarkSearchStatMessagePtr __p = new ::BeobotEvents::LandmarkSearchStatMessage(*this);
    return __p;
}

static const ::std::string __BeobotEvents__LandmarkSearchStatMessage_ids[3] =
{
    "::BeobotEvents::LandmarkSearchStatMessage",
    "::Ice::Object",
    "::RobotSimEvents::EventMessage"
};

bool
BeobotEvents::LandmarkSearchStatMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__BeobotEvents__LandmarkSearchStatMessage_ids, __BeobotEvents__LandmarkSearchStatMessage_ids + 3, _s);
}

::std::vector< ::std::string>
BeobotEvents::LandmarkSearchStatMessage::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__BeobotEvents__LandmarkSearchStatMessage_ids[0], &__BeobotEvents__LandmarkSearchStatMessage_ids[3]);
}

const ::std::string&
BeobotEvents::LandmarkSearchStatMessage::ice_id(const ::Ice::Current&) const
{
    return __BeobotEvents__LandmarkSearchStatMessage_ids[0];
}

const ::std::string&
BeobotEvents::LandmarkSearchStatMessage::ice_staticId()
{
    return __BeobotEvents__LandmarkSearchStatMessage_ids[0];
}

void
BeobotEvents::LandmarkSearchStatMessage::__write(::IceInternal::BasicStream* __os) const
{
    __os->writeTypeId(ice_staticId());
    __os->startWriteSlice();
    __os->write(inputSalRegID);
    __os->write(numObjSearch);
    __os->write(found);
    __os->write(RequestID);
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__write(__os);
#else
    ::RobotSimEvents::EventMessage::__write(__os);
#endif
}

void
BeobotEvents::LandmarkSearchStatMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    __is->read(inputSalRegID);
    __is->read(numObjSearch);
    __is->read(found);
    __is->read(RequestID);
    __is->endReadSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__read(__is, true);
#else
    ::RobotSimEvents::EventMessage::__read(__is, true);
#endif
}

void
BeobotEvents::LandmarkSearchStatMessage::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type BeobotEvents::LandmarkSearchStatMessage was not generated with stream support";
    throw ex;
}

void
BeobotEvents::LandmarkSearchStatMessage::__read(const ::Ice::InputStreamPtr&, bool)
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type BeobotEvents::LandmarkSearchStatMessage was not generated with stream support";
    throw ex;
}

class __F__BeobotEvents__LandmarkSearchStatMessage : public ::Ice::ObjectFactory
{
public:

    virtual ::Ice::ObjectPtr
    create(const ::std::string& type)
    {
        assert(type == ::BeobotEvents::LandmarkSearchStatMessage::ice_staticId());
        return new ::BeobotEvents::LandmarkSearchStatMessage;
    }

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__BeobotEvents__LandmarkSearchStatMessage_Ptr = new __F__BeobotEvents__LandmarkSearchStatMessage;

const ::Ice::ObjectFactoryPtr&
BeobotEvents::LandmarkSearchStatMessage::ice_factory()
{
    return __F__BeobotEvents__LandmarkSearchStatMessage_Ptr;
}

class __F__BeobotEvents__LandmarkSearchStatMessage__Init
{
public:

    __F__BeobotEvents__LandmarkSearchStatMessage__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::BeobotEvents::LandmarkSearchStatMessage::ice_staticId(), ::BeobotEvents::LandmarkSearchStatMessage::ice_factory());
    }

    ~__F__BeobotEvents__LandmarkSearchStatMessage__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::BeobotEvents::LandmarkSearchStatMessage::ice_staticId());
    }
};

static __F__BeobotEvents__LandmarkSearchStatMessage__Init __F__BeobotEvents__LandmarkSearchStatMessage__i;

#ifdef __APPLE__
extern "C" { void __F__BeobotEvents__LandmarkSearchStatMessage__initializer() {} }
#endif

void
BeobotEvents::__patch__LandmarkSearchStatMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::BeobotEvents::LandmarkSearchStatMessagePtr* p = static_cast< ::BeobotEvents::LandmarkSearchStatMessagePtr*>(__addr);
    assert(p);
    *p = ::BeobotEvents::LandmarkSearchStatMessagePtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::BeobotEvents::LandmarkSearchStatMessage::ice_staticId(), v->ice_id());
    }
}

bool
BeobotEvents::operator==(const ::BeobotEvents::LandmarkSearchStatMessage& l, const ::BeobotEvents::LandmarkSearchStatMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

bool
BeobotEvents::operator<(const ::BeobotEvents::LandmarkSearchStatMessage& l, const ::BeobotEvents::LandmarkSearchStatMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}

BeobotEvents::LandmarkMatchResultMessage::LandmarkMatchResultMessage(::Ice::Int __ice_RequestID, const ::ImageIceMod::ImageIce& __ice_voMatchImage, const ::BeobotEvents::LandmarkSearchJob& __ice_matchInfo, ::Ice::Int __ice_segNumMatch, ::Ice::Float __ice_lenTravMatch, ::Ice::Float __ice_MatchScore) :
    RequestID(__ice_RequestID),
    voMatchImage(__ice_voMatchImage),
    matchInfo(__ice_matchInfo),
    segNumMatch(__ice_segNumMatch),
    lenTravMatch(__ice_lenTravMatch),
    MatchScore(__ice_MatchScore)
{
}

::Ice::ObjectPtr
BeobotEvents::LandmarkMatchResultMessage::ice_clone() const
{
    ::BeobotEvents::LandmarkMatchResultMessagePtr __p = new ::BeobotEvents::LandmarkMatchResultMessage(*this);
    return __p;
}

static const ::std::string __BeobotEvents__LandmarkMatchResultMessage_ids[3] =
{
    "::BeobotEvents::LandmarkMatchResultMessage",
    "::Ice::Object",
    "::RobotSimEvents::EventMessage"
};

bool
BeobotEvents::LandmarkMatchResultMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__BeobotEvents__LandmarkMatchResultMessage_ids, __BeobotEvents__LandmarkMatchResultMessage_ids + 3, _s);
}

::std::vector< ::std::string>
BeobotEvents::LandmarkMatchResultMessage::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__BeobotEvents__LandmarkMatchResultMessage_ids[0], &__BeobotEvents__LandmarkMatchResultMessage_ids[3]);
}

const ::std::string&
BeobotEvents::LandmarkMatchResultMessage::ice_id(const ::Ice::Current&) const
{
    return __BeobotEvents__LandmarkMatchResultMessage_ids[0];
}

const ::std::string&
BeobotEvents::LandmarkMatchResultMessage::ice_staticId()
{
    return __BeobotEvents__LandmarkMatchResultMessage_ids[0];
}

void
BeobotEvents::LandmarkMatchResultMessage::__write(::IceInternal::BasicStream* __os) const
{
    __os->writeTypeId(ice_staticId());
    __os->startWriteSlice();
    __os->write(RequestID);
    voMatchImage.__write(__os);
    matchInfo.__write(__os);
    __os->write(segNumMatch);
    __os->write(lenTravMatch);
    __os->write(MatchScore);
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__write(__os);
#else
    ::RobotSimEvents::EventMessage::__write(__os);
#endif
}

void
BeobotEvents::LandmarkMatchResultMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    __is->read(RequestID);
    voMatchImage.__read(__is);
    matchInfo.__read(__is);
    __is->read(segNumMatch);
    __is->read(lenTravMatch);
    __is->read(MatchScore);
    __is->endReadSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__read(__is, true);
#else
    ::RobotSimEvents::EventMessage::__read(__is, true);
#endif
}

void
BeobotEvents::LandmarkMatchResultMessage::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type BeobotEvents::LandmarkMatchResultMessage was not generated with stream support";
    throw ex;
}

void
BeobotEvents::LandmarkMatchResultMessage::__read(const ::Ice::InputStreamPtr&, bool)
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type BeobotEvents::LandmarkMatchResultMessage was not generated with stream support";
    throw ex;
}

class __F__BeobotEvents__LandmarkMatchResultMessage : public ::Ice::ObjectFactory
{
public:

    virtual ::Ice::ObjectPtr
    create(const ::std::string& type)
    {
        assert(type == ::BeobotEvents::LandmarkMatchResultMessage::ice_staticId());
        return new ::BeobotEvents::LandmarkMatchResultMessage;
    }

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__BeobotEvents__LandmarkMatchResultMessage_Ptr = new __F__BeobotEvents__LandmarkMatchResultMessage;

const ::Ice::ObjectFactoryPtr&
BeobotEvents::LandmarkMatchResultMessage::ice_factory()
{
    return __F__BeobotEvents__LandmarkMatchResultMessage_Ptr;
}

class __F__BeobotEvents__LandmarkMatchResultMessage__Init
{
public:

    __F__BeobotEvents__LandmarkMatchResultMessage__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::BeobotEvents::LandmarkMatchResultMessage::ice_staticId(), ::BeobotEvents::LandmarkMatchResultMessage::ice_factory());
    }

    ~__F__BeobotEvents__LandmarkMatchResultMessage__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::BeobotEvents::LandmarkMatchResultMessage::ice_staticId());
    }
};

static __F__BeobotEvents__LandmarkMatchResultMessage__Init __F__BeobotEvents__LandmarkMatchResultMessage__i;

#ifdef __APPLE__
extern "C" { void __F__BeobotEvents__LandmarkMatchResultMessage__initializer() {} }
#endif

void
BeobotEvents::__patch__LandmarkMatchResultMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::BeobotEvents::LandmarkMatchResultMessagePtr* p = static_cast< ::BeobotEvents::LandmarkMatchResultMessagePtr*>(__addr);
    assert(p);
    *p = ::BeobotEvents::LandmarkMatchResultMessagePtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::BeobotEvents::LandmarkMatchResultMessage::ice_staticId(), v->ice_id());
    }
}

bool
BeobotEvents::operator==(const ::BeobotEvents::LandmarkMatchResultMessage& l, const ::BeobotEvents::LandmarkMatchResultMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

bool
BeobotEvents::operator<(const ::BeobotEvents::LandmarkMatchResultMessage& l, const ::BeobotEvents::LandmarkMatchResultMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}

BeobotEvents::LandmarkDBSearchResultMessage::LandmarkDBSearchResultMessage(::Ice::Int __ice_RequestID, const ::BeobotEvents::LandmarkSearchJobSeq& __ice_matches) :
    RequestID(__ice_RequestID),
    matches(__ice_matches)
{
}

::Ice::ObjectPtr
BeobotEvents::LandmarkDBSearchResultMessage::ice_clone() const
{
    ::BeobotEvents::LandmarkDBSearchResultMessagePtr __p = new ::BeobotEvents::LandmarkDBSearchResultMessage(*this);
    return __p;
}

static const ::std::string __BeobotEvents__LandmarkDBSearchResultMessage_ids[3] =
{
    "::BeobotEvents::LandmarkDBSearchResultMessage",
    "::Ice::Object",
    "::RobotSimEvents::EventMessage"
};

bool
BeobotEvents::LandmarkDBSearchResultMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__BeobotEvents__LandmarkDBSearchResultMessage_ids, __BeobotEvents__LandmarkDBSearchResultMessage_ids + 3, _s);
}

::std::vector< ::std::string>
BeobotEvents::LandmarkDBSearchResultMessage::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__BeobotEvents__LandmarkDBSearchResultMessage_ids[0], &__BeobotEvents__LandmarkDBSearchResultMessage_ids[3]);
}

const ::std::string&
BeobotEvents::LandmarkDBSearchResultMessage::ice_id(const ::Ice::Current&) const
{
    return __BeobotEvents__LandmarkDBSearchResultMessage_ids[0];
}

const ::std::string&
BeobotEvents::LandmarkDBSearchResultMessage::ice_staticId()
{
    return __BeobotEvents__LandmarkDBSearchResultMessage_ids[0];
}

void
BeobotEvents::LandmarkDBSearchResultMessage::__write(::IceInternal::BasicStream* __os) const
{
    __os->writeTypeId(ice_staticId());
    __os->startWriteSlice();
    __os->write(RequestID);
    if(matches.size() == 0)
    {
        __os->writeSize(0);
    }
    else
    {
        ::BeobotEvents::__writeLandmarkSearchJobSeq(__os, &matches[0], &matches[0] + matches.size());
    }
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__write(__os);
#else
    ::RobotSimEvents::EventMessage::__write(__os);
#endif
}

void
BeobotEvents::LandmarkDBSearchResultMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    __is->read(RequestID);
    ::BeobotEvents::__readLandmarkSearchJobSeq(__is, matches);
    __is->endReadSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__read(__is, true);
#else
    ::RobotSimEvents::EventMessage::__read(__is, true);
#endif
}

void
BeobotEvents::LandmarkDBSearchResultMessage::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type BeobotEvents::LandmarkDBSearchResultMessage was not generated with stream support";
    throw ex;
}

void
BeobotEvents::LandmarkDBSearchResultMessage::__read(const ::Ice::InputStreamPtr&, bool)
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type BeobotEvents::LandmarkDBSearchResultMessage was not generated with stream support";
    throw ex;
}

class __F__BeobotEvents__LandmarkDBSearchResultMessage : public ::Ice::ObjectFactory
{
public:

    virtual ::Ice::ObjectPtr
    create(const ::std::string& type)
    {
        assert(type == ::BeobotEvents::LandmarkDBSearchResultMessage::ice_staticId());
        return new ::BeobotEvents::LandmarkDBSearchResultMessage;
    }

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__BeobotEvents__LandmarkDBSearchResultMessage_Ptr = new __F__BeobotEvents__LandmarkDBSearchResultMessage;

const ::Ice::ObjectFactoryPtr&
BeobotEvents::LandmarkDBSearchResultMessage::ice_factory()
{
    return __F__BeobotEvents__LandmarkDBSearchResultMessage_Ptr;
}

class __F__BeobotEvents__LandmarkDBSearchResultMessage__Init
{
public:

    __F__BeobotEvents__LandmarkDBSearchResultMessage__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::BeobotEvents::LandmarkDBSearchResultMessage::ice_staticId(), ::BeobotEvents::LandmarkDBSearchResultMessage::ice_factory());
    }

    ~__F__BeobotEvents__LandmarkDBSearchResultMessage__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::BeobotEvents::LandmarkDBSearchResultMessage::ice_staticId());
    }
};

static __F__BeobotEvents__LandmarkDBSearchResultMessage__Init __F__BeobotEvents__LandmarkDBSearchResultMessage__i;

#ifdef __APPLE__
extern "C" { void __F__BeobotEvents__LandmarkDBSearchResultMessage__initializer() {} }
#endif

void
BeobotEvents::__patch__LandmarkDBSearchResultMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::BeobotEvents::LandmarkDBSearchResultMessagePtr* p = static_cast< ::BeobotEvents::LandmarkDBSearchResultMessagePtr*>(__addr);
    assert(p);
    *p = ::BeobotEvents::LandmarkDBSearchResultMessagePtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::BeobotEvents::LandmarkDBSearchResultMessage::ice_staticId(), v->ice_id());
    }
}

bool
BeobotEvents::operator==(const ::BeobotEvents::LandmarkDBSearchResultMessage& l, const ::BeobotEvents::LandmarkDBSearchResultMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

bool
BeobotEvents::operator<(const ::BeobotEvents::LandmarkDBSearchResultMessage& l, const ::BeobotEvents::LandmarkDBSearchResultMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}

BeobotEvents::CurrentLocationMessage::CurrentLocationMessage(::Ice::Int __ice_RequestID, ::Ice::Int __ice_segNum, ::Ice::Float __ice_lenTrav) :
    RequestID(__ice_RequestID),
    segNum(__ice_segNum),
    lenTrav(__ice_lenTrav)
{
}

::Ice::ObjectPtr
BeobotEvents::CurrentLocationMessage::ice_clone() const
{
    ::BeobotEvents::CurrentLocationMessagePtr __p = new ::BeobotEvents::CurrentLocationMessage(*this);
    return __p;
}

static const ::std::string __BeobotEvents__CurrentLocationMessage_ids[3] =
{
    "::BeobotEvents::CurrentLocationMessage",
    "::Ice::Object",
    "::RobotSimEvents::EventMessage"
};

bool
BeobotEvents::CurrentLocationMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__BeobotEvents__CurrentLocationMessage_ids, __BeobotEvents__CurrentLocationMessage_ids + 3, _s);
}

::std::vector< ::std::string>
BeobotEvents::CurrentLocationMessage::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__BeobotEvents__CurrentLocationMessage_ids[0], &__BeobotEvents__CurrentLocationMessage_ids[3]);
}

const ::std::string&
BeobotEvents::CurrentLocationMessage::ice_id(const ::Ice::Current&) const
{
    return __BeobotEvents__CurrentLocationMessage_ids[0];
}

const ::std::string&
BeobotEvents::CurrentLocationMessage::ice_staticId()
{
    return __BeobotEvents__CurrentLocationMessage_ids[0];
}

void
BeobotEvents::CurrentLocationMessage::__write(::IceInternal::BasicStream* __os) const
{
    __os->writeTypeId(ice_staticId());
    __os->startWriteSlice();
    __os->write(RequestID);
    __os->write(segNum);
    __os->write(lenTrav);
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__write(__os);
#else
    ::RobotSimEvents::EventMessage::__write(__os);
#endif
}

void
BeobotEvents::CurrentLocationMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    __is->read(RequestID);
    __is->read(segNum);
    __is->read(lenTrav);
    __is->endReadSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__read(__is, true);
#else
    ::RobotSimEvents::EventMessage::__read(__is, true);
#endif
}

void
BeobotEvents::CurrentLocationMessage::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type BeobotEvents::CurrentLocationMessage was not generated with stream support";
    throw ex;
}

void
BeobotEvents::CurrentLocationMessage::__read(const ::Ice::InputStreamPtr&, bool)
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type BeobotEvents::CurrentLocationMessage was not generated with stream support";
    throw ex;
}

class __F__BeobotEvents__CurrentLocationMessage : public ::Ice::ObjectFactory
{
public:

    virtual ::Ice::ObjectPtr
    create(const ::std::string& type)
    {
        assert(type == ::BeobotEvents::CurrentLocationMessage::ice_staticId());
        return new ::BeobotEvents::CurrentLocationMessage;
    }

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__BeobotEvents__CurrentLocationMessage_Ptr = new __F__BeobotEvents__CurrentLocationMessage;

const ::Ice::ObjectFactoryPtr&
BeobotEvents::CurrentLocationMessage::ice_factory()
{
    return __F__BeobotEvents__CurrentLocationMessage_Ptr;
}

class __F__BeobotEvents__CurrentLocationMessage__Init
{
public:

    __F__BeobotEvents__CurrentLocationMessage__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::BeobotEvents::CurrentLocationMessage::ice_staticId(), ::BeobotEvents::CurrentLocationMessage::ice_factory());
    }

    ~__F__BeobotEvents__CurrentLocationMessage__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::BeobotEvents::CurrentLocationMessage::ice_staticId());
    }
};

static __F__BeobotEvents__CurrentLocationMessage__Init __F__BeobotEvents__CurrentLocationMessage__i;

#ifdef __APPLE__
extern "C" { void __F__BeobotEvents__CurrentLocationMessage__initializer() {} }
#endif

void
BeobotEvents::__patch__CurrentLocationMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::BeobotEvents::CurrentLocationMessagePtr* p = static_cast< ::BeobotEvents::CurrentLocationMessagePtr*>(__addr);
    assert(p);
    *p = ::BeobotEvents::CurrentLocationMessagePtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::BeobotEvents::CurrentLocationMessage::ice_staticId(), v->ice_id());
    }
}

bool
BeobotEvents::operator==(const ::BeobotEvents::CurrentLocationMessage& l, const ::BeobotEvents::CurrentLocationMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

bool
BeobotEvents::operator<(const ::BeobotEvents::CurrentLocationMessage& l, const ::BeobotEvents::CurrentLocationMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}

BeobotEvents::CancelSearchMessage::CancelSearchMessage(::Ice::Int __ice_RequestID, bool __ice_abort) :
    RequestID(__ice_RequestID),
    abort(__ice_abort)
{
}

::Ice::ObjectPtr
BeobotEvents::CancelSearchMessage::ice_clone() const
{
    ::BeobotEvents::CancelSearchMessagePtr __p = new ::BeobotEvents::CancelSearchMessage(*this);
    return __p;
}

static const ::std::string __BeobotEvents__CancelSearchMessage_ids[3] =
{
    "::BeobotEvents::CancelSearchMessage",
    "::Ice::Object",
    "::RobotSimEvents::EventMessage"
};

bool
BeobotEvents::CancelSearchMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__BeobotEvents__CancelSearchMessage_ids, __BeobotEvents__CancelSearchMessage_ids + 3, _s);
}

::std::vector< ::std::string>
BeobotEvents::CancelSearchMessage::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__BeobotEvents__CancelSearchMessage_ids[0], &__BeobotEvents__CancelSearchMessage_ids[3]);
}

const ::std::string&
BeobotEvents::CancelSearchMessage::ice_id(const ::Ice::Current&) const
{
    return __BeobotEvents__CancelSearchMessage_ids[0];
}

const ::std::string&
BeobotEvents::CancelSearchMessage::ice_staticId()
{
    return __BeobotEvents__CancelSearchMessage_ids[0];
}

void
BeobotEvents::CancelSearchMessage::__write(::IceInternal::BasicStream* __os) const
{
    __os->writeTypeId(ice_staticId());
    __os->startWriteSlice();
    __os->write(RequestID);
    __os->write(abort);
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__write(__os);
#else
    ::RobotSimEvents::EventMessage::__write(__os);
#endif
}

void
BeobotEvents::CancelSearchMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    __is->read(RequestID);
    __is->read(abort);
    __is->endReadSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__read(__is, true);
#else
    ::RobotSimEvents::EventMessage::__read(__is, true);
#endif
}

void
BeobotEvents::CancelSearchMessage::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type BeobotEvents::CancelSearchMessage was not generated with stream support";
    throw ex;
}

void
BeobotEvents::CancelSearchMessage::__read(const ::Ice::InputStreamPtr&, bool)
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type BeobotEvents::CancelSearchMessage was not generated with stream support";
    throw ex;
}

class __F__BeobotEvents__CancelSearchMessage : public ::Ice::ObjectFactory
{
public:

    virtual ::Ice::ObjectPtr
    create(const ::std::string& type)
    {
        assert(type == ::BeobotEvents::CancelSearchMessage::ice_staticId());
        return new ::BeobotEvents::CancelSearchMessage;
    }

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__BeobotEvents__CancelSearchMessage_Ptr = new __F__BeobotEvents__CancelSearchMessage;

const ::Ice::ObjectFactoryPtr&
BeobotEvents::CancelSearchMessage::ice_factory()
{
    return __F__BeobotEvents__CancelSearchMessage_Ptr;
}

class __F__BeobotEvents__CancelSearchMessage__Init
{
public:

    __F__BeobotEvents__CancelSearchMessage__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::BeobotEvents::CancelSearchMessage::ice_staticId(), ::BeobotEvents::CancelSearchMessage::ice_factory());
    }

    ~__F__BeobotEvents__CancelSearchMessage__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::BeobotEvents::CancelSearchMessage::ice_staticId());
    }
};

static __F__BeobotEvents__CancelSearchMessage__Init __F__BeobotEvents__CancelSearchMessage__i;

#ifdef __APPLE__
extern "C" { void __F__BeobotEvents__CancelSearchMessage__initializer() {} }
#endif

void
BeobotEvents::__patch__CancelSearchMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::BeobotEvents::CancelSearchMessagePtr* p = static_cast< ::BeobotEvents::CancelSearchMessagePtr*>(__addr);
    assert(p);
    *p = ::BeobotEvents::CancelSearchMessagePtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::BeobotEvents::CancelSearchMessage::ice_staticId(), v->ice_id());
    }
}

bool
BeobotEvents::operator==(const ::BeobotEvents::CancelSearchMessage& l, const ::BeobotEvents::CancelSearchMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

bool
BeobotEvents::operator<(const ::BeobotEvents::CancelSearchMessage& l, const ::BeobotEvents::CancelSearchMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}

BeobotEvents::SearchDoneMessage::SearchDoneMessage(::Ice::Int __ice_RequestID) :
    RequestID(__ice_RequestID)
{
}

::Ice::ObjectPtr
BeobotEvents::SearchDoneMessage::ice_clone() const
{
    ::BeobotEvents::SearchDoneMessagePtr __p = new ::BeobotEvents::SearchDoneMessage(*this);
    return __p;
}

static const ::std::string __BeobotEvents__SearchDoneMessage_ids[3] =
{
    "::BeobotEvents::SearchDoneMessage",
    "::Ice::Object",
    "::RobotSimEvents::EventMessage"
};

bool
BeobotEvents::SearchDoneMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__BeobotEvents__SearchDoneMessage_ids, __BeobotEvents__SearchDoneMessage_ids + 3, _s);
}

::std::vector< ::std::string>
BeobotEvents::SearchDoneMessage::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__BeobotEvents__SearchDoneMessage_ids[0], &__BeobotEvents__SearchDoneMessage_ids[3]);
}

const ::std::string&
BeobotEvents::SearchDoneMessage::ice_id(const ::Ice::Current&) const
{
    return __BeobotEvents__SearchDoneMessage_ids[0];
}

const ::std::string&
BeobotEvents::SearchDoneMessage::ice_staticId()
{
    return __BeobotEvents__SearchDoneMessage_ids[0];
}

void
BeobotEvents::SearchDoneMessage::__write(::IceInternal::BasicStream* __os) const
{
    __os->writeTypeId(ice_staticId());
    __os->startWriteSlice();
    __os->write(RequestID);
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__write(__os);
#else
    ::RobotSimEvents::EventMessage::__write(__os);
#endif
}

void
BeobotEvents::SearchDoneMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    __is->read(RequestID);
    __is->endReadSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__read(__is, true);
#else
    ::RobotSimEvents::EventMessage::__read(__is, true);
#endif
}

void
BeobotEvents::SearchDoneMessage::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type BeobotEvents::SearchDoneMessage was not generated with stream support";
    throw ex;
}

void
BeobotEvents::SearchDoneMessage::__read(const ::Ice::InputStreamPtr&, bool)
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type BeobotEvents::SearchDoneMessage was not generated with stream support";
    throw ex;
}

class __F__BeobotEvents__SearchDoneMessage : public ::Ice::ObjectFactory
{
public:

    virtual ::Ice::ObjectPtr
    create(const ::std::string& type)
    {
        assert(type == ::BeobotEvents::SearchDoneMessage::ice_staticId());
        return new ::BeobotEvents::SearchDoneMessage;
    }

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__BeobotEvents__SearchDoneMessage_Ptr = new __F__BeobotEvents__SearchDoneMessage;

const ::Ice::ObjectFactoryPtr&
BeobotEvents::SearchDoneMessage::ice_factory()
{
    return __F__BeobotEvents__SearchDoneMessage_Ptr;
}

class __F__BeobotEvents__SearchDoneMessage__Init
{
public:

    __F__BeobotEvents__SearchDoneMessage__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::BeobotEvents::SearchDoneMessage::ice_staticId(), ::BeobotEvents::SearchDoneMessage::ice_factory());
    }

    ~__F__BeobotEvents__SearchDoneMessage__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::BeobotEvents::SearchDoneMessage::ice_staticId());
    }
};

static __F__BeobotEvents__SearchDoneMessage__Init __F__BeobotEvents__SearchDoneMessage__i;

#ifdef __APPLE__
extern "C" { void __F__BeobotEvents__SearchDoneMessage__initializer() {} }
#endif

void
BeobotEvents::__patch__SearchDoneMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::BeobotEvents::SearchDoneMessagePtr* p = static_cast< ::BeobotEvents::SearchDoneMessagePtr*>(__addr);
    assert(p);
    *p = ::BeobotEvents::SearchDoneMessagePtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::BeobotEvents::SearchDoneMessage::ice_staticId(), v->ice_id());
    }
}

bool
BeobotEvents::operator==(const ::BeobotEvents::SearchDoneMessage& l, const ::BeobotEvents::SearchDoneMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

bool
BeobotEvents::operator<(const ::BeobotEvents::SearchDoneMessage& l, const ::BeobotEvents::SearchDoneMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}

BeobotEvents::NextFrameMessage::NextFrameMessage(::Ice::Int __ice_RequestID) :
    RequestID(__ice_RequestID)
{
}

::Ice::ObjectPtr
BeobotEvents::NextFrameMessage::ice_clone() const
{
    ::BeobotEvents::NextFrameMessagePtr __p = new ::BeobotEvents::NextFrameMessage(*this);
    return __p;
}

static const ::std::string __BeobotEvents__NextFrameMessage_ids[3] =
{
    "::BeobotEvents::NextFrameMessage",
    "::Ice::Object",
    "::RobotSimEvents::EventMessage"
};

bool
BeobotEvents::NextFrameMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__BeobotEvents__NextFrameMessage_ids, __BeobotEvents__NextFrameMessage_ids + 3, _s);
}

::std::vector< ::std::string>
BeobotEvents::NextFrameMessage::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__BeobotEvents__NextFrameMessage_ids[0], &__BeobotEvents__NextFrameMessage_ids[3]);
}

const ::std::string&
BeobotEvents::NextFrameMessage::ice_id(const ::Ice::Current&) const
{
    return __BeobotEvents__NextFrameMessage_ids[0];
}

const ::std::string&
BeobotEvents::NextFrameMessage::ice_staticId()
{
    return __BeobotEvents__NextFrameMessage_ids[0];
}

void
BeobotEvents::NextFrameMessage::__write(::IceInternal::BasicStream* __os) const
{
    __os->writeTypeId(ice_staticId());
    __os->startWriteSlice();
    __os->write(RequestID);
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__write(__os);
#else
    ::RobotSimEvents::EventMessage::__write(__os);
#endif
}

void
BeobotEvents::NextFrameMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    __is->read(RequestID);
    __is->endReadSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__read(__is, true);
#else
    ::RobotSimEvents::EventMessage::__read(__is, true);
#endif
}

void
BeobotEvents::NextFrameMessage::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type BeobotEvents::NextFrameMessage was not generated with stream support";
    throw ex;
}

void
BeobotEvents::NextFrameMessage::__read(const ::Ice::InputStreamPtr&, bool)
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type BeobotEvents::NextFrameMessage was not generated with stream support";
    throw ex;
}

class __F__BeobotEvents__NextFrameMessage : public ::Ice::ObjectFactory
{
public:

    virtual ::Ice::ObjectPtr
    create(const ::std::string& type)
    {
        assert(type == ::BeobotEvents::NextFrameMessage::ice_staticId());
        return new ::BeobotEvents::NextFrameMessage;
    }

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__BeobotEvents__NextFrameMessage_Ptr = new __F__BeobotEvents__NextFrameMessage;

const ::Ice::ObjectFactoryPtr&
BeobotEvents::NextFrameMessage::ice_factory()
{
    return __F__BeobotEvents__NextFrameMessage_Ptr;
}

class __F__BeobotEvents__NextFrameMessage__Init
{
public:

    __F__BeobotEvents__NextFrameMessage__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::BeobotEvents::NextFrameMessage::ice_staticId(), ::BeobotEvents::NextFrameMessage::ice_factory());
    }

    ~__F__BeobotEvents__NextFrameMessage__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::BeobotEvents::NextFrameMessage::ice_staticId());
    }
};

static __F__BeobotEvents__NextFrameMessage__Init __F__BeobotEvents__NextFrameMessage__i;

#ifdef __APPLE__
extern "C" { void __F__BeobotEvents__NextFrameMessage__initializer() {} }
#endif

void
BeobotEvents::__patch__NextFrameMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::BeobotEvents::NextFrameMessagePtr* p = static_cast< ::BeobotEvents::NextFrameMessagePtr*>(__addr);
    assert(p);
    *p = ::BeobotEvents::NextFrameMessagePtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::BeobotEvents::NextFrameMessage::ice_staticId(), v->ice_id());
    }
}

bool
BeobotEvents::operator==(const ::BeobotEvents::NextFrameMessage& l, const ::BeobotEvents::NextFrameMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

bool
BeobotEvents::operator<(const ::BeobotEvents::NextFrameMessage& l, const ::BeobotEvents::NextFrameMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}

BeobotEvents::AbortMessage::AbortMessage(::Ice::Int __ice_RequestID) :
    RequestID(__ice_RequestID)
{
}

::Ice::ObjectPtr
BeobotEvents::AbortMessage::ice_clone() const
{
    ::BeobotEvents::AbortMessagePtr __p = new ::BeobotEvents::AbortMessage(*this);
    return __p;
}

static const ::std::string __BeobotEvents__AbortMessage_ids[3] =
{
    "::BeobotEvents::AbortMessage",
    "::Ice::Object",
    "::RobotSimEvents::EventMessage"
};

bool
BeobotEvents::AbortMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__BeobotEvents__AbortMessage_ids, __BeobotEvents__AbortMessage_ids + 3, _s);
}

::std::vector< ::std::string>
BeobotEvents::AbortMessage::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__BeobotEvents__AbortMessage_ids[0], &__BeobotEvents__AbortMessage_ids[3]);
}

const ::std::string&
BeobotEvents::AbortMessage::ice_id(const ::Ice::Current&) const
{
    return __BeobotEvents__AbortMessage_ids[0];
}

const ::std::string&
BeobotEvents::AbortMessage::ice_staticId()
{
    return __BeobotEvents__AbortMessage_ids[0];
}

void
BeobotEvents::AbortMessage::__write(::IceInternal::BasicStream* __os) const
{
    __os->writeTypeId(ice_staticId());
    __os->startWriteSlice();
    __os->write(RequestID);
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__write(__os);
#else
    ::RobotSimEvents::EventMessage::__write(__os);
#endif
}

void
BeobotEvents::AbortMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    __is->read(RequestID);
    __is->endReadSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__read(__is, true);
#else
    ::RobotSimEvents::EventMessage::__read(__is, true);
#endif
}

void
BeobotEvents::AbortMessage::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type BeobotEvents::AbortMessage was not generated with stream support";
    throw ex;
}

void
BeobotEvents::AbortMessage::__read(const ::Ice::InputStreamPtr&, bool)
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type BeobotEvents::AbortMessage was not generated with stream support";
    throw ex;
}

class __F__BeobotEvents__AbortMessage : public ::Ice::ObjectFactory
{
public:

    virtual ::Ice::ObjectPtr
    create(const ::std::string& type)
    {
        assert(type == ::BeobotEvents::AbortMessage::ice_staticId());
        return new ::BeobotEvents::AbortMessage;
    }

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__BeobotEvents__AbortMessage_Ptr = new __F__BeobotEvents__AbortMessage;

const ::Ice::ObjectFactoryPtr&
BeobotEvents::AbortMessage::ice_factory()
{
    return __F__BeobotEvents__AbortMessage_Ptr;
}

class __F__BeobotEvents__AbortMessage__Init
{
public:

    __F__BeobotEvents__AbortMessage__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::BeobotEvents::AbortMessage::ice_staticId(), ::BeobotEvents::AbortMessage::ice_factory());
    }

    ~__F__BeobotEvents__AbortMessage__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::BeobotEvents::AbortMessage::ice_staticId());
    }
};

static __F__BeobotEvents__AbortMessage__Init __F__BeobotEvents__AbortMessage__i;

#ifdef __APPLE__
extern "C" { void __F__BeobotEvents__AbortMessage__initializer() {} }
#endif

void
BeobotEvents::__patch__AbortMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::BeobotEvents::AbortMessagePtr* p = static_cast< ::BeobotEvents::AbortMessagePtr*>(__addr);
    assert(p);
    *p = ::BeobotEvents::AbortMessagePtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::BeobotEvents::AbortMessage::ice_staticId(), v->ice_id());
    }
}

bool
BeobotEvents::operator==(const ::BeobotEvents::AbortMessage& l, const ::BeobotEvents::AbortMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

bool
BeobotEvents::operator<(const ::BeobotEvents::AbortMessage& l, const ::BeobotEvents::AbortMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}

BeobotEvents::FacesMessage::FacesMessage(const ::BeobotEvents::RectangleIceSeq& __ice_faces, ::Ice::Int __ice_RequestID) :
    faces(__ice_faces),
    RequestID(__ice_RequestID)
{
}

::Ice::ObjectPtr
BeobotEvents::FacesMessage::ice_clone() const
{
    ::BeobotEvents::FacesMessagePtr __p = new ::BeobotEvents::FacesMessage(*this);
    return __p;
}

static const ::std::string __BeobotEvents__FacesMessage_ids[3] =
{
    "::BeobotEvents::FacesMessage",
    "::Ice::Object",
    "::RobotSimEvents::EventMessage"
};

bool
BeobotEvents::FacesMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__BeobotEvents__FacesMessage_ids, __BeobotEvents__FacesMessage_ids + 3, _s);
}

::std::vector< ::std::string>
BeobotEvents::FacesMessage::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__BeobotEvents__FacesMessage_ids[0], &__BeobotEvents__FacesMessage_ids[3]);
}

const ::std::string&
BeobotEvents::FacesMessage::ice_id(const ::Ice::Current&) const
{
    return __BeobotEvents__FacesMessage_ids[0];
}

const ::std::string&
BeobotEvents::FacesMessage::ice_staticId()
{
    return __BeobotEvents__FacesMessage_ids[0];
}

void
BeobotEvents::FacesMessage::__write(::IceInternal::BasicStream* __os) const
{
    __os->writeTypeId(ice_staticId());
    __os->startWriteSlice();
    if(faces.size() == 0)
    {
        __os->writeSize(0);
    }
    else
    {
        ::BeobotEvents::__writeRectangleIceSeq(__os, &faces[0], &faces[0] + faces.size());
    }
    __os->write(RequestID);
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__write(__os);
#else
    ::RobotSimEvents::EventMessage::__write(__os);
#endif
}

void
BeobotEvents::FacesMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    ::BeobotEvents::__readRectangleIceSeq(__is, faces);
    __is->read(RequestID);
    __is->endReadSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__read(__is, true);
#else
    ::RobotSimEvents::EventMessage::__read(__is, true);
#endif
}

void
BeobotEvents::FacesMessage::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type BeobotEvents::FacesMessage was not generated with stream support";
    throw ex;
}

void
BeobotEvents::FacesMessage::__read(const ::Ice::InputStreamPtr&, bool)
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type BeobotEvents::FacesMessage was not generated with stream support";
    throw ex;
}

class __F__BeobotEvents__FacesMessage : public ::Ice::ObjectFactory
{
public:

    virtual ::Ice::ObjectPtr
    create(const ::std::string& type)
    {
        assert(type == ::BeobotEvents::FacesMessage::ice_staticId());
        return new ::BeobotEvents::FacesMessage;
    }

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__BeobotEvents__FacesMessage_Ptr = new __F__BeobotEvents__FacesMessage;

const ::Ice::ObjectFactoryPtr&
BeobotEvents::FacesMessage::ice_factory()
{
    return __F__BeobotEvents__FacesMessage_Ptr;
}

class __F__BeobotEvents__FacesMessage__Init
{
public:

    __F__BeobotEvents__FacesMessage__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::BeobotEvents::FacesMessage::ice_staticId(), ::BeobotEvents::FacesMessage::ice_factory());
    }

    ~__F__BeobotEvents__FacesMessage__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::BeobotEvents::FacesMessage::ice_staticId());
    }
};

static __F__BeobotEvents__FacesMessage__Init __F__BeobotEvents__FacesMessage__i;

#ifdef __APPLE__
extern "C" { void __F__BeobotEvents__FacesMessage__initializer() {} }
#endif

void
BeobotEvents::__patch__FacesMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::BeobotEvents::FacesMessagePtr* p = static_cast< ::BeobotEvents::FacesMessagePtr*>(__addr);
    assert(p);
    *p = ::BeobotEvents::FacesMessagePtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::BeobotEvents::FacesMessage::ice_staticId(), v->ice_id());
    }
}

bool
BeobotEvents::operator==(const ::BeobotEvents::FacesMessage& l, const ::BeobotEvents::FacesMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

bool
BeobotEvents::operator<(const ::BeobotEvents::FacesMessage& l, const ::BeobotEvents::FacesMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}

BeobotEvents::GUISpeechMessage::GUISpeechMessage(::Ice::Int __ice_RequestID, const ::std::string& __ice_itsMessage, ::Ice::Int __ice_itsCommand) :
    RequestID(__ice_RequestID),
    itsMessage(__ice_itsMessage),
    itsCommand(__ice_itsCommand)
{
}

::Ice::ObjectPtr
BeobotEvents::GUISpeechMessage::ice_clone() const
{
    ::BeobotEvents::GUISpeechMessagePtr __p = new ::BeobotEvents::GUISpeechMessage(*this);
    return __p;
}

static const ::std::string __BeobotEvents__GUISpeechMessage_ids[3] =
{
    "::BeobotEvents::GUISpeechMessage",
    "::Ice::Object",
    "::RobotSimEvents::EventMessage"
};

bool
BeobotEvents::GUISpeechMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__BeobotEvents__GUISpeechMessage_ids, __BeobotEvents__GUISpeechMessage_ids + 3, _s);
}

::std::vector< ::std::string>
BeobotEvents::GUISpeechMessage::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__BeobotEvents__GUISpeechMessage_ids[0], &__BeobotEvents__GUISpeechMessage_ids[3]);
}

const ::std::string&
BeobotEvents::GUISpeechMessage::ice_id(const ::Ice::Current&) const
{
    return __BeobotEvents__GUISpeechMessage_ids[0];
}

const ::std::string&
BeobotEvents::GUISpeechMessage::ice_staticId()
{
    return __BeobotEvents__GUISpeechMessage_ids[0];
}

void
BeobotEvents::GUISpeechMessage::__write(::IceInternal::BasicStream* __os) const
{
    __os->writeTypeId(ice_staticId());
    __os->startWriteSlice();
    __os->write(RequestID);
    __os->write(itsMessage);
    __os->write(itsCommand);
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__write(__os);
#else
    ::RobotSimEvents::EventMessage::__write(__os);
#endif
}

void
BeobotEvents::GUISpeechMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    __is->read(RequestID);
    __is->read(itsMessage);
    __is->read(itsCommand);
    __is->endReadSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__read(__is, true);
#else
    ::RobotSimEvents::EventMessage::__read(__is, true);
#endif
}

void
BeobotEvents::GUISpeechMessage::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type BeobotEvents::GUISpeechMessage was not generated with stream support";
    throw ex;
}

void
BeobotEvents::GUISpeechMessage::__read(const ::Ice::InputStreamPtr&, bool)
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type BeobotEvents::GUISpeechMessage was not generated with stream support";
    throw ex;
}

class __F__BeobotEvents__GUISpeechMessage : public ::Ice::ObjectFactory
{
public:

    virtual ::Ice::ObjectPtr
    create(const ::std::string& type)
    {
        assert(type == ::BeobotEvents::GUISpeechMessage::ice_staticId());
        return new ::BeobotEvents::GUISpeechMessage;
    }

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__BeobotEvents__GUISpeechMessage_Ptr = new __F__BeobotEvents__GUISpeechMessage;

const ::Ice::ObjectFactoryPtr&
BeobotEvents::GUISpeechMessage::ice_factory()
{
    return __F__BeobotEvents__GUISpeechMessage_Ptr;
}

class __F__BeobotEvents__GUISpeechMessage__Init
{
public:

    __F__BeobotEvents__GUISpeechMessage__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::BeobotEvents::GUISpeechMessage::ice_staticId(), ::BeobotEvents::GUISpeechMessage::ice_factory());
    }

    ~__F__BeobotEvents__GUISpeechMessage__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::BeobotEvents::GUISpeechMessage::ice_staticId());
    }
};

static __F__BeobotEvents__GUISpeechMessage__Init __F__BeobotEvents__GUISpeechMessage__i;

#ifdef __APPLE__
extern "C" { void __F__BeobotEvents__GUISpeechMessage__initializer() {} }
#endif

void
BeobotEvents::__patch__GUISpeechMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::BeobotEvents::GUISpeechMessagePtr* p = static_cast< ::BeobotEvents::GUISpeechMessagePtr*>(__addr);
    assert(p);
    *p = ::BeobotEvents::GUISpeechMessagePtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::BeobotEvents::GUISpeechMessage::ice_staticId(), v->ice_id());
    }
}

bool
BeobotEvents::operator==(const ::BeobotEvents::GUISpeechMessage& l, const ::BeobotEvents::GUISpeechMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

bool
BeobotEvents::operator<(const ::BeobotEvents::GUISpeechMessage& l, const ::BeobotEvents::GUISpeechMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}