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

#include <BrainObjects.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 __BrainObjects__Retina__getOutput_name = "getOutput";

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

::Ice::Object* IceInternal::upCast(::BrainObjects::VisualCortex* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::BrainObjects::VisualCortex* p) { return p; }

::Ice::Object* IceInternal::upCast(::BrainObjects::SaliencyMap* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::BrainObjects::SaliencyMap* p) { return p; }

::Ice::Object* IceInternal::upCast(::BrainObjects::VisualTracker* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::BrainObjects::VisualTracker* p) { return p; }

::Ice::Object* IceInternal::upCast(::BrainObjects::PTZ* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::BrainObjects::PTZ* p) { return p; }

::Ice::Object* IceInternal::upCast(::BrainObjects::Segmenter* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::BrainObjects::Segmenter* p) { return p; }

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

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

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

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

::Ice::Object* IceInternal::upCast(::BrainObjects::SimulationViewer* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::BrainObjects::SimulationViewer* p) { return p; }

::Ice::Object* IceInternal::upCast(::BrainObjects::HomeInterface* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::BrainObjects::HomeInterface* p) { return p; }

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

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

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

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

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

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

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

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

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

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

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

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

::ImageIceMod::ImageIce
IceProxy::BrainObjects::Retina::getOutput(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(__BrainObjects__Retina__getOutput_name);
            __delBase = __getDelegate(false);
            ::IceDelegate::BrainObjects::Retina* __del = dynamic_cast< ::IceDelegate::BrainObjects::Retina*>(__delBase.get());
            return __del->getOutput(__ctx);
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex, 0);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, 0, __cnt);
        }
    }
}

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

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

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

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

const ::std::string&
IceProxy::BrainObjects::VisualCortex::ice_staticId()
{
    return ::BrainObjects::VisualCortex::ice_staticId();
}

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

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

::IceProxy::Ice::Object*
IceProxy::BrainObjects::VisualCortex::__newInstance() const
{
    return new VisualCortex;
}

const ::std::string&
IceProxy::BrainObjects::SaliencyMap::ice_staticId()
{
    return ::BrainObjects::SaliencyMap::ice_staticId();
}

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

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

::IceProxy::Ice::Object*
IceProxy::BrainObjects::SaliencyMap::__newInstance() const
{
    return new SaliencyMap;
}

const ::std::string&
IceProxy::BrainObjects::VisualTracker::ice_staticId()
{
    return ::BrainObjects::VisualTracker::ice_staticId();
}

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

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

::IceProxy::Ice::Object*
IceProxy::BrainObjects::VisualTracker::__newInstance() const
{
    return new VisualTracker;
}

const ::std::string&
IceProxy::BrainObjects::PTZ::ice_staticId()
{
    return ::BrainObjects::PTZ::ice_staticId();
}

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

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

::IceProxy::Ice::Object*
IceProxy::BrainObjects::PTZ::__newInstance() const
{
    return new PTZ;
}

const ::std::string&
IceProxy::BrainObjects::Segmenter::ice_staticId()
{
    return ::BrainObjects::Segmenter::ice_staticId();
}

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

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

::IceProxy::Ice::Object*
IceProxy::BrainObjects::Segmenter::__newInstance() const
{
    return new Segmenter;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

const ::std::string&
IceProxy::BrainObjects::SimulationViewer::ice_staticId()
{
    return ::BrainObjects::SimulationViewer::ice_staticId();
}

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

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

::IceProxy::Ice::Object*
IceProxy::BrainObjects::SimulationViewer::__newInstance() const
{
    return new SimulationViewer;
}

const ::std::string&
IceProxy::BrainObjects::HomeInterface::ice_staticId()
{
    return ::BrainObjects::HomeInterface::ice_staticId();
}

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

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

::IceProxy::Ice::Object*
IceProxy::BrainObjects::HomeInterface::__newInstance() const
{
    return new HomeInterface;
}

::ImageIceMod::ImageIce
IceDelegateM::BrainObjects::Retina::getOutput(const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __BrainObjects__Retina__getOutput_name, ::Ice::Normal, __context);
    bool __ok = __og.invoke();
    ::ImageIceMod::ImageIce __ret;
    try
    {
        if(!__ok)
        {
            try
            {
                __og.throwUserException();
            }
            catch(const ::Ice::UserException& __ex)
            {
                ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
                throw __uue;
            }
        }
        ::IceInternal::BasicStream* __is = __og.is();
        __is->startReadEncaps();
        __ret.__read(__is);
        __is->endReadEncaps();
        return __ret;
    }
    catch(const ::Ice::LocalException& __ex)
    {
        throw ::IceInternal::LocalExceptionWrapper(__ex, false);
    }
}

::ImageIceMod::ImageIce
IceDelegateD::BrainObjects::Retina::getOutput(const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

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

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

    private:

        ::ImageIceMod::ImageIce& _result;
    };

    ::Ice::Current __current;
    __initCurrent(__current, __BrainObjects__Retina__getOutput_name, ::Ice::Normal, __context);
    ::ImageIceMod::ImageIce __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::ObjectPtr
BrainObjects::Retina::ice_clone() const
{
    throw ::Ice::CloneNotImplementedException(__FILE__, __LINE__);
    return 0; // to avoid a warning with some compilers
}

static const ::std::string __BrainObjects__Retina_ids[3] =
{
    "::BrainObjects::Retina",
    "::Ice::Object",
    "::SimEvents::Events"
};

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

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

const ::std::string&
BrainObjects::Retina::ice_id(const ::Ice::Current&) const
{
    return __BrainObjects__Retina_ids[0];
}

const ::std::string&
BrainObjects::Retina::ice_staticId()
{
    return __BrainObjects__Retina_ids[0];
}

::Ice::DispatchStatus
BrainObjects::Retina::___getOutput(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    __inS.is()->skipEmptyEncaps();
    ::IceInternal::BasicStream* __os = __inS.os();
    ::ImageIceMod::ImageIce __ret = getOutput(__current);
    __ret.__write(__os);
    return ::Ice::DispatchOK;
}

static ::std::string __BrainObjects__Retina_all[] =
{
    "evolve",
    "getOutput",
    "ice_id",
    "ice_ids",
    "ice_isA",
    "ice_ping"
};

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

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

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

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

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

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

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

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

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

static const ::std::string __BrainObjects__VisualCortex_ids[3] =
{
    "::BrainObjects::VisualCortex",
    "::Ice::Object",
    "::SimEvents::Events"
};

bool
BrainObjects::VisualCortex::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__BrainObjects__VisualCortex_ids, __BrainObjects__VisualCortex_ids + 3, _s);
}

::std::vector< ::std::string>
BrainObjects::VisualCortex::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__BrainObjects__VisualCortex_ids[0], &__BrainObjects__VisualCortex_ids[3]);
}

const ::std::string&
BrainObjects::VisualCortex::ice_id(const ::Ice::Current&) const
{
    return __BrainObjects__VisualCortex_ids[0];
}

const ::std::string&
BrainObjects::VisualCortex::ice_staticId()
{
    return __BrainObjects__VisualCortex_ids[0];
}

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

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

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

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

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

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

void
BrainObjects::__patch__VisualCortexPtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::BrainObjects::VisualCortexPtr* p = static_cast< ::BrainObjects::VisualCortexPtr*>(__addr);
    assert(p);
    *p = ::BrainObjects::VisualCortexPtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::BrainObjects::VisualCortex::ice_staticId(), v->ice_id());
    }
}

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

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

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

static const ::std::string __BrainObjects__SaliencyMap_ids[3] =
{
    "::BrainObjects::SaliencyMap",
    "::Ice::Object",
    "::SimEvents::Events"
};

bool
BrainObjects::SaliencyMap::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__BrainObjects__SaliencyMap_ids, __BrainObjects__SaliencyMap_ids + 3, _s);
}

::std::vector< ::std::string>
BrainObjects::SaliencyMap::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__BrainObjects__SaliencyMap_ids[0], &__BrainObjects__SaliencyMap_ids[3]);
}

const ::std::string&
BrainObjects::SaliencyMap::ice_id(const ::Ice::Current&) const
{
    return __BrainObjects__SaliencyMap_ids[0];
}

const ::std::string&
BrainObjects::SaliencyMap::ice_staticId()
{
    return __BrainObjects__SaliencyMap_ids[0];
}

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

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

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

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

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

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

void
BrainObjects::__patch__SaliencyMapPtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::BrainObjects::SaliencyMapPtr* p = static_cast< ::BrainObjects::SaliencyMapPtr*>(__addr);
    assert(p);
    *p = ::BrainObjects::SaliencyMapPtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::BrainObjects::SaliencyMap::ice_staticId(), v->ice_id());
    }
}

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

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

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

static const ::std::string __BrainObjects__VisualTracker_ids[3] =
{
    "::BrainObjects::VisualTracker",
    "::Ice::Object",
    "::SimEvents::Events"
};

bool
BrainObjects::VisualTracker::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__BrainObjects__VisualTracker_ids, __BrainObjects__VisualTracker_ids + 3, _s);
}

::std::vector< ::std::string>
BrainObjects::VisualTracker::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__BrainObjects__VisualTracker_ids[0], &__BrainObjects__VisualTracker_ids[3]);
}

const ::std::string&
BrainObjects::VisualTracker::ice_id(const ::Ice::Current&) const
{
    return __BrainObjects__VisualTracker_ids[0];
}

const ::std::string&
BrainObjects::VisualTracker::ice_staticId()
{
    return __BrainObjects__VisualTracker_ids[0];
}

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

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

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

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

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

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

void
BrainObjects::__patch__VisualTrackerPtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::BrainObjects::VisualTrackerPtr* p = static_cast< ::BrainObjects::VisualTrackerPtr*>(__addr);
    assert(p);
    *p = ::BrainObjects::VisualTrackerPtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::BrainObjects::VisualTracker::ice_staticId(), v->ice_id());
    }
}

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

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

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

static const ::std::string __BrainObjects__PTZ_ids[3] =
{
    "::BrainObjects::PTZ",
    "::Ice::Object",
    "::SimEvents::Events"
};

bool
BrainObjects::PTZ::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__BrainObjects__PTZ_ids, __BrainObjects__PTZ_ids + 3, _s);
}

::std::vector< ::std::string>
BrainObjects::PTZ::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__BrainObjects__PTZ_ids[0], &__BrainObjects__PTZ_ids[3]);
}

const ::std::string&
BrainObjects::PTZ::ice_id(const ::Ice::Current&) const
{
    return __BrainObjects__PTZ_ids[0];
}

const ::std::string&
BrainObjects::PTZ::ice_staticId()
{
    return __BrainObjects__PTZ_ids[0];
}

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

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

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

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

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

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

void
BrainObjects::__patch__PTZPtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::BrainObjects::PTZPtr* p = static_cast< ::BrainObjects::PTZPtr*>(__addr);
    assert(p);
    *p = ::BrainObjects::PTZPtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::BrainObjects::PTZ::ice_staticId(), v->ice_id());
    }
}

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

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

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

static const ::std::string __BrainObjects__Segmenter_ids[3] =
{
    "::BrainObjects::Segmenter",
    "::Ice::Object",
    "::SimEvents::Events"
};

bool
BrainObjects::Segmenter::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__BrainObjects__Segmenter_ids, __BrainObjects__Segmenter_ids + 3, _s);
}

::std::vector< ::std::string>
BrainObjects::Segmenter::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__BrainObjects__Segmenter_ids[0], &__BrainObjects__Segmenter_ids[3]);
}

const ::std::string&
BrainObjects::Segmenter::ice_id(const ::Ice::Current&) const
{
    return __BrainObjects__Segmenter_ids[0];
}

const ::std::string&
BrainObjects::Segmenter::ice_staticId()
{
    return __BrainObjects__Segmenter_ids[0];
}

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

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

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

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

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

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

void
BrainObjects::__patch__SegmenterPtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::BrainObjects::SegmenterPtr* p = static_cast< ::BrainObjects::SegmenterPtr*>(__addr);
    assert(p);
    *p = ::BrainObjects::SegmenterPtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::BrainObjects::Segmenter::ice_staticId(), v->ice_id());
    }
}

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

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

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

static const ::std::string __BrainObjects__InferotemporalCortex_ids[3] =
{
    "::BrainObjects::InferotemporalCortex",
    "::Ice::Object",
    "::SimEvents::Events"
};

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

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

const ::std::string&
BrainObjects::InferotemporalCortex::ice_id(const ::Ice::Current&) const
{
    return __BrainObjects__InferotemporalCortex_ids[0];
}

const ::std::string&
BrainObjects::InferotemporalCortex::ice_staticId()
{
    return __BrainObjects__InferotemporalCortex_ids[0];
}

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

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

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

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

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

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

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

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

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

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

static const ::std::string __BrainObjects__Hippocampus_ids[3] =
{
    "::BrainObjects::Hippocampus",
    "::Ice::Object",
    "::SimEvents::Events"
};

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

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

const ::std::string&
BrainObjects::Hippocampus::ice_id(const ::Ice::Current&) const
{
    return __BrainObjects__Hippocampus_ids[0];
}

const ::std::string&
BrainObjects::Hippocampus::ice_staticId()
{
    return __BrainObjects__Hippocampus_ids[0];
}

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

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

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

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

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

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

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

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

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

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

static const ::std::string __BrainObjects__PrimaryMotorCortex_ids[3] =
{
    "::BrainObjects::PrimaryMotorCortex",
    "::Ice::Object",
    "::SimEvents::Events"
};

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

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

const ::std::string&
BrainObjects::PrimaryMotorCortex::ice_id(const ::Ice::Current&) const
{
    return __BrainObjects__PrimaryMotorCortex_ids[0];
}

const ::std::string&
BrainObjects::PrimaryMotorCortex::ice_staticId()
{
    return __BrainObjects__PrimaryMotorCortex_ids[0];
}

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

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

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

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

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

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

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

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

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

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

static const ::std::string __BrainObjects__PrefrontalCortex_ids[3] =
{
    "::BrainObjects::PrefrontalCortex",
    "::Ice::Object",
    "::SimEvents::Events"
};

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

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

const ::std::string&
BrainObjects::PrefrontalCortex::ice_id(const ::Ice::Current&) const
{
    return __BrainObjects__PrefrontalCortex_ids[0];
}

const ::std::string&
BrainObjects::PrefrontalCortex::ice_staticId()
{
    return __BrainObjects__PrefrontalCortex_ids[0];
}

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

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

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

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

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

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

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

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

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

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

static const ::std::string __BrainObjects__SimulationViewer_ids[3] =
{
    "::BrainObjects::SimulationViewer",
    "::Ice::Object",
    "::SimEvents::Events"
};

bool
BrainObjects::SimulationViewer::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__BrainObjects__SimulationViewer_ids, __BrainObjects__SimulationViewer_ids + 3, _s);
}

::std::vector< ::std::string>
BrainObjects::SimulationViewer::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__BrainObjects__SimulationViewer_ids[0], &__BrainObjects__SimulationViewer_ids[3]);
}

const ::std::string&
BrainObjects::SimulationViewer::ice_id(const ::Ice::Current&) const
{
    return __BrainObjects__SimulationViewer_ids[0];
}

const ::std::string&
BrainObjects::SimulationViewer::ice_staticId()
{
    return __BrainObjects__SimulationViewer_ids[0];
}

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

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

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

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

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

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

void
BrainObjects::__patch__SimulationViewerPtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::BrainObjects::SimulationViewerPtr* p = static_cast< ::BrainObjects::SimulationViewerPtr*>(__addr);
    assert(p);
    *p = ::BrainObjects::SimulationViewerPtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::BrainObjects::SimulationViewer::ice_staticId(), v->ice_id());
    }
}

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

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

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

static const ::std::string __BrainObjects__HomeInterface_ids[3] =
{
    "::BrainObjects::HomeInterface",
    "::Ice::Object",
    "::SimEvents::Events"
};

bool
BrainObjects::HomeInterface::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__BrainObjects__HomeInterface_ids, __BrainObjects__HomeInterface_ids + 3, _s);
}

::std::vector< ::std::string>
BrainObjects::HomeInterface::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__BrainObjects__HomeInterface_ids[0], &__BrainObjects__HomeInterface_ids[3]);
}

const ::std::string&
BrainObjects::HomeInterface::ice_id(const ::Ice::Current&) const
{
    return __BrainObjects__HomeInterface_ids[0];
}

const ::std::string&
BrainObjects::HomeInterface::ice_staticId()
{
    return __BrainObjects__HomeInterface_ids[0];
}

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

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

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

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

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

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

void
BrainObjects::__patch__HomeInterfacePtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::BrainObjects::HomeInterfacePtr* p = static_cast< ::BrainObjects::HomeInterfacePtr*>(__addr);
    assert(p);
    *p = ::BrainObjects::HomeInterfacePtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::BrainObjects::HomeInterface::ice_staticId(), v->ice_id());
    }
}

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

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