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

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

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

::Ice::Object* IceInternal::upCast(::RobotBrainObjects::Retina* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::RobotBrainObjects::Retina* p) { return p; }

::Ice::Object* IceInternal::upCast(::RobotBrainObjects::SaliencyModule* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::RobotBrainObjects::SaliencyModule* p) { return p; }

::Ice::Object* IceInternal::upCast(::RobotBrainObjects::PrimaryMotorCortex* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::RobotBrainObjects::PrimaryMotorCortex* p) { return p; }

::Ice::Object* IceInternal::upCast(::RobotBrainObjects::PrimarySomatosensoryCortex* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::RobotBrainObjects::PrimarySomatosensoryCortex* p) { return p; }

::Ice::Object* IceInternal::upCast(::RobotBrainObjects::LateralGeniculateNucleus* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::RobotBrainObjects::LateralGeniculateNucleus* p) { return p; }

::Ice::Object* IceInternal::upCast(::RobotBrainObjects::Hippocampus* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::RobotBrainObjects::Hippocampus* p) { return p; }

::Ice::Object* IceInternal::upCast(::RobotBrainObjects::SupplementaryMotorArea* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::RobotBrainObjects::SupplementaryMotorArea* p) { return p; }

::Ice::Object* IceInternal::upCast(::RobotBrainObjects::PrefrontalCortex* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::RobotBrainObjects::PrefrontalCortex* p) { return p; }

::Ice::Object* IceInternal::upCast(::RobotBrainObjects::InferotemporalCortex* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::RobotBrainObjects::InferotemporalCortex* p) { return p; }

::Ice::Object* IceInternal::upCast(::RobotBrainObjects::Observer* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::RobotBrainObjects::Observer* p) { return p; }

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

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

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

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

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

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

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

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

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

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

const ::std::string&
IceProxy::RobotBrainObjects::Retina::ice_staticId()
{
    return ::RobotBrainObjects::Retina::ice_staticId();
}

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

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

::IceProxy::Ice::Object*
IceProxy::RobotBrainObjects::Retina::__newInstance() const
{
    return new Retina;
}

const ::std::string&
IceProxy::RobotBrainObjects::SaliencyModule::ice_staticId()
{
    return ::RobotBrainObjects::SaliencyModule::ice_staticId();
}

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

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

::IceProxy::Ice::Object*
IceProxy::RobotBrainObjects::SaliencyModule::__newInstance() const
{
    return new SaliencyModule;
}

const ::std::string&
IceProxy::RobotBrainObjects::PrimaryMotorCortex::ice_staticId()
{
    return ::RobotBrainObjects::PrimaryMotorCortex::ice_staticId();
}

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

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

::IceProxy::Ice::Object*
IceProxy::RobotBrainObjects::PrimaryMotorCortex::__newInstance() const
{
    return new PrimaryMotorCortex;
}

const ::std::string&
IceProxy::RobotBrainObjects::PrimarySomatosensoryCortex::ice_staticId()
{
    return ::RobotBrainObjects::PrimarySomatosensoryCortex::ice_staticId();
}

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

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

::IceProxy::Ice::Object*
IceProxy::RobotBrainObjects::PrimarySomatosensoryCortex::__newInstance() const
{
    return new PrimarySomatosensoryCortex;
}

const ::std::string&
IceProxy::RobotBrainObjects::LateralGeniculateNucleus::ice_staticId()
{
    return ::RobotBrainObjects::LateralGeniculateNucleus::ice_staticId();
}

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

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

::IceProxy::Ice::Object*
IceProxy::RobotBrainObjects::LateralGeniculateNucleus::__newInstance() const
{
    return new LateralGeniculateNucleus;
}

const ::std::string&
IceProxy::RobotBrainObjects::Hippocampus::ice_staticId()
{
    return ::RobotBrainObjects::Hippocampus::ice_staticId();
}

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

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

::IceProxy::Ice::Object*
IceProxy::RobotBrainObjects::Hippocampus::__newInstance() const
{
    return new Hippocampus;
}

const ::std::string&
IceProxy::RobotBrainObjects::SupplementaryMotorArea::ice_staticId()
{
    return ::RobotBrainObjects::SupplementaryMotorArea::ice_staticId();
}

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

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

::IceProxy::Ice::Object*
IceProxy::RobotBrainObjects::SupplementaryMotorArea::__newInstance() const
{
    return new SupplementaryMotorArea;
}

const ::std::string&
IceProxy::RobotBrainObjects::PrefrontalCortex::ice_staticId()
{
    return ::RobotBrainObjects::PrefrontalCortex::ice_staticId();
}

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

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

::IceProxy::Ice::Object*
IceProxy::RobotBrainObjects::PrefrontalCortex::__newInstance() const
{
    return new PrefrontalCortex;
}

const ::std::string&
IceProxy::RobotBrainObjects::InferotemporalCortex::ice_staticId()
{
    return ::RobotBrainObjects::InferotemporalCortex::ice_staticId();
}

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

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

::IceProxy::Ice::Object*
IceProxy::RobotBrainObjects::InferotemporalCortex::__newInstance() const
{
    return new InferotemporalCortex;
}

const ::std::string&
IceProxy::RobotBrainObjects::Observer::ice_staticId()
{
    return ::RobotBrainObjects::Observer::ice_staticId();
}

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

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

::IceProxy::Ice::Object*
IceProxy::RobotBrainObjects::Observer::__newInstance() const
{
    return new Observer;
}

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

static const ::std::string __RobotBrainObjects__Retina_ids[3] =
{
    "::Ice::Object",
    "::RobotBrainObjects::Retina",
    "::RobotSimEvents::Events"
};

bool
RobotBrainObjects::Retina::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__RobotBrainObjects__Retina_ids, __RobotBrainObjects__Retina_ids + 3, _s);
}

::std::vector< ::std::string>
RobotBrainObjects::Retina::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__RobotBrainObjects__Retina_ids[0], &__RobotBrainObjects__Retina_ids[3]);
}

const ::std::string&
RobotBrainObjects::Retina::ice_id(const ::Ice::Current&) const
{
    return __RobotBrainObjects__Retina_ids[1];
}

const ::std::string&
RobotBrainObjects::Retina::ice_staticId()
{
    return __RobotBrainObjects__Retina_ids[1];
}

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

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

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

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

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

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

void
RobotBrainObjects::__patch__RetinaPtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::RobotBrainObjects::RetinaPtr* p = static_cast< ::RobotBrainObjects::RetinaPtr*>(__addr);
    assert(p);
    *p = ::RobotBrainObjects::RetinaPtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::RobotBrainObjects::Retina::ice_staticId(), v->ice_id());
    }
}

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

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

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

static const ::std::string __RobotBrainObjects__SaliencyModule_ids[3] =
{
    "::Ice::Object",
    "::RobotBrainObjects::SaliencyModule",
    "::RobotSimEvents::Events"
};

bool
RobotBrainObjects::SaliencyModule::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__RobotBrainObjects__SaliencyModule_ids, __RobotBrainObjects__SaliencyModule_ids + 3, _s);
}

::std::vector< ::std::string>
RobotBrainObjects::SaliencyModule::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__RobotBrainObjects__SaliencyModule_ids[0], &__RobotBrainObjects__SaliencyModule_ids[3]);
}

const ::std::string&
RobotBrainObjects::SaliencyModule::ice_id(const ::Ice::Current&) const
{
    return __RobotBrainObjects__SaliencyModule_ids[1];
}

const ::std::string&
RobotBrainObjects::SaliencyModule::ice_staticId()
{
    return __RobotBrainObjects__SaliencyModule_ids[1];
}

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

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

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

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

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

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

void
RobotBrainObjects::__patch__SaliencyModulePtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::RobotBrainObjects::SaliencyModulePtr* p = static_cast< ::RobotBrainObjects::SaliencyModulePtr*>(__addr);
    assert(p);
    *p = ::RobotBrainObjects::SaliencyModulePtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::RobotBrainObjects::SaliencyModule::ice_staticId(), v->ice_id());
    }
}

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

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

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

static const ::std::string __RobotBrainObjects__PrimaryMotorCortex_ids[3] =
{
    "::Ice::Object",
    "::RobotBrainObjects::PrimaryMotorCortex",
    "::RobotSimEvents::Events"
};

bool
RobotBrainObjects::PrimaryMotorCortex::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__RobotBrainObjects__PrimaryMotorCortex_ids, __RobotBrainObjects__PrimaryMotorCortex_ids + 3, _s);
}

::std::vector< ::std::string>
RobotBrainObjects::PrimaryMotorCortex::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__RobotBrainObjects__PrimaryMotorCortex_ids[0], &__RobotBrainObjects__PrimaryMotorCortex_ids[3]);
}

const ::std::string&
RobotBrainObjects::PrimaryMotorCortex::ice_id(const ::Ice::Current&) const
{
    return __RobotBrainObjects__PrimaryMotorCortex_ids[1];
}

const ::std::string&
RobotBrainObjects::PrimaryMotorCortex::ice_staticId()
{
    return __RobotBrainObjects__PrimaryMotorCortex_ids[1];
}

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

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

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

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

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

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

void
RobotBrainObjects::__patch__PrimaryMotorCortexPtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::RobotBrainObjects::PrimaryMotorCortexPtr* p = static_cast< ::RobotBrainObjects::PrimaryMotorCortexPtr*>(__addr);
    assert(p);
    *p = ::RobotBrainObjects::PrimaryMotorCortexPtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::RobotBrainObjects::PrimaryMotorCortex::ice_staticId(), v->ice_id());
    }
}

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

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

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

static const ::std::string __RobotBrainObjects__PrimarySomatosensoryCortex_ids[3] =
{
    "::Ice::Object",
    "::RobotBrainObjects::PrimarySomatosensoryCortex",
    "::RobotSimEvents::Events"
};

bool
RobotBrainObjects::PrimarySomatosensoryCortex::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__RobotBrainObjects__PrimarySomatosensoryCortex_ids, __RobotBrainObjects__PrimarySomatosensoryCortex_ids + 3, _s);
}

::std::vector< ::std::string>
RobotBrainObjects::PrimarySomatosensoryCortex::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__RobotBrainObjects__PrimarySomatosensoryCortex_ids[0], &__RobotBrainObjects__PrimarySomatosensoryCortex_ids[3]);
}

const ::std::string&
RobotBrainObjects::PrimarySomatosensoryCortex::ice_id(const ::Ice::Current&) const
{
    return __RobotBrainObjects__PrimarySomatosensoryCortex_ids[1];
}

const ::std::string&
RobotBrainObjects::PrimarySomatosensoryCortex::ice_staticId()
{
    return __RobotBrainObjects__PrimarySomatosensoryCortex_ids[1];
}

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

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

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

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

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

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

void
RobotBrainObjects::__patch__PrimarySomatosensoryCortexPtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::RobotBrainObjects::PrimarySomatosensoryCortexPtr* p = static_cast< ::RobotBrainObjects::PrimarySomatosensoryCortexPtr*>(__addr);
    assert(p);
    *p = ::RobotBrainObjects::PrimarySomatosensoryCortexPtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::RobotBrainObjects::PrimarySomatosensoryCortex::ice_staticId(), v->ice_id());
    }
}

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

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

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

static const ::std::string __RobotBrainObjects__LateralGeniculateNucleus_ids[3] =
{
    "::Ice::Object",
    "::RobotBrainObjects::LateralGeniculateNucleus",
    "::RobotSimEvents::Events"
};

bool
RobotBrainObjects::LateralGeniculateNucleus::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__RobotBrainObjects__LateralGeniculateNucleus_ids, __RobotBrainObjects__LateralGeniculateNucleus_ids + 3, _s);
}

::std::vector< ::std::string>
RobotBrainObjects::LateralGeniculateNucleus::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__RobotBrainObjects__LateralGeniculateNucleus_ids[0], &__RobotBrainObjects__LateralGeniculateNucleus_ids[3]);
}

const ::std::string&
RobotBrainObjects::LateralGeniculateNucleus::ice_id(const ::Ice::Current&) const
{
    return __RobotBrainObjects__LateralGeniculateNucleus_ids[1];
}

const ::std::string&
RobotBrainObjects::LateralGeniculateNucleus::ice_staticId()
{
    return __RobotBrainObjects__LateralGeniculateNucleus_ids[1];
}

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

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

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

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

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

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

void
RobotBrainObjects::__patch__LateralGeniculateNucleusPtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::RobotBrainObjects::LateralGeniculateNucleusPtr* p = static_cast< ::RobotBrainObjects::LateralGeniculateNucleusPtr*>(__addr);
    assert(p);
    *p = ::RobotBrainObjects::LateralGeniculateNucleusPtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::RobotBrainObjects::LateralGeniculateNucleus::ice_staticId(), v->ice_id());
    }
}

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

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

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

static const ::std::string __RobotBrainObjects__Hippocampus_ids[3] =
{
    "::Ice::Object",
    "::RobotBrainObjects::Hippocampus",
    "::RobotSimEvents::Events"
};

bool
RobotBrainObjects::Hippocampus::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__RobotBrainObjects__Hippocampus_ids, __RobotBrainObjects__Hippocampus_ids + 3, _s);
}

::std::vector< ::std::string>
RobotBrainObjects::Hippocampus::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__RobotBrainObjects__Hippocampus_ids[0], &__RobotBrainObjects__Hippocampus_ids[3]);
}

const ::std::string&
RobotBrainObjects::Hippocampus::ice_id(const ::Ice::Current&) const
{
    return __RobotBrainObjects__Hippocampus_ids[1];
}

const ::std::string&
RobotBrainObjects::Hippocampus::ice_staticId()
{
    return __RobotBrainObjects__Hippocampus_ids[1];
}

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

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

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

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

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

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

void
RobotBrainObjects::__patch__HippocampusPtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::RobotBrainObjects::HippocampusPtr* p = static_cast< ::RobotBrainObjects::HippocampusPtr*>(__addr);
    assert(p);
    *p = ::RobotBrainObjects::HippocampusPtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::RobotBrainObjects::Hippocampus::ice_staticId(), v->ice_id());
    }
}

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

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

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

static const ::std::string __RobotBrainObjects__SupplementaryMotorArea_ids[3] =
{
    "::Ice::Object",
    "::RobotBrainObjects::SupplementaryMotorArea",
    "::RobotSimEvents::Events"
};

bool
RobotBrainObjects::SupplementaryMotorArea::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__RobotBrainObjects__SupplementaryMotorArea_ids, __RobotBrainObjects__SupplementaryMotorArea_ids + 3, _s);
}

::std::vector< ::std::string>
RobotBrainObjects::SupplementaryMotorArea::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__RobotBrainObjects__SupplementaryMotorArea_ids[0], &__RobotBrainObjects__SupplementaryMotorArea_ids[3]);
}

const ::std::string&
RobotBrainObjects::SupplementaryMotorArea::ice_id(const ::Ice::Current&) const
{
    return __RobotBrainObjects__SupplementaryMotorArea_ids[1];
}

const ::std::string&
RobotBrainObjects::SupplementaryMotorArea::ice_staticId()
{
    return __RobotBrainObjects__SupplementaryMotorArea_ids[1];
}

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

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

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

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

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

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

void
RobotBrainObjects::__patch__SupplementaryMotorAreaPtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::RobotBrainObjects::SupplementaryMotorAreaPtr* p = static_cast< ::RobotBrainObjects::SupplementaryMotorAreaPtr*>(__addr);
    assert(p);
    *p = ::RobotBrainObjects::SupplementaryMotorAreaPtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::RobotBrainObjects::SupplementaryMotorArea::ice_staticId(), v->ice_id());
    }
}

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

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

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

static const ::std::string __RobotBrainObjects__PrefrontalCortex_ids[3] =
{
    "::Ice::Object",
    "::RobotBrainObjects::PrefrontalCortex",
    "::RobotSimEvents::Events"
};

bool
RobotBrainObjects::PrefrontalCortex::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__RobotBrainObjects__PrefrontalCortex_ids, __RobotBrainObjects__PrefrontalCortex_ids + 3, _s);
}

::std::vector< ::std::string>
RobotBrainObjects::PrefrontalCortex::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__RobotBrainObjects__PrefrontalCortex_ids[0], &__RobotBrainObjects__PrefrontalCortex_ids[3]);
}

const ::std::string&
RobotBrainObjects::PrefrontalCortex::ice_id(const ::Ice::Current&) const
{
    return __RobotBrainObjects__PrefrontalCortex_ids[1];
}

const ::std::string&
RobotBrainObjects::PrefrontalCortex::ice_staticId()
{
    return __RobotBrainObjects__PrefrontalCortex_ids[1];
}

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

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

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

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

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

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

void
RobotBrainObjects::__patch__PrefrontalCortexPtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::RobotBrainObjects::PrefrontalCortexPtr* p = static_cast< ::RobotBrainObjects::PrefrontalCortexPtr*>(__addr);
    assert(p);
    *p = ::RobotBrainObjects::PrefrontalCortexPtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::RobotBrainObjects::PrefrontalCortex::ice_staticId(), v->ice_id());
    }
}

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

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

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

static const ::std::string __RobotBrainObjects__InferotemporalCortex_ids[3] =
{
    "::Ice::Object",
    "::RobotBrainObjects::InferotemporalCortex",
    "::RobotSimEvents::Events"
};

bool
RobotBrainObjects::InferotemporalCortex::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__RobotBrainObjects__InferotemporalCortex_ids, __RobotBrainObjects__InferotemporalCortex_ids + 3, _s);
}

::std::vector< ::std::string>
RobotBrainObjects::InferotemporalCortex::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__RobotBrainObjects__InferotemporalCortex_ids[0], &__RobotBrainObjects__InferotemporalCortex_ids[3]);
}

const ::std::string&
RobotBrainObjects::InferotemporalCortex::ice_id(const ::Ice::Current&) const
{
    return __RobotBrainObjects__InferotemporalCortex_ids[1];
}

const ::std::string&
RobotBrainObjects::InferotemporalCortex::ice_staticId()
{
    return __RobotBrainObjects__InferotemporalCortex_ids[1];
}

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

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

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

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

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

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

void
RobotBrainObjects::__patch__InferotemporalCortexPtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::RobotBrainObjects::InferotemporalCortexPtr* p = static_cast< ::RobotBrainObjects::InferotemporalCortexPtr*>(__addr);
    assert(p);
    *p = ::RobotBrainObjects::InferotemporalCortexPtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::RobotBrainObjects::InferotemporalCortex::ice_staticId(), v->ice_id());
    }
}

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

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

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

static const ::std::string __RobotBrainObjects__Observer_ids[3] =
{
    "::Ice::Object",
    "::RobotBrainObjects::Observer",
    "::RobotSimEvents::Events"
};

bool
RobotBrainObjects::Observer::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__RobotBrainObjects__Observer_ids, __RobotBrainObjects__Observer_ids + 3, _s);
}

::std::vector< ::std::string>
RobotBrainObjects::Observer::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__RobotBrainObjects__Observer_ids[0], &__RobotBrainObjects__Observer_ids[3]);
}

const ::std::string&
RobotBrainObjects::Observer::ice_id(const ::Ice::Current&) const
{
    return __RobotBrainObjects__Observer_ids[1];
}

const ::std::string&
RobotBrainObjects::Observer::ice_staticId()
{
    return __RobotBrainObjects__Observer_ids[1];
}

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

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

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

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

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

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

void
RobotBrainObjects::__patch__ObserverPtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::RobotBrainObjects::ObserverPtr* p = static_cast< ::RobotBrainObjects::ObserverPtr*>(__addr);
    assert(p);
    *p = ::RobotBrainObjects::ObserverPtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::RobotBrainObjects::Observer::ice_staticId(), v->ice_id());
    }
}

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

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