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

#include <Scorbot.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__ScorbotIce__getIK_name = "getIK";

static const ::std::string __Robots__ScorbotIce__getEFpos_name = "getEFpos";

static const ::std::string __Robots__ScorbotIce__setEFPos_name = "setEFPos";

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

static const ::std::string __Robots__ScorbotIce__getPWM_name = "getPWM";

static const ::std::string __Robots__ScorbotIce__setJointPos_name = "setJointPos";

static const ::std::string __Robots__ScorbotIce__getJointPos_name = "getJointPos";

static const ::std::string __Robots__ScorbotIce__getEncoderAng_name = "getEncoderAng";

static const ::std::string __Robots__ScorbotIce__resetEncoders_name = "resetEncoders";

static const ::std::string __Robots__ScorbotIce__stopAllMotors_name = "stopAllMotors";

static const ::std::string __Robots__ScorbotIce__setSafety_name = "setSafety";

static const ::std::string __Robots__ScorbotIce__getMovementTime_name = "getMovementTime";

static const ::std::string __Robots__ScorbotIce__homeMotor_name = "homeMotor";

static const ::std::string __Robots__ScorbotIce__homeMotors_name = "homeMotors";

static const ::std::string __Robots__ScorbotIce__getMicroSwitch_name = "getMicroSwitch";

static const ::std::string __Robots__ScorbotIce__getMicroSwitchMotor_name = "getMicroSwitchMotor";

static const ::std::string __Robots__ScorbotIce__setArmPos_name = "setArmPos";

static const ::std::string __Robots__ScorbotIce__getArmPos_name = "getArmPos";

static const ::std::string __Robots__ScorbotIce__motorsOn_name = "motorsOn";

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

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

static const ::std::string __Robots__ScorbotIce__enc2ang_name = "enc2ang";

static const ::std::string __Robots__ScorbotIce__ang2enc_name = "ang2enc";

static const ::std::string __Robots__ScorbotIce__enc2mm_name = "enc2mm";

static const ::std::string __Robots__ScorbotIce__mm2enc_name = "mm2enc";

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

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

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

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

bool
Robots::ArmPos::operator==(const ArmPos& __rhs) const
{
    if(this == &__rhs)
    {
        return true;
    }
    if(base != __rhs.base)
    {
        return false;
    }
    if(shoulder != __rhs.shoulder)
    {
        return false;
    }
    if(elbow != __rhs.elbow)
    {
        return false;
    }
    if(wrist1 != __rhs.wrist1)
    {
        return false;
    }
    if(wrist2 != __rhs.wrist2)
    {
        return false;
    }
    if(gripper != __rhs.gripper)
    {
        return false;
    }
    if(ex1 != __rhs.ex1)
    {
        return false;
    }
    if(ex2 != __rhs.ex2)
    {
        return false;
    }
    if(wristroll != __rhs.wristroll)
    {
        return false;
    }
    if(wristpitch != __rhs.wristpitch)
    {
        return false;
    }
    if(duration != __rhs.duration)
    {
        return false;
    }
    return true;
}

bool
Robots::ArmPos::operator<(const ArmPos& __rhs) const
{
    if(this == &__rhs)
    {
        return false;
    }
    if(base < __rhs.base)
    {
        return true;
    }
    else if(__rhs.base < base)
    {
        return false;
    }
    if(shoulder < __rhs.shoulder)
    {
        return true;
    }
    else if(__rhs.shoulder < shoulder)
    {
        return false;
    }
    if(elbow < __rhs.elbow)
    {
        return true;
    }
    else if(__rhs.elbow < elbow)
    {
        return false;
    }
    if(wrist1 < __rhs.wrist1)
    {
        return true;
    }
    else if(__rhs.wrist1 < wrist1)
    {
        return false;
    }
    if(wrist2 < __rhs.wrist2)
    {
        return true;
    }
    else if(__rhs.wrist2 < wrist2)
    {
        return false;
    }
    if(gripper < __rhs.gripper)
    {
        return true;
    }
    else if(__rhs.gripper < gripper)
    {
        return false;
    }
    if(ex1 < __rhs.ex1)
    {
        return true;
    }
    else if(__rhs.ex1 < ex1)
    {
        return false;
    }
    if(ex2 < __rhs.ex2)
    {
        return true;
    }
    else if(__rhs.ex2 < ex2)
    {
        return false;
    }
    if(wristroll < __rhs.wristroll)
    {
        return true;
    }
    else if(__rhs.wristroll < wristroll)
    {
        return false;
    }
    if(wristpitch < __rhs.wristpitch)
    {
        return true;
    }
    else if(__rhs.wristpitch < wristpitch)
    {
        return false;
    }
    if(duration < __rhs.duration)
    {
        return true;
    }
    else if(__rhs.duration < duration)
    {
        return false;
    }
    return false;
}

void
Robots::ArmPos::__write(::IceInternal::BasicStream* __os) const
{
    __os->write(base);
    __os->write(shoulder);
    __os->write(elbow);
    __os->write(wrist1);
    __os->write(wrist2);
    __os->write(gripper);
    __os->write(ex1);
    __os->write(ex2);
    __os->write(wristroll);
    __os->write(wristpitch);
    __os->write(duration);
}

void
Robots::ArmPos::__read(::IceInternal::BasicStream* __is)
{
    __is->read(base);
    __is->read(shoulder);
    __is->read(elbow);
    __is->read(wrist1);
    __is->read(wrist2);
    __is->read(gripper);
    __is->read(ex1);
    __is->read(ex2);
    __is->read(wristroll);
    __is->read(wristpitch);
    __is->read(duration);
}

::Robots::ArmPos
IceProxy::Robots::ScorbotIce::getIK(::Ice::Float x, ::Ice::Float y, ::Ice::Float z, 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__ScorbotIce__getIK_name);
            __delBase = __getDelegate(false);
            ::IceDelegate::Robots::ScorbotIce* __del = dynamic_cast< ::IceDelegate::Robots::ScorbotIce*>(__delBase.get());
            return __del->getIK(x, y, z, __ctx);
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex, 0);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, 0, __cnt);
        }
    }
}

bool
IceProxy::Robots::ScorbotIce::getEFpos(::Ice::Float& x, ::Ice::Float& y, ::Ice::Float& z, 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__ScorbotIce__getEFpos_name);
            __delBase = __getDelegate(false);
            ::IceDelegate::Robots::ScorbotIce* __del = dynamic_cast< ::IceDelegate::Robots::ScorbotIce*>(__delBase.get());
            return __del->getEFpos(x, y, z, __ctx);
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex, 0);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, 0, __cnt);
        }
    }
}

bool
IceProxy::Robots::ScorbotIce::setEFPos(::Ice::Float x, ::Ice::Float y, ::Ice::Float z, 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__ScorbotIce__setEFPos_name);
            __delBase = __getDelegate(false);
            ::IceDelegate::Robots::ScorbotIce* __del = dynamic_cast< ::IceDelegate::Robots::ScorbotIce*>(__delBase.get());
            return __del->setEFPos(x, y, z, __ctx);
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex, 0);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, 0, __cnt);
        }
    }
}

bool
IceProxy::Robots::ScorbotIce::setMotor(::Robots::JOINTS joint, ::Ice::Int pwm, 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__ScorbotIce__setMotor_name);
            __delBase = __getDelegate(false);
            ::IceDelegate::Robots::ScorbotIce* __del = dynamic_cast< ::IceDelegate::Robots::ScorbotIce*>(__delBase.get());
            return __del->setMotor(joint, pwm, __ctx);
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex, 0);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, 0, __cnt);
        }
    }
}

::Ice::Int
IceProxy::Robots::ScorbotIce::getPWM(::Robots::JOINTS j, 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__ScorbotIce__getPWM_name);
            __delBase = __getDelegate(false);
            ::IceDelegate::Robots::ScorbotIce* __del = dynamic_cast< ::IceDelegate::Robots::ScorbotIce*>(__delBase.get());
            return __del->getPWM(j, __ctx);
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex, 0);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, 0, __cnt);
        }
    }
}

bool
IceProxy::Robots::ScorbotIce::setJointPos(::Robots::JOINTS joint, ::Ice::Int pos, 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__ScorbotIce__setJointPos_name);
            __delBase = __getDelegate(false);
            ::IceDelegate::Robots::ScorbotIce* __del = dynamic_cast< ::IceDelegate::Robots::ScorbotIce*>(__delBase.get());
            return __del->setJointPos(joint, pos, __ctx);
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex, 0);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, 0, __cnt);
        }
    }
}

::Ice::Int
IceProxy::Robots::ScorbotIce::getJointPos(::Robots::JOINTS joint, 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__ScorbotIce__getJointPos_name);
            __delBase = __getDelegate(false);
            ::IceDelegate::Robots::ScorbotIce* __del = dynamic_cast< ::IceDelegate::Robots::ScorbotIce*>(__delBase.get());
            return __del->getJointPos(joint, __ctx);
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex, 0);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, 0, __cnt);
        }
    }
}

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

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

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

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

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

void
IceProxy::Robots::ScorbotIce::homeMotor(::Robots::JOINTS joint, ::Ice::Int LimitSeekSpeed, ::Ice::Int MSJumpSpeed, ::Ice::Float MSJumpDelay, ::Ice::Int MSSeekSpeed, bool MSStopCondition, bool checkMS, 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::ScorbotIce* __del = dynamic_cast< ::IceDelegate::Robots::ScorbotIce*>(__delBase.get());
            __del->homeMotor(joint, LimitSeekSpeed, MSJumpSpeed, MSJumpDelay, MSSeekSpeed, MSStopCondition, checkMS, __ctx);
            return;
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex, 0);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, 0, __cnt);
        }
    }
}

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

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

::Ice::Int
IceProxy::Robots::ScorbotIce::getMicroSwitchMotor(::Robots::JOINTS m, 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__ScorbotIce__getMicroSwitchMotor_name);
            __delBase = __getDelegate(false);
            ::IceDelegate::Robots::ScorbotIce* __del = dynamic_cast< ::IceDelegate::Robots::ScorbotIce*>(__delBase.get());
            return __del->getMicroSwitchMotor(m, __ctx);
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex, 0);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, 0, __cnt);
        }
    }
}

bool
IceProxy::Robots::ScorbotIce::setArmPos(const ::Robots::ArmPos& pos, 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__ScorbotIce__setArmPos_name);
            __delBase = __getDelegate(false);
            ::IceDelegate::Robots::ScorbotIce* __del = dynamic_cast< ::IceDelegate::Robots::ScorbotIce*>(__delBase.get());
            return __del->setArmPos(pos, __ctx);
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex, 0);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, 0, __cnt);
        }
    }
}

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

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

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

void
IceProxy::Robots::ScorbotIce::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::ScorbotIce* __del = dynamic_cast< ::IceDelegate::Robots::ScorbotIce*>(__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);
        }
    }
}

::Ice::Double
IceProxy::Robots::ScorbotIce::enc2ang(::Ice::Int encoderTicks, 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__ScorbotIce__enc2ang_name);
            __delBase = __getDelegate(false);
            ::IceDelegate::Robots::ScorbotIce* __del = dynamic_cast< ::IceDelegate::Robots::ScorbotIce*>(__delBase.get());
            return __del->enc2ang(encoderTicks, __ctx);
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex, 0);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, 0, __cnt);
        }
    }
}

::Ice::Int
IceProxy::Robots::ScorbotIce::ang2enc(::Ice::Double degrees, 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__ScorbotIce__ang2enc_name);
            __delBase = __getDelegate(false);
            ::IceDelegate::Robots::ScorbotIce* __del = dynamic_cast< ::IceDelegate::Robots::ScorbotIce*>(__delBase.get());
            return __del->ang2enc(degrees, __ctx);
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex, 0);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, 0, __cnt);
        }
    }
}

::Ice::Double
IceProxy::Robots::ScorbotIce::enc2mm(::Ice::Int encoderTicks, 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__ScorbotIce__enc2mm_name);
            __delBase = __getDelegate(false);
            ::IceDelegate::Robots::ScorbotIce* __del = dynamic_cast< ::IceDelegate::Robots::ScorbotIce*>(__delBase.get());
            return __del->enc2mm(encoderTicks, __ctx);
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex, 0);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, 0, __cnt);
        }
    }
}

::Ice::Int
IceProxy::Robots::ScorbotIce::mm2enc(::Ice::Double mm, 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__ScorbotIce__mm2enc_name);
            __delBase = __getDelegate(false);
            ::IceDelegate::Robots::ScorbotIce* __del = dynamic_cast< ::IceDelegate::Robots::ScorbotIce*>(__delBase.get());
            return __del->mm2enc(mm, __ctx);
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex, 0);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, 0, __cnt);
        }
    }
}

const ::std::string&
IceProxy::Robots::ScorbotIce::ice_staticId()
{
    return ::Robots::ScorbotIce::ice_staticId();
}

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

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

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

::Robots::ArmPos
IceDelegateM::Robots::ScorbotIce::getIK(::Ice::Float x, ::Ice::Float y, ::Ice::Float z, const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __Robots__ScorbotIce__getIK_name, ::Ice::Normal, __context);
    try
    {
        ::IceInternal::BasicStream* __os = __og.os();
        __os->write(x);
        __os->write(y);
        __os->write(z);
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    bool __ok = __og.invoke();
    ::Robots::ArmPos __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);
    }
}

bool
IceDelegateM::Robots::ScorbotIce::getEFpos(::Ice::Float& x, ::Ice::Float& y, ::Ice::Float& z, const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __Robots__ScorbotIce__getEFpos_name, ::Ice::Normal, __context);
    bool __ok = __og.invoke();
    bool __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(x);
        __is->read(y);
        __is->read(z);
        __is->read(__ret);
        __is->endReadEncaps();
        return __ret;
    }
    catch(const ::Ice::LocalException& __ex)
    {
        throw ::IceInternal::LocalExceptionWrapper(__ex, false);
    }
}

bool
IceDelegateM::Robots::ScorbotIce::setEFPos(::Ice::Float x, ::Ice::Float y, ::Ice::Float z, const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __Robots__ScorbotIce__setEFPos_name, ::Ice::Normal, __context);
    try
    {
        ::IceInternal::BasicStream* __os = __og.os();
        __os->write(x);
        __os->write(y);
        __os->write(z);
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    bool __ok = __og.invoke();
    bool __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);
    }
}

bool
IceDelegateM::Robots::ScorbotIce::setMotor(::Robots::JOINTS joint, ::Ice::Int pwm, const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __Robots__ScorbotIce__setMotor_name, ::Ice::Normal, __context);
    try
    {
        ::IceInternal::BasicStream* __os = __og.os();
        ::Robots::__write(__os, joint);
        __os->write(pwm);
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    bool __ok = __og.invoke();
    bool __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::Int
IceDelegateM::Robots::ScorbotIce::getPWM(::Robots::JOINTS j, const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __Robots__ScorbotIce__getPWM_name, ::Ice::Normal, __context);
    try
    {
        ::IceInternal::BasicStream* __os = __og.os();
        ::Robots::__write(__os, j);
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    bool __ok = __og.invoke();
    ::Ice::Int __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);
    }
}

bool
IceDelegateM::Robots::ScorbotIce::setJointPos(::Robots::JOINTS joint, ::Ice::Int pos, const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __Robots__ScorbotIce__setJointPos_name, ::Ice::Normal, __context);
    try
    {
        ::IceInternal::BasicStream* __os = __og.os();
        ::Robots::__write(__os, joint);
        __os->write(pos);
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    bool __ok = __og.invoke();
    bool __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::Int
IceDelegateM::Robots::ScorbotIce::getJointPos(::Robots::JOINTS joint, const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __Robots__ScorbotIce__getJointPos_name, ::Ice::Normal, __context);
    try
    {
        ::IceInternal::BasicStream* __os = __og.os();
        ::Robots::__write(__os, joint);
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    bool __ok = __og.invoke();
    ::Ice::Int __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::ScorbotIce::getEncoderAng(::Robots::JOINTS joint, const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __Robots__ScorbotIce__getEncoderAng_name, ::Ice::Normal, __context);
    try
    {
        ::IceInternal::BasicStream* __os = __og.os();
        ::Robots::__write(__os, joint);
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    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);
    }
}

void
IceDelegateM::Robots::ScorbotIce::resetEncoders(const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __Robots__ScorbotIce__resetEncoders_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::ScorbotIce::stopAllMotors(const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __Robots__ScorbotIce__stopAllMotors_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::ScorbotIce::setSafety(bool val, const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __Robots__ScorbotIce__setSafety_name, ::Ice::Normal, __context);
    try
    {
        ::IceInternal::BasicStream* __os = __og.os();
        __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::Int
IceDelegateM::Robots::ScorbotIce::getMovementTime(const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __Robots__ScorbotIce__getMovementTime_name, ::Ice::Normal, __context);
    bool __ok = __og.invoke();
    ::Ice::Int __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::ScorbotIce::homeMotor(::Robots::JOINTS joint, ::Ice::Int LimitSeekSpeed, ::Ice::Int MSJumpSpeed, ::Ice::Float MSJumpDelay, ::Ice::Int MSSeekSpeed, bool MSStopCondition, bool checkMS, const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __Robots__ScorbotIce__homeMotor_name, ::Ice::Normal, __context);
    try
    {
        ::IceInternal::BasicStream* __os = __og.os();
        ::Robots::__write(__os, joint);
        __os->write(LimitSeekSpeed);
        __os->write(MSJumpSpeed);
        __os->write(MSJumpDelay);
        __os->write(MSSeekSpeed);
        __os->write(MSStopCondition);
        __os->write(checkMS);
    }
    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::ScorbotIce::homeMotors(const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __Robots__ScorbotIce__homeMotors_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::Int
IceDelegateM::Robots::ScorbotIce::getMicroSwitch(const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __Robots__ScorbotIce__getMicroSwitch_name, ::Ice::Normal, __context);
    bool __ok = __og.invoke();
    ::Ice::Int __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::Int
IceDelegateM::Robots::ScorbotIce::getMicroSwitchMotor(::Robots::JOINTS m, const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __Robots__ScorbotIce__getMicroSwitchMotor_name, ::Ice::Normal, __context);
    try
    {
        ::IceInternal::BasicStream* __os = __og.os();
        ::Robots::__write(__os, m);
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    bool __ok = __og.invoke();
    ::Ice::Int __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);
    }
}

bool
IceDelegateM::Robots::ScorbotIce::setArmPos(const ::Robots::ArmPos& pos, const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __Robots__ScorbotIce__setArmPos_name, ::Ice::Normal, __context);
    try
    {
        ::IceInternal::BasicStream* __os = __og.os();
        pos.__write(__os);
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    bool __ok = __og.invoke();
    bool __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);
    }
}

::Robots::ArmPos
IceDelegateM::Robots::ScorbotIce::getArmPos(const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __Robots__ScorbotIce__getArmPos_name, ::Ice::Normal, __context);
    bool __ok = __og.invoke();
    ::Robots::ArmPos __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);
    }
}

void
IceDelegateM::Robots::ScorbotIce::motorsOn(const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __Robots__ScorbotIce__motorsOn_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::ScorbotIce::motorsOff(const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __Robots__ScorbotIce__motorsOff_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::ScorbotIce::shutdown(const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __Robots__ScorbotIce__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::Double
IceDelegateM::Robots::ScorbotIce::enc2ang(::Ice::Int encoderTicks, const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __Robots__ScorbotIce__enc2ang_name, ::Ice::Normal, __context);
    try
    {
        ::IceInternal::BasicStream* __os = __og.os();
        __os->write(encoderTicks);
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    bool __ok = __og.invoke();
    ::Ice::Double __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::Int
IceDelegateM::Robots::ScorbotIce::ang2enc(::Ice::Double degrees, const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __Robots__ScorbotIce__ang2enc_name, ::Ice::Normal, __context);
    try
    {
        ::IceInternal::BasicStream* __os = __og.os();
        __os->write(degrees);
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    bool __ok = __og.invoke();
    ::Ice::Int __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::Double
IceDelegateM::Robots::ScorbotIce::enc2mm(::Ice::Int encoderTicks, const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __Robots__ScorbotIce__enc2mm_name, ::Ice::Normal, __context);
    try
    {
        ::IceInternal::BasicStream* __os = __og.os();
        __os->write(encoderTicks);
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    bool __ok = __og.invoke();
    ::Ice::Double __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::Int
IceDelegateM::Robots::ScorbotIce::mm2enc(::Ice::Double mm, const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __Robots__ScorbotIce__mm2enc_name, ::Ice::Normal, __context);
    try
    {
        ::IceInternal::BasicStream* __os = __og.os();
        __os->write(mm);
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    bool __ok = __og.invoke();
    ::Ice::Int __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);
    }
}

::Robots::ArmPos
IceDelegateD::Robots::ScorbotIce::getIK(::Ice::Float x, ::Ice::Float y, ::Ice::Float z, const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

        _DirectI(::Robots::ArmPos& __result, ::Ice::Float x, ::Ice::Float y, ::Ice::Float z, const ::Ice::Current& __current) :
            ::IceInternal::Direct(__current),
            _result(__result),
            _m_x(x),
            _m_y(y),
            _m_z(z)
        {
        }

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

    private:

        ::Robots::ArmPos& _result;
        ::Ice::Float _m_x;
        ::Ice::Float _m_y;
        ::Ice::Float _m_z;
    };

    ::Ice::Current __current;
    __initCurrent(__current, __Robots__ScorbotIce__getIK_name, ::Ice::Normal, __context);
    ::Robots::ArmPos __result;
    try
    {
        _DirectI __direct(__result, x, y, z, __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;
}

bool
IceDelegateD::Robots::ScorbotIce::getEFpos(::Ice::Float& x, ::Ice::Float& y, ::Ice::Float& z, const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

        _DirectI(bool& __result, ::Ice::Float& x, ::Ice::Float& y, ::Ice::Float& z, const ::Ice::Current& __current) :
            ::IceInternal::Direct(__current),
            _result(__result),
            _m_x(x),
            _m_y(y),
            _m_z(z)
        {
        }

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

    private:

        bool& _result;
        ::Ice::Float& _m_x;
        ::Ice::Float& _m_y;
        ::Ice::Float& _m_z;
    };

    ::Ice::Current __current;
    __initCurrent(__current, __Robots__ScorbotIce__getEFpos_name, ::Ice::Normal, __context);
    bool __result;
    try
    {
        _DirectI __direct(__result, x, y, z, __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;
}

bool
IceDelegateD::Robots::ScorbotIce::setEFPos(::Ice::Float x, ::Ice::Float y, ::Ice::Float z, const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

        _DirectI(bool& __result, ::Ice::Float x, ::Ice::Float y, ::Ice::Float z, const ::Ice::Current& __current) :
            ::IceInternal::Direct(__current),
            _result(__result),
            _m_x(x),
            _m_y(y),
            _m_z(z)
        {
        }

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

    private:

        bool& _result;
        ::Ice::Float _m_x;
        ::Ice::Float _m_y;
        ::Ice::Float _m_z;
    };

    ::Ice::Current __current;
    __initCurrent(__current, __Robots__ScorbotIce__setEFPos_name, ::Ice::Normal, __context);
    bool __result;
    try
    {
        _DirectI __direct(__result, x, y, z, __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;
}

bool
IceDelegateD::Robots::ScorbotIce::setMotor(::Robots::JOINTS joint, ::Ice::Int pwm, const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

        _DirectI(bool& __result, ::Robots::JOINTS joint, ::Ice::Int pwm, const ::Ice::Current& __current) :
            ::IceInternal::Direct(__current),
            _result(__result),
            _m_joint(joint),
            _m_pwm(pwm)
        {
        }

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

    private:

        bool& _result;
        ::Robots::JOINTS _m_joint;
        ::Ice::Int _m_pwm;
    };

    ::Ice::Current __current;
    __initCurrent(__current, __Robots__ScorbotIce__setMotor_name, ::Ice::Normal, __context);
    bool __result;
    try
    {
        _DirectI __direct(__result, joint, pwm, __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::Int
IceDelegateD::Robots::ScorbotIce::getPWM(::Robots::JOINTS j, const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

        _DirectI(::Ice::Int& __result, ::Robots::JOINTS j, const ::Ice::Current& __current) :
            ::IceInternal::Direct(__current),
            _result(__result),
            _m_j(j)
        {
        }

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

    private:

        ::Ice::Int& _result;
        ::Robots::JOINTS _m_j;
    };

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

bool
IceDelegateD::Robots::ScorbotIce::setJointPos(::Robots::JOINTS joint, ::Ice::Int pos, const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

        _DirectI(bool& __result, ::Robots::JOINTS joint, ::Ice::Int pos, const ::Ice::Current& __current) :
            ::IceInternal::Direct(__current),
            _result(__result),
            _m_joint(joint),
            _m_pos(pos)
        {
        }

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

    private:

        bool& _result;
        ::Robots::JOINTS _m_joint;
        ::Ice::Int _m_pos;
    };

    ::Ice::Current __current;
    __initCurrent(__current, __Robots__ScorbotIce__setJointPos_name, ::Ice::Normal, __context);
    bool __result;
    try
    {
        _DirectI __direct(__result, joint, pos, __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::Int
IceDelegateD::Robots::ScorbotIce::getJointPos(::Robots::JOINTS joint, const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

        _DirectI(::Ice::Int& __result, ::Robots::JOINTS joint, const ::Ice::Current& __current) :
            ::IceInternal::Direct(__current),
            _result(__result),
            _m_joint(joint)
        {
        }

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

    private:

        ::Ice::Int& _result;
        ::Robots::JOINTS _m_joint;
    };

    ::Ice::Current __current;
    __initCurrent(__current, __Robots__ScorbotIce__getJointPos_name, ::Ice::Normal, __context);
    ::Ice::Int __result;
    try
    {
        _DirectI __direct(__result, joint, __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::ScorbotIce::getEncoderAng(::Robots::JOINTS joint, const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

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

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

    private:

        ::Ice::Float& _result;
        ::Robots::JOINTS _m_joint;
    };

    ::Ice::Current __current;
    __initCurrent(__current, __Robots__ScorbotIce__getEncoderAng_name, ::Ice::Normal, __context);
    ::Ice::Float __result;
    try
    {
        _DirectI __direct(__result, joint, __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::ScorbotIce::resetEncoders(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::ScorbotIce* servant = dynamic_cast< ::Robots::ScorbotIce*>(object);
            if(!servant)
            {
                throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
            }
            servant->resetEncoders(_current);
            return ::Ice::DispatchOK;
        }

    private:

    };

    ::Ice::Current __current;
    __initCurrent(__current, __Robots__ScorbotIce__resetEncoders_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::ScorbotIce::stopAllMotors(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::ScorbotIce* servant = dynamic_cast< ::Robots::ScorbotIce*>(object);
            if(!servant)
            {
                throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
            }
            servant->stopAllMotors(_current);
            return ::Ice::DispatchOK;
        }

    private:

    };

    ::Ice::Current __current;
    __initCurrent(__current, __Robots__ScorbotIce__stopAllMotors_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::ScorbotIce::setSafety(bool val, const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

        _DirectI(bool val, const ::Ice::Current& __current) :
            ::IceInternal::Direct(__current),
            _m_val(val)
        {
        }

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

    private:

        bool _m_val;
    };

    ::Ice::Current __current;
    __initCurrent(__current, __Robots__ScorbotIce__setSafety_name, ::Ice::Normal, __context);
    try
    {
        _DirectI __direct(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::Int
IceDelegateD::Robots::ScorbotIce::getMovementTime(const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

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

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

    private:

        ::Ice::Int& _result;
    };

    ::Ice::Current __current;
    __initCurrent(__current, __Robots__ScorbotIce__getMovementTime_name, ::Ice::Normal, __context);
    ::Ice::Int __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;
}

void
IceDelegateD::Robots::ScorbotIce::homeMotor(::Robots::JOINTS joint, ::Ice::Int LimitSeekSpeed, ::Ice::Int MSJumpSpeed, ::Ice::Float MSJumpDelay, ::Ice::Int MSSeekSpeed, bool MSStopCondition, bool checkMS, const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

        _DirectI(::Robots::JOINTS joint, ::Ice::Int LimitSeekSpeed, ::Ice::Int MSJumpSpeed, ::Ice::Float MSJumpDelay, ::Ice::Int MSSeekSpeed, bool MSStopCondition, bool checkMS, const ::Ice::Current& __current) :
            ::IceInternal::Direct(__current),
            _m_joint(joint),
            _m_LimitSeekSpeed(LimitSeekSpeed),
            _m_MSJumpSpeed(MSJumpSpeed),
            _m_MSJumpDelay(MSJumpDelay),
            _m_MSSeekSpeed(MSSeekSpeed),
            _m_MSStopCondition(MSStopCondition),
            _m_checkMS(checkMS)
        {
        }

        virtual ::Ice::DispatchStatus
        run(::Ice::Object* object)
        {
            ::Robots::ScorbotIce* servant = dynamic_cast< ::Robots::ScorbotIce*>(object);
            if(!servant)
            {
                throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
            }
            servant->homeMotor(_m_joint, _m_LimitSeekSpeed, _m_MSJumpSpeed, _m_MSJumpDelay, _m_MSSeekSpeed, _m_MSStopCondition, _m_checkMS, _current);
            return ::Ice::DispatchOK;
        }

    private:

        ::Robots::JOINTS _m_joint;
        ::Ice::Int _m_LimitSeekSpeed;
        ::Ice::Int _m_MSJumpSpeed;
        ::Ice::Float _m_MSJumpDelay;
        ::Ice::Int _m_MSSeekSpeed;
        bool _m_MSStopCondition;
        bool _m_checkMS;
    };

    ::Ice::Current __current;
    __initCurrent(__current, __Robots__ScorbotIce__homeMotor_name, ::Ice::Normal, __context);
    try
    {
        _DirectI __direct(joint, LimitSeekSpeed, MSJumpSpeed, MSJumpDelay, MSSeekSpeed, MSStopCondition, checkMS, __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::ScorbotIce::homeMotors(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::ScorbotIce* servant = dynamic_cast< ::Robots::ScorbotIce*>(object);
            if(!servant)
            {
                throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
            }
            servant->homeMotors(_current);
            return ::Ice::DispatchOK;
        }

    private:

    };

    ::Ice::Current __current;
    __initCurrent(__current, __Robots__ScorbotIce__homeMotors_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::Int
IceDelegateD::Robots::ScorbotIce::getMicroSwitch(const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

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

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

    private:

        ::Ice::Int& _result;
    };

    ::Ice::Current __current;
    __initCurrent(__current, __Robots__ScorbotIce__getMicroSwitch_name, ::Ice::Normal, __context);
    ::Ice::Int __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::Int
IceDelegateD::Robots::ScorbotIce::getMicroSwitchMotor(::Robots::JOINTS m, const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

        _DirectI(::Ice::Int& __result, ::Robots::JOINTS m, const ::Ice::Current& __current) :
            ::IceInternal::Direct(__current),
            _result(__result),
            _m_m(m)
        {
        }

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

    private:

        ::Ice::Int& _result;
        ::Robots::JOINTS _m_m;
    };

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

bool
IceDelegateD::Robots::ScorbotIce::setArmPos(const ::Robots::ArmPos& pos, const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

        _DirectI(bool& __result, const ::Robots::ArmPos& pos, const ::Ice::Current& __current) :
            ::IceInternal::Direct(__current),
            _result(__result),
            _m_pos(pos)
        {
        }

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

    private:

        bool& _result;
        const ::Robots::ArmPos& _m_pos;
    };

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

::Robots::ArmPos
IceDelegateD::Robots::ScorbotIce::getArmPos(const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

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

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

    private:

        ::Robots::ArmPos& _result;
    };

    ::Ice::Current __current;
    __initCurrent(__current, __Robots__ScorbotIce__getArmPos_name, ::Ice::Normal, __context);
    ::Robots::ArmPos __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;
}

void
IceDelegateD::Robots::ScorbotIce::motorsOn(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::ScorbotIce* servant = dynamic_cast< ::Robots::ScorbotIce*>(object);
            if(!servant)
            {
                throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
            }
            servant->motorsOn(_current);
            return ::Ice::DispatchOK;
        }

    private:

    };

    ::Ice::Current __current;
    __initCurrent(__current, __Robots__ScorbotIce__motorsOn_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::ScorbotIce::motorsOff(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::ScorbotIce* servant = dynamic_cast< ::Robots::ScorbotIce*>(object);
            if(!servant)
            {
                throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
            }
            servant->motorsOff(_current);
            return ::Ice::DispatchOK;
        }

    private:

    };

    ::Ice::Current __current;
    __initCurrent(__current, __Robots__ScorbotIce__motorsOff_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::ScorbotIce::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::ScorbotIce* servant = dynamic_cast< ::Robots::ScorbotIce*>(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__ScorbotIce__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::Double
IceDelegateD::Robots::ScorbotIce::enc2ang(::Ice::Int encoderTicks, const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

        _DirectI(::Ice::Double& __result, ::Ice::Int encoderTicks, const ::Ice::Current& __current) :
            ::IceInternal::Direct(__current),
            _result(__result),
            _m_encoderTicks(encoderTicks)
        {
        }

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

    private:

        ::Ice::Double& _result;
        ::Ice::Int _m_encoderTicks;
    };

    ::Ice::Current __current;
    __initCurrent(__current, __Robots__ScorbotIce__enc2ang_name, ::Ice::Normal, __context);
    ::Ice::Double __result;
    try
    {
        _DirectI __direct(__result, encoderTicks, __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::Int
IceDelegateD::Robots::ScorbotIce::ang2enc(::Ice::Double degrees, const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

        _DirectI(::Ice::Int& __result, ::Ice::Double degrees, const ::Ice::Current& __current) :
            ::IceInternal::Direct(__current),
            _result(__result),
            _m_degrees(degrees)
        {
        }

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

    private:

        ::Ice::Int& _result;
        ::Ice::Double _m_degrees;
    };

    ::Ice::Current __current;
    __initCurrent(__current, __Robots__ScorbotIce__ang2enc_name, ::Ice::Normal, __context);
    ::Ice::Int __result;
    try
    {
        _DirectI __direct(__result, degrees, __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::Double
IceDelegateD::Robots::ScorbotIce::enc2mm(::Ice::Int encoderTicks, const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

        _DirectI(::Ice::Double& __result, ::Ice::Int encoderTicks, const ::Ice::Current& __current) :
            ::IceInternal::Direct(__current),
            _result(__result),
            _m_encoderTicks(encoderTicks)
        {
        }

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

    private:

        ::Ice::Double& _result;
        ::Ice::Int _m_encoderTicks;
    };

    ::Ice::Current __current;
    __initCurrent(__current, __Robots__ScorbotIce__enc2mm_name, ::Ice::Normal, __context);
    ::Ice::Double __result;
    try
    {
        _DirectI __direct(__result, encoderTicks, __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::Int
IceDelegateD::Robots::ScorbotIce::mm2enc(::Ice::Double mm, const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

        _DirectI(::Ice::Int& __result, ::Ice::Double mm, const ::Ice::Current& __current) :
            ::IceInternal::Direct(__current),
            _result(__result),
            _m_mm(mm)
        {
        }

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

    private:

        ::Ice::Int& _result;
        ::Ice::Double _m_mm;
    };

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

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

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

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

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

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

::Ice::DispatchStatus
Robots::ScorbotIce::___getIK(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.is();
    __is->startReadEncaps();
    ::Ice::Float x;
    ::Ice::Float y;
    ::Ice::Float z;
    __is->read(x);
    __is->read(y);
    __is->read(z);
    __is->endReadEncaps();
    ::IceInternal::BasicStream* __os = __inS.os();
    ::Robots::ArmPos __ret = getIK(x, y, z, __current);
    __ret.__write(__os);
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robots::ScorbotIce::___getEFpos(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    __inS.is()->skipEmptyEncaps();
    ::IceInternal::BasicStream* __os = __inS.os();
    ::Ice::Float x;
    ::Ice::Float y;
    ::Ice::Float z;
    bool __ret = getEFpos(x, y, z, __current);
    __os->write(x);
    __os->write(y);
    __os->write(z);
    __os->write(__ret);
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robots::ScorbotIce::___setEFPos(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.is();
    __is->startReadEncaps();
    ::Ice::Float x;
    ::Ice::Float y;
    ::Ice::Float z;
    __is->read(x);
    __is->read(y);
    __is->read(z);
    __is->endReadEncaps();
    ::IceInternal::BasicStream* __os = __inS.os();
    bool __ret = setEFPos(x, y, z, __current);
    __os->write(__ret);
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robots::ScorbotIce::___setMotor(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.is();
    __is->startReadEncaps();
    ::Robots::JOINTS joint;
    ::Ice::Int pwm;
    ::Robots::__read(__is, joint);
    __is->read(pwm);
    __is->endReadEncaps();
    ::IceInternal::BasicStream* __os = __inS.os();
    bool __ret = setMotor(joint, pwm, __current);
    __os->write(__ret);
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robots::ScorbotIce::___getPWM(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.is();
    __is->startReadEncaps();
    ::Robots::JOINTS j;
    ::Robots::__read(__is, j);
    __is->endReadEncaps();
    ::IceInternal::BasicStream* __os = __inS.os();
    ::Ice::Int __ret = getPWM(j, __current);
    __os->write(__ret);
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robots::ScorbotIce::___setJointPos(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.is();
    __is->startReadEncaps();
    ::Robots::JOINTS joint;
    ::Ice::Int pos;
    ::Robots::__read(__is, joint);
    __is->read(pos);
    __is->endReadEncaps();
    ::IceInternal::BasicStream* __os = __inS.os();
    bool __ret = setJointPos(joint, pos, __current);
    __os->write(__ret);
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robots::ScorbotIce::___getJointPos(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.is();
    __is->startReadEncaps();
    ::Robots::JOINTS joint;
    ::Robots::__read(__is, joint);
    __is->endReadEncaps();
    ::IceInternal::BasicStream* __os = __inS.os();
    ::Ice::Int __ret = getJointPos(joint, __current);
    __os->write(__ret);
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robots::ScorbotIce::___getEncoderAng(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.is();
    __is->startReadEncaps();
    ::Robots::JOINTS joint;
    ::Robots::__read(__is, joint);
    __is->endReadEncaps();
    ::IceInternal::BasicStream* __os = __inS.os();
    ::Ice::Float __ret = getEncoderAng(joint, __current);
    __os->write(__ret);
    return ::Ice::DispatchOK;
}

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

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

::Ice::DispatchStatus
Robots::ScorbotIce::___setSafety(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.is();
    __is->startReadEncaps();
    bool val;
    __is->read(val);
    __is->endReadEncaps();
    setSafety(val, __current);
    return ::Ice::DispatchOK;
}

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

::Ice::DispatchStatus
Robots::ScorbotIce::___homeMotor(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.is();
    __is->startReadEncaps();
    ::Robots::JOINTS joint;
    ::Ice::Int LimitSeekSpeed;
    ::Ice::Int MSJumpSpeed;
    ::Ice::Float MSJumpDelay;
    ::Ice::Int MSSeekSpeed;
    bool MSStopCondition;
    bool checkMS;
    ::Robots::__read(__is, joint);
    __is->read(LimitSeekSpeed);
    __is->read(MSJumpSpeed);
    __is->read(MSJumpDelay);
    __is->read(MSSeekSpeed);
    __is->read(MSStopCondition);
    __is->read(checkMS);
    __is->endReadEncaps();
    homeMotor(joint, LimitSeekSpeed, MSJumpSpeed, MSJumpDelay, MSSeekSpeed, MSStopCondition, checkMS, __current);
    return ::Ice::DispatchOK;
}

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

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

::Ice::DispatchStatus
Robots::ScorbotIce::___getMicroSwitchMotor(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.is();
    __is->startReadEncaps();
    ::Robots::JOINTS m;
    ::Robots::__read(__is, m);
    __is->endReadEncaps();
    ::IceInternal::BasicStream* __os = __inS.os();
    ::Ice::Int __ret = getMicroSwitchMotor(m, __current);
    __os->write(__ret);
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robots::ScorbotIce::___setArmPos(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.is();
    __is->startReadEncaps();
    ::Robots::ArmPos pos;
    pos.__read(__is);
    __is->endReadEncaps();
    ::IceInternal::BasicStream* __os = __inS.os();
    bool __ret = setArmPos(pos, __current);
    __os->write(__ret);
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robots::ScorbotIce::___getArmPos(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    __inS.is()->skipEmptyEncaps();
    ::IceInternal::BasicStream* __os = __inS.os();
    ::Robots::ArmPos __ret = getArmPos(__current);
    __ret.__write(__os);
    return ::Ice::DispatchOK;
}

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

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

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

::Ice::DispatchStatus
Robots::ScorbotIce::___enc2ang(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.is();
    __is->startReadEncaps();
    ::Ice::Int encoderTicks;
    __is->read(encoderTicks);
    __is->endReadEncaps();
    ::IceInternal::BasicStream* __os = __inS.os();
    ::Ice::Double __ret = enc2ang(encoderTicks, __current);
    __os->write(__ret);
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robots::ScorbotIce::___ang2enc(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.is();
    __is->startReadEncaps();
    ::Ice::Double degrees;
    __is->read(degrees);
    __is->endReadEncaps();
    ::IceInternal::BasicStream* __os = __inS.os();
    ::Ice::Int __ret = ang2enc(degrees, __current);
    __os->write(__ret);
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robots::ScorbotIce::___enc2mm(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.is();
    __is->startReadEncaps();
    ::Ice::Int encoderTicks;
    __is->read(encoderTicks);
    __is->endReadEncaps();
    ::IceInternal::BasicStream* __os = __inS.os();
    ::Ice::Double __ret = enc2mm(encoderTicks, __current);
    __os->write(__ret);
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robots::ScorbotIce::___mm2enc(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.is();
    __is->startReadEncaps();
    ::Ice::Double mm;
    __is->read(mm);
    __is->endReadEncaps();
    ::IceInternal::BasicStream* __os = __inS.os();
    ::Ice::Int __ret = mm2enc(mm, __current);
    __os->write(__ret);
    return ::Ice::DispatchOK;
}

static ::std::string __Robots__ScorbotIce_all[] =
{
    "ang2enc",
    "enc2ang",
    "enc2mm",
    "getArmPos",
    "getEFpos",
    "getEncoderAng",
    "getIK",
    "getJointPos",
    "getMicroSwitch",
    "getMicroSwitchMotor",
    "getMovementTime",
    "getPWM",
    "homeMotor",
    "homeMotors",
    "ice_id",
    "ice_ids",
    "ice_isA",
    "ice_ping",
    "mm2enc",
    "motorsOff",
    "motorsOn",
    "resetEncoders",
    "setArmPos",
    "setEFPos",
    "setJointPos",
    "setMotor",
    "setSafety",
    "shutdown",
    "stopAllMotors"
};

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

    switch(r.first - __Robots__ScorbotIce_all)
    {
        case 0:
        {
            return ___ang2enc(in, current);
        }
        case 1:
        {
            return ___enc2ang(in, current);
        }
        case 2:
        {
            return ___enc2mm(in, current);
        }
        case 3:
        {
            return ___getArmPos(in, current);
        }
        case 4:
        {
            return ___getEFpos(in, current);
        }
        case 5:
        {
            return ___getEncoderAng(in, current);
        }
        case 6:
        {
            return ___getIK(in, current);
        }
        case 7:
        {
            return ___getJointPos(in, current);
        }
        case 8:
        {
            return ___getMicroSwitch(in, current);
        }
        case 9:
        {
            return ___getMicroSwitchMotor(in, current);
        }
        case 10:
        {
            return ___getMovementTime(in, current);
        }
        case 11:
        {
            return ___getPWM(in, current);
        }
        case 12:
        {
            return ___homeMotor(in, current);
        }
        case 13:
        {
            return ___homeMotors(in, current);
        }
        case 14:
        {
            return ___ice_id(in, current);
        }
        case 15:
        {
            return ___ice_ids(in, current);
        }
        case 16:
        {
            return ___ice_isA(in, current);
        }
        case 17:
        {
            return ___ice_ping(in, current);
        }
        case 18:
        {
            return ___mm2enc(in, current);
        }
        case 19:
        {
            return ___motorsOff(in, current);
        }
        case 20:
        {
            return ___motorsOn(in, current);
        }
        case 21:
        {
            return ___resetEncoders(in, current);
        }
        case 22:
        {
            return ___setArmPos(in, current);
        }
        case 23:
        {
            return ___setEFPos(in, current);
        }
        case 24:
        {
            return ___setJointPos(in, current);
        }
        case 25:
        {
            return ___setMotor(in, current);
        }
        case 26:
        {
            return ___setSafety(in, current);
        }
        case 27:
        {
            return ___shutdown(in, current);
        }
        case 28:
        {
            return ___stopAllMotors(in, current);
        }
    }

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

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

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

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

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

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