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

#include <Gumbot.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 __Robots__Gumbot__getSpeed_name = "getSpeed";

static const ::std::string __Robots__Gumbot__setSpeed_name = "setSpeed";

static const ::std::string __Robots__Gumbot__getSteering_name = "getSteering";

static const ::std::string __Robots__Gumbot__setSteering_name = "setSteering";

static const ::std::string __Robots__Gumbot__getImageSensor_name = "getImageSensor";

static const ::std::string __Robots__Gumbot__getImageSensorDims_name = "getImageSensorDims";

static const ::std::string __Robots__Gumbot__getSensorValue_name = "getSensorValue";

static const ::std::string __Robots__Gumbot__motorsOff_name = "motorsOff";

static const ::std::string __Robots__Gumbot__setMotor_name = "setMotor";

static const ::std::string __Robots__Gumbot__sendRawCmd_name = "sendRawCmd";

static const ::std::string __Robots__Gumbot__playSong_name = "playSong";

static const ::std::string __Robots__Gumbot__sendStart_name = "sendStart";

static const ::std::string __Robots__Gumbot__setMode_name = "setMode";

static const ::std::string __Robots__Gumbot__setDemo_name = "setDemo";

static const ::std::string __Robots__Gumbot__setLED_name = "setLED";

static const ::std::string __Robots__Gumbot__shutdown_name = "shutdown";

::Ice::Object* IceInternal::upCast(::Robots::Gumbot* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::Robots::Gumbot* p) { return p; }

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

void
Robots::__write(::IceInternal::BasicStream* __os, ::Robots::GumbotModes v)
{
    __os->write(static_cast< ::Ice::Byte>(v), 5);
}

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

::Ice::Float
IceProxy::Robots::Gumbot::getSpeed(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
            __checkTwowayOnly(__Robots__Gumbot__getSpeed_name);
            __delBase = __getDelegate(false);
            ::IceDelegate::Robots::Gumbot* __del = dynamic_cast< ::IceDelegate::Robots::Gumbot*>(__delBase.get());
            return __del->getSpeed(__ctx);
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex, 0);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, 0, __cnt);
        }
    }
}

::Ice::Short
IceProxy::Robots::Gumbot::setSpeed(::Ice::Float speed, 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
            __checkTwowayOnly(__Robots__Gumbot__setSpeed_name);
            __delBase = __getDelegate(false);
            ::IceDelegate::Robots::Gumbot* __del = dynamic_cast< ::IceDelegate::Robots::Gumbot*>(__delBase.get());
            return __del->setSpeed(speed, __ctx);
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex, 0);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, 0, __cnt);
        }
    }
}

::Ice::Float
IceProxy::Robots::Gumbot::getSteering(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
            __checkTwowayOnly(__Robots__Gumbot__getSteering_name);
            __delBase = __getDelegate(false);
            ::IceDelegate::Robots::Gumbot* __del = dynamic_cast< ::IceDelegate::Robots::Gumbot*>(__delBase.get());
            return __del->getSteering(__ctx);
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex, 0);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, 0, __cnt);
        }
    }
}

::Ice::Short
IceProxy::Robots::Gumbot::setSteering(::Ice::Float steeringPos, 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
            __checkTwowayOnly(__Robots__Gumbot__setSteering_name);
            __delBase = __getDelegate(false);
            ::IceDelegate::Robots::Gumbot* __del = dynamic_cast< ::IceDelegate::Robots::Gumbot*>(__delBase.get());
            return __del->setSteering(steeringPos, __ctx);
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex, 0);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, 0, __cnt);
        }
    }
}

::ImageIceMod::ImageIce
IceProxy::Robots::Gumbot::getImageSensor(::Ice::Short i, 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
            __checkTwowayOnly(__Robots__Gumbot__getImageSensor_name);
            __delBase = __getDelegate(false);
            ::IceDelegate::Robots::Gumbot* __del = dynamic_cast< ::IceDelegate::Robots::Gumbot*>(__delBase.get());
            return __del->getImageSensor(i, __ctx);
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex, 0);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, 0, __cnt);
        }
    }
}

::ImageIceMod::DimsIce
IceProxy::Robots::Gumbot::getImageSensorDims(::Ice::Short i, 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
            __checkTwowayOnly(__Robots__Gumbot__getImageSensorDims_name);
            __delBase = __getDelegate(false);
            ::IceDelegate::Robots::Gumbot* __del = dynamic_cast< ::IceDelegate::Robots::Gumbot*>(__delBase.get());
            return __del->getImageSensorDims(i, __ctx);
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex, 0);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, 0, __cnt);
        }
    }
}

::Ice::Short
IceProxy::Robots::Gumbot::getSensorValue(::Ice::Short i, 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
            __checkTwowayOnly(__Robots__Gumbot__getSensorValue_name);
            __delBase = __getDelegate(false);
            ::IceDelegate::Robots::Gumbot* __del = dynamic_cast< ::IceDelegate::Robots::Gumbot*>(__delBase.get());
            return __del->getSensorValue(i, __ctx);
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex, 0);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, 0, __cnt);
        }
    }
}

void
IceProxy::Robots::Gumbot::motorsOff(::Ice::Short i, 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::Robots::Gumbot* __del = dynamic_cast< ::IceDelegate::Robots::Gumbot*>(__delBase.get());
            __del->motorsOff(i, __ctx);
            return;
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex, 0);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, 0, __cnt);
        }
    }
}

void
IceProxy::Robots::Gumbot::setMotor(::Ice::Short i, ::Ice::Float val, 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::Robots::Gumbot* __del = dynamic_cast< ::IceDelegate::Robots::Gumbot*>(__delBase.get());
            __del->setMotor(i, val, __ctx);
            return;
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex, 0);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, 0, __cnt);
        }
    }
}

::Ice::Short
IceProxy::Robots::Gumbot::sendRawCmd(const ::std::string& data, 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
            __checkTwowayOnly(__Robots__Gumbot__sendRawCmd_name);
            __delBase = __getDelegate(false);
            ::IceDelegate::Robots::Gumbot* __del = dynamic_cast< ::IceDelegate::Robots::Gumbot*>(__delBase.get());
            return __del->sendRawCmd(data, __ctx);
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex, 0);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, 0, __cnt);
        }
    }
}

void
IceProxy::Robots::Gumbot::playSong(::Ice::Short song, 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::Robots::Gumbot* __del = dynamic_cast< ::IceDelegate::Robots::Gumbot*>(__delBase.get());
            __del->playSong(song, __ctx);
            return;
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex, 0);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, 0, __cnt);
        }
    }
}

void
IceProxy::Robots::Gumbot::sendStart(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::Robots::Gumbot* __del = dynamic_cast< ::IceDelegate::Robots::Gumbot*>(__delBase.get());
            __del->sendStart(__ctx);
            return;
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex, 0);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, 0, __cnt);
        }
    }
}

void
IceProxy::Robots::Gumbot::setMode(::Robots::GumbotModes mode, 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::Robots::Gumbot* __del = dynamic_cast< ::IceDelegate::Robots::Gumbot*>(__delBase.get());
            __del->setMode(mode, __ctx);
            return;
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex, 0);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, 0, __cnt);
        }
    }
}

void
IceProxy::Robots::Gumbot::setDemo(::Ice::Short demo, 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::Robots::Gumbot* __del = dynamic_cast< ::IceDelegate::Robots::Gumbot*>(__delBase.get());
            __del->setDemo(demo, __ctx);
            return;
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex, 0);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, 0, __cnt);
        }
    }
}

void
IceProxy::Robots::Gumbot::setLED(::Ice::Short led, ::Ice::Short color, ::Ice::Short intensity, 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::Robots::Gumbot* __del = dynamic_cast< ::IceDelegate::Robots::Gumbot*>(__delBase.get());
            __del->setLED(led, color, intensity, __ctx);
            return;
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex, 0);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, 0, __cnt);
        }
    }
}

void
IceProxy::Robots::Gumbot::shutdown(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::Robots::Gumbot* __del = dynamic_cast< ::IceDelegate::Robots::Gumbot*>(__delBase.get());
            __del->shutdown(__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::Robots::Gumbot::ice_staticId()
{
    return ::Robots::Gumbot::ice_staticId();
}

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

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

::IceProxy::Ice::Object*
IceProxy::Robots::Gumbot::__newInstance() const
{
    return new Gumbot;
}

::Ice::Float
IceDelegateM::Robots::Gumbot::getSpeed(const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __Robots__Gumbot__getSpeed_name, ::Ice::Normal, __context);
    bool __ok = __og.invoke();
    ::Ice::Float __ret;
    try
    {
        if(!__ok)
        {
            try
            {
                __og.throwUserException();
            }
            catch(const ::Ice::UserException& __ex)
            {
                ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
                throw __uue;
            }
        }
        ::IceInternal::BasicStream* __is = __og.is();
        __is->startReadEncaps();
        __is->read(__ret);
        __is->endReadEncaps();
        return __ret;
    }
    catch(const ::Ice::LocalException& __ex)
    {
        throw ::IceInternal::LocalExceptionWrapper(__ex, false);
    }
}

::Ice::Short
IceDelegateM::Robots::Gumbot::setSpeed(::Ice::Float speed, const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __Robots__Gumbot__setSpeed_name, ::Ice::Normal, __context);
    try
    {
        ::IceInternal::BasicStream* __os = __og.os();
        __os->write(speed);
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    bool __ok = __og.invoke();
    ::Ice::Short __ret;
    try
    {
        if(!__ok)
        {
            try
            {
                __og.throwUserException();
            }
            catch(const ::Ice::UserException& __ex)
            {
                ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
                throw __uue;
            }
        }
        ::IceInternal::BasicStream* __is = __og.is();
        __is->startReadEncaps();
        __is->read(__ret);
        __is->endReadEncaps();
        return __ret;
    }
    catch(const ::Ice::LocalException& __ex)
    {
        throw ::IceInternal::LocalExceptionWrapper(__ex, false);
    }
}

::Ice::Float
IceDelegateM::Robots::Gumbot::getSteering(const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __Robots__Gumbot__getSteering_name, ::Ice::Normal, __context);
    bool __ok = __og.invoke();
    ::Ice::Float __ret;
    try
    {
        if(!__ok)
        {
            try
            {
                __og.throwUserException();
            }
            catch(const ::Ice::UserException& __ex)
            {
                ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
                throw __uue;
            }
        }
        ::IceInternal::BasicStream* __is = __og.is();
        __is->startReadEncaps();
        __is->read(__ret);
        __is->endReadEncaps();
        return __ret;
    }
    catch(const ::Ice::LocalException& __ex)
    {
        throw ::IceInternal::LocalExceptionWrapper(__ex, false);
    }
}

::Ice::Short
IceDelegateM::Robots::Gumbot::setSteering(::Ice::Float steeringPos, const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __Robots__Gumbot__setSteering_name, ::Ice::Normal, __context);
    try
    {
        ::IceInternal::BasicStream* __os = __og.os();
        __os->write(steeringPos);
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    bool __ok = __og.invoke();
    ::Ice::Short __ret;
    try
    {
        if(!__ok)
        {
            try
            {
                __og.throwUserException();
            }
            catch(const ::Ice::UserException& __ex)
            {
                ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
                throw __uue;
            }
        }
        ::IceInternal::BasicStream* __is = __og.is();
        __is->startReadEncaps();
        __is->read(__ret);
        __is->endReadEncaps();
        return __ret;
    }
    catch(const ::Ice::LocalException& __ex)
    {
        throw ::IceInternal::LocalExceptionWrapper(__ex, false);
    }
}

::ImageIceMod::ImageIce
IceDelegateM::Robots::Gumbot::getImageSensor(::Ice::Short i, const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __Robots__Gumbot__getImageSensor_name, ::Ice::Normal, __context);
    try
    {
        ::IceInternal::BasicStream* __os = __og.os();
        __os->write(i);
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    bool __ok = __og.invoke();
    ::ImageIceMod::ImageIce __ret;
    try
    {
        if(!__ok)
        {
            try
            {
                __og.throwUserException();
            }
            catch(const ::Ice::UserException& __ex)
            {
                ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
                throw __uue;
            }
        }
        ::IceInternal::BasicStream* __is = __og.is();
        __is->startReadEncaps();
        __ret.__read(__is);
        __is->endReadEncaps();
        return __ret;
    }
    catch(const ::Ice::LocalException& __ex)
    {
        throw ::IceInternal::LocalExceptionWrapper(__ex, false);
    }
}

::ImageIceMod::DimsIce
IceDelegateM::Robots::Gumbot::getImageSensorDims(::Ice::Short i, const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __Robots__Gumbot__getImageSensorDims_name, ::Ice::Normal, __context);
    try
    {
        ::IceInternal::BasicStream* __os = __og.os();
        __os->write(i);
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    bool __ok = __og.invoke();
    ::ImageIceMod::DimsIce __ret;
    try
    {
        if(!__ok)
        {
            try
            {
                __og.throwUserException();
            }
            catch(const ::Ice::UserException& __ex)
            {
                ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
                throw __uue;
            }
        }
        ::IceInternal::BasicStream* __is = __og.is();
        __is->startReadEncaps();
        __ret.__read(__is);
        __is->endReadEncaps();
        return __ret;
    }
    catch(const ::Ice::LocalException& __ex)
    {
        throw ::IceInternal::LocalExceptionWrapper(__ex, false);
    }
}

::Ice::Short
IceDelegateM::Robots::Gumbot::getSensorValue(::Ice::Short i, const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __Robots__Gumbot__getSensorValue_name, ::Ice::Normal, __context);
    try
    {
        ::IceInternal::BasicStream* __os = __og.os();
        __os->write(i);
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    bool __ok = __og.invoke();
    ::Ice::Short __ret;
    try
    {
        if(!__ok)
        {
            try
            {
                __og.throwUserException();
            }
            catch(const ::Ice::UserException& __ex)
            {
                ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
                throw __uue;
            }
        }
        ::IceInternal::BasicStream* __is = __og.is();
        __is->startReadEncaps();
        __is->read(__ret);
        __is->endReadEncaps();
        return __ret;
    }
    catch(const ::Ice::LocalException& __ex)
    {
        throw ::IceInternal::LocalExceptionWrapper(__ex, false);
    }
}

void
IceDelegateM::Robots::Gumbot::motorsOff(::Ice::Short i, const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __Robots__Gumbot__motorsOff_name, ::Ice::Normal, __context);
    try
    {
        ::IceInternal::BasicStream* __os = __og.os();
        __os->write(i);
    }
    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
IceDelegateM::Robots::Gumbot::setMotor(::Ice::Short i, ::Ice::Float val, const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __Robots__Gumbot__setMotor_name, ::Ice::Normal, __context);
    try
    {
        ::IceInternal::BasicStream* __os = __og.os();
        __os->write(i);
        __os->write(val);
    }
    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);
        }
    }
}

::Ice::Short
IceDelegateM::Robots::Gumbot::sendRawCmd(const ::std::string& data, const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __Robots__Gumbot__sendRawCmd_name, ::Ice::Normal, __context);
    try
    {
        ::IceInternal::BasicStream* __os = __og.os();
        __os->write(data);
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    bool __ok = __og.invoke();
    ::Ice::Short __ret;
    try
    {
        if(!__ok)
        {
            try
            {
                __og.throwUserException();
            }
            catch(const ::Ice::UserException& __ex)
            {
                ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
                throw __uue;
            }
        }
        ::IceInternal::BasicStream* __is = __og.is();
        __is->startReadEncaps();
        __is->read(__ret);
        __is->endReadEncaps();
        return __ret;
    }
    catch(const ::Ice::LocalException& __ex)
    {
        throw ::IceInternal::LocalExceptionWrapper(__ex, false);
    }
}

void
IceDelegateM::Robots::Gumbot::playSong(::Ice::Short song, const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __Robots__Gumbot__playSong_name, ::Ice::Normal, __context);
    try
    {
        ::IceInternal::BasicStream* __os = __og.os();
        __os->write(song);
    }
    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
IceDelegateM::Robots::Gumbot::sendStart(const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __Robots__Gumbot__sendStart_name, ::Ice::Normal, __context);
    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
IceDelegateM::Robots::Gumbot::setMode(::Robots::GumbotModes mode, const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __Robots__Gumbot__setMode_name, ::Ice::Normal, __context);
    try
    {
        ::IceInternal::BasicStream* __os = __og.os();
        ::Robots::__write(__os, mode);
    }
    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
IceDelegateM::Robots::Gumbot::setDemo(::Ice::Short demo, const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __Robots__Gumbot__setDemo_name, ::Ice::Normal, __context);
    try
    {
        ::IceInternal::BasicStream* __os = __og.os();
        __os->write(demo);
    }
    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
IceDelegateM::Robots::Gumbot::setLED(::Ice::Short led, ::Ice::Short color, ::Ice::Short intensity, const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __Robots__Gumbot__setLED_name, ::Ice::Normal, __context);
    try
    {
        ::IceInternal::BasicStream* __os = __og.os();
        __os->write(led);
        __os->write(color);
        __os->write(intensity);
    }
    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
IceDelegateM::Robots::Gumbot::shutdown(const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __Robots__Gumbot__shutdown_name, ::Ice::Normal, __context);
    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);
        }
    }
}

::Ice::Float
IceDelegateD::Robots::Gumbot::getSpeed(const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

        _DirectI(::Ice::Float& __result, const ::Ice::Current& __current) :
            ::IceInternal::Direct(__current),
            _result(__result)
        {
        }

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

    private:

        ::Ice::Float& _result;
    };

    ::Ice::Current __current;
    __initCurrent(__current, __Robots__Gumbot__getSpeed_name, ::Ice::Normal, __context);
    ::Ice::Float __result;
    try
    {
        _DirectI __direct(__result, __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);
    }
    return __result;
}

::Ice::Short
IceDelegateD::Robots::Gumbot::setSpeed(::Ice::Float speed, const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

        _DirectI(::Ice::Short& __result, ::Ice::Float speed, const ::Ice::Current& __current) :
            ::IceInternal::Direct(__current),
            _result(__result),
            _m_speed(speed)
        {
        }

        virtual ::Ice::DispatchStatus
        run(::Ice::Object* object)
        {
            ::Robots::Gumbot* servant = dynamic_cast< ::Robots::Gumbot*>(object);
            if(!servant)
            {
                throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
            }
            _result = servant->setSpeed(_m_speed, _current);
            return ::Ice::DispatchOK;
        }

    private:

        ::Ice::Short& _result;
        ::Ice::Float _m_speed;
    };

    ::Ice::Current __current;
    __initCurrent(__current, __Robots__Gumbot__setSpeed_name, ::Ice::Normal, __context);
    ::Ice::Short __result;
    try
    {
        _DirectI __direct(__result, speed, __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);
    }
    return __result;
}

::Ice::Float
IceDelegateD::Robots::Gumbot::getSteering(const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

        _DirectI(::Ice::Float& __result, const ::Ice::Current& __current) :
            ::IceInternal::Direct(__current),
            _result(__result)
        {
        }

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

    private:

        ::Ice::Float& _result;
    };

    ::Ice::Current __current;
    __initCurrent(__current, __Robots__Gumbot__getSteering_name, ::Ice::Normal, __context);
    ::Ice::Float __result;
    try
    {
        _DirectI __direct(__result, __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);
    }
    return __result;
}

::Ice::Short
IceDelegateD::Robots::Gumbot::setSteering(::Ice::Float steeringPos, const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

        _DirectI(::Ice::Short& __result, ::Ice::Float steeringPos, const ::Ice::Current& __current) :
            ::IceInternal::Direct(__current),
            _result(__result),
            _m_steeringPos(steeringPos)
        {
        }

        virtual ::Ice::DispatchStatus
        run(::Ice::Object* object)
        {
            ::Robots::Gumbot* servant = dynamic_cast< ::Robots::Gumbot*>(object);
            if(!servant)
            {
                throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
            }
            _result = servant->setSteering(_m_steeringPos, _current);
            return ::Ice::DispatchOK;
        }

    private:

        ::Ice::Short& _result;
        ::Ice::Float _m_steeringPos;
    };

    ::Ice::Current __current;
    __initCurrent(__current, __Robots__Gumbot__setSteering_name, ::Ice::Normal, __context);
    ::Ice::Short __result;
    try
    {
        _DirectI __direct(__result, steeringPos, __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);
    }
    return __result;
}

::ImageIceMod::ImageIce
IceDelegateD::Robots::Gumbot::getImageSensor(::Ice::Short i, const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

        _DirectI(::ImageIceMod::ImageIce& __result, ::Ice::Short i, const ::Ice::Current& __current) :
            ::IceInternal::Direct(__current),
            _result(__result),
            _m_i(i)
        {
        }

        virtual ::Ice::DispatchStatus
        run(::Ice::Object* object)
        {
            ::Robots::Gumbot* servant = dynamic_cast< ::Robots::Gumbot*>(object);
            if(!servant)
            {
                throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
            }
            _result = servant->getImageSensor(_m_i, _current);
            return ::Ice::DispatchOK;
        }

    private:

        ::ImageIceMod::ImageIce& _result;
        ::Ice::Short _m_i;
    };

    ::Ice::Current __current;
    __initCurrent(__current, __Robots__Gumbot__getImageSensor_name, ::Ice::Normal, __context);
    ::ImageIceMod::ImageIce __result;
    try
    {
        _DirectI __direct(__result, i, __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);
    }
    return __result;
}

::ImageIceMod::DimsIce
IceDelegateD::Robots::Gumbot::getImageSensorDims(::Ice::Short i, const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

        _DirectI(::ImageIceMod::DimsIce& __result, ::Ice::Short i, const ::Ice::Current& __current) :
            ::IceInternal::Direct(__current),
            _result(__result),
            _m_i(i)
        {
        }

        virtual ::Ice::DispatchStatus
        run(::Ice::Object* object)
        {
            ::Robots::Gumbot* servant = dynamic_cast< ::Robots::Gumbot*>(object);
            if(!servant)
            {
                throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
            }
            _result = servant->getImageSensorDims(_m_i, _current);
            return ::Ice::DispatchOK;
        }

    private:

        ::ImageIceMod::DimsIce& _result;
        ::Ice::Short _m_i;
    };

    ::Ice::Current __current;
    __initCurrent(__current, __Robots__Gumbot__getImageSensorDims_name, ::Ice::Normal, __context);
    ::ImageIceMod::DimsIce __result;
    try
    {
        _DirectI __direct(__result, i, __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);
    }
    return __result;
}

::Ice::Short
IceDelegateD::Robots::Gumbot::getSensorValue(::Ice::Short i, const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

        _DirectI(::Ice::Short& __result, ::Ice::Short i, const ::Ice::Current& __current) :
            ::IceInternal::Direct(__current),
            _result(__result),
            _m_i(i)
        {
        }

        virtual ::Ice::DispatchStatus
        run(::Ice::Object* object)
        {
            ::Robots::Gumbot* servant = dynamic_cast< ::Robots::Gumbot*>(object);
            if(!servant)
            {
                throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
            }
            _result = servant->getSensorValue(_m_i, _current);
            return ::Ice::DispatchOK;
        }

    private:

        ::Ice::Short& _result;
        ::Ice::Short _m_i;
    };

    ::Ice::Current __current;
    __initCurrent(__current, __Robots__Gumbot__getSensorValue_name, ::Ice::Normal, __context);
    ::Ice::Short __result;
    try
    {
        _DirectI __direct(__result, i, __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);
    }
    return __result;
}

void
IceDelegateD::Robots::Gumbot::motorsOff(::Ice::Short i, const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

        _DirectI(::Ice::Short i, const ::Ice::Current& __current) :
            ::IceInternal::Direct(__current),
            _m_i(i)
        {
        }

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

    private:

        ::Ice::Short _m_i;
    };

    ::Ice::Current __current;
    __initCurrent(__current, __Robots__Gumbot__motorsOff_name, ::Ice::Normal, __context);
    try
    {
        _DirectI __direct(i, __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);
    }
}

void
IceDelegateD::Robots::Gumbot::setMotor(::Ice::Short i, ::Ice::Float val, const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

        _DirectI(::Ice::Short i, ::Ice::Float val, const ::Ice::Current& __current) :
            ::IceInternal::Direct(__current),
            _m_i(i),
            _m_val(val)
        {
        }

        virtual ::Ice::DispatchStatus
        run(::Ice::Object* object)
        {
            ::Robots::Gumbot* servant = dynamic_cast< ::Robots::Gumbot*>(object);
            if(!servant)
            {
                throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
            }
            servant->setMotor(_m_i, _m_val, _current);
            return ::Ice::DispatchOK;
        }

    private:

        ::Ice::Short _m_i;
        ::Ice::Float _m_val;
    };

    ::Ice::Current __current;
    __initCurrent(__current, __Robots__Gumbot__setMotor_name, ::Ice::Normal, __context);
    try
    {
        _DirectI __direct(i, val, __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::Short
IceDelegateD::Robots::Gumbot::sendRawCmd(const ::std::string& data, const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

        _DirectI(::Ice::Short& __result, const ::std::string& data, const ::Ice::Current& __current) :
            ::IceInternal::Direct(__current),
            _result(__result),
            _m_data(data)
        {
        }

        virtual ::Ice::DispatchStatus
        run(::Ice::Object* object)
        {
            ::Robots::Gumbot* servant = dynamic_cast< ::Robots::Gumbot*>(object);
            if(!servant)
            {
                throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
            }
            _result = servant->sendRawCmd(_m_data, _current);
            return ::Ice::DispatchOK;
        }

    private:

        ::Ice::Short& _result;
        const ::std::string& _m_data;
    };

    ::Ice::Current __current;
    __initCurrent(__current, __Robots__Gumbot__sendRawCmd_name, ::Ice::Normal, __context);
    ::Ice::Short __result;
    try
    {
        _DirectI __direct(__result, data, __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);
    }
    return __result;
}

void
IceDelegateD::Robots::Gumbot::playSong(::Ice::Short song, const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

        _DirectI(::Ice::Short song, const ::Ice::Current& __current) :
            ::IceInternal::Direct(__current),
            _m_song(song)
        {
        }

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

    private:

        ::Ice::Short _m_song;
    };

    ::Ice::Current __current;
    __initCurrent(__current, __Robots__Gumbot__playSong_name, ::Ice::Normal, __context);
    try
    {
        _DirectI __direct(song, __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);
    }
}

void
IceDelegateD::Robots::Gumbot::sendStart(const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

        _DirectI(const ::Ice::Current& __current) :
            ::IceInternal::Direct(__current)
        {
        }

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

    private:

    };

    ::Ice::Current __current;
    __initCurrent(__current, __Robots__Gumbot__sendStart_name, ::Ice::Normal, __context);
    try
    {
        _DirectI __direct(__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);
    }
}

void
IceDelegateD::Robots::Gumbot::setMode(::Robots::GumbotModes mode, const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

        _DirectI(::Robots::GumbotModes mode, const ::Ice::Current& __current) :
            ::IceInternal::Direct(__current),
            _m_mode(mode)
        {
        }

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

    private:

        ::Robots::GumbotModes _m_mode;
    };

    ::Ice::Current __current;
    __initCurrent(__current, __Robots__Gumbot__setMode_name, ::Ice::Normal, __context);
    try
    {
        _DirectI __direct(mode, __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);
    }
}

void
IceDelegateD::Robots::Gumbot::setDemo(::Ice::Short demo, const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

        _DirectI(::Ice::Short demo, const ::Ice::Current& __current) :
            ::IceInternal::Direct(__current),
            _m_demo(demo)
        {
        }

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

    private:

        ::Ice::Short _m_demo;
    };

    ::Ice::Current __current;
    __initCurrent(__current, __Robots__Gumbot__setDemo_name, ::Ice::Normal, __context);
    try
    {
        _DirectI __direct(demo, __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);
    }
}

void
IceDelegateD::Robots::Gumbot::setLED(::Ice::Short led, ::Ice::Short color, ::Ice::Short intensity, const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

        _DirectI(::Ice::Short led, ::Ice::Short color, ::Ice::Short intensity, const ::Ice::Current& __current) :
            ::IceInternal::Direct(__current),
            _m_led(led),
            _m_color(color),
            _m_intensity(intensity)
        {
        }

        virtual ::Ice::DispatchStatus
        run(::Ice::Object* object)
        {
            ::Robots::Gumbot* servant = dynamic_cast< ::Robots::Gumbot*>(object);
            if(!servant)
            {
                throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
            }
            servant->setLED(_m_led, _m_color, _m_intensity, _current);
            return ::Ice::DispatchOK;
        }

    private:

        ::Ice::Short _m_led;
        ::Ice::Short _m_color;
        ::Ice::Short _m_intensity;
    };

    ::Ice::Current __current;
    __initCurrent(__current, __Robots__Gumbot__setLED_name, ::Ice::Normal, __context);
    try
    {
        _DirectI __direct(led, color, intensity, __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);
    }
}

void
IceDelegateD::Robots::Gumbot::shutdown(const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

        _DirectI(const ::Ice::Current& __current) :
            ::IceInternal::Direct(__current)
        {
        }

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

    private:

    };

    ::Ice::Current __current;
    __initCurrent(__current, __Robots__Gumbot__shutdown_name, ::Ice::Normal, __context);
    try
    {
        _DirectI __direct(__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
Robots::Gumbot::ice_clone() const
{
    throw ::Ice::CloneNotImplementedException(__FILE__, __LINE__);
    return 0; // to avoid a warning with some compilers
}

static const ::std::string __Robots__Gumbot_ids[2] =
{
    "::Ice::Object",
    "::Robots::Gumbot"
};

bool
Robots::Gumbot::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__Robots__Gumbot_ids, __Robots__Gumbot_ids + 2, _s);
}

::std::vector< ::std::string>
Robots::Gumbot::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__Robots__Gumbot_ids[0], &__Robots__Gumbot_ids[2]);
}

const ::std::string&
Robots::Gumbot::ice_id(const ::Ice::Current&) const
{
    return __Robots__Gumbot_ids[1];
}

const ::std::string&
Robots::Gumbot::ice_staticId()
{
    return __Robots__Gumbot_ids[1];
}

::Ice::DispatchStatus
Robots::Gumbot::___getSpeed(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    __inS.is()->skipEmptyEncaps();
    ::IceInternal::BasicStream* __os = __inS.os();
    ::Ice::Float __ret = getSpeed(__current);
    __os->write(__ret);
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robots::Gumbot::___setSpeed(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.is();
    __is->startReadEncaps();
    ::Ice::Float speed;
    __is->read(speed);
    __is->endReadEncaps();
    ::IceInternal::BasicStream* __os = __inS.os();
    ::Ice::Short __ret = setSpeed(speed, __current);
    __os->write(__ret);
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robots::Gumbot::___getSteering(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    __inS.is()->skipEmptyEncaps();
    ::IceInternal::BasicStream* __os = __inS.os();
    ::Ice::Float __ret = getSteering(__current);
    __os->write(__ret);
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robots::Gumbot::___setSteering(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.is();
    __is->startReadEncaps();
    ::Ice::Float steeringPos;
    __is->read(steeringPos);
    __is->endReadEncaps();
    ::IceInternal::BasicStream* __os = __inS.os();
    ::Ice::Short __ret = setSteering(steeringPos, __current);
    __os->write(__ret);
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robots::Gumbot::___getImageSensor(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.is();
    __is->startReadEncaps();
    ::Ice::Short i;
    __is->read(i);
    __is->endReadEncaps();
    ::IceInternal::BasicStream* __os = __inS.os();
    ::ImageIceMod::ImageIce __ret = getImageSensor(i, __current);
    __ret.__write(__os);
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robots::Gumbot::___getImageSensorDims(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.is();
    __is->startReadEncaps();
    ::Ice::Short i;
    __is->read(i);
    __is->endReadEncaps();
    ::IceInternal::BasicStream* __os = __inS.os();
    ::ImageIceMod::DimsIce __ret = getImageSensorDims(i, __current);
    __ret.__write(__os);
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robots::Gumbot::___getSensorValue(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.is();
    __is->startReadEncaps();
    ::Ice::Short i;
    __is->read(i);
    __is->endReadEncaps();
    ::IceInternal::BasicStream* __os = __inS.os();
    ::Ice::Short __ret = getSensorValue(i, __current);
    __os->write(__ret);
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robots::Gumbot::___motorsOff(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.is();
    __is->startReadEncaps();
    ::Ice::Short i;
    __is->read(i);
    __is->endReadEncaps();
    motorsOff(i, __current);
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robots::Gumbot::___setMotor(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.is();
    __is->startReadEncaps();
    ::Ice::Short i;
    ::Ice::Float val;
    __is->read(i);
    __is->read(val);
    __is->endReadEncaps();
    setMotor(i, val, __current);
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robots::Gumbot::___sendRawCmd(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.is();
    __is->startReadEncaps();
    ::std::string data;
    __is->read(data);
    __is->endReadEncaps();
    ::IceInternal::BasicStream* __os = __inS.os();
    ::Ice::Short __ret = sendRawCmd(data, __current);
    __os->write(__ret);
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robots::Gumbot::___playSong(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.is();
    __is->startReadEncaps();
    ::Ice::Short song;
    __is->read(song);
    __is->endReadEncaps();
    playSong(song, __current);
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robots::Gumbot::___sendStart(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    __inS.is()->skipEmptyEncaps();
    sendStart(__current);
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robots::Gumbot::___setMode(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.is();
    __is->startReadEncaps();
    ::Robots::GumbotModes mode;
    ::Robots::__read(__is, mode);
    __is->endReadEncaps();
    setMode(mode, __current);
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robots::Gumbot::___setDemo(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.is();
    __is->startReadEncaps();
    ::Ice::Short demo;
    __is->read(demo);
    __is->endReadEncaps();
    setDemo(demo, __current);
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robots::Gumbot::___setLED(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.is();
    __is->startReadEncaps();
    ::Ice::Short led;
    ::Ice::Short color;
    ::Ice::Short intensity;
    __is->read(led);
    __is->read(color);
    __is->read(intensity);
    __is->endReadEncaps();
    setLED(led, color, intensity, __current);
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robots::Gumbot::___shutdown(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    __inS.is()->skipEmptyEncaps();
    shutdown(__current);
    return ::Ice::DispatchOK;
}

static ::std::string __Robots__Gumbot_all[] =
{
    "getImageSensor",
    "getImageSensorDims",
    "getSensorValue",
    "getSpeed",
    "getSteering",
    "ice_id",
    "ice_ids",
    "ice_isA",
    "ice_ping",
    "motorsOff",
    "playSong",
    "sendRawCmd",
    "sendStart",
    "setDemo",
    "setLED",
    "setMode",
    "setMotor",
    "setSpeed",
    "setSteering",
    "shutdown"
};

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

    switch(r.first - __Robots__Gumbot_all)
    {
        case 0:
        {
            return ___getImageSensor(in, current);
        }
        case 1:
        {
            return ___getImageSensorDims(in, current);
        }
        case 2:
        {
            return ___getSensorValue(in, current);
        }
        case 3:
        {
            return ___getSpeed(in, current);
        }
        case 4:
        {
            return ___getSteering(in, current);
        }
        case 5:
        {
            return ___ice_id(in, current);
        }
        case 6:
        {
            return ___ice_ids(in, current);
        }
        case 7:
        {
            return ___ice_isA(in, current);
        }
        case 8:
        {
            return ___ice_ping(in, current);
        }
        case 9:
        {
            return ___motorsOff(in, current);
        }
        case 10:
        {
            return ___playSong(in, current);
        }
        case 11:
        {
            return ___sendRawCmd(in, current);
        }
        case 12:
        {
            return ___sendStart(in, current);
        }
        case 13:
        {
            return ___setDemo(in, current);
        }
        case 14:
        {
            return ___setLED(in, current);
        }
        case 15:
        {
            return ___setMode(in, current);
        }
        case 16:
        {
            return ___setMotor(in, current);
        }
        case 17:
        {
            return ___setSpeed(in, current);
        }
        case 18:
        {
            return ___setSteering(in, current);
        }
        case 19:
        {
            return ___shutdown(in, current);
        }
    }

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

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

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

void
Robots::__patch__GumbotPtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::Robots::GumbotPtr* p = static_cast< ::Robots::GumbotPtr*>(__addr);
    assert(p);
    *p = ::Robots::GumbotPtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::Robots::Gumbot::ice_staticId(), v->ice_id());
    }
}

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

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