RobotSimEvents.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 `RobotSimEvents.ice'

#include <RobotSimEvents.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

static const ::std::string __RobotSimEvents__Events__updateMessage_name = "updateMessage";

::Ice::Object* IceInternal::upCast(::RobotSimEvents::EventMessage* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::RobotSimEvents::EventMessage* p) { return p; }

::Ice::Object* IceInternal::upCast(::RobotSimEvents::Events* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::RobotSimEvents::Events* p) { return p; }

::Ice::Object* IceInternal::upCast(::RobotSimEvents::ActionMessage* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::RobotSimEvents::ActionMessage* p) { return p; }

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

::Ice::Object* IceInternal::upCast(::RobotSimEvents::MotionMessage* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::RobotSimEvents::MotionMessage* p) { return p; }

::Ice::Object* IceInternal::upCast(::RobotSimEvents::RetinaMessage* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::RobotSimEvents::RetinaMessage* p) { return p; }

::Ice::Object* IceInternal::upCast(::RobotSimEvents::MovementControllerMessage* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::RobotSimEvents::MovementControllerMessage* p) { return p; }

::Ice::Object* IceInternal::upCast(::RobotSimEvents::JoyStickControlMessage* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::RobotSimEvents::JoyStickControlMessage* p) { return p; }

::Ice::Object* IceInternal::upCast(::RobotSimEvents::BeeStemConfigMessage* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::RobotSimEvents::BeeStemConfigMessage* p) { return p; }

::Ice::Object* IceInternal::upCast(::RobotSimEvents::IMUDataServerMessage* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::RobotSimEvents::IMUDataServerMessage* p) { return p; }

::Ice::Object* IceInternal::upCast(::RobotSimEvents::BeeStemMotorControllerMessage* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::RobotSimEvents::BeeStemMotorControllerMessage* p) { return p; }

::Ice::Object* IceInternal::upCast(::RobotSimEvents::LocalizationMessage* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::RobotSimEvents::LocalizationMessage* p) { return p; }

::Ice::Object* IceInternal::upCast(::RobotSimEvents::BeeStemMessage* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::RobotSimEvents::BeeStemMessage* p) { return p; }

::Ice::Object* IceInternal::upCast(::RobotSimEvents::ChatMessage* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::RobotSimEvents::ChatMessage* p) { return p; }

::Ice::Object* IceInternal::upCast(::RobotSimEvents::RemoteControlMessage* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::RobotSimEvents::RemoteControlMessage* p) { return p; }

::Ice::Object* IceInternal::upCast(::RobotSimEvents::StateMessage* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::RobotSimEvents::StateMessage* p) { return p; }

::Ice::Object* IceInternal::upCast(::RobotSimEvents::GoalStateMessage* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::RobotSimEvents::GoalStateMessage* p) { return p; }

::Ice::Object* IceInternal::upCast(::RobotSimEvents::GoalProgressMessage* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::RobotSimEvents::GoalProgressMessage* p) { return p; }

::Ice::Object* IceInternal::upCast(::RobotSimEvents::AttendedRegionMessage* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::RobotSimEvents::AttendedRegionMessage* p) { return p; }

::Ice::Object* IceInternal::upCast(::RobotSimEvents::ObjectMessage* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::RobotSimEvents::ObjectMessage* p) { return p; }

::Ice::Object* IceInternal::upCast(::RobotSimEvents::SeaBeePositionMessage* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::RobotSimEvents::SeaBeePositionMessage* p) { return p; }

::Ice::Object* IceInternal::upCast(::RobotSimEvents::SeaBeeStateConditionMessage* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::RobotSimEvents::SeaBeeStateConditionMessage* p) { return p; }

::Ice::Object* IceInternal::upCast(::RobotSimEvents::VisionRectangleMessage* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::RobotSimEvents::VisionRectangleMessage* p) { return p; }

::Ice::Object* IceInternal::upCast(::RobotSimEvents::StraightEdgeMessage* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::RobotSimEvents::StraightEdgeMessage* p) { return p; }

::Ice::Object* IceInternal::upCast(::RobotSimEvents::VisionObjectMessage* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::RobotSimEvents::VisionObjectMessage* p) { return p; }

::Ice::Object* IceInternal::upCast(::RobotSimEvents::LandmarksMessage* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::RobotSimEvents::LandmarksMessage* p) { return p; }

::Ice::Object* IceInternal::upCast(::RobotSimEvents::CameraConfigMessage* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::RobotSimEvents::CameraConfigMessage* p) { return p; }

::Ice::Object* IceInternal::upCast(::RobotSimEvents::SalientPointMessage* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::RobotSimEvents::SalientPointMessage* p) { return p; }

::Ice::Object* IceInternal::upCast(::RobotSimEvents::BuoyColorSegmentMessage* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::RobotSimEvents::BuoyColorSegmentMessage* p) { return p; }

::Ice::Object* IceInternal::upCast(::RobotSimEvents::PipeColorSegmentMessage* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::RobotSimEvents::PipeColorSegmentMessage* p) { return p; }

::Ice::Object* IceInternal::upCast(::RobotSimEvents::BuoyColorSegmentConfigMessage* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::RobotSimEvents::BuoyColorSegmentConfigMessage* p) { return p; }

::Ice::Object* IceInternal::upCast(::RobotSimEvents::PipeColorSegmentConfigMessage* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::RobotSimEvents::PipeColorSegmentConfigMessage* p) { return p; }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void
RobotSimEvents::__writeSensorVoteVector(::IceInternal::BasicStream* __os, const ::ImageIceMod::SensorVote* begin, const ::ImageIceMod::SensorVote* 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
RobotSimEvents::__readSensorVoteVector(::IceInternal::BasicStream* __is, ::RobotSimEvents::SensorVoteVector& v)
{
    ::Ice::Int sz;
    __is->readSize(sz);
    __is->checkFixedSeq(sz, 25);
    v.resize(sz);
    for(int i = 0; i < sz; ++i)
    {
        v[i].__read(__is);
    }
}

void
RobotSimEvents::__writeQuadrilateralIceVector(::IceInternal::BasicStream* __os, const ::ImageIceMod::QuadrilateralIce* begin, const ::ImageIceMod::QuadrilateralIce* 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
RobotSimEvents::__readQuadrilateralIceVector(::IceInternal::BasicStream* __is, ::RobotSimEvents::QuadrilateralIceVector& v)
{
    ::Ice::Int sz;
    __is->readSize(sz);
    __is->checkFixedSeq(sz, 48);
    v.resize(sz);
    for(int i = 0; i < sz; ++i)
    {
        v[i].__read(__is);
    }
}

void
RobotSimEvents::__write(::IceInternal::BasicStream* __os, ::RobotSimEvents::SeaBeeObjectType v)
{
    __os->write(static_cast< ::Ice::Byte>(v), 8);
}

void
RobotSimEvents::__read(::IceInternal::BasicStream* __is, ::RobotSimEvents::SeaBeeObjectType& v)
{
    ::Ice::Byte val;
    __is->read(val, 8);
    v = static_cast< ::RobotSimEvents::SeaBeeObjectType>(val);
}

bool
RobotSimEvents::LandmarkInfo::operator==(const LandmarkInfo& __rhs) const
{
    if(this == &__rhs)
    {
        return true;
    }
    if(id != __rhs.id)
    {
        return false;
    }
    if(name != __rhs.name)
    {
        return false;
    }
    if(fv != __rhs.fv)
    {
        return false;
    }
    if(range != __rhs.range)
    {
        return false;
    }
    if(bearing != __rhs.bearing)
    {
        return false;
    }
    if(prob != __rhs.prob)
    {
        return false;
    }
    return true;
}

bool
RobotSimEvents::LandmarkInfo::operator<(const LandmarkInfo& __rhs) const
{
    if(this == &__rhs)
    {
        return false;
    }
    if(id < __rhs.id)
    {
        return true;
    }
    else if(__rhs.id < id)
    {
        return false;
    }
    if(name < __rhs.name)
    {
        return true;
    }
    else if(__rhs.name < name)
    {
        return false;
    }
    if(fv < __rhs.fv)
    {
        return true;
    }
    else if(__rhs.fv < fv)
    {
        return false;
    }
    if(range < __rhs.range)
    {
        return true;
    }
    else if(__rhs.range < range)
    {
        return false;
    }
    if(bearing < __rhs.bearing)
    {
        return true;
    }
    else if(__rhs.bearing < bearing)
    {
        return false;
    }
    if(prob < __rhs.prob)
    {
        return true;
    }
    else if(__rhs.prob < prob)
    {
        return false;
    }
    return false;
}

void
RobotSimEvents::LandmarkInfo::__write(::IceInternal::BasicStream* __os) const
{
    __os->write(id);
    __os->write(name);
    if(fv.size() == 0)
    {
        __os->writeSize(0);
    }
    else
    {
        __os->write(&fv[0], &fv[0] + fv.size());
    }
    __os->write(range);
    __os->write(bearing);
    __os->write(prob);
}

void
RobotSimEvents::LandmarkInfo::__read(::IceInternal::BasicStream* __is)
{
    __is->read(id);
    __is->read(name);
    ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*> ___fv;
    __is->read(___fv);
    ::std::vector< ::Ice::Byte>(___fv.first, ___fv.second).swap(fv);
    __is->read(range);
    __is->read(bearing);
    __is->read(prob);
}

void
RobotSimEvents::__writeLandmarksInfo(::IceInternal::BasicStream* __os, const ::RobotSimEvents::LandmarkInfo* begin, const ::RobotSimEvents::LandmarkInfo* 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
RobotSimEvents::__readLandmarksInfo(::IceInternal::BasicStream* __is, ::RobotSimEvents::LandmarksInfo& v)
{
    ::Ice::Int sz;
    __is->readSize(sz);
    __is->startSeq(sz, 18);
    v.resize(sz);
    for(int i = 0; i < sz; ++i)
    {
        v[i].__read(__is);
        __is->checkSeq();
        __is->endElement();
    }
    __is->endSeq(sz);
}

const ::std::string&
IceProxy::RobotSimEvents::EventMessage::ice_staticId()
{
    return ::RobotSimEvents::EventMessage::ice_staticId();
}

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

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

::IceProxy::Ice::Object*
IceProxy::RobotSimEvents::EventMessage::__newInstance() const
{
    return new EventMessage;
}

void
IceProxy::RobotSimEvents::Events::updateMessage(const ::RobotSimEvents::EventMessagePtr& eMsg, const ::Ice::Context* __ctx)
{
    int __cnt = 0;
    while(true)
    {
        ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
        try
        {
#if defined(__BCPLUSPLUS__) && (__BCPLUSPLUS__ >= 0x0600) // C++Builder 2009 compiler bug
            IceUtil::DummyBCC dummy;
#endif
            __delBase = __getDelegate(false);
            ::IceDelegate::RobotSimEvents::Events* __del = dynamic_cast< ::IceDelegate::RobotSimEvents::Events*>(__delBase.get());
            __del->updateMessage(eMsg, __ctx);
            return;
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex, 0);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, 0, __cnt);
        }
    }
}

const ::std::string&
IceProxy::RobotSimEvents::Events::ice_staticId()
{
    return ::RobotSimEvents::Events::ice_staticId();
}

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

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

::IceProxy::Ice::Object*
IceProxy::RobotSimEvents::Events::__newInstance() const
{
    return new Events;
}

const ::std::string&
IceProxy::RobotSimEvents::ActionMessage::ice_staticId()
{
    return ::RobotSimEvents::ActionMessage::ice_staticId();
}

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

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

::IceProxy::Ice::Object*
IceProxy::RobotSimEvents::ActionMessage::__newInstance() const
{
    return new ActionMessage;
}

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

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

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

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

const ::std::string&
IceProxy::RobotSimEvents::MotionMessage::ice_staticId()
{
    return ::RobotSimEvents::MotionMessage::ice_staticId();
}

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

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

::IceProxy::Ice::Object*
IceProxy::RobotSimEvents::MotionMessage::__newInstance() const
{
    return new MotionMessage;
}

const ::std::string&
IceProxy::RobotSimEvents::RetinaMessage::ice_staticId()
{
    return ::RobotSimEvents::RetinaMessage::ice_staticId();
}

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

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

::IceProxy::Ice::Object*
IceProxy::RobotSimEvents::RetinaMessage::__newInstance() const
{
    return new RetinaMessage;
}

const ::std::string&
IceProxy::RobotSimEvents::MovementControllerMessage::ice_staticId()
{
    return ::RobotSimEvents::MovementControllerMessage::ice_staticId();
}

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

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

::IceProxy::Ice::Object*
IceProxy::RobotSimEvents::MovementControllerMessage::__newInstance() const
{
    return new MovementControllerMessage;
}

const ::std::string&
IceProxy::RobotSimEvents::JoyStickControlMessage::ice_staticId()
{
    return ::RobotSimEvents::JoyStickControlMessage::ice_staticId();
}

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

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

::IceProxy::Ice::Object*
IceProxy::RobotSimEvents::JoyStickControlMessage::__newInstance() const
{
    return new JoyStickControlMessage;
}

const ::std::string&
IceProxy::RobotSimEvents::BeeStemConfigMessage::ice_staticId()
{
    return ::RobotSimEvents::BeeStemConfigMessage::ice_staticId();
}

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

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

::IceProxy::Ice::Object*
IceProxy::RobotSimEvents::BeeStemConfigMessage::__newInstance() const
{
    return new BeeStemConfigMessage;
}

const ::std::string&
IceProxy::RobotSimEvents::IMUDataServerMessage::ice_staticId()
{
    return ::RobotSimEvents::IMUDataServerMessage::ice_staticId();
}

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

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

::IceProxy::Ice::Object*
IceProxy::RobotSimEvents::IMUDataServerMessage::__newInstance() const
{
    return new IMUDataServerMessage;
}

const ::std::string&
IceProxy::RobotSimEvents::BeeStemMotorControllerMessage::ice_staticId()
{
    return ::RobotSimEvents::BeeStemMotorControllerMessage::ice_staticId();
}

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

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

::IceProxy::Ice::Object*
IceProxy::RobotSimEvents::BeeStemMotorControllerMessage::__newInstance() const
{
    return new BeeStemMotorControllerMessage;
}

const ::std::string&
IceProxy::RobotSimEvents::LocalizationMessage::ice_staticId()
{
    return ::RobotSimEvents::LocalizationMessage::ice_staticId();
}

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

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

::IceProxy::Ice::Object*
IceProxy::RobotSimEvents::LocalizationMessage::__newInstance() const
{
    return new LocalizationMessage;
}

const ::std::string&
IceProxy::RobotSimEvents::BeeStemMessage::ice_staticId()
{
    return ::RobotSimEvents::BeeStemMessage::ice_staticId();
}

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

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

::IceProxy::Ice::Object*
IceProxy::RobotSimEvents::BeeStemMessage::__newInstance() const
{
    return new BeeStemMessage;
}

const ::std::string&
IceProxy::RobotSimEvents::ChatMessage::ice_staticId()
{
    return ::RobotSimEvents::ChatMessage::ice_staticId();
}

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

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

::IceProxy::Ice::Object*
IceProxy::RobotSimEvents::ChatMessage::__newInstance() const
{
    return new ChatMessage;
}

const ::std::string&
IceProxy::RobotSimEvents::RemoteControlMessage::ice_staticId()
{
    return ::RobotSimEvents::RemoteControlMessage::ice_staticId();
}

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

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

::IceProxy::Ice::Object*
IceProxy::RobotSimEvents::RemoteControlMessage::__newInstance() const
{
    return new RemoteControlMessage;
}

const ::std::string&
IceProxy::RobotSimEvents::StateMessage::ice_staticId()
{
    return ::RobotSimEvents::StateMessage::ice_staticId();
}

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

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

::IceProxy::Ice::Object*
IceProxy::RobotSimEvents::StateMessage::__newInstance() const
{
    return new StateMessage;
}

const ::std::string&
IceProxy::RobotSimEvents::GoalStateMessage::ice_staticId()
{
    return ::RobotSimEvents::GoalStateMessage::ice_staticId();
}

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

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

::IceProxy::Ice::Object*
IceProxy::RobotSimEvents::GoalStateMessage::__newInstance() const
{
    return new GoalStateMessage;
}

const ::std::string&
IceProxy::RobotSimEvents::GoalProgressMessage::ice_staticId()
{
    return ::RobotSimEvents::GoalProgressMessage::ice_staticId();
}

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

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

::IceProxy::Ice::Object*
IceProxy::RobotSimEvents::GoalProgressMessage::__newInstance() const
{
    return new GoalProgressMessage;
}

const ::std::string&
IceProxy::RobotSimEvents::AttendedRegionMessage::ice_staticId()
{
    return ::RobotSimEvents::AttendedRegionMessage::ice_staticId();
}

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

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

::IceProxy::Ice::Object*
IceProxy::RobotSimEvents::AttendedRegionMessage::__newInstance() const
{
    return new AttendedRegionMessage;
}

const ::std::string&
IceProxy::RobotSimEvents::ObjectMessage::ice_staticId()
{
    return ::RobotSimEvents::ObjectMessage::ice_staticId();
}

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

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

::IceProxy::Ice::Object*
IceProxy::RobotSimEvents::ObjectMessage::__newInstance() const
{
    return new ObjectMessage;
}

const ::std::string&
IceProxy::RobotSimEvents::SeaBeePositionMessage::ice_staticId()
{
    return ::RobotSimEvents::SeaBeePositionMessage::ice_staticId();
}

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

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

::IceProxy::Ice::Object*
IceProxy::RobotSimEvents::SeaBeePositionMessage::__newInstance() const
{
    return new SeaBeePositionMessage;
}

const ::std::string&
IceProxy::RobotSimEvents::SeaBeeStateConditionMessage::ice_staticId()
{
    return ::RobotSimEvents::SeaBeeStateConditionMessage::ice_staticId();
}

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

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

::IceProxy::Ice::Object*
IceProxy::RobotSimEvents::SeaBeeStateConditionMessage::__newInstance() const
{
    return new SeaBeeStateConditionMessage;
}

const ::std::string&
IceProxy::RobotSimEvents::VisionRectangleMessage::ice_staticId()
{
    return ::RobotSimEvents::VisionRectangleMessage::ice_staticId();
}

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

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

::IceProxy::Ice::Object*
IceProxy::RobotSimEvents::VisionRectangleMessage::__newInstance() const
{
    return new VisionRectangleMessage;
}

const ::std::string&
IceProxy::RobotSimEvents::StraightEdgeMessage::ice_staticId()
{
    return ::RobotSimEvents::StraightEdgeMessage::ice_staticId();
}

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

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

::IceProxy::Ice::Object*
IceProxy::RobotSimEvents::StraightEdgeMessage::__newInstance() const
{
    return new StraightEdgeMessage;
}

const ::std::string&
IceProxy::RobotSimEvents::VisionObjectMessage::ice_staticId()
{
    return ::RobotSimEvents::VisionObjectMessage::ice_staticId();
}

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

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

::IceProxy::Ice::Object*
IceProxy::RobotSimEvents::VisionObjectMessage::__newInstance() const
{
    return new VisionObjectMessage;
}

const ::std::string&
IceProxy::RobotSimEvents::LandmarksMessage::ice_staticId()
{
    return ::RobotSimEvents::LandmarksMessage::ice_staticId();
}

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

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

::IceProxy::Ice::Object*
IceProxy::RobotSimEvents::LandmarksMessage::__newInstance() const
{
    return new LandmarksMessage;
}

const ::std::string&
IceProxy::RobotSimEvents::CameraConfigMessage::ice_staticId()
{
    return ::RobotSimEvents::CameraConfigMessage::ice_staticId();
}

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

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

::IceProxy::Ice::Object*
IceProxy::RobotSimEvents::CameraConfigMessage::__newInstance() const
{
    return new CameraConfigMessage;
}

const ::std::string&
IceProxy::RobotSimEvents::SalientPointMessage::ice_staticId()
{
    return ::RobotSimEvents::SalientPointMessage::ice_staticId();
}

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

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

::IceProxy::Ice::Object*
IceProxy::RobotSimEvents::SalientPointMessage::__newInstance() const
{
    return new SalientPointMessage;
}

const ::std::string&
IceProxy::RobotSimEvents::BuoyColorSegmentMessage::ice_staticId()
{
    return ::RobotSimEvents::BuoyColorSegmentMessage::ice_staticId();
}

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

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

::IceProxy::Ice::Object*
IceProxy::RobotSimEvents::BuoyColorSegmentMessage::__newInstance() const
{
    return new BuoyColorSegmentMessage;
}

const ::std::string&
IceProxy::RobotSimEvents::PipeColorSegmentMessage::ice_staticId()
{
    return ::RobotSimEvents::PipeColorSegmentMessage::ice_staticId();
}

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

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

::IceProxy::Ice::Object*
IceProxy::RobotSimEvents::PipeColorSegmentMessage::__newInstance() const
{
    return new PipeColorSegmentMessage;
}

const ::std::string&
IceProxy::RobotSimEvents::BuoyColorSegmentConfigMessage::ice_staticId()
{
    return ::RobotSimEvents::BuoyColorSegmentConfigMessage::ice_staticId();
}

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

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

::IceProxy::Ice::Object*
IceProxy::RobotSimEvents::BuoyColorSegmentConfigMessage::__newInstance() const
{
    return new BuoyColorSegmentConfigMessage;
}

const ::std::string&
IceProxy::RobotSimEvents::PipeColorSegmentConfigMessage::ice_staticId()
{
    return ::RobotSimEvents::PipeColorSegmentConfigMessage::ice_staticId();
}

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

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

::IceProxy::Ice::Object*
IceProxy::RobotSimEvents::PipeColorSegmentConfigMessage::__newInstance() const
{
    return new PipeColorSegmentConfigMessage;
}

void
IceDelegateM::RobotSimEvents::Events::updateMessage(const ::RobotSimEvents::EventMessagePtr& eMsg, const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __RobotSimEvents__Events__updateMessage_name, ::Ice::Normal, __context);
    try
    {
        ::IceInternal::BasicStream* __os = __og.os();
        __os->write(::Ice::ObjectPtr(::IceInternal::upCast(eMsg.get())));
        __os->writePendingObjects();
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    bool __ok = __og.invoke();
    if(!__og.is()->b.empty())
    {
        try
        {
            if(!__ok)
            {
                try
                {
                    __og.throwUserException();
                }
                catch(const ::Ice::UserException& __ex)
                {
                    ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
                    throw __uue;
                }
            }
            __og.is()->skipEmptyEncaps();
        }
        catch(const ::Ice::LocalException& __ex)
        {
            throw ::IceInternal::LocalExceptionWrapper(__ex, false);
        }
    }
}

void
IceDelegateD::RobotSimEvents::Events::updateMessage(const ::RobotSimEvents::EventMessagePtr& eMsg, const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

        _DirectI(const ::RobotSimEvents::EventMessagePtr& eMsg, const ::Ice::Current& __current) :
            ::IceInternal::Direct(__current),
            _m_eMsg(eMsg)
        {
        }

        virtual ::Ice::DispatchStatus
        run(::Ice::Object* object)
        {
            ::RobotSimEvents::Events* servant = dynamic_cast< ::RobotSimEvents::Events*>(object);
            if(!servant)
            {
                throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
            }
            servant->updateMessage(_m_eMsg, _current);
            return ::Ice::DispatchOK;
        }

    private:

        const ::RobotSimEvents::EventMessagePtr& _m_eMsg;
    };

    ::Ice::Current __current;
    __initCurrent(__current, __RobotSimEvents__Events__updateMessage_name, ::Ice::Normal, __context);
    try
    {
        _DirectI __direct(eMsg, __current);
        try
        {
            __direct.servant()->__collocDispatch(__direct);
        }
        catch(...)
        {
            __direct.destroy();
            throw;
        }
        __direct.destroy();
    }
    catch(const ::Ice::SystemException&)
    {
        throw;
    }
    catch(const ::IceInternal::LocalExceptionWrapper&)
    {
        throw;
    }
    catch(const ::std::exception& __ex)
    {
        ::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
    }
    catch(...)
    {
        throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
    }
}

::Ice::ObjectPtr
RobotSimEvents::EventMessage::ice_clone() const
{
    ::RobotSimEvents::EventMessagePtr __p = new ::RobotSimEvents::EventMessage(*this);
    return __p;
}

static const ::std::string __RobotSimEvents__EventMessage_ids[2] =
{
    "::Ice::Object",
    "::RobotSimEvents::EventMessage"
};

bool
RobotSimEvents::EventMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__RobotSimEvents__EventMessage_ids, __RobotSimEvents__EventMessage_ids + 2, _s);
}

::std::vector< ::std::string>
RobotSimEvents::EventMessage::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__RobotSimEvents__EventMessage_ids[0], &__RobotSimEvents__EventMessage_ids[2]);
}

const ::std::string&
RobotSimEvents::EventMessage::ice_id(const ::Ice::Current&) const
{
    return __RobotSimEvents__EventMessage_ids[1];
}

const ::std::string&
RobotSimEvents::EventMessage::ice_staticId()
{
    return __RobotSimEvents__EventMessage_ids[1];
}

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

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

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

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

class __F__RobotSimEvents__EventMessage : public ::Ice::ObjectFactory
{
public:

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

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__RobotSimEvents__EventMessage_Ptr = new __F__RobotSimEvents__EventMessage;

const ::Ice::ObjectFactoryPtr&
RobotSimEvents::EventMessage::ice_factory()
{
    return __F__RobotSimEvents__EventMessage_Ptr;
}

class __F__RobotSimEvents__EventMessage__Init
{
public:

    __F__RobotSimEvents__EventMessage__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::RobotSimEvents::EventMessage::ice_staticId(), ::RobotSimEvents::EventMessage::ice_factory());
    }

    ~__F__RobotSimEvents__EventMessage__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::RobotSimEvents::EventMessage::ice_staticId());
    }
};

static __F__RobotSimEvents__EventMessage__Init __F__RobotSimEvents__EventMessage__i;

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

void
RobotSimEvents::__patch__EventMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::RobotSimEvents::EventMessagePtr* p = static_cast< ::RobotSimEvents::EventMessagePtr*>(__addr);
    assert(p);
    *p = ::RobotSimEvents::EventMessagePtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::RobotSimEvents::EventMessage::ice_staticId(), v->ice_id());
    }
}

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

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

::Ice::ObjectPtr
RobotSimEvents::Events::ice_clone() const
{
    throw ::Ice::CloneNotImplementedException(__FILE__, __LINE__);
    return 0; // to avoid a warning with some compilers
}

static const ::std::string __RobotSimEvents__Events_ids[2] =
{
    "::Ice::Object",
    "::RobotSimEvents::Events"
};

bool
RobotSimEvents::Events::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__RobotSimEvents__Events_ids, __RobotSimEvents__Events_ids + 2, _s);
}

::std::vector< ::std::string>
RobotSimEvents::Events::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__RobotSimEvents__Events_ids[0], &__RobotSimEvents__Events_ids[2]);
}

const ::std::string&
RobotSimEvents::Events::ice_id(const ::Ice::Current&) const
{
    return __RobotSimEvents__Events_ids[1];
}

const ::std::string&
RobotSimEvents::Events::ice_staticId()
{
    return __RobotSimEvents__Events_ids[1];
}

::Ice::DispatchStatus
RobotSimEvents::Events::___updateMessage(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.is();
    __is->startReadEncaps();
    ::RobotSimEvents::EventMessagePtr eMsg;
    __is->read(::RobotSimEvents::__patch__EventMessagePtr, &eMsg);
    __is->readPendingObjects();
    __is->endReadEncaps();
    updateMessage(eMsg, __current);
    return ::Ice::DispatchOK;
}

static ::std::string __RobotSimEvents__Events_all[] =
{
    "ice_id",
    "ice_ids",
    "ice_isA",
    "ice_ping",
    "updateMessage"
};

::Ice::DispatchStatus
RobotSimEvents::Events::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
{
    ::std::pair< ::std::string*, ::std::string*> r = ::std::equal_range(__RobotSimEvents__Events_all, __RobotSimEvents__Events_all + 5, current.operation);
    if(r.first == r.second)
    {
        throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
    }

    switch(r.first - __RobotSimEvents__Events_all)
    {
        case 0:
        {
            return ___ice_id(in, current);
        }
        case 1:
        {
            return ___ice_ids(in, current);
        }
        case 2:
        {
            return ___ice_isA(in, current);
        }
        case 3:
        {
            return ___ice_ping(in, current);
        }
        case 4:
        {
            return ___updateMessage(in, current);
        }
    }

    assert(false);
    throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
}

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

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

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

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

void
RobotSimEvents::__patch__EventsPtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::RobotSimEvents::EventsPtr* p = static_cast< ::RobotSimEvents::EventsPtr*>(__addr);
    assert(p);
    *p = ::RobotSimEvents::EventsPtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::RobotSimEvents::Events::ice_staticId(), v->ice_id());
    }
}

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

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

RobotSimEvents::ActionMessage::ActionMessage(::Ice::Float __ice_transVel, ::Ice::Float __ice_rotVel) :
    transVel(__ice_transVel),
    rotVel(__ice_rotVel)
{
}

::Ice::ObjectPtr
RobotSimEvents::ActionMessage::ice_clone() const
{
    ::RobotSimEvents::ActionMessagePtr __p = new ::RobotSimEvents::ActionMessage(*this);
    return __p;
}

static const ::std::string __RobotSimEvents__ActionMessage_ids[3] =
{
    "::Ice::Object",
    "::RobotSimEvents::ActionMessage",
    "::RobotSimEvents::EventMessage"
};

bool
RobotSimEvents::ActionMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__RobotSimEvents__ActionMessage_ids, __RobotSimEvents__ActionMessage_ids + 3, _s);
}

::std::vector< ::std::string>
RobotSimEvents::ActionMessage::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__RobotSimEvents__ActionMessage_ids[0], &__RobotSimEvents__ActionMessage_ids[3]);
}

const ::std::string&
RobotSimEvents::ActionMessage::ice_id(const ::Ice::Current&) const
{
    return __RobotSimEvents__ActionMessage_ids[1];
}

const ::std::string&
RobotSimEvents::ActionMessage::ice_staticId()
{
    return __RobotSimEvents__ActionMessage_ids[1];
}

void
RobotSimEvents::ActionMessage::__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
RobotSimEvents::ActionMessage::__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
RobotSimEvents::ActionMessage::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type RobotSimEvents::ActionMessage was not generated with stream support";
    throw ex;
}

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

class __F__RobotSimEvents__ActionMessage : public ::Ice::ObjectFactory
{
public:

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

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__RobotSimEvents__ActionMessage_Ptr = new __F__RobotSimEvents__ActionMessage;

const ::Ice::ObjectFactoryPtr&
RobotSimEvents::ActionMessage::ice_factory()
{
    return __F__RobotSimEvents__ActionMessage_Ptr;
}

class __F__RobotSimEvents__ActionMessage__Init
{
public:

    __F__RobotSimEvents__ActionMessage__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::RobotSimEvents::ActionMessage::ice_staticId(), ::RobotSimEvents::ActionMessage::ice_factory());
    }

    ~__F__RobotSimEvents__ActionMessage__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::RobotSimEvents::ActionMessage::ice_staticId());
    }
};

static __F__RobotSimEvents__ActionMessage__Init __F__RobotSimEvents__ActionMessage__i;

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

void
RobotSimEvents::__patch__ActionMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::RobotSimEvents::ActionMessagePtr* p = static_cast< ::RobotSimEvents::ActionMessagePtr*>(__addr);
    assert(p);
    *p = ::RobotSimEvents::ActionMessagePtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::RobotSimEvents::ActionMessage::ice_staticId(), v->ice_id());
    }
}

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

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

RobotSimEvents::GPSMessage::GPSMessage(::Ice::Float __ice_xPos, ::Ice::Float __ice_yPos, ::Ice::Float __ice_orientation) :
    xPos(__ice_xPos),
    yPos(__ice_yPos),
    orientation(__ice_orientation)
{
}

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

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

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

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

const ::std::string&
RobotSimEvents::GPSMessage::ice_id(const ::Ice::Current&) const
{
    return __RobotSimEvents__GPSMessage_ids[2];
}

const ::std::string&
RobotSimEvents::GPSMessage::ice_staticId()
{
    return __RobotSimEvents__GPSMessage_ids[2];
}

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

void
RobotSimEvents::GPSMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    __is->read(xPos);
    __is->read(yPos);
    __is->read(orientation);
    __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
RobotSimEvents::GPSMessage::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type RobotSimEvents::GPSMessage was not generated with stream support";
    throw ex;
}

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

class __F__RobotSimEvents__GPSMessage : public ::Ice::ObjectFactory
{
public:

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

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__RobotSimEvents__GPSMessage_Ptr = new __F__RobotSimEvents__GPSMessage;

const ::Ice::ObjectFactoryPtr&
RobotSimEvents::GPSMessage::ice_factory()
{
    return __F__RobotSimEvents__GPSMessage_Ptr;
}

class __F__RobotSimEvents__GPSMessage__Init
{
public:

    __F__RobotSimEvents__GPSMessage__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::RobotSimEvents::GPSMessage::ice_staticId(), ::RobotSimEvents::GPSMessage::ice_factory());
    }

    ~__F__RobotSimEvents__GPSMessage__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::RobotSimEvents::GPSMessage::ice_staticId());
    }
};

static __F__RobotSimEvents__GPSMessage__Init __F__RobotSimEvents__GPSMessage__i;

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

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

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

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

RobotSimEvents::MotionMessage::MotionMessage(::Ice::Float __ice_distance, ::Ice::Float __ice_angle) :
    distance(__ice_distance),
    angle(__ice_angle)
{
}

::Ice::ObjectPtr
RobotSimEvents::MotionMessage::ice_clone() const
{
    ::RobotSimEvents::MotionMessagePtr __p = new ::RobotSimEvents::MotionMessage(*this);
    return __p;
}

static const ::std::string __RobotSimEvents__MotionMessage_ids[3] =
{
    "::Ice::Object",
    "::RobotSimEvents::EventMessage",
    "::RobotSimEvents::MotionMessage"
};

bool
RobotSimEvents::MotionMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__RobotSimEvents__MotionMessage_ids, __RobotSimEvents__MotionMessage_ids + 3, _s);
}

::std::vector< ::std::string>
RobotSimEvents::MotionMessage::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__RobotSimEvents__MotionMessage_ids[0], &__RobotSimEvents__MotionMessage_ids[3]);
}

const ::std::string&
RobotSimEvents::MotionMessage::ice_id(const ::Ice::Current&) const
{
    return __RobotSimEvents__MotionMessage_ids[2];
}

const ::std::string&
RobotSimEvents::MotionMessage::ice_staticId()
{
    return __RobotSimEvents__MotionMessage_ids[2];
}

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

void
RobotSimEvents::MotionMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    __is->read(distance);
    __is->read(angle);
    __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
RobotSimEvents::MotionMessage::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type RobotSimEvents::MotionMessage was not generated with stream support";
    throw ex;
}

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

class __F__RobotSimEvents__MotionMessage : public ::Ice::ObjectFactory
{
public:

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

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__RobotSimEvents__MotionMessage_Ptr = new __F__RobotSimEvents__MotionMessage;

const ::Ice::ObjectFactoryPtr&
RobotSimEvents::MotionMessage::ice_factory()
{
    return __F__RobotSimEvents__MotionMessage_Ptr;
}

class __F__RobotSimEvents__MotionMessage__Init
{
public:

    __F__RobotSimEvents__MotionMessage__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::RobotSimEvents::MotionMessage::ice_staticId(), ::RobotSimEvents::MotionMessage::ice_factory());
    }

    ~__F__RobotSimEvents__MotionMessage__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::RobotSimEvents::MotionMessage::ice_staticId());
    }
};

static __F__RobotSimEvents__MotionMessage__Init __F__RobotSimEvents__MotionMessage__i;

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

void
RobotSimEvents::__patch__MotionMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::RobotSimEvents::MotionMessagePtr* p = static_cast< ::RobotSimEvents::MotionMessagePtr*>(__addr);
    assert(p);
    *p = ::RobotSimEvents::MotionMessagePtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::RobotSimEvents::MotionMessage::ice_staticId(), v->ice_id());
    }
}

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

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

RobotSimEvents::RetinaMessage::RetinaMessage(const ::ImageIceMod::ImageIce& __ice_img, const ::std::string& __ice_cameraID) :
    img(__ice_img),
    cameraID(__ice_cameraID)
{
}

::Ice::ObjectPtr
RobotSimEvents::RetinaMessage::ice_clone() const
{
    ::RobotSimEvents::RetinaMessagePtr __p = new ::RobotSimEvents::RetinaMessage(*this);
    return __p;
}

static const ::std::string __RobotSimEvents__RetinaMessage_ids[3] =
{
    "::Ice::Object",
    "::RobotSimEvents::EventMessage",
    "::RobotSimEvents::RetinaMessage"
};

bool
RobotSimEvents::RetinaMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__RobotSimEvents__RetinaMessage_ids, __RobotSimEvents__RetinaMessage_ids + 3, _s);
}

::std::vector< ::std::string>
RobotSimEvents::RetinaMessage::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__RobotSimEvents__RetinaMessage_ids[0], &__RobotSimEvents__RetinaMessage_ids[3]);
}

const ::std::string&
RobotSimEvents::RetinaMessage::ice_id(const ::Ice::Current&) const
{
    return __RobotSimEvents__RetinaMessage_ids[2];
}

const ::std::string&
RobotSimEvents::RetinaMessage::ice_staticId()
{
    return __RobotSimEvents__RetinaMessage_ids[2];
}

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

void
RobotSimEvents::RetinaMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    img.__read(__is);
    __is->read(cameraID);
    __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
RobotSimEvents::RetinaMessage::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type RobotSimEvents::RetinaMessage was not generated with stream support";
    throw ex;
}

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

class __F__RobotSimEvents__RetinaMessage : public ::Ice::ObjectFactory
{
public:

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

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__RobotSimEvents__RetinaMessage_Ptr = new __F__RobotSimEvents__RetinaMessage;

const ::Ice::ObjectFactoryPtr&
RobotSimEvents::RetinaMessage::ice_factory()
{
    return __F__RobotSimEvents__RetinaMessage_Ptr;
}

class __F__RobotSimEvents__RetinaMessage__Init
{
public:

    __F__RobotSimEvents__RetinaMessage__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::RobotSimEvents::RetinaMessage::ice_staticId(), ::RobotSimEvents::RetinaMessage::ice_factory());
    }

    ~__F__RobotSimEvents__RetinaMessage__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::RobotSimEvents::RetinaMessage::ice_staticId());
    }
};

static __F__RobotSimEvents__RetinaMessage__Init __F__RobotSimEvents__RetinaMessage__i;

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

void
RobotSimEvents::__patch__RetinaMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::RobotSimEvents::RetinaMessagePtr* p = static_cast< ::RobotSimEvents::RetinaMessagePtr*>(__addr);
    assert(p);
    *p = ::RobotSimEvents::RetinaMessagePtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::RobotSimEvents::RetinaMessage::ice_staticId(), v->ice_id());
    }
}

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

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

RobotSimEvents::MovementControllerMessage::MovementControllerMessage(const ::RobotSimEvents::SensorVoteVector& __ice_votes, ::Ice::Float __ice_compositeHeading, ::Ice::Float __ice_compositeDepth) :
    votes(__ice_votes),
    compositeHeading(__ice_compositeHeading),
    compositeDepth(__ice_compositeDepth)
{
}

::Ice::ObjectPtr
RobotSimEvents::MovementControllerMessage::ice_clone() const
{
    ::RobotSimEvents::MovementControllerMessagePtr __p = new ::RobotSimEvents::MovementControllerMessage(*this);
    return __p;
}

static const ::std::string __RobotSimEvents__MovementControllerMessage_ids[3] =
{
    "::Ice::Object",
    "::RobotSimEvents::EventMessage",
    "::RobotSimEvents::MovementControllerMessage"
};

bool
RobotSimEvents::MovementControllerMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__RobotSimEvents__MovementControllerMessage_ids, __RobotSimEvents__MovementControllerMessage_ids + 3, _s);
}

::std::vector< ::std::string>
RobotSimEvents::MovementControllerMessage::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__RobotSimEvents__MovementControllerMessage_ids[0], &__RobotSimEvents__MovementControllerMessage_ids[3]);
}

const ::std::string&
RobotSimEvents::MovementControllerMessage::ice_id(const ::Ice::Current&) const
{
    return __RobotSimEvents__MovementControllerMessage_ids[2];
}

const ::std::string&
RobotSimEvents::MovementControllerMessage::ice_staticId()
{
    return __RobotSimEvents__MovementControllerMessage_ids[2];
}

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

void
RobotSimEvents::MovementControllerMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    ::RobotSimEvents::__readSensorVoteVector(__is, votes);
    __is->read(compositeHeading);
    __is->read(compositeDepth);
    __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
RobotSimEvents::MovementControllerMessage::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type RobotSimEvents::MovementControllerMessage was not generated with stream support";
    throw ex;
}

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

class __F__RobotSimEvents__MovementControllerMessage : public ::Ice::ObjectFactory
{
public:

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

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__RobotSimEvents__MovementControllerMessage_Ptr = new __F__RobotSimEvents__MovementControllerMessage;

const ::Ice::ObjectFactoryPtr&
RobotSimEvents::MovementControllerMessage::ice_factory()
{
    return __F__RobotSimEvents__MovementControllerMessage_Ptr;
}

class __F__RobotSimEvents__MovementControllerMessage__Init
{
public:

    __F__RobotSimEvents__MovementControllerMessage__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::RobotSimEvents::MovementControllerMessage::ice_staticId(), ::RobotSimEvents::MovementControllerMessage::ice_factory());
    }

    ~__F__RobotSimEvents__MovementControllerMessage__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::RobotSimEvents::MovementControllerMessage::ice_staticId());
    }
};

static __F__RobotSimEvents__MovementControllerMessage__Init __F__RobotSimEvents__MovementControllerMessage__i;

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

void
RobotSimEvents::__patch__MovementControllerMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::RobotSimEvents::MovementControllerMessagePtr* p = static_cast< ::RobotSimEvents::MovementControllerMessagePtr*>(__addr);
    assert(p);
    *p = ::RobotSimEvents::MovementControllerMessagePtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::RobotSimEvents::MovementControllerMessage::ice_staticId(), v->ice_id());
    }
}

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

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

RobotSimEvents::JoyStickControlMessage::JoyStickControlMessage(const ::std::string& __ice_axisName, ::Ice::Int __ice_axis, ::Ice::Int __ice_axisVal, ::Ice::Int __ice_button, ::Ice::Int __ice_butVal) :
    axisName(__ice_axisName),
    axis(__ice_axis),
    axisVal(__ice_axisVal),
    button(__ice_button),
    butVal(__ice_butVal)
{
}

::Ice::ObjectPtr
RobotSimEvents::JoyStickControlMessage::ice_clone() const
{
    ::RobotSimEvents::JoyStickControlMessagePtr __p = new ::RobotSimEvents::JoyStickControlMessage(*this);
    return __p;
}

static const ::std::string __RobotSimEvents__JoyStickControlMessage_ids[3] =
{
    "::Ice::Object",
    "::RobotSimEvents::EventMessage",
    "::RobotSimEvents::JoyStickControlMessage"
};

bool
RobotSimEvents::JoyStickControlMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__RobotSimEvents__JoyStickControlMessage_ids, __RobotSimEvents__JoyStickControlMessage_ids + 3, _s);
}

::std::vector< ::std::string>
RobotSimEvents::JoyStickControlMessage::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__RobotSimEvents__JoyStickControlMessage_ids[0], &__RobotSimEvents__JoyStickControlMessage_ids[3]);
}

const ::std::string&
RobotSimEvents::JoyStickControlMessage::ice_id(const ::Ice::Current&) const
{
    return __RobotSimEvents__JoyStickControlMessage_ids[2];
}

const ::std::string&
RobotSimEvents::JoyStickControlMessage::ice_staticId()
{
    return __RobotSimEvents__JoyStickControlMessage_ids[2];
}

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

void
RobotSimEvents::JoyStickControlMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    __is->read(axisName);
    __is->read(axis);
    __is->read(axisVal);
    __is->read(button);
    __is->read(butVal);
    __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
RobotSimEvents::JoyStickControlMessage::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type RobotSimEvents::JoyStickControlMessage was not generated with stream support";
    throw ex;
}

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

class __F__RobotSimEvents__JoyStickControlMessage : public ::Ice::ObjectFactory
{
public:

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

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__RobotSimEvents__JoyStickControlMessage_Ptr = new __F__RobotSimEvents__JoyStickControlMessage;

const ::Ice::ObjectFactoryPtr&
RobotSimEvents::JoyStickControlMessage::ice_factory()
{
    return __F__RobotSimEvents__JoyStickControlMessage_Ptr;
}

class __F__RobotSimEvents__JoyStickControlMessage__Init
{
public:

    __F__RobotSimEvents__JoyStickControlMessage__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::RobotSimEvents::JoyStickControlMessage::ice_staticId(), ::RobotSimEvents::JoyStickControlMessage::ice_factory());
    }

    ~__F__RobotSimEvents__JoyStickControlMessage__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::RobotSimEvents::JoyStickControlMessage::ice_staticId());
    }
};

static __F__RobotSimEvents__JoyStickControlMessage__Init __F__RobotSimEvents__JoyStickControlMessage__i;

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

void
RobotSimEvents::__patch__JoyStickControlMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::RobotSimEvents::JoyStickControlMessagePtr* p = static_cast< ::RobotSimEvents::JoyStickControlMessagePtr*>(__addr);
    assert(p);
    *p = ::RobotSimEvents::JoyStickControlMessagePtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::RobotSimEvents::JoyStickControlMessage::ice_staticId(), v->ice_id());
    }
}

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

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

RobotSimEvents::BeeStemConfigMessage::BeeStemConfigMessage(::Ice::Int __ice_deviceToFire, ::Ice::Int __ice_desiredHeading, ::Ice::Int __ice_desiredDepth, ::Ice::Int __ice_desiredSpeed, ::Ice::Int __ice_updateDesiredValue, ::Ice::Float __ice_headingK, ::Ice::Float __ice_headingP, ::Ice::Float __ice_headingI, ::Ice::Float __ice_headingD, ::Ice::Int __ice_updateHeadingPID, ::Ice::Float __ice_depthK, ::Ice::Float __ice_depthP, ::Ice::Float __ice_depthI, ::Ice::Float __ice_depthD, ::Ice::Int __ice_updateDepthPID, ::Ice::Int __ice_enablePID, ::Ice::Int __ice_enableVal) :
    deviceToFire(__ice_deviceToFire),
    desiredHeading(__ice_desiredHeading),
    desiredDepth(__ice_desiredDepth),
    desiredSpeed(__ice_desiredSpeed),
    updateDesiredValue(__ice_updateDesiredValue),
    headingK(__ice_headingK),
    headingP(__ice_headingP),
    headingI(__ice_headingI),
    headingD(__ice_headingD),
    updateHeadingPID(__ice_updateHeadingPID),
    depthK(__ice_depthK),
    depthP(__ice_depthP),
    depthI(__ice_depthI),
    depthD(__ice_depthD),
    updateDepthPID(__ice_updateDepthPID),
    enablePID(__ice_enablePID),
    enableVal(__ice_enableVal)
{
}

::Ice::ObjectPtr
RobotSimEvents::BeeStemConfigMessage::ice_clone() const
{
    ::RobotSimEvents::BeeStemConfigMessagePtr __p = new ::RobotSimEvents::BeeStemConfigMessage(*this);
    return __p;
}

static const ::std::string __RobotSimEvents__BeeStemConfigMessage_ids[3] =
{
    "::Ice::Object",
    "::RobotSimEvents::BeeStemConfigMessage",
    "::RobotSimEvents::EventMessage"
};

bool
RobotSimEvents::BeeStemConfigMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__RobotSimEvents__BeeStemConfigMessage_ids, __RobotSimEvents__BeeStemConfigMessage_ids + 3, _s);
}

::std::vector< ::std::string>
RobotSimEvents::BeeStemConfigMessage::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__RobotSimEvents__BeeStemConfigMessage_ids[0], &__RobotSimEvents__BeeStemConfigMessage_ids[3]);
}

const ::std::string&
RobotSimEvents::BeeStemConfigMessage::ice_id(const ::Ice::Current&) const
{
    return __RobotSimEvents__BeeStemConfigMessage_ids[1];
}

const ::std::string&
RobotSimEvents::BeeStemConfigMessage::ice_staticId()
{
    return __RobotSimEvents__BeeStemConfigMessage_ids[1];
}

void
RobotSimEvents::BeeStemConfigMessage::__write(::IceInternal::BasicStream* __os) const
{
    __os->writeTypeId(ice_staticId());
    __os->startWriteSlice();
    __os->write(deviceToFire);
    __os->write(desiredHeading);
    __os->write(desiredDepth);
    __os->write(desiredSpeed);
    __os->write(updateDesiredValue);
    __os->write(headingK);
    __os->write(headingP);
    __os->write(headingI);
    __os->write(headingD);
    __os->write(updateHeadingPID);
    __os->write(depthK);
    __os->write(depthP);
    __os->write(depthI);
    __os->write(depthD);
    __os->write(updateDepthPID);
    __os->write(enablePID);
    __os->write(enableVal);
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__write(__os);
#else
    ::RobotSimEvents::EventMessage::__write(__os);
#endif
}

void
RobotSimEvents::BeeStemConfigMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    __is->read(deviceToFire);
    __is->read(desiredHeading);
    __is->read(desiredDepth);
    __is->read(desiredSpeed);
    __is->read(updateDesiredValue);
    __is->read(headingK);
    __is->read(headingP);
    __is->read(headingI);
    __is->read(headingD);
    __is->read(updateHeadingPID);
    __is->read(depthK);
    __is->read(depthP);
    __is->read(depthI);
    __is->read(depthD);
    __is->read(updateDepthPID);
    __is->read(enablePID);
    __is->read(enableVal);
    __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
RobotSimEvents::BeeStemConfigMessage::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type RobotSimEvents::BeeStemConfigMessage was not generated with stream support";
    throw ex;
}

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

class __F__RobotSimEvents__BeeStemConfigMessage : public ::Ice::ObjectFactory
{
public:

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

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__RobotSimEvents__BeeStemConfigMessage_Ptr = new __F__RobotSimEvents__BeeStemConfigMessage;

const ::Ice::ObjectFactoryPtr&
RobotSimEvents::BeeStemConfigMessage::ice_factory()
{
    return __F__RobotSimEvents__BeeStemConfigMessage_Ptr;
}

class __F__RobotSimEvents__BeeStemConfigMessage__Init
{
public:

    __F__RobotSimEvents__BeeStemConfigMessage__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::RobotSimEvents::BeeStemConfigMessage::ice_staticId(), ::RobotSimEvents::BeeStemConfigMessage::ice_factory());
    }

    ~__F__RobotSimEvents__BeeStemConfigMessage__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::RobotSimEvents::BeeStemConfigMessage::ice_staticId());
    }
};

static __F__RobotSimEvents__BeeStemConfigMessage__Init __F__RobotSimEvents__BeeStemConfigMessage__i;

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

void
RobotSimEvents::__patch__BeeStemConfigMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::RobotSimEvents::BeeStemConfigMessagePtr* p = static_cast< ::RobotSimEvents::BeeStemConfigMessagePtr*>(__addr);
    assert(p);
    *p = ::RobotSimEvents::BeeStemConfigMessagePtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::RobotSimEvents::BeeStemConfigMessage::ice_staticId(), v->ice_id());
    }
}

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

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

RobotSimEvents::IMUDataServerMessage::IMUDataServerMessage(::Ice::Double __ice_temp, const ::ImageIceMod::Point3DIce& __ice_accel, const ::ImageIceMod::Point3DIce& __ice_gyro, const ::ImageIceMod::Point3DIce& __ice_mag, ::Ice::Int __ice_angleMode, const ::RobotSimEvents::FloatVector& __ice_orientation) :
    temp(__ice_temp),
    accel(__ice_accel),
    gyro(__ice_gyro),
    mag(__ice_mag),
    angleMode(__ice_angleMode),
    orientation(__ice_orientation)
{
}

::Ice::ObjectPtr
RobotSimEvents::IMUDataServerMessage::ice_clone() const
{
    ::RobotSimEvents::IMUDataServerMessagePtr __p = new ::RobotSimEvents::IMUDataServerMessage(*this);
    return __p;
}

static const ::std::string __RobotSimEvents__IMUDataServerMessage_ids[3] =
{
    "::Ice::Object",
    "::RobotSimEvents::EventMessage",
    "::RobotSimEvents::IMUDataServerMessage"
};

bool
RobotSimEvents::IMUDataServerMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__RobotSimEvents__IMUDataServerMessage_ids, __RobotSimEvents__IMUDataServerMessage_ids + 3, _s);
}

::std::vector< ::std::string>
RobotSimEvents::IMUDataServerMessage::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__RobotSimEvents__IMUDataServerMessage_ids[0], &__RobotSimEvents__IMUDataServerMessage_ids[3]);
}

const ::std::string&
RobotSimEvents::IMUDataServerMessage::ice_id(const ::Ice::Current&) const
{
    return __RobotSimEvents__IMUDataServerMessage_ids[2];
}

const ::std::string&
RobotSimEvents::IMUDataServerMessage::ice_staticId()
{
    return __RobotSimEvents__IMUDataServerMessage_ids[2];
}

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

void
RobotSimEvents::IMUDataServerMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    __is->read(temp);
    accel.__read(__is);
    gyro.__read(__is);
    mag.__read(__is);
    __is->read(angleMode);
    __is->read(orientation);
    __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
RobotSimEvents::IMUDataServerMessage::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type RobotSimEvents::IMUDataServerMessage was not generated with stream support";
    throw ex;
}

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

class __F__RobotSimEvents__IMUDataServerMessage : public ::Ice::ObjectFactory
{
public:

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

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__RobotSimEvents__IMUDataServerMessage_Ptr = new __F__RobotSimEvents__IMUDataServerMessage;

const ::Ice::ObjectFactoryPtr&
RobotSimEvents::IMUDataServerMessage::ice_factory()
{
    return __F__RobotSimEvents__IMUDataServerMessage_Ptr;
}

class __F__RobotSimEvents__IMUDataServerMessage__Init
{
public:

    __F__RobotSimEvents__IMUDataServerMessage__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::RobotSimEvents::IMUDataServerMessage::ice_staticId(), ::RobotSimEvents::IMUDataServerMessage::ice_factory());
    }

    ~__F__RobotSimEvents__IMUDataServerMessage__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::RobotSimEvents::IMUDataServerMessage::ice_staticId());
    }
};

static __F__RobotSimEvents__IMUDataServerMessage__Init __F__RobotSimEvents__IMUDataServerMessage__i;

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

void
RobotSimEvents::__patch__IMUDataServerMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::RobotSimEvents::IMUDataServerMessagePtr* p = static_cast< ::RobotSimEvents::IMUDataServerMessagePtr*>(__addr);
    assert(p);
    *p = ::RobotSimEvents::IMUDataServerMessagePtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::RobotSimEvents::IMUDataServerMessage::ice_staticId(), v->ice_id());
    }
}

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

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

RobotSimEvents::BeeStemMotorControllerMessage::BeeStemMotorControllerMessage(const ::RobotSimEvents::IntVector& __ice_mask, const ::RobotSimEvents::IntVector& __ice_values) :
    mask(__ice_mask),
    values(__ice_values)
{
}

::Ice::ObjectPtr
RobotSimEvents::BeeStemMotorControllerMessage::ice_clone() const
{
    ::RobotSimEvents::BeeStemMotorControllerMessagePtr __p = new ::RobotSimEvents::BeeStemMotorControllerMessage(*this);
    return __p;
}

static const ::std::string __RobotSimEvents__BeeStemMotorControllerMessage_ids[3] =
{
    "::Ice::Object",
    "::RobotSimEvents::BeeStemMotorControllerMessage",
    "::RobotSimEvents::EventMessage"
};

bool
RobotSimEvents::BeeStemMotorControllerMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__RobotSimEvents__BeeStemMotorControllerMessage_ids, __RobotSimEvents__BeeStemMotorControllerMessage_ids + 3, _s);
}

::std::vector< ::std::string>
RobotSimEvents::BeeStemMotorControllerMessage::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__RobotSimEvents__BeeStemMotorControllerMessage_ids[0], &__RobotSimEvents__BeeStemMotorControllerMessage_ids[3]);
}

const ::std::string&
RobotSimEvents::BeeStemMotorControllerMessage::ice_id(const ::Ice::Current&) const
{
    return __RobotSimEvents__BeeStemMotorControllerMessage_ids[1];
}

const ::std::string&
RobotSimEvents::BeeStemMotorControllerMessage::ice_staticId()
{
    return __RobotSimEvents__BeeStemMotorControllerMessage_ids[1];
}

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

void
RobotSimEvents::BeeStemMotorControllerMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    __is->read(mask);
    __is->read(values);
    __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
RobotSimEvents::BeeStemMotorControllerMessage::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type RobotSimEvents::BeeStemMotorControllerMessage was not generated with stream support";
    throw ex;
}

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

class __F__RobotSimEvents__BeeStemMotorControllerMessage : public ::Ice::ObjectFactory
{
public:

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

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__RobotSimEvents__BeeStemMotorControllerMessage_Ptr = new __F__RobotSimEvents__BeeStemMotorControllerMessage;

const ::Ice::ObjectFactoryPtr&
RobotSimEvents::BeeStemMotorControllerMessage::ice_factory()
{
    return __F__RobotSimEvents__BeeStemMotorControllerMessage_Ptr;
}

class __F__RobotSimEvents__BeeStemMotorControllerMessage__Init
{
public:

    __F__RobotSimEvents__BeeStemMotorControllerMessage__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::RobotSimEvents::BeeStemMotorControllerMessage::ice_staticId(), ::RobotSimEvents::BeeStemMotorControllerMessage::ice_factory());
    }

    ~__F__RobotSimEvents__BeeStemMotorControllerMessage__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::RobotSimEvents::BeeStemMotorControllerMessage::ice_staticId());
    }
};

static __F__RobotSimEvents__BeeStemMotorControllerMessage__Init __F__RobotSimEvents__BeeStemMotorControllerMessage__i;

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

void
RobotSimEvents::__patch__BeeStemMotorControllerMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::RobotSimEvents::BeeStemMotorControllerMessagePtr* p = static_cast< ::RobotSimEvents::BeeStemMotorControllerMessagePtr*>(__addr);
    assert(p);
    *p = ::RobotSimEvents::BeeStemMotorControllerMessagePtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::RobotSimEvents::BeeStemMotorControllerMessage::ice_staticId(), v->ice_id());
    }
}

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

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

RobotSimEvents::LocalizationMessage::LocalizationMessage(const ::ImageIceMod::Point2DIce& __ice_pos, ::Ice::Float __ice_heading, ::Ice::Int __ice_mode, const ::ImageIceMod::WaypointIce& __ice_currentWaypoint) :
    pos(__ice_pos),
    heading(__ice_heading),
    mode(__ice_mode),
    currentWaypoint(__ice_currentWaypoint)
{
}

::Ice::ObjectPtr
RobotSimEvents::LocalizationMessage::ice_clone() const
{
    ::RobotSimEvents::LocalizationMessagePtr __p = new ::RobotSimEvents::LocalizationMessage(*this);
    return __p;
}

static const ::std::string __RobotSimEvents__LocalizationMessage_ids[3] =
{
    "::Ice::Object",
    "::RobotSimEvents::EventMessage",
    "::RobotSimEvents::LocalizationMessage"
};

bool
RobotSimEvents::LocalizationMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__RobotSimEvents__LocalizationMessage_ids, __RobotSimEvents__LocalizationMessage_ids + 3, _s);
}

::std::vector< ::std::string>
RobotSimEvents::LocalizationMessage::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__RobotSimEvents__LocalizationMessage_ids[0], &__RobotSimEvents__LocalizationMessage_ids[3]);
}

const ::std::string&
RobotSimEvents::LocalizationMessage::ice_id(const ::Ice::Current&) const
{
    return __RobotSimEvents__LocalizationMessage_ids[2];
}

const ::std::string&
RobotSimEvents::LocalizationMessage::ice_staticId()
{
    return __RobotSimEvents__LocalizationMessage_ids[2];
}

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

void
RobotSimEvents::LocalizationMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    pos.__read(__is);
    __is->read(heading);
    __is->read(mode);
    currentWaypoint.__read(__is);
    __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
RobotSimEvents::LocalizationMessage::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type RobotSimEvents::LocalizationMessage was not generated with stream support";
    throw ex;
}

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

class __F__RobotSimEvents__LocalizationMessage : public ::Ice::ObjectFactory
{
public:

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

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__RobotSimEvents__LocalizationMessage_Ptr = new __F__RobotSimEvents__LocalizationMessage;

const ::Ice::ObjectFactoryPtr&
RobotSimEvents::LocalizationMessage::ice_factory()
{
    return __F__RobotSimEvents__LocalizationMessage_Ptr;
}

class __F__RobotSimEvents__LocalizationMessage__Init
{
public:

    __F__RobotSimEvents__LocalizationMessage__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::RobotSimEvents::LocalizationMessage::ice_staticId(), ::RobotSimEvents::LocalizationMessage::ice_factory());
    }

    ~__F__RobotSimEvents__LocalizationMessage__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::RobotSimEvents::LocalizationMessage::ice_staticId());
    }
};

static __F__RobotSimEvents__LocalizationMessage__Init __F__RobotSimEvents__LocalizationMessage__i;

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

void
RobotSimEvents::__patch__LocalizationMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::RobotSimEvents::LocalizationMessagePtr* p = static_cast< ::RobotSimEvents::LocalizationMessagePtr*>(__addr);
    assert(p);
    *p = ::RobotSimEvents::LocalizationMessagePtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::RobotSimEvents::LocalizationMessage::ice_staticId(), v->ice_id());
    }
}

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

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

RobotSimEvents::BeeStemMessage::BeeStemMessage(::Ice::Int __ice_accelX, ::Ice::Int __ice_accelY, ::Ice::Int __ice_accelZ, ::Ice::Int __ice_compassHeading, ::Ice::Int __ice_compassPitch, ::Ice::Int __ice_compassRoll, ::Ice::Int __ice_internalPressure, ::Ice::Int __ice_externalPressure, ::Ice::Int __ice_desiredHeading, ::Ice::Int __ice_desiredDepth, ::Ice::Int __ice_desiredSpeed, ::Ice::Int __ice_headingK, ::Ice::Int __ice_headingP, ::Ice::Int __ice_headingD, ::Ice::Int __ice_headingI, ::Ice::Int __ice_headingOutput, ::Ice::Int __ice_depthK, ::Ice::Int __ice_depthP, ::Ice::Int __ice_depthD, ::Ice::Int __ice_depthI, ::Ice::Int __ice_depthOutput, ::Ice::Int __ice_thruster1, ::Ice::Int __ice_thruster2, ::Ice::Int __ice_thruster3, ::Ice::Int __ice_thruster4, ::Ice::Int __ice_thruster5, ::Ice::Int __ice_thruster6, ::Ice::Int __ice_killSwitch) :
    accelX(__ice_accelX),
    accelY(__ice_accelY),
    accelZ(__ice_accelZ),
    compassHeading(__ice_compassHeading),
    compassPitch(__ice_compassPitch),
    compassRoll(__ice_compassRoll),
    internalPressure(__ice_internalPressure),
    externalPressure(__ice_externalPressure),
    desiredHeading(__ice_desiredHeading),
    desiredDepth(__ice_desiredDepth),
    desiredSpeed(__ice_desiredSpeed),
    headingK(__ice_headingK),
    headingP(__ice_headingP),
    headingD(__ice_headingD),
    headingI(__ice_headingI),
    headingOutput(__ice_headingOutput),
    depthK(__ice_depthK),
    depthP(__ice_depthP),
    depthD(__ice_depthD),
    depthI(__ice_depthI),
    depthOutput(__ice_depthOutput),
    thruster1(__ice_thruster1),
    thruster2(__ice_thruster2),
    thruster3(__ice_thruster3),
    thruster4(__ice_thruster4),
    thruster5(__ice_thruster5),
    thruster6(__ice_thruster6),
    killSwitch(__ice_killSwitch)
{
}

::Ice::ObjectPtr
RobotSimEvents::BeeStemMessage::ice_clone() const
{
    ::RobotSimEvents::BeeStemMessagePtr __p = new ::RobotSimEvents::BeeStemMessage(*this);
    return __p;
}

static const ::std::string __RobotSimEvents__BeeStemMessage_ids[3] =
{
    "::Ice::Object",
    "::RobotSimEvents::BeeStemMessage",
    "::RobotSimEvents::EventMessage"
};

bool
RobotSimEvents::BeeStemMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__RobotSimEvents__BeeStemMessage_ids, __RobotSimEvents__BeeStemMessage_ids + 3, _s);
}

::std::vector< ::std::string>
RobotSimEvents::BeeStemMessage::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__RobotSimEvents__BeeStemMessage_ids[0], &__RobotSimEvents__BeeStemMessage_ids[3]);
}

const ::std::string&
RobotSimEvents::BeeStemMessage::ice_id(const ::Ice::Current&) const
{
    return __RobotSimEvents__BeeStemMessage_ids[1];
}

const ::std::string&
RobotSimEvents::BeeStemMessage::ice_staticId()
{
    return __RobotSimEvents__BeeStemMessage_ids[1];
}

void
RobotSimEvents::BeeStemMessage::__write(::IceInternal::BasicStream* __os) const
{
    __os->writeTypeId(ice_staticId());
    __os->startWriteSlice();
    __os->write(accelX);
    __os->write(accelY);
    __os->write(accelZ);
    __os->write(compassHeading);
    __os->write(compassPitch);
    __os->write(compassRoll);
    __os->write(internalPressure);
    __os->write(externalPressure);
    __os->write(desiredHeading);
    __os->write(desiredDepth);
    __os->write(desiredSpeed);
    __os->write(headingK);
    __os->write(headingP);
    __os->write(headingD);
    __os->write(headingI);
    __os->write(headingOutput);
    __os->write(depthK);
    __os->write(depthP);
    __os->write(depthD);
    __os->write(depthI);
    __os->write(depthOutput);
    __os->write(thruster1);
    __os->write(thruster2);
    __os->write(thruster3);
    __os->write(thruster4);
    __os->write(thruster5);
    __os->write(thruster6);
    __os->write(killSwitch);
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__write(__os);
#else
    ::RobotSimEvents::EventMessage::__write(__os);
#endif
}

void
RobotSimEvents::BeeStemMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    __is->read(accelX);
    __is->read(accelY);
    __is->read(accelZ);
    __is->read(compassHeading);
    __is->read(compassPitch);
    __is->read(compassRoll);
    __is->read(internalPressure);
    __is->read(externalPressure);
    __is->read(desiredHeading);
    __is->read(desiredDepth);
    __is->read(desiredSpeed);
    __is->read(headingK);
    __is->read(headingP);
    __is->read(headingD);
    __is->read(headingI);
    __is->read(headingOutput);
    __is->read(depthK);
    __is->read(depthP);
    __is->read(depthD);
    __is->read(depthI);
    __is->read(depthOutput);
    __is->read(thruster1);
    __is->read(thruster2);
    __is->read(thruster3);
    __is->read(thruster4);
    __is->read(thruster5);
    __is->read(thruster6);
    __is->read(killSwitch);
    __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
RobotSimEvents::BeeStemMessage::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type RobotSimEvents::BeeStemMessage was not generated with stream support";
    throw ex;
}

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

class __F__RobotSimEvents__BeeStemMessage : public ::Ice::ObjectFactory
{
public:

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

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__RobotSimEvents__BeeStemMessage_Ptr = new __F__RobotSimEvents__BeeStemMessage;

const ::Ice::ObjectFactoryPtr&
RobotSimEvents::BeeStemMessage::ice_factory()
{
    return __F__RobotSimEvents__BeeStemMessage_Ptr;
}

class __F__RobotSimEvents__BeeStemMessage__Init
{
public:

    __F__RobotSimEvents__BeeStemMessage__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::RobotSimEvents::BeeStemMessage::ice_staticId(), ::RobotSimEvents::BeeStemMessage::ice_factory());
    }

    ~__F__RobotSimEvents__BeeStemMessage__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::RobotSimEvents::BeeStemMessage::ice_staticId());
    }
};

static __F__RobotSimEvents__BeeStemMessage__Init __F__RobotSimEvents__BeeStemMessage__i;

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

void
RobotSimEvents::__patch__BeeStemMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::RobotSimEvents::BeeStemMessagePtr* p = static_cast< ::RobotSimEvents::BeeStemMessagePtr*>(__addr);
    assert(p);
    *p = ::RobotSimEvents::BeeStemMessagePtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::RobotSimEvents::BeeStemMessage::ice_staticId(), v->ice_id());
    }
}

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

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

RobotSimEvents::ChatMessage::ChatMessage(const ::std::string& __ice_text, const ::std::string& __ice_from) :
    text(__ice_text),
    from(__ice_from)
{
}

::Ice::ObjectPtr
RobotSimEvents::ChatMessage::ice_clone() const
{
    ::RobotSimEvents::ChatMessagePtr __p = new ::RobotSimEvents::ChatMessage(*this);
    return __p;
}

static const ::std::string __RobotSimEvents__ChatMessage_ids[3] =
{
    "::Ice::Object",
    "::RobotSimEvents::ChatMessage",
    "::RobotSimEvents::EventMessage"
};

bool
RobotSimEvents::ChatMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__RobotSimEvents__ChatMessage_ids, __RobotSimEvents__ChatMessage_ids + 3, _s);
}

::std::vector< ::std::string>
RobotSimEvents::ChatMessage::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__RobotSimEvents__ChatMessage_ids[0], &__RobotSimEvents__ChatMessage_ids[3]);
}

const ::std::string&
RobotSimEvents::ChatMessage::ice_id(const ::Ice::Current&) const
{
    return __RobotSimEvents__ChatMessage_ids[1];
}

const ::std::string&
RobotSimEvents::ChatMessage::ice_staticId()
{
    return __RobotSimEvents__ChatMessage_ids[1];
}

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

void
RobotSimEvents::ChatMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    __is->read(text);
    __is->read(from);
    __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
RobotSimEvents::ChatMessage::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type RobotSimEvents::ChatMessage was not generated with stream support";
    throw ex;
}

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

class __F__RobotSimEvents__ChatMessage : public ::Ice::ObjectFactory
{
public:

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

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__RobotSimEvents__ChatMessage_Ptr = new __F__RobotSimEvents__ChatMessage;

const ::Ice::ObjectFactoryPtr&
RobotSimEvents::ChatMessage::ice_factory()
{
    return __F__RobotSimEvents__ChatMessage_Ptr;
}

class __F__RobotSimEvents__ChatMessage__Init
{
public:

    __F__RobotSimEvents__ChatMessage__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::RobotSimEvents::ChatMessage::ice_staticId(), ::RobotSimEvents::ChatMessage::ice_factory());
    }

    ~__F__RobotSimEvents__ChatMessage__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::RobotSimEvents::ChatMessage::ice_staticId());
    }
};

static __F__RobotSimEvents__ChatMessage__Init __F__RobotSimEvents__ChatMessage__i;

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

void
RobotSimEvents::__patch__ChatMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::RobotSimEvents::ChatMessagePtr* p = static_cast< ::RobotSimEvents::ChatMessagePtr*>(__addr);
    assert(p);
    *p = ::RobotSimEvents::ChatMessagePtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::RobotSimEvents::ChatMessage::ice_staticId(), v->ice_id());
    }
}

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

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

RobotSimEvents::RemoteControlMessage::RemoteControlMessage(::Ice::Int __ice_x, ::Ice::Int __ice_y, ::Ice::Int __ice_imgStreamId) :
    x(__ice_x),
    y(__ice_y),
    imgStreamId(__ice_imgStreamId)
{
}

::Ice::ObjectPtr
RobotSimEvents::RemoteControlMessage::ice_clone() const
{
    ::RobotSimEvents::RemoteControlMessagePtr __p = new ::RobotSimEvents::RemoteControlMessage(*this);
    return __p;
}

static const ::std::string __RobotSimEvents__RemoteControlMessage_ids[3] =
{
    "::Ice::Object",
    "::RobotSimEvents::EventMessage",
    "::RobotSimEvents::RemoteControlMessage"
};

bool
RobotSimEvents::RemoteControlMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__RobotSimEvents__RemoteControlMessage_ids, __RobotSimEvents__RemoteControlMessage_ids + 3, _s);
}

::std::vector< ::std::string>
RobotSimEvents::RemoteControlMessage::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__RobotSimEvents__RemoteControlMessage_ids[0], &__RobotSimEvents__RemoteControlMessage_ids[3]);
}

const ::std::string&
RobotSimEvents::RemoteControlMessage::ice_id(const ::Ice::Current&) const
{
    return __RobotSimEvents__RemoteControlMessage_ids[2];
}

const ::std::string&
RobotSimEvents::RemoteControlMessage::ice_staticId()
{
    return __RobotSimEvents__RemoteControlMessage_ids[2];
}

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

void
RobotSimEvents::RemoteControlMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    __is->read(x);
    __is->read(y);
    __is->read(imgStreamId);
    __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
RobotSimEvents::RemoteControlMessage::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type RobotSimEvents::RemoteControlMessage was not generated with stream support";
    throw ex;
}

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

class __F__RobotSimEvents__RemoteControlMessage : public ::Ice::ObjectFactory
{
public:

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

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__RobotSimEvents__RemoteControlMessage_Ptr = new __F__RobotSimEvents__RemoteControlMessage;

const ::Ice::ObjectFactoryPtr&
RobotSimEvents::RemoteControlMessage::ice_factory()
{
    return __F__RobotSimEvents__RemoteControlMessage_Ptr;
}

class __F__RobotSimEvents__RemoteControlMessage__Init
{
public:

    __F__RobotSimEvents__RemoteControlMessage__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::RobotSimEvents::RemoteControlMessage::ice_staticId(), ::RobotSimEvents::RemoteControlMessage::ice_factory());
    }

    ~__F__RobotSimEvents__RemoteControlMessage__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::RobotSimEvents::RemoteControlMessage::ice_staticId());
    }
};

static __F__RobotSimEvents__RemoteControlMessage__Init __F__RobotSimEvents__RemoteControlMessage__i;

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

void
RobotSimEvents::__patch__RemoteControlMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::RobotSimEvents::RemoteControlMessagePtr* p = static_cast< ::RobotSimEvents::RemoteControlMessagePtr*>(__addr);
    assert(p);
    *p = ::RobotSimEvents::RemoteControlMessagePtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::RobotSimEvents::RemoteControlMessage::ice_staticId(), v->ice_id());
    }
}

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

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

RobotSimEvents::StateMessage::StateMessage(::Ice::Float __ice_xPos, ::Ice::Float __ice_yPos, ::Ice::Float __ice_orientation) :
    xPos(__ice_xPos),
    yPos(__ice_yPos),
    orientation(__ice_orientation)
{
}

::Ice::ObjectPtr
RobotSimEvents::StateMessage::ice_clone() const
{
    ::RobotSimEvents::StateMessagePtr __p = new ::RobotSimEvents::StateMessage(*this);
    return __p;
}

static const ::std::string __RobotSimEvents__StateMessage_ids[3] =
{
    "::Ice::Object",
    "::RobotSimEvents::EventMessage",
    "::RobotSimEvents::StateMessage"
};

bool
RobotSimEvents::StateMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__RobotSimEvents__StateMessage_ids, __RobotSimEvents__StateMessage_ids + 3, _s);
}

::std::vector< ::std::string>
RobotSimEvents::StateMessage::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__RobotSimEvents__StateMessage_ids[0], &__RobotSimEvents__StateMessage_ids[3]);
}

const ::std::string&
RobotSimEvents::StateMessage::ice_id(const ::Ice::Current&) const
{
    return __RobotSimEvents__StateMessage_ids[2];
}

const ::std::string&
RobotSimEvents::StateMessage::ice_staticId()
{
    return __RobotSimEvents__StateMessage_ids[2];
}

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

void
RobotSimEvents::StateMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    __is->read(xPos);
    __is->read(yPos);
    __is->read(orientation);
    __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
RobotSimEvents::StateMessage::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type RobotSimEvents::StateMessage was not generated with stream support";
    throw ex;
}

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

class __F__RobotSimEvents__StateMessage : public ::Ice::ObjectFactory
{
public:

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

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__RobotSimEvents__StateMessage_Ptr = new __F__RobotSimEvents__StateMessage;

const ::Ice::ObjectFactoryPtr&
RobotSimEvents::StateMessage::ice_factory()
{
    return __F__RobotSimEvents__StateMessage_Ptr;
}

class __F__RobotSimEvents__StateMessage__Init
{
public:

    __F__RobotSimEvents__StateMessage__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::RobotSimEvents::StateMessage::ice_staticId(), ::RobotSimEvents::StateMessage::ice_factory());
    }

    ~__F__RobotSimEvents__StateMessage__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::RobotSimEvents::StateMessage::ice_staticId());
    }
};

static __F__RobotSimEvents__StateMessage__Init __F__RobotSimEvents__StateMessage__i;

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

void
RobotSimEvents::__patch__StateMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::RobotSimEvents::StateMessagePtr* p = static_cast< ::RobotSimEvents::StateMessagePtr*>(__addr);
    assert(p);
    *p = ::RobotSimEvents::StateMessagePtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::RobotSimEvents::StateMessage::ice_staticId(), v->ice_id());
    }
}

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

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

RobotSimEvents::GoalStateMessage::GoalStateMessage(::Ice::Float __ice_xPos, ::Ice::Float __ice_yPos, ::Ice::Float __ice_orientation) :
    xPos(__ice_xPos),
    yPos(__ice_yPos),
    orientation(__ice_orientation)
{
}

::Ice::ObjectPtr
RobotSimEvents::GoalStateMessage::ice_clone() const
{
    ::RobotSimEvents::GoalStateMessagePtr __p = new ::RobotSimEvents::GoalStateMessage(*this);
    return __p;
}

static const ::std::string __RobotSimEvents__GoalStateMessage_ids[3] =
{
    "::Ice::Object",
    "::RobotSimEvents::EventMessage",
    "::RobotSimEvents::GoalStateMessage"
};

bool
RobotSimEvents::GoalStateMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__RobotSimEvents__GoalStateMessage_ids, __RobotSimEvents__GoalStateMessage_ids + 3, _s);
}

::std::vector< ::std::string>
RobotSimEvents::GoalStateMessage::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__RobotSimEvents__GoalStateMessage_ids[0], &__RobotSimEvents__GoalStateMessage_ids[3]);
}

const ::std::string&
RobotSimEvents::GoalStateMessage::ice_id(const ::Ice::Current&) const
{
    return __RobotSimEvents__GoalStateMessage_ids[2];
}

const ::std::string&
RobotSimEvents::GoalStateMessage::ice_staticId()
{
    return __RobotSimEvents__GoalStateMessage_ids[2];
}

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

void
RobotSimEvents::GoalStateMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    __is->read(xPos);
    __is->read(yPos);
    __is->read(orientation);
    __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
RobotSimEvents::GoalStateMessage::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type RobotSimEvents::GoalStateMessage was not generated with stream support";
    throw ex;
}

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

class __F__RobotSimEvents__GoalStateMessage : public ::Ice::ObjectFactory
{
public:

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

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__RobotSimEvents__GoalStateMessage_Ptr = new __F__RobotSimEvents__GoalStateMessage;

const ::Ice::ObjectFactoryPtr&
RobotSimEvents::GoalStateMessage::ice_factory()
{
    return __F__RobotSimEvents__GoalStateMessage_Ptr;
}

class __F__RobotSimEvents__GoalStateMessage__Init
{
public:

    __F__RobotSimEvents__GoalStateMessage__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::RobotSimEvents::GoalStateMessage::ice_staticId(), ::RobotSimEvents::GoalStateMessage::ice_factory());
    }

    ~__F__RobotSimEvents__GoalStateMessage__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::RobotSimEvents::GoalStateMessage::ice_staticId());
    }
};

static __F__RobotSimEvents__GoalStateMessage__Init __F__RobotSimEvents__GoalStateMessage__i;

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

void
RobotSimEvents::__patch__GoalStateMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::RobotSimEvents::GoalStateMessagePtr* p = static_cast< ::RobotSimEvents::GoalStateMessagePtr*>(__addr);
    assert(p);
    *p = ::RobotSimEvents::GoalStateMessagePtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::RobotSimEvents::GoalStateMessage::ice_staticId(), v->ice_id());
    }
}

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

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

RobotSimEvents::GoalProgressMessage::GoalProgressMessage(::Ice::Float __ice_err) :
    err(__ice_err)
{
}

::Ice::ObjectPtr
RobotSimEvents::GoalProgressMessage::ice_clone() const
{
    ::RobotSimEvents::GoalProgressMessagePtr __p = new ::RobotSimEvents::GoalProgressMessage(*this);
    return __p;
}

static const ::std::string __RobotSimEvents__GoalProgressMessage_ids[3] =
{
    "::Ice::Object",
    "::RobotSimEvents::EventMessage",
    "::RobotSimEvents::GoalProgressMessage"
};

bool
RobotSimEvents::GoalProgressMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__RobotSimEvents__GoalProgressMessage_ids, __RobotSimEvents__GoalProgressMessage_ids + 3, _s);
}

::std::vector< ::std::string>
RobotSimEvents::GoalProgressMessage::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__RobotSimEvents__GoalProgressMessage_ids[0], &__RobotSimEvents__GoalProgressMessage_ids[3]);
}

const ::std::string&
RobotSimEvents::GoalProgressMessage::ice_id(const ::Ice::Current&) const
{
    return __RobotSimEvents__GoalProgressMessage_ids[2];
}

const ::std::string&
RobotSimEvents::GoalProgressMessage::ice_staticId()
{
    return __RobotSimEvents__GoalProgressMessage_ids[2];
}

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

void
RobotSimEvents::GoalProgressMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    __is->read(err);
    __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
RobotSimEvents::GoalProgressMessage::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type RobotSimEvents::GoalProgressMessage was not generated with stream support";
    throw ex;
}

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

class __F__RobotSimEvents__GoalProgressMessage : public ::Ice::ObjectFactory
{
public:

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

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__RobotSimEvents__GoalProgressMessage_Ptr = new __F__RobotSimEvents__GoalProgressMessage;

const ::Ice::ObjectFactoryPtr&
RobotSimEvents::GoalProgressMessage::ice_factory()
{
    return __F__RobotSimEvents__GoalProgressMessage_Ptr;
}

class __F__RobotSimEvents__GoalProgressMessage__Init
{
public:

    __F__RobotSimEvents__GoalProgressMessage__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::RobotSimEvents::GoalProgressMessage::ice_staticId(), ::RobotSimEvents::GoalProgressMessage::ice_factory());
    }

    ~__F__RobotSimEvents__GoalProgressMessage__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::RobotSimEvents::GoalProgressMessage::ice_staticId());
    }
};

static __F__RobotSimEvents__GoalProgressMessage__Init __F__RobotSimEvents__GoalProgressMessage__i;

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

void
RobotSimEvents::__patch__GoalProgressMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::RobotSimEvents::GoalProgressMessagePtr* p = static_cast< ::RobotSimEvents::GoalProgressMessagePtr*>(__addr);
    assert(p);
    *p = ::RobotSimEvents::GoalProgressMessagePtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::RobotSimEvents::GoalProgressMessage::ice_staticId(), v->ice_id());
    }
}

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

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

RobotSimEvents::AttendedRegionMessage::AttendedRegionMessage(const ::ImageIceMod::ImageIce& __ice_img, ::Ice::Int __ice_objId, const ::std::string& __ice_name, ::Ice::Float __ice_objWidth, ::Ice::Float __ice_objHeight, const ::ImageIceMod::Point2DIce& __ice_attTopLeft, ::Ice::Int __ice_attWidth, ::Ice::Int __ice_attHeight) :
    img(__ice_img),
    objId(__ice_objId),
    name(__ice_name),
    objWidth(__ice_objWidth),
    objHeight(__ice_objHeight),
    attTopLeft(__ice_attTopLeft),
    attWidth(__ice_attWidth),
    attHeight(__ice_attHeight)
{
}

::Ice::ObjectPtr
RobotSimEvents::AttendedRegionMessage::ice_clone() const
{
    ::RobotSimEvents::AttendedRegionMessagePtr __p = new ::RobotSimEvents::AttendedRegionMessage(*this);
    return __p;
}

static const ::std::string __RobotSimEvents__AttendedRegionMessage_ids[3] =
{
    "::Ice::Object",
    "::RobotSimEvents::AttendedRegionMessage",
    "::RobotSimEvents::EventMessage"
};

bool
RobotSimEvents::AttendedRegionMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__RobotSimEvents__AttendedRegionMessage_ids, __RobotSimEvents__AttendedRegionMessage_ids + 3, _s);
}

::std::vector< ::std::string>
RobotSimEvents::AttendedRegionMessage::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__RobotSimEvents__AttendedRegionMessage_ids[0], &__RobotSimEvents__AttendedRegionMessage_ids[3]);
}

const ::std::string&
RobotSimEvents::AttendedRegionMessage::ice_id(const ::Ice::Current&) const
{
    return __RobotSimEvents__AttendedRegionMessage_ids[1];
}

const ::std::string&
RobotSimEvents::AttendedRegionMessage::ice_staticId()
{
    return __RobotSimEvents__AttendedRegionMessage_ids[1];
}

void
RobotSimEvents::AttendedRegionMessage::__write(::IceInternal::BasicStream* __os) const
{
    __os->writeTypeId(ice_staticId());
    __os->startWriteSlice();
    img.__write(__os);
    __os->write(objId);
    __os->write(name);
    __os->write(objWidth);
    __os->write(objHeight);
    attTopLeft.__write(__os);
    __os->write(attWidth);
    __os->write(attHeight);
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__write(__os);
#else
    ::RobotSimEvents::EventMessage::__write(__os);
#endif
}

void
RobotSimEvents::AttendedRegionMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    img.__read(__is);
    __is->read(objId);
    __is->read(name);
    __is->read(objWidth);
    __is->read(objHeight);
    attTopLeft.__read(__is);
    __is->read(attWidth);
    __is->read(attHeight);
    __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
RobotSimEvents::AttendedRegionMessage::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type RobotSimEvents::AttendedRegionMessage was not generated with stream support";
    throw ex;
}

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

class __F__RobotSimEvents__AttendedRegionMessage : public ::Ice::ObjectFactory
{
public:

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

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__RobotSimEvents__AttendedRegionMessage_Ptr = new __F__RobotSimEvents__AttendedRegionMessage;

const ::Ice::ObjectFactoryPtr&
RobotSimEvents::AttendedRegionMessage::ice_factory()
{
    return __F__RobotSimEvents__AttendedRegionMessage_Ptr;
}

class __F__RobotSimEvents__AttendedRegionMessage__Init
{
public:

    __F__RobotSimEvents__AttendedRegionMessage__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::RobotSimEvents::AttendedRegionMessage::ice_staticId(), ::RobotSimEvents::AttendedRegionMessage::ice_factory());
    }

    ~__F__RobotSimEvents__AttendedRegionMessage__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::RobotSimEvents::AttendedRegionMessage::ice_staticId());
    }
};

static __F__RobotSimEvents__AttendedRegionMessage__Init __F__RobotSimEvents__AttendedRegionMessage__i;

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

void
RobotSimEvents::__patch__AttendedRegionMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::RobotSimEvents::AttendedRegionMessagePtr* p = static_cast< ::RobotSimEvents::AttendedRegionMessagePtr*>(__addr);
    assert(p);
    *p = ::RobotSimEvents::AttendedRegionMessagePtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::RobotSimEvents::AttendedRegionMessage::ice_staticId(), v->ice_id());
    }
}

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

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

RobotSimEvents::ObjectMessage::ObjectMessage(::Ice::Int __ice_id, const ::std::string& __ice_name, ::Ice::Float __ice_score, ::Ice::Int __ice_nKeyp, ::Ice::Float __ice_dist, const ::ImageIceMod::Point2DIce& __ice_tl, const ::ImageIceMod::Point2DIce& __ice_tr, const ::ImageIceMod::Point2DIce& __ice_br, const ::ImageIceMod::Point2DIce& __ice_bl) :
    id(__ice_id),
    name(__ice_name),
    score(__ice_score),
    nKeyp(__ice_nKeyp),
    dist(__ice_dist),
    tl(__ice_tl),
    tr(__ice_tr),
    br(__ice_br),
    bl(__ice_bl)
{
}

::Ice::ObjectPtr
RobotSimEvents::ObjectMessage::ice_clone() const
{
    ::RobotSimEvents::ObjectMessagePtr __p = new ::RobotSimEvents::ObjectMessage(*this);
    return __p;
}

static const ::std::string __RobotSimEvents__ObjectMessage_ids[3] =
{
    "::Ice::Object",
    "::RobotSimEvents::EventMessage",
    "::RobotSimEvents::ObjectMessage"
};

bool
RobotSimEvents::ObjectMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__RobotSimEvents__ObjectMessage_ids, __RobotSimEvents__ObjectMessage_ids + 3, _s);
}

::std::vector< ::std::string>
RobotSimEvents::ObjectMessage::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__RobotSimEvents__ObjectMessage_ids[0], &__RobotSimEvents__ObjectMessage_ids[3]);
}

const ::std::string&
RobotSimEvents::ObjectMessage::ice_id(const ::Ice::Current&) const
{
    return __RobotSimEvents__ObjectMessage_ids[2];
}

const ::std::string&
RobotSimEvents::ObjectMessage::ice_staticId()
{
    return __RobotSimEvents__ObjectMessage_ids[2];
}

void
RobotSimEvents::ObjectMessage::__write(::IceInternal::BasicStream* __os) const
{
    __os->writeTypeId(ice_staticId());
    __os->startWriteSlice();
    __os->write(id);
    __os->write(name);
    __os->write(score);
    __os->write(nKeyp);
    __os->write(dist);
    tl.__write(__os);
    tr.__write(__os);
    br.__write(__os);
    bl.__write(__os);
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__write(__os);
#else
    ::RobotSimEvents::EventMessage::__write(__os);
#endif
}

void
RobotSimEvents::ObjectMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    __is->read(id);
    __is->read(name);
    __is->read(score);
    __is->read(nKeyp);
    __is->read(dist);
    tl.__read(__is);
    tr.__read(__is);
    br.__read(__is);
    bl.__read(__is);
    __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
RobotSimEvents::ObjectMessage::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type RobotSimEvents::ObjectMessage was not generated with stream support";
    throw ex;
}

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

class __F__RobotSimEvents__ObjectMessage : public ::Ice::ObjectFactory
{
public:

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

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__RobotSimEvents__ObjectMessage_Ptr = new __F__RobotSimEvents__ObjectMessage;

const ::Ice::ObjectFactoryPtr&
RobotSimEvents::ObjectMessage::ice_factory()
{
    return __F__RobotSimEvents__ObjectMessage_Ptr;
}

class __F__RobotSimEvents__ObjectMessage__Init
{
public:

    __F__RobotSimEvents__ObjectMessage__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::RobotSimEvents::ObjectMessage::ice_staticId(), ::RobotSimEvents::ObjectMessage::ice_factory());
    }

    ~__F__RobotSimEvents__ObjectMessage__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::RobotSimEvents::ObjectMessage::ice_staticId());
    }
};

static __F__RobotSimEvents__ObjectMessage__Init __F__RobotSimEvents__ObjectMessage__i;

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

void
RobotSimEvents::__patch__ObjectMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::RobotSimEvents::ObjectMessagePtr* p = static_cast< ::RobotSimEvents::ObjectMessagePtr*>(__addr);
    assert(p);
    *p = ::RobotSimEvents::ObjectMessagePtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::RobotSimEvents::ObjectMessage::ice_staticId(), v->ice_id());
    }
}

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

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

RobotSimEvents::SeaBeePositionMessage::SeaBeePositionMessage(::Ice::Float __ice_x, ::Ice::Float __ice_y, ::Ice::Float __ice_orientation, ::Ice::Float __ice_xVar, ::Ice::Float __ice_yVar) :
    x(__ice_x),
    y(__ice_y),
    orientation(__ice_orientation),
    xVar(__ice_xVar),
    yVar(__ice_yVar)
{
}

::Ice::ObjectPtr
RobotSimEvents::SeaBeePositionMessage::ice_clone() const
{
    ::RobotSimEvents::SeaBeePositionMessagePtr __p = new ::RobotSimEvents::SeaBeePositionMessage(*this);
    return __p;
}

static const ::std::string __RobotSimEvents__SeaBeePositionMessage_ids[3] =
{
    "::Ice::Object",
    "::RobotSimEvents::EventMessage",
    "::RobotSimEvents::SeaBeePositionMessage"
};

bool
RobotSimEvents::SeaBeePositionMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__RobotSimEvents__SeaBeePositionMessage_ids, __RobotSimEvents__SeaBeePositionMessage_ids + 3, _s);
}

::std::vector< ::std::string>
RobotSimEvents::SeaBeePositionMessage::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__RobotSimEvents__SeaBeePositionMessage_ids[0], &__RobotSimEvents__SeaBeePositionMessage_ids[3]);
}

const ::std::string&
RobotSimEvents::SeaBeePositionMessage::ice_id(const ::Ice::Current&) const
{
    return __RobotSimEvents__SeaBeePositionMessage_ids[2];
}

const ::std::string&
RobotSimEvents::SeaBeePositionMessage::ice_staticId()
{
    return __RobotSimEvents__SeaBeePositionMessage_ids[2];
}

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

void
RobotSimEvents::SeaBeePositionMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    __is->read(x);
    __is->read(y);
    __is->read(orientation);
    __is->read(xVar);
    __is->read(yVar);
    __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
RobotSimEvents::SeaBeePositionMessage::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type RobotSimEvents::SeaBeePositionMessage was not generated with stream support";
    throw ex;
}

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

class __F__RobotSimEvents__SeaBeePositionMessage : public ::Ice::ObjectFactory
{
public:

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

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__RobotSimEvents__SeaBeePositionMessage_Ptr = new __F__RobotSimEvents__SeaBeePositionMessage;

const ::Ice::ObjectFactoryPtr&
RobotSimEvents::SeaBeePositionMessage::ice_factory()
{
    return __F__RobotSimEvents__SeaBeePositionMessage_Ptr;
}

class __F__RobotSimEvents__SeaBeePositionMessage__Init
{
public:

    __F__RobotSimEvents__SeaBeePositionMessage__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::RobotSimEvents::SeaBeePositionMessage::ice_staticId(), ::RobotSimEvents::SeaBeePositionMessage::ice_factory());
    }

    ~__F__RobotSimEvents__SeaBeePositionMessage__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::RobotSimEvents::SeaBeePositionMessage::ice_staticId());
    }
};

static __F__RobotSimEvents__SeaBeePositionMessage__Init __F__RobotSimEvents__SeaBeePositionMessage__i;

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

void
RobotSimEvents::__patch__SeaBeePositionMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::RobotSimEvents::SeaBeePositionMessagePtr* p = static_cast< ::RobotSimEvents::SeaBeePositionMessagePtr*>(__addr);
    assert(p);
    *p = ::RobotSimEvents::SeaBeePositionMessagePtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::RobotSimEvents::SeaBeePositionMessage::ice_staticId(), v->ice_id());
    }
}

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

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

RobotSimEvents::SeaBeeStateConditionMessage::SeaBeeStateConditionMessage(::Ice::Int __ice_StartOver, ::Ice::Int __ice_InitDone, ::Ice::Int __ice_GateFound, ::Ice::Int __ice_GateDone, ::Ice::Int __ice_ContourFoundFlare, ::Ice::Int __ice_FlareDone, ::Ice::Int __ice_ContourFoundBarbwire, ::Ice::Int __ice_BarbwireDone, ::Ice::Int __ice_ContourFoundBoxes, ::Ice::Int __ice_BombingRunDone, ::Ice::Int __ice_BriefcaseFound, ::Ice::Int __ice_TimeUp, ::Ice::Int __ice_PathFollowFinished) :
    StartOver(__ice_StartOver),
    InitDone(__ice_InitDone),
    GateFound(__ice_GateFound),
    GateDone(__ice_GateDone),
    ContourFoundFlare(__ice_ContourFoundFlare),
    FlareDone(__ice_FlareDone),
    ContourFoundBarbwire(__ice_ContourFoundBarbwire),
    BarbwireDone(__ice_BarbwireDone),
    ContourFoundBoxes(__ice_ContourFoundBoxes),
    BombingRunDone(__ice_BombingRunDone),
    BriefcaseFound(__ice_BriefcaseFound),
    TimeUp(__ice_TimeUp),
    PathFollowFinished(__ice_PathFollowFinished)
{
}

::Ice::ObjectPtr
RobotSimEvents::SeaBeeStateConditionMessage::ice_clone() const
{
    ::RobotSimEvents::SeaBeeStateConditionMessagePtr __p = new ::RobotSimEvents::SeaBeeStateConditionMessage(*this);
    return __p;
}

static const ::std::string __RobotSimEvents__SeaBeeStateConditionMessage_ids[3] =
{
    "::Ice::Object",
    "::RobotSimEvents::EventMessage",
    "::RobotSimEvents::SeaBeeStateConditionMessage"
};

bool
RobotSimEvents::SeaBeeStateConditionMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__RobotSimEvents__SeaBeeStateConditionMessage_ids, __RobotSimEvents__SeaBeeStateConditionMessage_ids + 3, _s);
}

::std::vector< ::std::string>
RobotSimEvents::SeaBeeStateConditionMessage::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__RobotSimEvents__SeaBeeStateConditionMessage_ids[0], &__RobotSimEvents__SeaBeeStateConditionMessage_ids[3]);
}

const ::std::string&
RobotSimEvents::SeaBeeStateConditionMessage::ice_id(const ::Ice::Current&) const
{
    return __RobotSimEvents__SeaBeeStateConditionMessage_ids[2];
}

const ::std::string&
RobotSimEvents::SeaBeeStateConditionMessage::ice_staticId()
{
    return __RobotSimEvents__SeaBeeStateConditionMessage_ids[2];
}

void
RobotSimEvents::SeaBeeStateConditionMessage::__write(::IceInternal::BasicStream* __os) const
{
    __os->writeTypeId(ice_staticId());
    __os->startWriteSlice();
    __os->write(StartOver);
    __os->write(InitDone);
    __os->write(GateFound);
    __os->write(GateDone);
    __os->write(ContourFoundFlare);
    __os->write(FlareDone);
    __os->write(ContourFoundBarbwire);
    __os->write(BarbwireDone);
    __os->write(ContourFoundBoxes);
    __os->write(BombingRunDone);
    __os->write(BriefcaseFound);
    __os->write(TimeUp);
    __os->write(PathFollowFinished);
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__write(__os);
#else
    ::RobotSimEvents::EventMessage::__write(__os);
#endif
}

void
RobotSimEvents::SeaBeeStateConditionMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    __is->read(StartOver);
    __is->read(InitDone);
    __is->read(GateFound);
    __is->read(GateDone);
    __is->read(ContourFoundFlare);
    __is->read(FlareDone);
    __is->read(ContourFoundBarbwire);
    __is->read(BarbwireDone);
    __is->read(ContourFoundBoxes);
    __is->read(BombingRunDone);
    __is->read(BriefcaseFound);
    __is->read(TimeUp);
    __is->read(PathFollowFinished);
    __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
RobotSimEvents::SeaBeeStateConditionMessage::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type RobotSimEvents::SeaBeeStateConditionMessage was not generated with stream support";
    throw ex;
}

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

class __F__RobotSimEvents__SeaBeeStateConditionMessage : public ::Ice::ObjectFactory
{
public:

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

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__RobotSimEvents__SeaBeeStateConditionMessage_Ptr = new __F__RobotSimEvents__SeaBeeStateConditionMessage;

const ::Ice::ObjectFactoryPtr&
RobotSimEvents::SeaBeeStateConditionMessage::ice_factory()
{
    return __F__RobotSimEvents__SeaBeeStateConditionMessage_Ptr;
}

class __F__RobotSimEvents__SeaBeeStateConditionMessage__Init
{
public:

    __F__RobotSimEvents__SeaBeeStateConditionMessage__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::RobotSimEvents::SeaBeeStateConditionMessage::ice_staticId(), ::RobotSimEvents::SeaBeeStateConditionMessage::ice_factory());
    }

    ~__F__RobotSimEvents__SeaBeeStateConditionMessage__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::RobotSimEvents::SeaBeeStateConditionMessage::ice_staticId());
    }
};

static __F__RobotSimEvents__SeaBeeStateConditionMessage__Init __F__RobotSimEvents__SeaBeeStateConditionMessage__i;

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

void
RobotSimEvents::__patch__SeaBeeStateConditionMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::RobotSimEvents::SeaBeeStateConditionMessagePtr* p = static_cast< ::RobotSimEvents::SeaBeeStateConditionMessagePtr*>(__addr);
    assert(p);
    *p = ::RobotSimEvents::SeaBeeStateConditionMessagePtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::RobotSimEvents::SeaBeeStateConditionMessage::ice_staticId(), v->ice_id());
    }
}

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

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

RobotSimEvents::VisionRectangleMessage::VisionRectangleMessage(const ::RobotSimEvents::QuadrilateralIceVector& __ice_quads, bool __ice_isFwdCamera) :
    quads(__ice_quads),
    isFwdCamera(__ice_isFwdCamera)
{
}

::Ice::ObjectPtr
RobotSimEvents::VisionRectangleMessage::ice_clone() const
{
    ::RobotSimEvents::VisionRectangleMessagePtr __p = new ::RobotSimEvents::VisionRectangleMessage(*this);
    return __p;
}

static const ::std::string __RobotSimEvents__VisionRectangleMessage_ids[3] =
{
    "::Ice::Object",
    "::RobotSimEvents::EventMessage",
    "::RobotSimEvents::VisionRectangleMessage"
};

bool
RobotSimEvents::VisionRectangleMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__RobotSimEvents__VisionRectangleMessage_ids, __RobotSimEvents__VisionRectangleMessage_ids + 3, _s);
}

::std::vector< ::std::string>
RobotSimEvents::VisionRectangleMessage::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__RobotSimEvents__VisionRectangleMessage_ids[0], &__RobotSimEvents__VisionRectangleMessage_ids[3]);
}

const ::std::string&
RobotSimEvents::VisionRectangleMessage::ice_id(const ::Ice::Current&) const
{
    return __RobotSimEvents__VisionRectangleMessage_ids[2];
}

const ::std::string&
RobotSimEvents::VisionRectangleMessage::ice_staticId()
{
    return __RobotSimEvents__VisionRectangleMessage_ids[2];
}

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

void
RobotSimEvents::VisionRectangleMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    ::RobotSimEvents::__readQuadrilateralIceVector(__is, quads);
    __is->read(isFwdCamera);
    __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
RobotSimEvents::VisionRectangleMessage::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type RobotSimEvents::VisionRectangleMessage was not generated with stream support";
    throw ex;
}

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

class __F__RobotSimEvents__VisionRectangleMessage : public ::Ice::ObjectFactory
{
public:

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

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__RobotSimEvents__VisionRectangleMessage_Ptr = new __F__RobotSimEvents__VisionRectangleMessage;

const ::Ice::ObjectFactoryPtr&
RobotSimEvents::VisionRectangleMessage::ice_factory()
{
    return __F__RobotSimEvents__VisionRectangleMessage_Ptr;
}

class __F__RobotSimEvents__VisionRectangleMessage__Init
{
public:

    __F__RobotSimEvents__VisionRectangleMessage__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::RobotSimEvents::VisionRectangleMessage::ice_staticId(), ::RobotSimEvents::VisionRectangleMessage::ice_factory());
    }

    ~__F__RobotSimEvents__VisionRectangleMessage__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::RobotSimEvents::VisionRectangleMessage::ice_staticId());
    }
};

static __F__RobotSimEvents__VisionRectangleMessage__Init __F__RobotSimEvents__VisionRectangleMessage__i;

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

void
RobotSimEvents::__patch__VisionRectangleMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::RobotSimEvents::VisionRectangleMessagePtr* p = static_cast< ::RobotSimEvents::VisionRectangleMessagePtr*>(__addr);
    assert(p);
    *p = ::RobotSimEvents::VisionRectangleMessagePtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::RobotSimEvents::VisionRectangleMessage::ice_staticId(), v->ice_id());
    }
}

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

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

RobotSimEvents::StraightEdgeMessage::StraightEdgeMessage(const ::ImageIceMod::LineIce& __ice_line, bool __ice_isFwdCamera) :
    line(__ice_line),
    isFwdCamera(__ice_isFwdCamera)
{
}

::Ice::ObjectPtr
RobotSimEvents::StraightEdgeMessage::ice_clone() const
{
    ::RobotSimEvents::StraightEdgeMessagePtr __p = new ::RobotSimEvents::StraightEdgeMessage(*this);
    return __p;
}

static const ::std::string __RobotSimEvents__StraightEdgeMessage_ids[3] =
{
    "::Ice::Object",
    "::RobotSimEvents::EventMessage",
    "::RobotSimEvents::StraightEdgeMessage"
};

bool
RobotSimEvents::StraightEdgeMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__RobotSimEvents__StraightEdgeMessage_ids, __RobotSimEvents__StraightEdgeMessage_ids + 3, _s);
}

::std::vector< ::std::string>
RobotSimEvents::StraightEdgeMessage::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__RobotSimEvents__StraightEdgeMessage_ids[0], &__RobotSimEvents__StraightEdgeMessage_ids[3]);
}

const ::std::string&
RobotSimEvents::StraightEdgeMessage::ice_id(const ::Ice::Current&) const
{
    return __RobotSimEvents__StraightEdgeMessage_ids[2];
}

const ::std::string&
RobotSimEvents::StraightEdgeMessage::ice_staticId()
{
    return __RobotSimEvents__StraightEdgeMessage_ids[2];
}

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

void
RobotSimEvents::StraightEdgeMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    line.__read(__is);
    __is->read(isFwdCamera);
    __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
RobotSimEvents::StraightEdgeMessage::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type RobotSimEvents::StraightEdgeMessage was not generated with stream support";
    throw ex;
}

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

class __F__RobotSimEvents__StraightEdgeMessage : public ::Ice::ObjectFactory
{
public:

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

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__RobotSimEvents__StraightEdgeMessage_Ptr = new __F__RobotSimEvents__StraightEdgeMessage;

const ::Ice::ObjectFactoryPtr&
RobotSimEvents::StraightEdgeMessage::ice_factory()
{
    return __F__RobotSimEvents__StraightEdgeMessage_Ptr;
}

class __F__RobotSimEvents__StraightEdgeMessage__Init
{
public:

    __F__RobotSimEvents__StraightEdgeMessage__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::RobotSimEvents::StraightEdgeMessage::ice_staticId(), ::RobotSimEvents::StraightEdgeMessage::ice_factory());
    }

    ~__F__RobotSimEvents__StraightEdgeMessage__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::RobotSimEvents::StraightEdgeMessage::ice_staticId());
    }
};

static __F__RobotSimEvents__StraightEdgeMessage__Init __F__RobotSimEvents__StraightEdgeMessage__i;

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

void
RobotSimEvents::__patch__StraightEdgeMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::RobotSimEvents::StraightEdgeMessagePtr* p = static_cast< ::RobotSimEvents::StraightEdgeMessagePtr*>(__addr);
    assert(p);
    *p = ::RobotSimEvents::StraightEdgeMessagePtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::RobotSimEvents::StraightEdgeMessage::ice_staticId(), v->ice_id());
    }
}

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

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

RobotSimEvents::VisionObjectMessage::VisionObjectMessage(::RobotSimEvents::SeaBeeObjectType __ice_objectType, bool __ice_forwardCamera, const ::ImageIceMod::Point3DIce& __ice_objectPosition, const ::ImageIceMod::Point3DIce& __ice_objectVariance) :
    objectType(__ice_objectType),
    forwardCamera(__ice_forwardCamera),
    objectPosition(__ice_objectPosition),
    objectVariance(__ice_objectVariance)
{
}

::Ice::ObjectPtr
RobotSimEvents::VisionObjectMessage::ice_clone() const
{
    ::RobotSimEvents::VisionObjectMessagePtr __p = new ::RobotSimEvents::VisionObjectMessage(*this);
    return __p;
}

static const ::std::string __RobotSimEvents__VisionObjectMessage_ids[3] =
{
    "::Ice::Object",
    "::RobotSimEvents::EventMessage",
    "::RobotSimEvents::VisionObjectMessage"
};

bool
RobotSimEvents::VisionObjectMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__RobotSimEvents__VisionObjectMessage_ids, __RobotSimEvents__VisionObjectMessage_ids + 3, _s);
}

::std::vector< ::std::string>
RobotSimEvents::VisionObjectMessage::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__RobotSimEvents__VisionObjectMessage_ids[0], &__RobotSimEvents__VisionObjectMessage_ids[3]);
}

const ::std::string&
RobotSimEvents::VisionObjectMessage::ice_id(const ::Ice::Current&) const
{
    return __RobotSimEvents__VisionObjectMessage_ids[2];
}

const ::std::string&
RobotSimEvents::VisionObjectMessage::ice_staticId()
{
    return __RobotSimEvents__VisionObjectMessage_ids[2];
}

void
RobotSimEvents::VisionObjectMessage::__write(::IceInternal::BasicStream* __os) const
{
    __os->writeTypeId(ice_staticId());
    __os->startWriteSlice();
    ::RobotSimEvents::__write(__os, objectType);
    __os->write(forwardCamera);
    objectPosition.__write(__os);
    objectVariance.__write(__os);
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__write(__os);
#else
    ::RobotSimEvents::EventMessage::__write(__os);
#endif
}

void
RobotSimEvents::VisionObjectMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    ::RobotSimEvents::__read(__is, objectType);
    __is->read(forwardCamera);
    objectPosition.__read(__is);
    objectVariance.__read(__is);
    __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
RobotSimEvents::VisionObjectMessage::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type RobotSimEvents::VisionObjectMessage was not generated with stream support";
    throw ex;
}

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

class __F__RobotSimEvents__VisionObjectMessage : public ::Ice::ObjectFactory
{
public:

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

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__RobotSimEvents__VisionObjectMessage_Ptr = new __F__RobotSimEvents__VisionObjectMessage;

const ::Ice::ObjectFactoryPtr&
RobotSimEvents::VisionObjectMessage::ice_factory()
{
    return __F__RobotSimEvents__VisionObjectMessage_Ptr;
}

class __F__RobotSimEvents__VisionObjectMessage__Init
{
public:

    __F__RobotSimEvents__VisionObjectMessage__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::RobotSimEvents::VisionObjectMessage::ice_staticId(), ::RobotSimEvents::VisionObjectMessage::ice_factory());
    }

    ~__F__RobotSimEvents__VisionObjectMessage__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::RobotSimEvents::VisionObjectMessage::ice_staticId());
    }
};

static __F__RobotSimEvents__VisionObjectMessage__Init __F__RobotSimEvents__VisionObjectMessage__i;

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

void
RobotSimEvents::__patch__VisionObjectMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::RobotSimEvents::VisionObjectMessagePtr* p = static_cast< ::RobotSimEvents::VisionObjectMessagePtr*>(__addr);
    assert(p);
    *p = ::RobotSimEvents::VisionObjectMessagePtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::RobotSimEvents::VisionObjectMessage::ice_staticId(), v->ice_id());
    }
}

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

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

RobotSimEvents::LandmarksMessage::LandmarksMessage(const ::RobotSimEvents::LandmarksInfo& __ice_landmarks) :
    landmarks(__ice_landmarks)
{
}

::Ice::ObjectPtr
RobotSimEvents::LandmarksMessage::ice_clone() const
{
    ::RobotSimEvents::LandmarksMessagePtr __p = new ::RobotSimEvents::LandmarksMessage(*this);
    return __p;
}

static const ::std::string __RobotSimEvents__LandmarksMessage_ids[3] =
{
    "::Ice::Object",
    "::RobotSimEvents::EventMessage",
    "::RobotSimEvents::LandmarksMessage"
};

bool
RobotSimEvents::LandmarksMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__RobotSimEvents__LandmarksMessage_ids, __RobotSimEvents__LandmarksMessage_ids + 3, _s);
}

::std::vector< ::std::string>
RobotSimEvents::LandmarksMessage::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__RobotSimEvents__LandmarksMessage_ids[0], &__RobotSimEvents__LandmarksMessage_ids[3]);
}

const ::std::string&
RobotSimEvents::LandmarksMessage::ice_id(const ::Ice::Current&) const
{
    return __RobotSimEvents__LandmarksMessage_ids[2];
}

const ::std::string&
RobotSimEvents::LandmarksMessage::ice_staticId()
{
    return __RobotSimEvents__LandmarksMessage_ids[2];
}

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

void
RobotSimEvents::LandmarksMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    ::RobotSimEvents::__readLandmarksInfo(__is, landmarks);
    __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
RobotSimEvents::LandmarksMessage::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type RobotSimEvents::LandmarksMessage was not generated with stream support";
    throw ex;
}

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

class __F__RobotSimEvents__LandmarksMessage : public ::Ice::ObjectFactory
{
public:

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

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__RobotSimEvents__LandmarksMessage_Ptr = new __F__RobotSimEvents__LandmarksMessage;

const ::Ice::ObjectFactoryPtr&
RobotSimEvents::LandmarksMessage::ice_factory()
{
    return __F__RobotSimEvents__LandmarksMessage_Ptr;
}

class __F__RobotSimEvents__LandmarksMessage__Init
{
public:

    __F__RobotSimEvents__LandmarksMessage__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::RobotSimEvents::LandmarksMessage::ice_staticId(), ::RobotSimEvents::LandmarksMessage::ice_factory());
    }

    ~__F__RobotSimEvents__LandmarksMessage__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::RobotSimEvents::LandmarksMessage::ice_staticId());
    }
};

static __F__RobotSimEvents__LandmarksMessage__Init __F__RobotSimEvents__LandmarksMessage__i;

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

void
RobotSimEvents::__patch__LandmarksMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::RobotSimEvents::LandmarksMessagePtr* p = static_cast< ::RobotSimEvents::LandmarksMessagePtr*>(__addr);
    assert(p);
    *p = ::RobotSimEvents::LandmarksMessagePtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::RobotSimEvents::LandmarksMessage::ice_staticId(), v->ice_id());
    }
}

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

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

RobotSimEvents::CameraConfigMessage::CameraConfigMessage(const ::std::string& __ice_cameraID, bool __ice_active) :
    cameraID(__ice_cameraID),
    active(__ice_active)
{
}

::Ice::ObjectPtr
RobotSimEvents::CameraConfigMessage::ice_clone() const
{
    ::RobotSimEvents::CameraConfigMessagePtr __p = new ::RobotSimEvents::CameraConfigMessage(*this);
    return __p;
}

static const ::std::string __RobotSimEvents__CameraConfigMessage_ids[3] =
{
    "::Ice::Object",
    "::RobotSimEvents::CameraConfigMessage",
    "::RobotSimEvents::EventMessage"
};

bool
RobotSimEvents::CameraConfigMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__RobotSimEvents__CameraConfigMessage_ids, __RobotSimEvents__CameraConfigMessage_ids + 3, _s);
}

::std::vector< ::std::string>
RobotSimEvents::CameraConfigMessage::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__RobotSimEvents__CameraConfigMessage_ids[0], &__RobotSimEvents__CameraConfigMessage_ids[3]);
}

const ::std::string&
RobotSimEvents::CameraConfigMessage::ice_id(const ::Ice::Current&) const
{
    return __RobotSimEvents__CameraConfigMessage_ids[1];
}

const ::std::string&
RobotSimEvents::CameraConfigMessage::ice_staticId()
{
    return __RobotSimEvents__CameraConfigMessage_ids[1];
}

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

void
RobotSimEvents::CameraConfigMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    __is->read(cameraID);
    __is->read(active);
    __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
RobotSimEvents::CameraConfigMessage::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type RobotSimEvents::CameraConfigMessage was not generated with stream support";
    throw ex;
}

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

class __F__RobotSimEvents__CameraConfigMessage : public ::Ice::ObjectFactory
{
public:

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

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__RobotSimEvents__CameraConfigMessage_Ptr = new __F__RobotSimEvents__CameraConfigMessage;

const ::Ice::ObjectFactoryPtr&
RobotSimEvents::CameraConfigMessage::ice_factory()
{
    return __F__RobotSimEvents__CameraConfigMessage_Ptr;
}

class __F__RobotSimEvents__CameraConfigMessage__Init
{
public:

    __F__RobotSimEvents__CameraConfigMessage__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::RobotSimEvents::CameraConfigMessage::ice_staticId(), ::RobotSimEvents::CameraConfigMessage::ice_factory());
    }

    ~__F__RobotSimEvents__CameraConfigMessage__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::RobotSimEvents::CameraConfigMessage::ice_staticId());
    }
};

static __F__RobotSimEvents__CameraConfigMessage__Init __F__RobotSimEvents__CameraConfigMessage__i;

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

void
RobotSimEvents::__patch__CameraConfigMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::RobotSimEvents::CameraConfigMessagePtr* p = static_cast< ::RobotSimEvents::CameraConfigMessagePtr*>(__addr);
    assert(p);
    *p = ::RobotSimEvents::CameraConfigMessagePtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::RobotSimEvents::CameraConfigMessage::ice_staticId(), v->ice_id());
    }
}

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

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

RobotSimEvents::SalientPointMessage::SalientPointMessage(::Ice::Float __ice_x, ::Ice::Float __ice_y, ::Ice::Int __ice_saliency, const ::std::string& __ice_imageDescr) :
    x(__ice_x),
    y(__ice_y),
    saliency(__ice_saliency),
    imageDescr(__ice_imageDescr)
{
}

::Ice::ObjectPtr
RobotSimEvents::SalientPointMessage::ice_clone() const
{
    ::RobotSimEvents::SalientPointMessagePtr __p = new ::RobotSimEvents::SalientPointMessage(*this);
    return __p;
}

static const ::std::string __RobotSimEvents__SalientPointMessage_ids[3] =
{
    "::Ice::Object",
    "::RobotSimEvents::EventMessage",
    "::RobotSimEvents::SalientPointMessage"
};

bool
RobotSimEvents::SalientPointMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__RobotSimEvents__SalientPointMessage_ids, __RobotSimEvents__SalientPointMessage_ids + 3, _s);
}

::std::vector< ::std::string>
RobotSimEvents::SalientPointMessage::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__RobotSimEvents__SalientPointMessage_ids[0], &__RobotSimEvents__SalientPointMessage_ids[3]);
}

const ::std::string&
RobotSimEvents::SalientPointMessage::ice_id(const ::Ice::Current&) const
{
    return __RobotSimEvents__SalientPointMessage_ids[2];
}

const ::std::string&
RobotSimEvents::SalientPointMessage::ice_staticId()
{
    return __RobotSimEvents__SalientPointMessage_ids[2];
}

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

void
RobotSimEvents::SalientPointMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    __is->read(x);
    __is->read(y);
    __is->read(saliency);
    __is->read(imageDescr);
    __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
RobotSimEvents::SalientPointMessage::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type RobotSimEvents::SalientPointMessage was not generated with stream support";
    throw ex;
}

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

class __F__RobotSimEvents__SalientPointMessage : public ::Ice::ObjectFactory
{
public:

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

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__RobotSimEvents__SalientPointMessage_Ptr = new __F__RobotSimEvents__SalientPointMessage;

const ::Ice::ObjectFactoryPtr&
RobotSimEvents::SalientPointMessage::ice_factory()
{
    return __F__RobotSimEvents__SalientPointMessage_Ptr;
}

class __F__RobotSimEvents__SalientPointMessage__Init
{
public:

    __F__RobotSimEvents__SalientPointMessage__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::RobotSimEvents::SalientPointMessage::ice_staticId(), ::RobotSimEvents::SalientPointMessage::ice_factory());
    }

    ~__F__RobotSimEvents__SalientPointMessage__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::RobotSimEvents::SalientPointMessage::ice_staticId());
    }
};

static __F__RobotSimEvents__SalientPointMessage__Init __F__RobotSimEvents__SalientPointMessage__i;

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

void
RobotSimEvents::__patch__SalientPointMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::RobotSimEvents::SalientPointMessagePtr* p = static_cast< ::RobotSimEvents::SalientPointMessagePtr*>(__addr);
    assert(p);
    *p = ::RobotSimEvents::SalientPointMessagePtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::RobotSimEvents::SalientPointMessage::ice_staticId(), v->ice_id());
    }
}

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

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

RobotSimEvents::BuoyColorSegmentMessage::BuoyColorSegmentMessage(::Ice::Float __ice_x, ::Ice::Float __ice_y, ::Ice::Float __ice_size) :
    x(__ice_x),
    y(__ice_y),
    size(__ice_size)
{
}

::Ice::ObjectPtr
RobotSimEvents::BuoyColorSegmentMessage::ice_clone() const
{
    ::RobotSimEvents::BuoyColorSegmentMessagePtr __p = new ::RobotSimEvents::BuoyColorSegmentMessage(*this);
    return __p;
}

static const ::std::string __RobotSimEvents__BuoyColorSegmentMessage_ids[3] =
{
    "::Ice::Object",
    "::RobotSimEvents::BuoyColorSegmentMessage",
    "::RobotSimEvents::EventMessage"
};

bool
RobotSimEvents::BuoyColorSegmentMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__RobotSimEvents__BuoyColorSegmentMessage_ids, __RobotSimEvents__BuoyColorSegmentMessage_ids + 3, _s);
}

::std::vector< ::std::string>
RobotSimEvents::BuoyColorSegmentMessage::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__RobotSimEvents__BuoyColorSegmentMessage_ids[0], &__RobotSimEvents__BuoyColorSegmentMessage_ids[3]);
}

const ::std::string&
RobotSimEvents::BuoyColorSegmentMessage::ice_id(const ::Ice::Current&) const
{
    return __RobotSimEvents__BuoyColorSegmentMessage_ids[1];
}

const ::std::string&
RobotSimEvents::BuoyColorSegmentMessage::ice_staticId()
{
    return __RobotSimEvents__BuoyColorSegmentMessage_ids[1];
}

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

void
RobotSimEvents::BuoyColorSegmentMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    __is->read(x);
    __is->read(y);
    __is->read(size);
    __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
RobotSimEvents::BuoyColorSegmentMessage::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type RobotSimEvents::BuoyColorSegmentMessage was not generated with stream support";
    throw ex;
}

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

class __F__RobotSimEvents__BuoyColorSegmentMessage : public ::Ice::ObjectFactory
{
public:

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

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__RobotSimEvents__BuoyColorSegmentMessage_Ptr = new __F__RobotSimEvents__BuoyColorSegmentMessage;

const ::Ice::ObjectFactoryPtr&
RobotSimEvents::BuoyColorSegmentMessage::ice_factory()
{
    return __F__RobotSimEvents__BuoyColorSegmentMessage_Ptr;
}

class __F__RobotSimEvents__BuoyColorSegmentMessage__Init
{
public:

    __F__RobotSimEvents__BuoyColorSegmentMessage__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::RobotSimEvents::BuoyColorSegmentMessage::ice_staticId(), ::RobotSimEvents::BuoyColorSegmentMessage::ice_factory());
    }

    ~__F__RobotSimEvents__BuoyColorSegmentMessage__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::RobotSimEvents::BuoyColorSegmentMessage::ice_staticId());
    }
};

static __F__RobotSimEvents__BuoyColorSegmentMessage__Init __F__RobotSimEvents__BuoyColorSegmentMessage__i;

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

void
RobotSimEvents::__patch__BuoyColorSegmentMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::RobotSimEvents::BuoyColorSegmentMessagePtr* p = static_cast< ::RobotSimEvents::BuoyColorSegmentMessagePtr*>(__addr);
    assert(p);
    *p = ::RobotSimEvents::BuoyColorSegmentMessagePtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::RobotSimEvents::BuoyColorSegmentMessage::ice_staticId(), v->ice_id());
    }
}

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

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

RobotSimEvents::PipeColorSegmentMessage::PipeColorSegmentMessage(::Ice::Float __ice_x, ::Ice::Float __ice_y, ::Ice::Float __ice_size) :
    x(__ice_x),
    y(__ice_y),
    size(__ice_size)
{
}

::Ice::ObjectPtr
RobotSimEvents::PipeColorSegmentMessage::ice_clone() const
{
    ::RobotSimEvents::PipeColorSegmentMessagePtr __p = new ::RobotSimEvents::PipeColorSegmentMessage(*this);
    return __p;
}

static const ::std::string __RobotSimEvents__PipeColorSegmentMessage_ids[3] =
{
    "::Ice::Object",
    "::RobotSimEvents::EventMessage",
    "::RobotSimEvents::PipeColorSegmentMessage"
};

bool
RobotSimEvents::PipeColorSegmentMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__RobotSimEvents__PipeColorSegmentMessage_ids, __RobotSimEvents__PipeColorSegmentMessage_ids + 3, _s);
}

::std::vector< ::std::string>
RobotSimEvents::PipeColorSegmentMessage::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__RobotSimEvents__PipeColorSegmentMessage_ids[0], &__RobotSimEvents__PipeColorSegmentMessage_ids[3]);
}

const ::std::string&
RobotSimEvents::PipeColorSegmentMessage::ice_id(const ::Ice::Current&) const
{
    return __RobotSimEvents__PipeColorSegmentMessage_ids[2];
}

const ::std::string&
RobotSimEvents::PipeColorSegmentMessage::ice_staticId()
{
    return __RobotSimEvents__PipeColorSegmentMessage_ids[2];
}

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

void
RobotSimEvents::PipeColorSegmentMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    __is->read(x);
    __is->read(y);
    __is->read(size);
    __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
RobotSimEvents::PipeColorSegmentMessage::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type RobotSimEvents::PipeColorSegmentMessage was not generated with stream support";
    throw ex;
}

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

class __F__RobotSimEvents__PipeColorSegmentMessage : public ::Ice::ObjectFactory
{
public:

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

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__RobotSimEvents__PipeColorSegmentMessage_Ptr = new __F__RobotSimEvents__PipeColorSegmentMessage;

const ::Ice::ObjectFactoryPtr&
RobotSimEvents::PipeColorSegmentMessage::ice_factory()
{
    return __F__RobotSimEvents__PipeColorSegmentMessage_Ptr;
}

class __F__RobotSimEvents__PipeColorSegmentMessage__Init
{
public:

    __F__RobotSimEvents__PipeColorSegmentMessage__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::RobotSimEvents::PipeColorSegmentMessage::ice_staticId(), ::RobotSimEvents::PipeColorSegmentMessage::ice_factory());
    }

    ~__F__RobotSimEvents__PipeColorSegmentMessage__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::RobotSimEvents::PipeColorSegmentMessage::ice_staticId());
    }
};

static __F__RobotSimEvents__PipeColorSegmentMessage__Init __F__RobotSimEvents__PipeColorSegmentMessage__i;

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

void
RobotSimEvents::__patch__PipeColorSegmentMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::RobotSimEvents::PipeColorSegmentMessagePtr* p = static_cast< ::RobotSimEvents::PipeColorSegmentMessagePtr*>(__addr);
    assert(p);
    *p = ::RobotSimEvents::PipeColorSegmentMessagePtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::RobotSimEvents::PipeColorSegmentMessage::ice_staticId(), v->ice_id());
    }
}

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

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

RobotSimEvents::BuoyColorSegmentConfigMessage::BuoyColorSegmentConfigMessage(::Ice::Double __ice_HUT, ::Ice::Double __ice_HLT, ::Ice::Double __ice_SUT, ::Ice::Double __ice_SLT, ::Ice::Double __ice_VUT, ::Ice::Double __ice_VLT) :
    HUT(__ice_HUT),
    HLT(__ice_HLT),
    SUT(__ice_SUT),
    SLT(__ice_SLT),
    VUT(__ice_VUT),
    VLT(__ice_VLT)
{
}

::Ice::ObjectPtr
RobotSimEvents::BuoyColorSegmentConfigMessage::ice_clone() const
{
    ::RobotSimEvents::BuoyColorSegmentConfigMessagePtr __p = new ::RobotSimEvents::BuoyColorSegmentConfigMessage(*this);
    return __p;
}

static const ::std::string __RobotSimEvents__BuoyColorSegmentConfigMessage_ids[3] =
{
    "::Ice::Object",
    "::RobotSimEvents::BuoyColorSegmentConfigMessage",
    "::RobotSimEvents::EventMessage"
};

bool
RobotSimEvents::BuoyColorSegmentConfigMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__RobotSimEvents__BuoyColorSegmentConfigMessage_ids, __RobotSimEvents__BuoyColorSegmentConfigMessage_ids + 3, _s);
}

::std::vector< ::std::string>
RobotSimEvents::BuoyColorSegmentConfigMessage::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__RobotSimEvents__BuoyColorSegmentConfigMessage_ids[0], &__RobotSimEvents__BuoyColorSegmentConfigMessage_ids[3]);
}

const ::std::string&
RobotSimEvents::BuoyColorSegmentConfigMessage::ice_id(const ::Ice::Current&) const
{
    return __RobotSimEvents__BuoyColorSegmentConfigMessage_ids[1];
}

const ::std::string&
RobotSimEvents::BuoyColorSegmentConfigMessage::ice_staticId()
{
    return __RobotSimEvents__BuoyColorSegmentConfigMessage_ids[1];
}

void
RobotSimEvents::BuoyColorSegmentConfigMessage::__write(::IceInternal::BasicStream* __os) const
{
    __os->writeTypeId(ice_staticId());
    __os->startWriteSlice();
    __os->write(HUT);
    __os->write(HLT);
    __os->write(SUT);
    __os->write(SLT);
    __os->write(VUT);
    __os->write(VLT);
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__write(__os);
#else
    ::RobotSimEvents::EventMessage::__write(__os);
#endif
}

void
RobotSimEvents::BuoyColorSegmentConfigMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    __is->read(HUT);
    __is->read(HLT);
    __is->read(SUT);
    __is->read(SLT);
    __is->read(VUT);
    __is->read(VLT);
    __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
RobotSimEvents::BuoyColorSegmentConfigMessage::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type RobotSimEvents::BuoyColorSegmentConfigMessage was not generated with stream support";
    throw ex;
}

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

class __F__RobotSimEvents__BuoyColorSegmentConfigMessage : public ::Ice::ObjectFactory
{
public:

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

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__RobotSimEvents__BuoyColorSegmentConfigMessage_Ptr = new __F__RobotSimEvents__BuoyColorSegmentConfigMessage;

const ::Ice::ObjectFactoryPtr&
RobotSimEvents::BuoyColorSegmentConfigMessage::ice_factory()
{
    return __F__RobotSimEvents__BuoyColorSegmentConfigMessage_Ptr;
}

class __F__RobotSimEvents__BuoyColorSegmentConfigMessage__Init
{
public:

    __F__RobotSimEvents__BuoyColorSegmentConfigMessage__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::RobotSimEvents::BuoyColorSegmentConfigMessage::ice_staticId(), ::RobotSimEvents::BuoyColorSegmentConfigMessage::ice_factory());
    }

    ~__F__RobotSimEvents__BuoyColorSegmentConfigMessage__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::RobotSimEvents::BuoyColorSegmentConfigMessage::ice_staticId());
    }
};

static __F__RobotSimEvents__BuoyColorSegmentConfigMessage__Init __F__RobotSimEvents__BuoyColorSegmentConfigMessage__i;

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

void
RobotSimEvents::__patch__BuoyColorSegmentConfigMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::RobotSimEvents::BuoyColorSegmentConfigMessagePtr* p = static_cast< ::RobotSimEvents::BuoyColorSegmentConfigMessagePtr*>(__addr);
    assert(p);
    *p = ::RobotSimEvents::BuoyColorSegmentConfigMessagePtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::RobotSimEvents::BuoyColorSegmentConfigMessage::ice_staticId(), v->ice_id());
    }
}

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

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

RobotSimEvents::PipeColorSegmentConfigMessage::PipeColorSegmentConfigMessage(::Ice::Double __ice_HUT, ::Ice::Double __ice_HLT, ::Ice::Double __ice_SUT, ::Ice::Double __ice_SLT, ::Ice::Double __ice_VUT, ::Ice::Double __ice_VLT) :
    HUT(__ice_HUT),
    HLT(__ice_HLT),
    SUT(__ice_SUT),
    SLT(__ice_SLT),
    VUT(__ice_VUT),
    VLT(__ice_VLT)
{
}

::Ice::ObjectPtr
RobotSimEvents::PipeColorSegmentConfigMessage::ice_clone() const
{
    ::RobotSimEvents::PipeColorSegmentConfigMessagePtr __p = new ::RobotSimEvents::PipeColorSegmentConfigMessage(*this);
    return __p;
}

static const ::std::string __RobotSimEvents__PipeColorSegmentConfigMessage_ids[3] =
{
    "::Ice::Object",
    "::RobotSimEvents::EventMessage",
    "::RobotSimEvents::PipeColorSegmentConfigMessage"
};

bool
RobotSimEvents::PipeColorSegmentConfigMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__RobotSimEvents__PipeColorSegmentConfigMessage_ids, __RobotSimEvents__PipeColorSegmentConfigMessage_ids + 3, _s);
}

::std::vector< ::std::string>
RobotSimEvents::PipeColorSegmentConfigMessage::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__RobotSimEvents__PipeColorSegmentConfigMessage_ids[0], &__RobotSimEvents__PipeColorSegmentConfigMessage_ids[3]);
}

const ::std::string&
RobotSimEvents::PipeColorSegmentConfigMessage::ice_id(const ::Ice::Current&) const
{
    return __RobotSimEvents__PipeColorSegmentConfigMessage_ids[2];
}

const ::std::string&
RobotSimEvents::PipeColorSegmentConfigMessage::ice_staticId()
{
    return __RobotSimEvents__PipeColorSegmentConfigMessage_ids[2];
}

void
RobotSimEvents::PipeColorSegmentConfigMessage::__write(::IceInternal::BasicStream* __os) const
{
    __os->writeTypeId(ice_staticId());
    __os->startWriteSlice();
    __os->write(HUT);
    __os->write(HLT);
    __os->write(SUT);
    __os->write(SLT);
    __os->write(VUT);
    __os->write(VLT);
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__write(__os);
#else
    ::RobotSimEvents::EventMessage::__write(__os);
#endif
}

void
RobotSimEvents::PipeColorSegmentConfigMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    __is->read(HUT);
    __is->read(HLT);
    __is->read(SUT);
    __is->read(SLT);
    __is->read(VUT);
    __is->read(VLT);
    __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
RobotSimEvents::PipeColorSegmentConfigMessage::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type RobotSimEvents::PipeColorSegmentConfigMessage was not generated with stream support";
    throw ex;
}

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

class __F__RobotSimEvents__PipeColorSegmentConfigMessage : public ::Ice::ObjectFactory
{
public:

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

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__RobotSimEvents__PipeColorSegmentConfigMessage_Ptr = new __F__RobotSimEvents__PipeColorSegmentConfigMessage;

const ::Ice::ObjectFactoryPtr&
RobotSimEvents::PipeColorSegmentConfigMessage::ice_factory()
{
    return __F__RobotSimEvents__PipeColorSegmentConfigMessage_Ptr;
}

class __F__RobotSimEvents__PipeColorSegmentConfigMessage__Init
{
public:

    __F__RobotSimEvents__PipeColorSegmentConfigMessage__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::RobotSimEvents::PipeColorSegmentConfigMessage::ice_staticId(), ::RobotSimEvents::PipeColorSegmentConfigMessage::ice_factory());
    }

    ~__F__RobotSimEvents__PipeColorSegmentConfigMessage__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::RobotSimEvents::PipeColorSegmentConfigMessage::ice_staticId());
    }
};

static __F__RobotSimEvents__PipeColorSegmentConfigMessage__Init __F__RobotSimEvents__PipeColorSegmentConfigMessage__i;

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

void
RobotSimEvents::__patch__PipeColorSegmentConfigMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::RobotSimEvents::PipeColorSegmentConfigMessagePtr* p = static_cast< ::RobotSimEvents::PipeColorSegmentConfigMessagePtr*>(__addr);
    assert(p);
    *p = ::RobotSimEvents::PipeColorSegmentConfigMessagePtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::RobotSimEvents::PipeColorSegmentConfigMessage::ice_staticId(), v->ice_id());
    }
}

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

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