RobotBrainObjects.ice.H

00001 // **********************************************************************
00002 //
00003 // Copyright (c) 2003-2009 ZeroC, Inc. All rights reserved.
00004 //
00005 // This copy of Ice is licensed to you under the terms described in the
00006 // ICE_LICENSE file included in this distribution.
00007 //
00008 // **********************************************************************
00009 
00010 // Ice version 3.3.1
00011 // Generated from file `RobotBrainObjects.ice'
00012 
00013 #ifndef __src_Ice__RobotBrainObjects_ice_H__
00014 #define __src_Ice__RobotBrainObjects_ice_H__
00015 
00016 #include <Ice/LocalObjectF.h>
00017 #include <Ice/ProxyF.h>
00018 #include <Ice/ObjectF.h>
00019 #include <Ice/Exception.h>
00020 #include <Ice/LocalObject.h>
00021 #include <Ice/Proxy.h>
00022 #include <Ice/Object.h>
00023 #include <Ice/Outgoing.h>
00024 #include <Ice/Incoming.h>
00025 #include <Ice/Direct.h>
00026 #include <Ice/FactoryTable.h>
00027 #include <Ice/StreamF.h>
00028 #include <Ice/ImageIce.ice.H>
00029 #include <Ice/RobotSimEvents.ice.H>
00030 #include <Ice/UndefSysMacros.h>
00031 
00032 #ifndef ICE_IGNORE_VERSION
00033 #   if ICE_INT_VERSION / 100 != 303
00034 #       error Ice version mismatch!
00035 #   endif
00036 #   if ICE_INT_VERSION % 100 > 50
00037 #       error Beta header file detected
00038 #   endif
00039 #   if ICE_INT_VERSION % 100 < 1
00040 #       error Ice patch level mismatch!
00041 #   endif
00042 #endif
00043 
00044 namespace IceProxy
00045 {
00046 
00047 namespace RobotBrainObjects
00048 {
00049 
00050 class Retina;
00051 
00052 class SaliencyModule;
00053 
00054 class PrimaryMotorCortex;
00055 
00056 class PrimarySomatosensoryCortex;
00057 
00058 class LateralGeniculateNucleus;
00059 
00060 class Hippocampus;
00061 
00062 class SupplementaryMotorArea;
00063 
00064 class PrefrontalCortex;
00065 
00066 class InferotemporalCortex;
00067 
00068 class Observer;
00069 
00070 }
00071 
00072 }
00073 
00074 namespace RobotBrainObjects
00075 {
00076 
00077 class Retina;
00078 bool operator==(const Retina&, const Retina&);
00079 bool operator<(const Retina&, const Retina&);
00080 
00081 class SaliencyModule;
00082 bool operator==(const SaliencyModule&, const SaliencyModule&);
00083 bool operator<(const SaliencyModule&, const SaliencyModule&);
00084 
00085 class PrimaryMotorCortex;
00086 bool operator==(const PrimaryMotorCortex&, const PrimaryMotorCortex&);
00087 bool operator<(const PrimaryMotorCortex&, const PrimaryMotorCortex&);
00088 
00089 class PrimarySomatosensoryCortex;
00090 bool operator==(const PrimarySomatosensoryCortex&, const PrimarySomatosensoryCortex&);
00091 bool operator<(const PrimarySomatosensoryCortex&, const PrimarySomatosensoryCortex&);
00092 
00093 class LateralGeniculateNucleus;
00094 bool operator==(const LateralGeniculateNucleus&, const LateralGeniculateNucleus&);
00095 bool operator<(const LateralGeniculateNucleus&, const LateralGeniculateNucleus&);
00096 
00097 class Hippocampus;
00098 bool operator==(const Hippocampus&, const Hippocampus&);
00099 bool operator<(const Hippocampus&, const Hippocampus&);
00100 
00101 class SupplementaryMotorArea;
00102 bool operator==(const SupplementaryMotorArea&, const SupplementaryMotorArea&);
00103 bool operator<(const SupplementaryMotorArea&, const SupplementaryMotorArea&);
00104 
00105 class PrefrontalCortex;
00106 bool operator==(const PrefrontalCortex&, const PrefrontalCortex&);
00107 bool operator<(const PrefrontalCortex&, const PrefrontalCortex&);
00108 
00109 class InferotemporalCortex;
00110 bool operator==(const InferotemporalCortex&, const InferotemporalCortex&);
00111 bool operator<(const InferotemporalCortex&, const InferotemporalCortex&);
00112 
00113 class Observer;
00114 bool operator==(const Observer&, const Observer&);
00115 bool operator<(const Observer&, const Observer&);
00116 
00117 }
00118 
00119 namespace IceInternal
00120 {
00121 
00122 ::Ice::Object* upCast(::RobotBrainObjects::Retina*);
00123 ::IceProxy::Ice::Object* upCast(::IceProxy::RobotBrainObjects::Retina*);
00124 
00125 ::Ice::Object* upCast(::RobotBrainObjects::SaliencyModule*);
00126 ::IceProxy::Ice::Object* upCast(::IceProxy::RobotBrainObjects::SaliencyModule*);
00127 
00128 ::Ice::Object* upCast(::RobotBrainObjects::PrimaryMotorCortex*);
00129 ::IceProxy::Ice::Object* upCast(::IceProxy::RobotBrainObjects::PrimaryMotorCortex*);
00130 
00131 ::Ice::Object* upCast(::RobotBrainObjects::PrimarySomatosensoryCortex*);
00132 ::IceProxy::Ice::Object* upCast(::IceProxy::RobotBrainObjects::PrimarySomatosensoryCortex*);
00133 
00134 ::Ice::Object* upCast(::RobotBrainObjects::LateralGeniculateNucleus*);
00135 ::IceProxy::Ice::Object* upCast(::IceProxy::RobotBrainObjects::LateralGeniculateNucleus*);
00136 
00137 ::Ice::Object* upCast(::RobotBrainObjects::Hippocampus*);
00138 ::IceProxy::Ice::Object* upCast(::IceProxy::RobotBrainObjects::Hippocampus*);
00139 
00140 ::Ice::Object* upCast(::RobotBrainObjects::SupplementaryMotorArea*);
00141 ::IceProxy::Ice::Object* upCast(::IceProxy::RobotBrainObjects::SupplementaryMotorArea*);
00142 
00143 ::Ice::Object* upCast(::RobotBrainObjects::PrefrontalCortex*);
00144 ::IceProxy::Ice::Object* upCast(::IceProxy::RobotBrainObjects::PrefrontalCortex*);
00145 
00146 ::Ice::Object* upCast(::RobotBrainObjects::InferotemporalCortex*);
00147 ::IceProxy::Ice::Object* upCast(::IceProxy::RobotBrainObjects::InferotemporalCortex*);
00148 
00149 ::Ice::Object* upCast(::RobotBrainObjects::Observer*);
00150 ::IceProxy::Ice::Object* upCast(::IceProxy::RobotBrainObjects::Observer*);
00151 
00152 }
00153 
00154 namespace RobotBrainObjects
00155 {
00156 
00157 typedef ::IceInternal::Handle< ::RobotBrainObjects::Retina> RetinaPtr;
00158 typedef ::IceInternal::ProxyHandle< ::IceProxy::RobotBrainObjects::Retina> RetinaPrx;
00159 
00160 void __read(::IceInternal::BasicStream*, RetinaPrx&);
00161 void __patch__RetinaPtr(void*, ::Ice::ObjectPtr&);
00162 
00163 typedef ::IceInternal::Handle< ::RobotBrainObjects::SaliencyModule> SaliencyModulePtr;
00164 typedef ::IceInternal::ProxyHandle< ::IceProxy::RobotBrainObjects::SaliencyModule> SaliencyModulePrx;
00165 
00166 void __read(::IceInternal::BasicStream*, SaliencyModulePrx&);
00167 void __patch__SaliencyModulePtr(void*, ::Ice::ObjectPtr&);
00168 
00169 typedef ::IceInternal::Handle< ::RobotBrainObjects::PrimaryMotorCortex> PrimaryMotorCortexPtr;
00170 typedef ::IceInternal::ProxyHandle< ::IceProxy::RobotBrainObjects::PrimaryMotorCortex> PrimaryMotorCortexPrx;
00171 
00172 void __read(::IceInternal::BasicStream*, PrimaryMotorCortexPrx&);
00173 void __patch__PrimaryMotorCortexPtr(void*, ::Ice::ObjectPtr&);
00174 
00175 typedef ::IceInternal::Handle< ::RobotBrainObjects::PrimarySomatosensoryCortex> PrimarySomatosensoryCortexPtr;
00176 typedef ::IceInternal::ProxyHandle< ::IceProxy::RobotBrainObjects::PrimarySomatosensoryCortex> PrimarySomatosensoryCortexPrx;
00177 
00178 void __read(::IceInternal::BasicStream*, PrimarySomatosensoryCortexPrx&);
00179 void __patch__PrimarySomatosensoryCortexPtr(void*, ::Ice::ObjectPtr&);
00180 
00181 typedef ::IceInternal::Handle< ::RobotBrainObjects::LateralGeniculateNucleus> LateralGeniculateNucleusPtr;
00182 typedef ::IceInternal::ProxyHandle< ::IceProxy::RobotBrainObjects::LateralGeniculateNucleus> LateralGeniculateNucleusPrx;
00183 
00184 void __read(::IceInternal::BasicStream*, LateralGeniculateNucleusPrx&);
00185 void __patch__LateralGeniculateNucleusPtr(void*, ::Ice::ObjectPtr&);
00186 
00187 typedef ::IceInternal::Handle< ::RobotBrainObjects::Hippocampus> HippocampusPtr;
00188 typedef ::IceInternal::ProxyHandle< ::IceProxy::RobotBrainObjects::Hippocampus> HippocampusPrx;
00189 
00190 void __read(::IceInternal::BasicStream*, HippocampusPrx&);
00191 void __patch__HippocampusPtr(void*, ::Ice::ObjectPtr&);
00192 
00193 typedef ::IceInternal::Handle< ::RobotBrainObjects::SupplementaryMotorArea> SupplementaryMotorAreaPtr;
00194 typedef ::IceInternal::ProxyHandle< ::IceProxy::RobotBrainObjects::SupplementaryMotorArea> SupplementaryMotorAreaPrx;
00195 
00196 void __read(::IceInternal::BasicStream*, SupplementaryMotorAreaPrx&);
00197 void __patch__SupplementaryMotorAreaPtr(void*, ::Ice::ObjectPtr&);
00198 
00199 typedef ::IceInternal::Handle< ::RobotBrainObjects::PrefrontalCortex> PrefrontalCortexPtr;
00200 typedef ::IceInternal::ProxyHandle< ::IceProxy::RobotBrainObjects::PrefrontalCortex> PrefrontalCortexPrx;
00201 
00202 void __read(::IceInternal::BasicStream*, PrefrontalCortexPrx&);
00203 void __patch__PrefrontalCortexPtr(void*, ::Ice::ObjectPtr&);
00204 
00205 typedef ::IceInternal::Handle< ::RobotBrainObjects::InferotemporalCortex> InferotemporalCortexPtr;
00206 typedef ::IceInternal::ProxyHandle< ::IceProxy::RobotBrainObjects::InferotemporalCortex> InferotemporalCortexPrx;
00207 
00208 void __read(::IceInternal::BasicStream*, InferotemporalCortexPrx&);
00209 void __patch__InferotemporalCortexPtr(void*, ::Ice::ObjectPtr&);
00210 
00211 typedef ::IceInternal::Handle< ::RobotBrainObjects::Observer> ObserverPtr;
00212 typedef ::IceInternal::ProxyHandle< ::IceProxy::RobotBrainObjects::Observer> ObserverPrx;
00213 
00214 void __read(::IceInternal::BasicStream*, ObserverPrx&);
00215 void __patch__ObserverPtr(void*, ::Ice::ObjectPtr&);
00216 
00217 }
00218 
00219 namespace RobotBrainObjects
00220 {
00221 
00222 const ::Ice::Int RobotBrainPort = 20004;
00223 
00224 const ::Ice::Int SaliencyModulePort = 20005;
00225 
00226 const ::Ice::Int RetinaPort = 20006;
00227 
00228 const ::Ice::Int SeaBeeGUIPort = 20007;
00229 
00230 }
00231 
00232 namespace IceProxy
00233 {
00234 
00235 namespace RobotBrainObjects
00236 {
00237 
00238 class Retina : virtual public ::IceProxy::RobotSimEvents::Events
00239 {
00240 public:
00241 
00242     ::IceInternal::ProxyHandle<Retina> ice_context(const ::Ice::Context& __context) const
00243     {
00244     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00245         typedef ::IceProxy::Ice::Object _Base;
00246         return dynamic_cast<Retina*>(_Base::ice_context(__context).get());
00247     #else
00248         return dynamic_cast<Retina*>(::IceProxy::Ice::Object::ice_context(__context).get());
00249     #endif
00250     }
00251 
00252     ::IceInternal::ProxyHandle<Retina> ice_adapterId(const std::string& __id) const
00253     {
00254     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00255         typedef ::IceProxy::Ice::Object _Base;
00256         return dynamic_cast<Retina*>(_Base::ice_adapterId(__id).get());
00257     #else
00258         return dynamic_cast<Retina*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
00259     #endif
00260     }
00261 
00262     ::IceInternal::ProxyHandle<Retina> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
00263     {
00264     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00265         typedef ::IceProxy::Ice::Object _Base;
00266         return dynamic_cast<Retina*>(_Base::ice_endpoints(__endpoints).get());
00267     #else
00268         return dynamic_cast<Retina*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
00269     #endif
00270     }
00271 
00272     ::IceInternal::ProxyHandle<Retina> ice_locatorCacheTimeout(int __timeout) const
00273     {
00274     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00275         typedef ::IceProxy::Ice::Object _Base;
00276         return dynamic_cast<Retina*>(_Base::ice_locatorCacheTimeout(__timeout).get());
00277     #else
00278         return dynamic_cast<Retina*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
00279     #endif
00280     }
00281 
00282     ::IceInternal::ProxyHandle<Retina> ice_connectionCached(bool __cached) const
00283     {
00284     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00285         typedef ::IceProxy::Ice::Object _Base;
00286         return dynamic_cast<Retina*>(_Base::ice_connectionCached(__cached).get());
00287     #else
00288         return dynamic_cast<Retina*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
00289     #endif
00290     }
00291 
00292     ::IceInternal::ProxyHandle<Retina> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
00293     {
00294     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00295         typedef ::IceProxy::Ice::Object _Base;
00296         return dynamic_cast<Retina*>(_Base::ice_endpointSelection(__est).get());
00297     #else
00298         return dynamic_cast<Retina*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
00299     #endif
00300     }
00301 
00302     ::IceInternal::ProxyHandle<Retina> ice_secure(bool __secure) const
00303     {
00304     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00305         typedef ::IceProxy::Ice::Object _Base;
00306         return dynamic_cast<Retina*>(_Base::ice_secure(__secure).get());
00307     #else
00308         return dynamic_cast<Retina*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
00309     #endif
00310     }
00311 
00312     ::IceInternal::ProxyHandle<Retina> ice_preferSecure(bool __preferSecure) const
00313     {
00314     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00315         typedef ::IceProxy::Ice::Object _Base;
00316         return dynamic_cast<Retina*>(_Base::ice_preferSecure(__preferSecure).get());
00317     #else
00318         return dynamic_cast<Retina*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
00319     #endif
00320     }
00321 
00322     ::IceInternal::ProxyHandle<Retina> ice_router(const ::Ice::RouterPrx& __router) const
00323     {
00324     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00325         typedef ::IceProxy::Ice::Object _Base;
00326         return dynamic_cast<Retina*>(_Base::ice_router(__router).get());
00327     #else
00328         return dynamic_cast<Retina*>(::IceProxy::Ice::Object::ice_router(__router).get());
00329     #endif
00330     }
00331 
00332     ::IceInternal::ProxyHandle<Retina> ice_locator(const ::Ice::LocatorPrx& __locator) const
00333     {
00334     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00335         typedef ::IceProxy::Ice::Object _Base;
00336         return dynamic_cast<Retina*>(_Base::ice_locator(__locator).get());
00337     #else
00338         return dynamic_cast<Retina*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
00339     #endif
00340     }
00341 
00342     ::IceInternal::ProxyHandle<Retina> ice_collocationOptimized(bool __co) const
00343     {
00344     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00345         typedef ::IceProxy::Ice::Object _Base;
00346         return dynamic_cast<Retina*>(_Base::ice_collocationOptimized(__co).get());
00347     #else
00348         return dynamic_cast<Retina*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
00349     #endif
00350     }
00351 
00352     ::IceInternal::ProxyHandle<Retina> ice_twoway() const
00353     {
00354     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00355         typedef ::IceProxy::Ice::Object _Base;
00356         return dynamic_cast<Retina*>(_Base::ice_twoway().get());
00357     #else
00358         return dynamic_cast<Retina*>(::IceProxy::Ice::Object::ice_twoway().get());
00359     #endif
00360     }
00361 
00362     ::IceInternal::ProxyHandle<Retina> ice_oneway() const
00363     {
00364     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00365         typedef ::IceProxy::Ice::Object _Base;
00366         return dynamic_cast<Retina*>(_Base::ice_oneway().get());
00367     #else
00368         return dynamic_cast<Retina*>(::IceProxy::Ice::Object::ice_oneway().get());
00369     #endif
00370     }
00371 
00372     ::IceInternal::ProxyHandle<Retina> ice_batchOneway() const
00373     {
00374     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00375         typedef ::IceProxy::Ice::Object _Base;
00376         return dynamic_cast<Retina*>(_Base::ice_batchOneway().get());
00377     #else
00378         return dynamic_cast<Retina*>(::IceProxy::Ice::Object::ice_batchOneway().get());
00379     #endif
00380     }
00381 
00382     ::IceInternal::ProxyHandle<Retina> ice_datagram() const
00383     {
00384     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00385         typedef ::IceProxy::Ice::Object _Base;
00386         return dynamic_cast<Retina*>(_Base::ice_datagram().get());
00387     #else
00388         return dynamic_cast<Retina*>(::IceProxy::Ice::Object::ice_datagram().get());
00389     #endif
00390     }
00391 
00392     ::IceInternal::ProxyHandle<Retina> ice_batchDatagram() const
00393     {
00394     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00395         typedef ::IceProxy::Ice::Object _Base;
00396         return dynamic_cast<Retina*>(_Base::ice_batchDatagram().get());
00397     #else
00398         return dynamic_cast<Retina*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
00399     #endif
00400     }
00401 
00402     ::IceInternal::ProxyHandle<Retina> ice_compress(bool __compress) const
00403     {
00404     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00405         typedef ::IceProxy::Ice::Object _Base;
00406         return dynamic_cast<Retina*>(_Base::ice_compress(__compress).get());
00407     #else
00408         return dynamic_cast<Retina*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
00409     #endif
00410     }
00411 
00412     ::IceInternal::ProxyHandle<Retina> ice_timeout(int __timeout) const
00413     {
00414     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00415         typedef ::IceProxy::Ice::Object _Base;
00416         return dynamic_cast<Retina*>(_Base::ice_timeout(__timeout).get());
00417     #else
00418         return dynamic_cast<Retina*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
00419     #endif
00420     }
00421 
00422     ::IceInternal::ProxyHandle<Retina> ice_connectionId(const std::string& __id) const
00423     {
00424     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00425         typedef ::IceProxy::Ice::Object _Base;
00426         return dynamic_cast<Retina*>(_Base::ice_connectionId(__id).get());
00427     #else
00428         return dynamic_cast<Retina*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
00429     #endif
00430     }
00431 
00432     static const ::std::string& ice_staticId();
00433 
00434 private:
00435 
00436     virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
00437     virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
00438     virtual ::IceProxy::Ice::Object* __newInstance() const;
00439 };
00440 
00441 class SaliencyModule : virtual public ::IceProxy::RobotSimEvents::Events
00442 {
00443 public:
00444 
00445     ::IceInternal::ProxyHandle<SaliencyModule> ice_context(const ::Ice::Context& __context) const
00446     {
00447     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00448         typedef ::IceProxy::Ice::Object _Base;
00449         return dynamic_cast<SaliencyModule*>(_Base::ice_context(__context).get());
00450     #else
00451         return dynamic_cast<SaliencyModule*>(::IceProxy::Ice::Object::ice_context(__context).get());
00452     #endif
00453     }
00454 
00455     ::IceInternal::ProxyHandle<SaliencyModule> ice_adapterId(const std::string& __id) const
00456     {
00457     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00458         typedef ::IceProxy::Ice::Object _Base;
00459         return dynamic_cast<SaliencyModule*>(_Base::ice_adapterId(__id).get());
00460     #else
00461         return dynamic_cast<SaliencyModule*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
00462     #endif
00463     }
00464 
00465     ::IceInternal::ProxyHandle<SaliencyModule> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
00466     {
00467     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00468         typedef ::IceProxy::Ice::Object _Base;
00469         return dynamic_cast<SaliencyModule*>(_Base::ice_endpoints(__endpoints).get());
00470     #else
00471         return dynamic_cast<SaliencyModule*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
00472     #endif
00473     }
00474 
00475     ::IceInternal::ProxyHandle<SaliencyModule> ice_locatorCacheTimeout(int __timeout) const
00476     {
00477     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00478         typedef ::IceProxy::Ice::Object _Base;
00479         return dynamic_cast<SaliencyModule*>(_Base::ice_locatorCacheTimeout(__timeout).get());
00480     #else
00481         return dynamic_cast<SaliencyModule*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
00482     #endif
00483     }
00484 
00485     ::IceInternal::ProxyHandle<SaliencyModule> ice_connectionCached(bool __cached) const
00486     {
00487     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00488         typedef ::IceProxy::Ice::Object _Base;
00489         return dynamic_cast<SaliencyModule*>(_Base::ice_connectionCached(__cached).get());
00490     #else
00491         return dynamic_cast<SaliencyModule*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
00492     #endif
00493     }
00494 
00495     ::IceInternal::ProxyHandle<SaliencyModule> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
00496     {
00497     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00498         typedef ::IceProxy::Ice::Object _Base;
00499         return dynamic_cast<SaliencyModule*>(_Base::ice_endpointSelection(__est).get());
00500     #else
00501         return dynamic_cast<SaliencyModule*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
00502     #endif
00503     }
00504 
00505     ::IceInternal::ProxyHandle<SaliencyModule> ice_secure(bool __secure) const
00506     {
00507     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00508         typedef ::IceProxy::Ice::Object _Base;
00509         return dynamic_cast<SaliencyModule*>(_Base::ice_secure(__secure).get());
00510     #else
00511         return dynamic_cast<SaliencyModule*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
00512     #endif
00513     }
00514 
00515     ::IceInternal::ProxyHandle<SaliencyModule> ice_preferSecure(bool __preferSecure) const
00516     {
00517     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00518         typedef ::IceProxy::Ice::Object _Base;
00519         return dynamic_cast<SaliencyModule*>(_Base::ice_preferSecure(__preferSecure).get());
00520     #else
00521         return dynamic_cast<SaliencyModule*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
00522     #endif
00523     }
00524 
00525     ::IceInternal::ProxyHandle<SaliencyModule> ice_router(const ::Ice::RouterPrx& __router) const
00526     {
00527     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00528         typedef ::IceProxy::Ice::Object _Base;
00529         return dynamic_cast<SaliencyModule*>(_Base::ice_router(__router).get());
00530     #else
00531         return dynamic_cast<SaliencyModule*>(::IceProxy::Ice::Object::ice_router(__router).get());
00532     #endif
00533     }
00534 
00535     ::IceInternal::ProxyHandle<SaliencyModule> ice_locator(const ::Ice::LocatorPrx& __locator) const
00536     {
00537     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00538         typedef ::IceProxy::Ice::Object _Base;
00539         return dynamic_cast<SaliencyModule*>(_Base::ice_locator(__locator).get());
00540     #else
00541         return dynamic_cast<SaliencyModule*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
00542     #endif
00543     }
00544 
00545     ::IceInternal::ProxyHandle<SaliencyModule> ice_collocationOptimized(bool __co) const
00546     {
00547     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00548         typedef ::IceProxy::Ice::Object _Base;
00549         return dynamic_cast<SaliencyModule*>(_Base::ice_collocationOptimized(__co).get());
00550     #else
00551         return dynamic_cast<SaliencyModule*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
00552     #endif
00553     }
00554 
00555     ::IceInternal::ProxyHandle<SaliencyModule> ice_twoway() const
00556     {
00557     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00558         typedef ::IceProxy::Ice::Object _Base;
00559         return dynamic_cast<SaliencyModule*>(_Base::ice_twoway().get());
00560     #else
00561         return dynamic_cast<SaliencyModule*>(::IceProxy::Ice::Object::ice_twoway().get());
00562     #endif
00563     }
00564 
00565     ::IceInternal::ProxyHandle<SaliencyModule> ice_oneway() const
00566     {
00567     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00568         typedef ::IceProxy::Ice::Object _Base;
00569         return dynamic_cast<SaliencyModule*>(_Base::ice_oneway().get());
00570     #else
00571         return dynamic_cast<SaliencyModule*>(::IceProxy::Ice::Object::ice_oneway().get());
00572     #endif
00573     }
00574 
00575     ::IceInternal::ProxyHandle<SaliencyModule> ice_batchOneway() const
00576     {
00577     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00578         typedef ::IceProxy::Ice::Object _Base;
00579         return dynamic_cast<SaliencyModule*>(_Base::ice_batchOneway().get());
00580     #else
00581         return dynamic_cast<SaliencyModule*>(::IceProxy::Ice::Object::ice_batchOneway().get());
00582     #endif
00583     }
00584 
00585     ::IceInternal::ProxyHandle<SaliencyModule> ice_datagram() const
00586     {
00587     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00588         typedef ::IceProxy::Ice::Object _Base;
00589         return dynamic_cast<SaliencyModule*>(_Base::ice_datagram().get());
00590     #else
00591         return dynamic_cast<SaliencyModule*>(::IceProxy::Ice::Object::ice_datagram().get());
00592     #endif
00593     }
00594 
00595     ::IceInternal::ProxyHandle<SaliencyModule> ice_batchDatagram() const
00596     {
00597     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00598         typedef ::IceProxy::Ice::Object _Base;
00599         return dynamic_cast<SaliencyModule*>(_Base::ice_batchDatagram().get());
00600     #else
00601         return dynamic_cast<SaliencyModule*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
00602     #endif
00603     }
00604 
00605     ::IceInternal::ProxyHandle<SaliencyModule> ice_compress(bool __compress) const
00606     {
00607     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00608         typedef ::IceProxy::Ice::Object _Base;
00609         return dynamic_cast<SaliencyModule*>(_Base::ice_compress(__compress).get());
00610     #else
00611         return dynamic_cast<SaliencyModule*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
00612     #endif
00613     }
00614 
00615     ::IceInternal::ProxyHandle<SaliencyModule> ice_timeout(int __timeout) const
00616     {
00617     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00618         typedef ::IceProxy::Ice::Object _Base;
00619         return dynamic_cast<SaliencyModule*>(_Base::ice_timeout(__timeout).get());
00620     #else
00621         return dynamic_cast<SaliencyModule*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
00622     #endif
00623     }
00624 
00625     ::IceInternal::ProxyHandle<SaliencyModule> ice_connectionId(const std::string& __id) const
00626     {
00627     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00628         typedef ::IceProxy::Ice::Object _Base;
00629         return dynamic_cast<SaliencyModule*>(_Base::ice_connectionId(__id).get());
00630     #else
00631         return dynamic_cast<SaliencyModule*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
00632     #endif
00633     }
00634 
00635     static const ::std::string& ice_staticId();
00636 
00637 private:
00638 
00639     virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
00640     virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
00641     virtual ::IceProxy::Ice::Object* __newInstance() const;
00642 };
00643 
00644 class PrimaryMotorCortex : virtual public ::IceProxy::RobotSimEvents::Events
00645 {
00646 public:
00647 
00648     ::IceInternal::ProxyHandle<PrimaryMotorCortex> ice_context(const ::Ice::Context& __context) const
00649     {
00650     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00651         typedef ::IceProxy::Ice::Object _Base;
00652         return dynamic_cast<PrimaryMotorCortex*>(_Base::ice_context(__context).get());
00653     #else
00654         return dynamic_cast<PrimaryMotorCortex*>(::IceProxy::Ice::Object::ice_context(__context).get());
00655     #endif
00656     }
00657 
00658     ::IceInternal::ProxyHandle<PrimaryMotorCortex> ice_adapterId(const std::string& __id) const
00659     {
00660     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00661         typedef ::IceProxy::Ice::Object _Base;
00662         return dynamic_cast<PrimaryMotorCortex*>(_Base::ice_adapterId(__id).get());
00663     #else
00664         return dynamic_cast<PrimaryMotorCortex*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
00665     #endif
00666     }
00667 
00668     ::IceInternal::ProxyHandle<PrimaryMotorCortex> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
00669     {
00670     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00671         typedef ::IceProxy::Ice::Object _Base;
00672         return dynamic_cast<PrimaryMotorCortex*>(_Base::ice_endpoints(__endpoints).get());
00673     #else
00674         return dynamic_cast<PrimaryMotorCortex*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
00675     #endif
00676     }
00677 
00678     ::IceInternal::ProxyHandle<PrimaryMotorCortex> ice_locatorCacheTimeout(int __timeout) const
00679     {
00680     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00681         typedef ::IceProxy::Ice::Object _Base;
00682         return dynamic_cast<PrimaryMotorCortex*>(_Base::ice_locatorCacheTimeout(__timeout).get());
00683     #else
00684         return dynamic_cast<PrimaryMotorCortex*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
00685     #endif
00686     }
00687 
00688     ::IceInternal::ProxyHandle<PrimaryMotorCortex> ice_connectionCached(bool __cached) const
00689     {
00690     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00691         typedef ::IceProxy::Ice::Object _Base;
00692         return dynamic_cast<PrimaryMotorCortex*>(_Base::ice_connectionCached(__cached).get());
00693     #else
00694         return dynamic_cast<PrimaryMotorCortex*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
00695     #endif
00696     }
00697 
00698     ::IceInternal::ProxyHandle<PrimaryMotorCortex> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
00699     {
00700     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00701         typedef ::IceProxy::Ice::Object _Base;
00702         return dynamic_cast<PrimaryMotorCortex*>(_Base::ice_endpointSelection(__est).get());
00703     #else
00704         return dynamic_cast<PrimaryMotorCortex*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
00705     #endif
00706     }
00707 
00708     ::IceInternal::ProxyHandle<PrimaryMotorCortex> ice_secure(bool __secure) const
00709     {
00710     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00711         typedef ::IceProxy::Ice::Object _Base;
00712         return dynamic_cast<PrimaryMotorCortex*>(_Base::ice_secure(__secure).get());
00713     #else
00714         return dynamic_cast<PrimaryMotorCortex*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
00715     #endif
00716     }
00717 
00718     ::IceInternal::ProxyHandle<PrimaryMotorCortex> ice_preferSecure(bool __preferSecure) const
00719     {
00720     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00721         typedef ::IceProxy::Ice::Object _Base;
00722         return dynamic_cast<PrimaryMotorCortex*>(_Base::ice_preferSecure(__preferSecure).get());
00723     #else
00724         return dynamic_cast<PrimaryMotorCortex*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
00725     #endif
00726     }
00727 
00728     ::IceInternal::ProxyHandle<PrimaryMotorCortex> ice_router(const ::Ice::RouterPrx& __router) const
00729     {
00730     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00731         typedef ::IceProxy::Ice::Object _Base;
00732         return dynamic_cast<PrimaryMotorCortex*>(_Base::ice_router(__router).get());
00733     #else
00734         return dynamic_cast<PrimaryMotorCortex*>(::IceProxy::Ice::Object::ice_router(__router).get());
00735     #endif
00736     }
00737 
00738     ::IceInternal::ProxyHandle<PrimaryMotorCortex> ice_locator(const ::Ice::LocatorPrx& __locator) const
00739     {
00740     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00741         typedef ::IceProxy::Ice::Object _Base;
00742         return dynamic_cast<PrimaryMotorCortex*>(_Base::ice_locator(__locator).get());
00743     #else
00744         return dynamic_cast<PrimaryMotorCortex*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
00745     #endif
00746     }
00747 
00748     ::IceInternal::ProxyHandle<PrimaryMotorCortex> ice_collocationOptimized(bool __co) const
00749     {
00750     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00751         typedef ::IceProxy::Ice::Object _Base;
00752         return dynamic_cast<PrimaryMotorCortex*>(_Base::ice_collocationOptimized(__co).get());
00753     #else
00754         return dynamic_cast<PrimaryMotorCortex*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
00755     #endif
00756     }
00757 
00758     ::IceInternal::ProxyHandle<PrimaryMotorCortex> ice_twoway() const
00759     {
00760     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00761         typedef ::IceProxy::Ice::Object _Base;
00762         return dynamic_cast<PrimaryMotorCortex*>(_Base::ice_twoway().get());
00763     #else
00764         return dynamic_cast<PrimaryMotorCortex*>(::IceProxy::Ice::Object::ice_twoway().get());
00765     #endif
00766     }
00767 
00768     ::IceInternal::ProxyHandle<PrimaryMotorCortex> ice_oneway() const
00769     {
00770     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00771         typedef ::IceProxy::Ice::Object _Base;
00772         return dynamic_cast<PrimaryMotorCortex*>(_Base::ice_oneway().get());
00773     #else
00774         return dynamic_cast<PrimaryMotorCortex*>(::IceProxy::Ice::Object::ice_oneway().get());
00775     #endif
00776     }
00777 
00778     ::IceInternal::ProxyHandle<PrimaryMotorCortex> ice_batchOneway() const
00779     {
00780     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00781         typedef ::IceProxy::Ice::Object _Base;
00782         return dynamic_cast<PrimaryMotorCortex*>(_Base::ice_batchOneway().get());
00783     #else
00784         return dynamic_cast<PrimaryMotorCortex*>(::IceProxy::Ice::Object::ice_batchOneway().get());
00785     #endif
00786     }
00787 
00788     ::IceInternal::ProxyHandle<PrimaryMotorCortex> ice_datagram() const
00789     {
00790     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00791         typedef ::IceProxy::Ice::Object _Base;
00792         return dynamic_cast<PrimaryMotorCortex*>(_Base::ice_datagram().get());
00793     #else
00794         return dynamic_cast<PrimaryMotorCortex*>(::IceProxy::Ice::Object::ice_datagram().get());
00795     #endif
00796     }
00797 
00798     ::IceInternal::ProxyHandle<PrimaryMotorCortex> ice_batchDatagram() const
00799     {
00800     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00801         typedef ::IceProxy::Ice::Object _Base;
00802         return dynamic_cast<PrimaryMotorCortex*>(_Base::ice_batchDatagram().get());
00803     #else
00804         return dynamic_cast<PrimaryMotorCortex*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
00805     #endif
00806     }
00807 
00808     ::IceInternal::ProxyHandle<PrimaryMotorCortex> ice_compress(bool __compress) const
00809     {
00810     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00811         typedef ::IceProxy::Ice::Object _Base;
00812         return dynamic_cast<PrimaryMotorCortex*>(_Base::ice_compress(__compress).get());
00813     #else
00814         return dynamic_cast<PrimaryMotorCortex*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
00815     #endif
00816     }
00817 
00818     ::IceInternal::ProxyHandle<PrimaryMotorCortex> ice_timeout(int __timeout) const
00819     {
00820     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00821         typedef ::IceProxy::Ice::Object _Base;
00822         return dynamic_cast<PrimaryMotorCortex*>(_Base::ice_timeout(__timeout).get());
00823     #else
00824         return dynamic_cast<PrimaryMotorCortex*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
00825     #endif
00826     }
00827 
00828     ::IceInternal::ProxyHandle<PrimaryMotorCortex> ice_connectionId(const std::string& __id) const
00829     {
00830     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00831         typedef ::IceProxy::Ice::Object _Base;
00832         return dynamic_cast<PrimaryMotorCortex*>(_Base::ice_connectionId(__id).get());
00833     #else
00834         return dynamic_cast<PrimaryMotorCortex*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
00835     #endif
00836     }
00837 
00838     static const ::std::string& ice_staticId();
00839 
00840 private:
00841 
00842     virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
00843     virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
00844     virtual ::IceProxy::Ice::Object* __newInstance() const;
00845 };
00846 
00847 class PrimarySomatosensoryCortex : virtual public ::IceProxy::RobotSimEvents::Events
00848 {
00849 public:
00850 
00851     ::IceInternal::ProxyHandle<PrimarySomatosensoryCortex> ice_context(const ::Ice::Context& __context) const
00852     {
00853     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00854         typedef ::IceProxy::Ice::Object _Base;
00855         return dynamic_cast<PrimarySomatosensoryCortex*>(_Base::ice_context(__context).get());
00856     #else
00857         return dynamic_cast<PrimarySomatosensoryCortex*>(::IceProxy::Ice::Object::ice_context(__context).get());
00858     #endif
00859     }
00860 
00861     ::IceInternal::ProxyHandle<PrimarySomatosensoryCortex> ice_adapterId(const std::string& __id) const
00862     {
00863     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00864         typedef ::IceProxy::Ice::Object _Base;
00865         return dynamic_cast<PrimarySomatosensoryCortex*>(_Base::ice_adapterId(__id).get());
00866     #else
00867         return dynamic_cast<PrimarySomatosensoryCortex*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
00868     #endif
00869     }
00870 
00871     ::IceInternal::ProxyHandle<PrimarySomatosensoryCortex> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
00872     {
00873     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00874         typedef ::IceProxy::Ice::Object _Base;
00875         return dynamic_cast<PrimarySomatosensoryCortex*>(_Base::ice_endpoints(__endpoints).get());
00876     #else
00877         return dynamic_cast<PrimarySomatosensoryCortex*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
00878     #endif
00879     }
00880 
00881     ::IceInternal::ProxyHandle<PrimarySomatosensoryCortex> ice_locatorCacheTimeout(int __timeout) const
00882     {
00883     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00884         typedef ::IceProxy::Ice::Object _Base;
00885         return dynamic_cast<PrimarySomatosensoryCortex*>(_Base::ice_locatorCacheTimeout(__timeout).get());
00886     #else
00887         return dynamic_cast<PrimarySomatosensoryCortex*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
00888     #endif
00889     }
00890 
00891     ::IceInternal::ProxyHandle<PrimarySomatosensoryCortex> ice_connectionCached(bool __cached) const
00892     {
00893     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00894         typedef ::IceProxy::Ice::Object _Base;
00895         return dynamic_cast<PrimarySomatosensoryCortex*>(_Base::ice_connectionCached(__cached).get());
00896     #else
00897         return dynamic_cast<PrimarySomatosensoryCortex*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
00898     #endif
00899     }
00900 
00901     ::IceInternal::ProxyHandle<PrimarySomatosensoryCortex> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
00902     {
00903     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00904         typedef ::IceProxy::Ice::Object _Base;
00905         return dynamic_cast<PrimarySomatosensoryCortex*>(_Base::ice_endpointSelection(__est).get());
00906     #else
00907         return dynamic_cast<PrimarySomatosensoryCortex*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
00908     #endif
00909     }
00910 
00911     ::IceInternal::ProxyHandle<PrimarySomatosensoryCortex> ice_secure(bool __secure) const
00912     {
00913     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00914         typedef ::IceProxy::Ice::Object _Base;
00915         return dynamic_cast<PrimarySomatosensoryCortex*>(_Base::ice_secure(__secure).get());
00916     #else
00917         return dynamic_cast<PrimarySomatosensoryCortex*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
00918     #endif
00919     }
00920 
00921     ::IceInternal::ProxyHandle<PrimarySomatosensoryCortex> ice_preferSecure(bool __preferSecure) const
00922     {
00923     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00924         typedef ::IceProxy::Ice::Object _Base;
00925         return dynamic_cast<PrimarySomatosensoryCortex*>(_Base::ice_preferSecure(__preferSecure).get());
00926     #else
00927         return dynamic_cast<PrimarySomatosensoryCortex*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
00928     #endif
00929     }
00930 
00931     ::IceInternal::ProxyHandle<PrimarySomatosensoryCortex> ice_router(const ::Ice::RouterPrx& __router) const
00932     {
00933     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00934         typedef ::IceProxy::Ice::Object _Base;
00935         return dynamic_cast<PrimarySomatosensoryCortex*>(_Base::ice_router(__router).get());
00936     #else
00937         return dynamic_cast<PrimarySomatosensoryCortex*>(::IceProxy::Ice::Object::ice_router(__router).get());
00938     #endif
00939     }
00940 
00941     ::IceInternal::ProxyHandle<PrimarySomatosensoryCortex> ice_locator(const ::Ice::LocatorPrx& __locator) const
00942     {
00943     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00944         typedef ::IceProxy::Ice::Object _Base;
00945         return dynamic_cast<PrimarySomatosensoryCortex*>(_Base::ice_locator(__locator).get());
00946     #else
00947         return dynamic_cast<PrimarySomatosensoryCortex*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
00948     #endif
00949     }
00950 
00951     ::IceInternal::ProxyHandle<PrimarySomatosensoryCortex> ice_collocationOptimized(bool __co) const
00952     {
00953     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00954         typedef ::IceProxy::Ice::Object _Base;
00955         return dynamic_cast<PrimarySomatosensoryCortex*>(_Base::ice_collocationOptimized(__co).get());
00956     #else
00957         return dynamic_cast<PrimarySomatosensoryCortex*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
00958     #endif
00959     }
00960 
00961     ::IceInternal::ProxyHandle<PrimarySomatosensoryCortex> ice_twoway() const
00962     {
00963     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00964         typedef ::IceProxy::Ice::Object _Base;
00965         return dynamic_cast<PrimarySomatosensoryCortex*>(_Base::ice_twoway().get());
00966     #else
00967         return dynamic_cast<PrimarySomatosensoryCortex*>(::IceProxy::Ice::Object::ice_twoway().get());
00968     #endif
00969     }
00970 
00971     ::IceInternal::ProxyHandle<PrimarySomatosensoryCortex> ice_oneway() const
00972     {
00973     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00974         typedef ::IceProxy::Ice::Object _Base;
00975         return dynamic_cast<PrimarySomatosensoryCortex*>(_Base::ice_oneway().get());
00976     #else
00977         return dynamic_cast<PrimarySomatosensoryCortex*>(::IceProxy::Ice::Object::ice_oneway().get());
00978     #endif
00979     }
00980 
00981     ::IceInternal::ProxyHandle<PrimarySomatosensoryCortex> ice_batchOneway() const
00982     {
00983     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00984         typedef ::IceProxy::Ice::Object _Base;
00985         return dynamic_cast<PrimarySomatosensoryCortex*>(_Base::ice_batchOneway().get());
00986     #else
00987         return dynamic_cast<PrimarySomatosensoryCortex*>(::IceProxy::Ice::Object::ice_batchOneway().get());
00988     #endif
00989     }
00990 
00991     ::IceInternal::ProxyHandle<PrimarySomatosensoryCortex> ice_datagram() const
00992     {
00993     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00994         typedef ::IceProxy::Ice::Object _Base;
00995         return dynamic_cast<PrimarySomatosensoryCortex*>(_Base::ice_datagram().get());
00996     #else
00997         return dynamic_cast<PrimarySomatosensoryCortex*>(::IceProxy::Ice::Object::ice_datagram().get());
00998     #endif
00999     }
01000 
01001     ::IceInternal::ProxyHandle<PrimarySomatosensoryCortex> ice_batchDatagram() const
01002     {
01003     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01004         typedef ::IceProxy::Ice::Object _Base;
01005         return dynamic_cast<PrimarySomatosensoryCortex*>(_Base::ice_batchDatagram().get());
01006     #else
01007         return dynamic_cast<PrimarySomatosensoryCortex*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
01008     #endif
01009     }
01010 
01011     ::IceInternal::ProxyHandle<PrimarySomatosensoryCortex> ice_compress(bool __compress) const
01012     {
01013     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01014         typedef ::IceProxy::Ice::Object _Base;
01015         return dynamic_cast<PrimarySomatosensoryCortex*>(_Base::ice_compress(__compress).get());
01016     #else
01017         return dynamic_cast<PrimarySomatosensoryCortex*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
01018     #endif
01019     }
01020 
01021     ::IceInternal::ProxyHandle<PrimarySomatosensoryCortex> ice_timeout(int __timeout) const
01022     {
01023     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01024         typedef ::IceProxy::Ice::Object _Base;
01025         return dynamic_cast<PrimarySomatosensoryCortex*>(_Base::ice_timeout(__timeout).get());
01026     #else
01027         return dynamic_cast<PrimarySomatosensoryCortex*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
01028     #endif
01029     }
01030 
01031     ::IceInternal::ProxyHandle<PrimarySomatosensoryCortex> ice_connectionId(const std::string& __id) const
01032     {
01033     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01034         typedef ::IceProxy::Ice::Object _Base;
01035         return dynamic_cast<PrimarySomatosensoryCortex*>(_Base::ice_connectionId(__id).get());
01036     #else
01037         return dynamic_cast<PrimarySomatosensoryCortex*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
01038     #endif
01039     }
01040 
01041     static const ::std::string& ice_staticId();
01042 
01043 private:
01044 
01045     virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
01046     virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
01047     virtual ::IceProxy::Ice::Object* __newInstance() const;
01048 };
01049 
01050 class LateralGeniculateNucleus : virtual public ::IceProxy::RobotSimEvents::Events
01051 {
01052 public:
01053 
01054     ::IceInternal::ProxyHandle<LateralGeniculateNucleus> ice_context(const ::Ice::Context& __context) const
01055     {
01056     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01057         typedef ::IceProxy::Ice::Object _Base;
01058         return dynamic_cast<LateralGeniculateNucleus*>(_Base::ice_context(__context).get());
01059     #else
01060         return dynamic_cast<LateralGeniculateNucleus*>(::IceProxy::Ice::Object::ice_context(__context).get());
01061     #endif
01062     }
01063 
01064     ::IceInternal::ProxyHandle<LateralGeniculateNucleus> ice_adapterId(const std::string& __id) const
01065     {
01066     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01067         typedef ::IceProxy::Ice::Object _Base;
01068         return dynamic_cast<LateralGeniculateNucleus*>(_Base::ice_adapterId(__id).get());
01069     #else
01070         return dynamic_cast<LateralGeniculateNucleus*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
01071     #endif
01072     }
01073 
01074     ::IceInternal::ProxyHandle<LateralGeniculateNucleus> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
01075     {
01076     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01077         typedef ::IceProxy::Ice::Object _Base;
01078         return dynamic_cast<LateralGeniculateNucleus*>(_Base::ice_endpoints(__endpoints).get());
01079     #else
01080         return dynamic_cast<LateralGeniculateNucleus*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
01081     #endif
01082     }
01083 
01084     ::IceInternal::ProxyHandle<LateralGeniculateNucleus> ice_locatorCacheTimeout(int __timeout) const
01085     {
01086     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01087         typedef ::IceProxy::Ice::Object _Base;
01088         return dynamic_cast<LateralGeniculateNucleus*>(_Base::ice_locatorCacheTimeout(__timeout).get());
01089     #else
01090         return dynamic_cast<LateralGeniculateNucleus*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
01091     #endif
01092     }
01093 
01094     ::IceInternal::ProxyHandle<LateralGeniculateNucleus> ice_connectionCached(bool __cached) const
01095     {
01096     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01097         typedef ::IceProxy::Ice::Object _Base;
01098         return dynamic_cast<LateralGeniculateNucleus*>(_Base::ice_connectionCached(__cached).get());
01099     #else
01100         return dynamic_cast<LateralGeniculateNucleus*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
01101     #endif
01102     }
01103 
01104     ::IceInternal::ProxyHandle<LateralGeniculateNucleus> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
01105     {
01106     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01107         typedef ::IceProxy::Ice::Object _Base;
01108         return dynamic_cast<LateralGeniculateNucleus*>(_Base::ice_endpointSelection(__est).get());
01109     #else
01110         return dynamic_cast<LateralGeniculateNucleus*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
01111     #endif
01112     }
01113 
01114     ::IceInternal::ProxyHandle<LateralGeniculateNucleus> ice_secure(bool __secure) const
01115     {
01116     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01117         typedef ::IceProxy::Ice::Object _Base;
01118         return dynamic_cast<LateralGeniculateNucleus*>(_Base::ice_secure(__secure).get());
01119     #else
01120         return dynamic_cast<LateralGeniculateNucleus*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
01121     #endif
01122     }
01123 
01124     ::IceInternal::ProxyHandle<LateralGeniculateNucleus> ice_preferSecure(bool __preferSecure) const
01125     {
01126     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01127         typedef ::IceProxy::Ice::Object _Base;
01128         return dynamic_cast<LateralGeniculateNucleus*>(_Base::ice_preferSecure(__preferSecure).get());
01129     #else
01130         return dynamic_cast<LateralGeniculateNucleus*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
01131     #endif
01132     }
01133 
01134     ::IceInternal::ProxyHandle<LateralGeniculateNucleus> ice_router(const ::Ice::RouterPrx& __router) const
01135     {
01136     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01137         typedef ::IceProxy::Ice::Object _Base;
01138         return dynamic_cast<LateralGeniculateNucleus*>(_Base::ice_router(__router).get());
01139     #else
01140         return dynamic_cast<LateralGeniculateNucleus*>(::IceProxy::Ice::Object::ice_router(__router).get());
01141     #endif
01142     }
01143 
01144     ::IceInternal::ProxyHandle<LateralGeniculateNucleus> ice_locator(const ::Ice::LocatorPrx& __locator) const
01145     {
01146     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01147         typedef ::IceProxy::Ice::Object _Base;
01148         return dynamic_cast<LateralGeniculateNucleus*>(_Base::ice_locator(__locator).get());
01149     #else
01150         return dynamic_cast<LateralGeniculateNucleus*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
01151     #endif
01152     }
01153 
01154     ::IceInternal::ProxyHandle<LateralGeniculateNucleus> ice_collocationOptimized(bool __co) const
01155     {
01156     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01157         typedef ::IceProxy::Ice::Object _Base;
01158         return dynamic_cast<LateralGeniculateNucleus*>(_Base::ice_collocationOptimized(__co).get());
01159     #else
01160         return dynamic_cast<LateralGeniculateNucleus*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
01161     #endif
01162     }
01163 
01164     ::IceInternal::ProxyHandle<LateralGeniculateNucleus> ice_twoway() const
01165     {
01166     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01167         typedef ::IceProxy::Ice::Object _Base;
01168         return dynamic_cast<LateralGeniculateNucleus*>(_Base::ice_twoway().get());
01169     #else
01170         return dynamic_cast<LateralGeniculateNucleus*>(::IceProxy::Ice::Object::ice_twoway().get());
01171     #endif
01172     }
01173 
01174     ::IceInternal::ProxyHandle<LateralGeniculateNucleus> ice_oneway() const
01175     {
01176     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01177         typedef ::IceProxy::Ice::Object _Base;
01178         return dynamic_cast<LateralGeniculateNucleus*>(_Base::ice_oneway().get());
01179     #else
01180         return dynamic_cast<LateralGeniculateNucleus*>(::IceProxy::Ice::Object::ice_oneway().get());
01181     #endif
01182     }
01183 
01184     ::IceInternal::ProxyHandle<LateralGeniculateNucleus> ice_batchOneway() const
01185     {
01186     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01187         typedef ::IceProxy::Ice::Object _Base;
01188         return dynamic_cast<LateralGeniculateNucleus*>(_Base::ice_batchOneway().get());
01189     #else
01190         return dynamic_cast<LateralGeniculateNucleus*>(::IceProxy::Ice::Object::ice_batchOneway().get());
01191     #endif
01192     }
01193 
01194     ::IceInternal::ProxyHandle<LateralGeniculateNucleus> ice_datagram() const
01195     {
01196     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01197         typedef ::IceProxy::Ice::Object _Base;
01198         return dynamic_cast<LateralGeniculateNucleus*>(_Base::ice_datagram().get());
01199     #else
01200         return dynamic_cast<LateralGeniculateNucleus*>(::IceProxy::Ice::Object::ice_datagram().get());
01201     #endif
01202     }
01203 
01204     ::IceInternal::ProxyHandle<LateralGeniculateNucleus> ice_batchDatagram() const
01205     {
01206     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01207         typedef ::IceProxy::Ice::Object _Base;
01208         return dynamic_cast<LateralGeniculateNucleus*>(_Base::ice_batchDatagram().get());
01209     #else
01210         return dynamic_cast<LateralGeniculateNucleus*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
01211     #endif
01212     }
01213 
01214     ::IceInternal::ProxyHandle<LateralGeniculateNucleus> ice_compress(bool __compress) const
01215     {
01216     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01217         typedef ::IceProxy::Ice::Object _Base;
01218         return dynamic_cast<LateralGeniculateNucleus*>(_Base::ice_compress(__compress).get());
01219     #else
01220         return dynamic_cast<LateralGeniculateNucleus*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
01221     #endif
01222     }
01223 
01224     ::IceInternal::ProxyHandle<LateralGeniculateNucleus> ice_timeout(int __timeout) const
01225     {
01226     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01227         typedef ::IceProxy::Ice::Object _Base;
01228         return dynamic_cast<LateralGeniculateNucleus*>(_Base::ice_timeout(__timeout).get());
01229     #else
01230         return dynamic_cast<LateralGeniculateNucleus*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
01231     #endif
01232     }
01233 
01234     ::IceInternal::ProxyHandle<LateralGeniculateNucleus> ice_connectionId(const std::string& __id) const
01235     {
01236     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01237         typedef ::IceProxy::Ice::Object _Base;
01238         return dynamic_cast<LateralGeniculateNucleus*>(_Base::ice_connectionId(__id).get());
01239     #else
01240         return dynamic_cast<LateralGeniculateNucleus*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
01241     #endif
01242     }
01243 
01244     static const ::std::string& ice_staticId();
01245 
01246 private:
01247 
01248     virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
01249     virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
01250     virtual ::IceProxy::Ice::Object* __newInstance() const;
01251 };
01252 
01253 class Hippocampus : virtual public ::IceProxy::RobotSimEvents::Events
01254 {
01255 public:
01256 
01257     ::IceInternal::ProxyHandle<Hippocampus> ice_context(const ::Ice::Context& __context) const
01258     {
01259     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01260         typedef ::IceProxy::Ice::Object _Base;
01261         return dynamic_cast<Hippocampus*>(_Base::ice_context(__context).get());
01262     #else
01263         return dynamic_cast<Hippocampus*>(::IceProxy::Ice::Object::ice_context(__context).get());
01264     #endif
01265     }
01266 
01267     ::IceInternal::ProxyHandle<Hippocampus> ice_adapterId(const std::string& __id) const
01268     {
01269     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01270         typedef ::IceProxy::Ice::Object _Base;
01271         return dynamic_cast<Hippocampus*>(_Base::ice_adapterId(__id).get());
01272     #else
01273         return dynamic_cast<Hippocampus*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
01274     #endif
01275     }
01276 
01277     ::IceInternal::ProxyHandle<Hippocampus> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
01278     {
01279     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01280         typedef ::IceProxy::Ice::Object _Base;
01281         return dynamic_cast<Hippocampus*>(_Base::ice_endpoints(__endpoints).get());
01282     #else
01283         return dynamic_cast<Hippocampus*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
01284     #endif
01285     }
01286 
01287     ::IceInternal::ProxyHandle<Hippocampus> ice_locatorCacheTimeout(int __timeout) const
01288     {
01289     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01290         typedef ::IceProxy::Ice::Object _Base;
01291         return dynamic_cast<Hippocampus*>(_Base::ice_locatorCacheTimeout(__timeout).get());
01292     #else
01293         return dynamic_cast<Hippocampus*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
01294     #endif
01295     }
01296 
01297     ::IceInternal::ProxyHandle<Hippocampus> ice_connectionCached(bool __cached) const
01298     {
01299     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01300         typedef ::IceProxy::Ice::Object _Base;
01301         return dynamic_cast<Hippocampus*>(_Base::ice_connectionCached(__cached).get());
01302     #else
01303         return dynamic_cast<Hippocampus*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
01304     #endif
01305     }
01306 
01307     ::IceInternal::ProxyHandle<Hippocampus> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
01308     {
01309     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01310         typedef ::IceProxy::Ice::Object _Base;
01311         return dynamic_cast<Hippocampus*>(_Base::ice_endpointSelection(__est).get());
01312     #else
01313         return dynamic_cast<Hippocampus*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
01314     #endif
01315     }
01316 
01317     ::IceInternal::ProxyHandle<Hippocampus> ice_secure(bool __secure) const
01318     {
01319     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01320         typedef ::IceProxy::Ice::Object _Base;
01321         return dynamic_cast<Hippocampus*>(_Base::ice_secure(__secure).get());
01322     #else
01323         return dynamic_cast<Hippocampus*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
01324     #endif
01325     }
01326 
01327     ::IceInternal::ProxyHandle<Hippocampus> ice_preferSecure(bool __preferSecure) const
01328     {
01329     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01330         typedef ::IceProxy::Ice::Object _Base;
01331         return dynamic_cast<Hippocampus*>(_Base::ice_preferSecure(__preferSecure).get());
01332     #else
01333         return dynamic_cast<Hippocampus*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
01334     #endif
01335     }
01336 
01337     ::IceInternal::ProxyHandle<Hippocampus> ice_router(const ::Ice::RouterPrx& __router) const
01338     {
01339     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01340         typedef ::IceProxy::Ice::Object _Base;
01341         return dynamic_cast<Hippocampus*>(_Base::ice_router(__router).get());
01342     #else
01343         return dynamic_cast<Hippocampus*>(::IceProxy::Ice::Object::ice_router(__router).get());
01344     #endif
01345     }
01346 
01347     ::IceInternal::ProxyHandle<Hippocampus> ice_locator(const ::Ice::LocatorPrx& __locator) const
01348     {
01349     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01350         typedef ::IceProxy::Ice::Object _Base;
01351         return dynamic_cast<Hippocampus*>(_Base::ice_locator(__locator).get());
01352     #else
01353         return dynamic_cast<Hippocampus*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
01354     #endif
01355     }
01356 
01357     ::IceInternal::ProxyHandle<Hippocampus> ice_collocationOptimized(bool __co) const
01358     {
01359     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01360         typedef ::IceProxy::Ice::Object _Base;
01361         return dynamic_cast<Hippocampus*>(_Base::ice_collocationOptimized(__co).get());
01362     #else
01363         return dynamic_cast<Hippocampus*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
01364     #endif
01365     }
01366 
01367     ::IceInternal::ProxyHandle<Hippocampus> ice_twoway() const
01368     {
01369     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01370         typedef ::IceProxy::Ice::Object _Base;
01371         return dynamic_cast<Hippocampus*>(_Base::ice_twoway().get());
01372     #else
01373         return dynamic_cast<Hippocampus*>(::IceProxy::Ice::Object::ice_twoway().get());
01374     #endif
01375     }
01376 
01377     ::IceInternal::ProxyHandle<Hippocampus> ice_oneway() const
01378     {
01379     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01380         typedef ::IceProxy::Ice::Object _Base;
01381         return dynamic_cast<Hippocampus*>(_Base::ice_oneway().get());
01382     #else
01383         return dynamic_cast<Hippocampus*>(::IceProxy::Ice::Object::ice_oneway().get());
01384     #endif
01385     }
01386 
01387     ::IceInternal::ProxyHandle<Hippocampus> ice_batchOneway() const
01388     {
01389     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01390         typedef ::IceProxy::Ice::Object _Base;
01391         return dynamic_cast<Hippocampus*>(_Base::ice_batchOneway().get());
01392     #else
01393         return dynamic_cast<Hippocampus*>(::IceProxy::Ice::Object::ice_batchOneway().get());
01394     #endif
01395     }
01396 
01397     ::IceInternal::ProxyHandle<Hippocampus> ice_datagram() const
01398     {
01399     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01400         typedef ::IceProxy::Ice::Object _Base;
01401         return dynamic_cast<Hippocampus*>(_Base::ice_datagram().get());
01402     #else
01403         return dynamic_cast<Hippocampus*>(::IceProxy::Ice::Object::ice_datagram().get());
01404     #endif
01405     }
01406 
01407     ::IceInternal::ProxyHandle<Hippocampus> ice_batchDatagram() const
01408     {
01409     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01410         typedef ::IceProxy::Ice::Object _Base;
01411         return dynamic_cast<Hippocampus*>(_Base::ice_batchDatagram().get());
01412     #else
01413         return dynamic_cast<Hippocampus*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
01414     #endif
01415     }
01416 
01417     ::IceInternal::ProxyHandle<Hippocampus> ice_compress(bool __compress) const
01418     {
01419     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01420         typedef ::IceProxy::Ice::Object _Base;
01421         return dynamic_cast<Hippocampus*>(_Base::ice_compress(__compress).get());
01422     #else
01423         return dynamic_cast<Hippocampus*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
01424     #endif
01425     }
01426 
01427     ::IceInternal::ProxyHandle<Hippocampus> ice_timeout(int __timeout) const
01428     {
01429     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01430         typedef ::IceProxy::Ice::Object _Base;
01431         return dynamic_cast<Hippocampus*>(_Base::ice_timeout(__timeout).get());
01432     #else
01433         return dynamic_cast<Hippocampus*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
01434     #endif
01435     }
01436 
01437     ::IceInternal::ProxyHandle<Hippocampus> ice_connectionId(const std::string& __id) const
01438     {
01439     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01440         typedef ::IceProxy::Ice::Object _Base;
01441         return dynamic_cast<Hippocampus*>(_Base::ice_connectionId(__id).get());
01442     #else
01443         return dynamic_cast<Hippocampus*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
01444     #endif
01445     }
01446 
01447     static const ::std::string& ice_staticId();
01448 
01449 private:
01450 
01451     virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
01452     virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
01453     virtual ::IceProxy::Ice::Object* __newInstance() const;
01454 };
01455 
01456 class SupplementaryMotorArea : virtual public ::IceProxy::RobotSimEvents::Events
01457 {
01458 public:
01459 
01460     ::IceInternal::ProxyHandle<SupplementaryMotorArea> ice_context(const ::Ice::Context& __context) const
01461     {
01462     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01463         typedef ::IceProxy::Ice::Object _Base;
01464         return dynamic_cast<SupplementaryMotorArea*>(_Base::ice_context(__context).get());
01465     #else
01466         return dynamic_cast<SupplementaryMotorArea*>(::IceProxy::Ice::Object::ice_context(__context).get());
01467     #endif
01468     }
01469 
01470     ::IceInternal::ProxyHandle<SupplementaryMotorArea> ice_adapterId(const std::string& __id) const
01471     {
01472     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01473         typedef ::IceProxy::Ice::Object _Base;
01474         return dynamic_cast<SupplementaryMotorArea*>(_Base::ice_adapterId(__id).get());
01475     #else
01476         return dynamic_cast<SupplementaryMotorArea*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
01477     #endif
01478     }
01479 
01480     ::IceInternal::ProxyHandle<SupplementaryMotorArea> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
01481     {
01482     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01483         typedef ::IceProxy::Ice::Object _Base;
01484         return dynamic_cast<SupplementaryMotorArea*>(_Base::ice_endpoints(__endpoints).get());
01485     #else
01486         return dynamic_cast<SupplementaryMotorArea*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
01487     #endif
01488     }
01489 
01490     ::IceInternal::ProxyHandle<SupplementaryMotorArea> ice_locatorCacheTimeout(int __timeout) const
01491     {
01492     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01493         typedef ::IceProxy::Ice::Object _Base;
01494         return dynamic_cast<SupplementaryMotorArea*>(_Base::ice_locatorCacheTimeout(__timeout).get());
01495     #else
01496         return dynamic_cast<SupplementaryMotorArea*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
01497     #endif
01498     }
01499 
01500     ::IceInternal::ProxyHandle<SupplementaryMotorArea> ice_connectionCached(bool __cached) const
01501     {
01502     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01503         typedef ::IceProxy::Ice::Object _Base;
01504         return dynamic_cast<SupplementaryMotorArea*>(_Base::ice_connectionCached(__cached).get());
01505     #else
01506         return dynamic_cast<SupplementaryMotorArea*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
01507     #endif
01508     }
01509 
01510     ::IceInternal::ProxyHandle<SupplementaryMotorArea> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
01511     {
01512     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01513         typedef ::IceProxy::Ice::Object _Base;
01514         return dynamic_cast<SupplementaryMotorArea*>(_Base::ice_endpointSelection(__est).get());
01515     #else
01516         return dynamic_cast<SupplementaryMotorArea*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
01517     #endif
01518     }
01519 
01520     ::IceInternal::ProxyHandle<SupplementaryMotorArea> ice_secure(bool __secure) const
01521     {
01522     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01523         typedef ::IceProxy::Ice::Object _Base;
01524         return dynamic_cast<SupplementaryMotorArea*>(_Base::ice_secure(__secure).get());
01525     #else
01526         return dynamic_cast<SupplementaryMotorArea*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
01527     #endif
01528     }
01529 
01530     ::IceInternal::ProxyHandle<SupplementaryMotorArea> ice_preferSecure(bool __preferSecure) const
01531     {
01532     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01533         typedef ::IceProxy::Ice::Object _Base;
01534         return dynamic_cast<SupplementaryMotorArea*>(_Base::ice_preferSecure(__preferSecure).get());
01535     #else
01536         return dynamic_cast<SupplementaryMotorArea*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
01537     #endif
01538     }
01539 
01540     ::IceInternal::ProxyHandle<SupplementaryMotorArea> ice_router(const ::Ice::RouterPrx& __router) const
01541     {
01542     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01543         typedef ::IceProxy::Ice::Object _Base;
01544         return dynamic_cast<SupplementaryMotorArea*>(_Base::ice_router(__router).get());
01545     #else
01546         return dynamic_cast<SupplementaryMotorArea*>(::IceProxy::Ice::Object::ice_router(__router).get());
01547     #endif
01548     }
01549 
01550     ::IceInternal::ProxyHandle<SupplementaryMotorArea> ice_locator(const ::Ice::LocatorPrx& __locator) const
01551     {
01552     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01553         typedef ::IceProxy::Ice::Object _Base;
01554         return dynamic_cast<SupplementaryMotorArea*>(_Base::ice_locator(__locator).get());
01555     #else
01556         return dynamic_cast<SupplementaryMotorArea*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
01557     #endif
01558     }
01559 
01560     ::IceInternal::ProxyHandle<SupplementaryMotorArea> ice_collocationOptimized(bool __co) const
01561     {
01562     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01563         typedef ::IceProxy::Ice::Object _Base;
01564         return dynamic_cast<SupplementaryMotorArea*>(_Base::ice_collocationOptimized(__co).get());
01565     #else
01566         return dynamic_cast<SupplementaryMotorArea*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
01567     #endif
01568     }
01569 
01570     ::IceInternal::ProxyHandle<SupplementaryMotorArea> ice_twoway() const
01571     {
01572     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01573         typedef ::IceProxy::Ice::Object _Base;
01574         return dynamic_cast<SupplementaryMotorArea*>(_Base::ice_twoway().get());
01575     #else
01576         return dynamic_cast<SupplementaryMotorArea*>(::IceProxy::Ice::Object::ice_twoway().get());
01577     #endif
01578     }
01579 
01580     ::IceInternal::ProxyHandle<SupplementaryMotorArea> ice_oneway() const
01581     {
01582     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01583         typedef ::IceProxy::Ice::Object _Base;
01584         return dynamic_cast<SupplementaryMotorArea*>(_Base::ice_oneway().get());
01585     #else
01586         return dynamic_cast<SupplementaryMotorArea*>(::IceProxy::Ice::Object::ice_oneway().get());
01587     #endif
01588     }
01589 
01590     ::IceInternal::ProxyHandle<SupplementaryMotorArea> ice_batchOneway() const
01591     {
01592     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01593         typedef ::IceProxy::Ice::Object _Base;
01594         return dynamic_cast<SupplementaryMotorArea*>(_Base::ice_batchOneway().get());
01595     #else
01596         return dynamic_cast<SupplementaryMotorArea*>(::IceProxy::Ice::Object::ice_batchOneway().get());
01597     #endif
01598     }
01599 
01600     ::IceInternal::ProxyHandle<SupplementaryMotorArea> ice_datagram() const
01601     {
01602     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01603         typedef ::IceProxy::Ice::Object _Base;
01604         return dynamic_cast<SupplementaryMotorArea*>(_Base::ice_datagram().get());
01605     #else
01606         return dynamic_cast<SupplementaryMotorArea*>(::IceProxy::Ice::Object::ice_datagram().get());
01607     #endif
01608     }
01609 
01610     ::IceInternal::ProxyHandle<SupplementaryMotorArea> ice_batchDatagram() const
01611     {
01612     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01613         typedef ::IceProxy::Ice::Object _Base;
01614         return dynamic_cast<SupplementaryMotorArea*>(_Base::ice_batchDatagram().get());
01615     #else
01616         return dynamic_cast<SupplementaryMotorArea*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
01617     #endif
01618     }
01619 
01620     ::IceInternal::ProxyHandle<SupplementaryMotorArea> ice_compress(bool __compress) const
01621     {
01622     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01623         typedef ::IceProxy::Ice::Object _Base;
01624         return dynamic_cast<SupplementaryMotorArea*>(_Base::ice_compress(__compress).get());
01625     #else
01626         return dynamic_cast<SupplementaryMotorArea*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
01627     #endif
01628     }
01629 
01630     ::IceInternal::ProxyHandle<SupplementaryMotorArea> ice_timeout(int __timeout) const
01631     {
01632     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01633         typedef ::IceProxy::Ice::Object _Base;
01634         return dynamic_cast<SupplementaryMotorArea*>(_Base::ice_timeout(__timeout).get());
01635     #else
01636         return dynamic_cast<SupplementaryMotorArea*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
01637     #endif
01638     }
01639 
01640     ::IceInternal::ProxyHandle<SupplementaryMotorArea> ice_connectionId(const std::string& __id) const
01641     {
01642     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01643         typedef ::IceProxy::Ice::Object _Base;
01644         return dynamic_cast<SupplementaryMotorArea*>(_Base::ice_connectionId(__id).get());
01645     #else
01646         return dynamic_cast<SupplementaryMotorArea*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
01647     #endif
01648     }
01649 
01650     static const ::std::string& ice_staticId();
01651 
01652 private:
01653 
01654     virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
01655     virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
01656     virtual ::IceProxy::Ice::Object* __newInstance() const;
01657 };
01658 
01659 class PrefrontalCortex : virtual public ::IceProxy::RobotSimEvents::Events
01660 {
01661 public:
01662 
01663     ::IceInternal::ProxyHandle<PrefrontalCortex> ice_context(const ::Ice::Context& __context) const
01664     {
01665     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01666         typedef ::IceProxy::Ice::Object _Base;
01667         return dynamic_cast<PrefrontalCortex*>(_Base::ice_context(__context).get());
01668     #else
01669         return dynamic_cast<PrefrontalCortex*>(::IceProxy::Ice::Object::ice_context(__context).get());
01670     #endif
01671     }
01672 
01673     ::IceInternal::ProxyHandle<PrefrontalCortex> ice_adapterId(const std::string& __id) const
01674     {
01675     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01676         typedef ::IceProxy::Ice::Object _Base;
01677         return dynamic_cast<PrefrontalCortex*>(_Base::ice_adapterId(__id).get());
01678     #else
01679         return dynamic_cast<PrefrontalCortex*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
01680     #endif
01681     }
01682 
01683     ::IceInternal::ProxyHandle<PrefrontalCortex> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
01684     {
01685     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01686         typedef ::IceProxy::Ice::Object _Base;
01687         return dynamic_cast<PrefrontalCortex*>(_Base::ice_endpoints(__endpoints).get());
01688     #else
01689         return dynamic_cast<PrefrontalCortex*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
01690     #endif
01691     }
01692 
01693     ::IceInternal::ProxyHandle<PrefrontalCortex> ice_locatorCacheTimeout(int __timeout) const
01694     {
01695     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01696         typedef ::IceProxy::Ice::Object _Base;
01697         return dynamic_cast<PrefrontalCortex*>(_Base::ice_locatorCacheTimeout(__timeout).get());
01698     #else
01699         return dynamic_cast<PrefrontalCortex*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
01700     #endif
01701     }
01702 
01703     ::IceInternal::ProxyHandle<PrefrontalCortex> ice_connectionCached(bool __cached) const
01704     {
01705     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01706         typedef ::IceProxy::Ice::Object _Base;
01707         return dynamic_cast<PrefrontalCortex*>(_Base::ice_connectionCached(__cached).get());
01708     #else
01709         return dynamic_cast<PrefrontalCortex*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
01710     #endif
01711     }
01712 
01713     ::IceInternal::ProxyHandle<PrefrontalCortex> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
01714     {
01715     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01716         typedef ::IceProxy::Ice::Object _Base;
01717         return dynamic_cast<PrefrontalCortex*>(_Base::ice_endpointSelection(__est).get());
01718     #else
01719         return dynamic_cast<PrefrontalCortex*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
01720     #endif
01721     }
01722 
01723     ::IceInternal::ProxyHandle<PrefrontalCortex> ice_secure(bool __secure) const
01724     {
01725     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01726         typedef ::IceProxy::Ice::Object _Base;
01727         return dynamic_cast<PrefrontalCortex*>(_Base::ice_secure(__secure).get());
01728     #else
01729         return dynamic_cast<PrefrontalCortex*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
01730     #endif
01731     }
01732 
01733     ::IceInternal::ProxyHandle<PrefrontalCortex> ice_preferSecure(bool __preferSecure) const
01734     {
01735     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01736         typedef ::IceProxy::Ice::Object _Base;
01737         return dynamic_cast<PrefrontalCortex*>(_Base::ice_preferSecure(__preferSecure).get());
01738     #else
01739         return dynamic_cast<PrefrontalCortex*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
01740     #endif
01741     }
01742 
01743     ::IceInternal::ProxyHandle<PrefrontalCortex> ice_router(const ::Ice::RouterPrx& __router) const
01744     {
01745     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01746         typedef ::IceProxy::Ice::Object _Base;
01747         return dynamic_cast<PrefrontalCortex*>(_Base::ice_router(__router).get());
01748     #else
01749         return dynamic_cast<PrefrontalCortex*>(::IceProxy::Ice::Object::ice_router(__router).get());
01750     #endif
01751     }
01752 
01753     ::IceInternal::ProxyHandle<PrefrontalCortex> ice_locator(const ::Ice::LocatorPrx& __locator) const
01754     {
01755     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01756         typedef ::IceProxy::Ice::Object _Base;
01757         return dynamic_cast<PrefrontalCortex*>(_Base::ice_locator(__locator).get());
01758     #else
01759         return dynamic_cast<PrefrontalCortex*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
01760     #endif
01761     }
01762 
01763     ::IceInternal::ProxyHandle<PrefrontalCortex> ice_collocationOptimized(bool __co) const
01764     {
01765     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01766         typedef ::IceProxy::Ice::Object _Base;
01767         return dynamic_cast<PrefrontalCortex*>(_Base::ice_collocationOptimized(__co).get());
01768     #else
01769         return dynamic_cast<PrefrontalCortex*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
01770     #endif
01771     }
01772 
01773     ::IceInternal::ProxyHandle<PrefrontalCortex> ice_twoway() const
01774     {
01775     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01776         typedef ::IceProxy::Ice::Object _Base;
01777         return dynamic_cast<PrefrontalCortex*>(_Base::ice_twoway().get());
01778     #else
01779         return dynamic_cast<PrefrontalCortex*>(::IceProxy::Ice::Object::ice_twoway().get());
01780     #endif
01781     }
01782 
01783     ::IceInternal::ProxyHandle<PrefrontalCortex> ice_oneway() const
01784     {
01785     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01786         typedef ::IceProxy::Ice::Object _Base;
01787         return dynamic_cast<PrefrontalCortex*>(_Base::ice_oneway().get());
01788     #else
01789         return dynamic_cast<PrefrontalCortex*>(::IceProxy::Ice::Object::ice_oneway().get());
01790     #endif
01791     }
01792 
01793     ::IceInternal::ProxyHandle<PrefrontalCortex> ice_batchOneway() const
01794     {
01795     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01796         typedef ::IceProxy::Ice::Object _Base;
01797         return dynamic_cast<PrefrontalCortex*>(_Base::ice_batchOneway().get());
01798     #else
01799         return dynamic_cast<PrefrontalCortex*>(::IceProxy::Ice::Object::ice_batchOneway().get());
01800     #endif
01801     }
01802 
01803     ::IceInternal::ProxyHandle<PrefrontalCortex> ice_datagram() const
01804     {
01805     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01806         typedef ::IceProxy::Ice::Object _Base;
01807         return dynamic_cast<PrefrontalCortex*>(_Base::ice_datagram().get());
01808     #else
01809         return dynamic_cast<PrefrontalCortex*>(::IceProxy::Ice::Object::ice_datagram().get());
01810     #endif
01811     }
01812 
01813     ::IceInternal::ProxyHandle<PrefrontalCortex> ice_batchDatagram() const
01814     {
01815     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01816         typedef ::IceProxy::Ice::Object _Base;
01817         return dynamic_cast<PrefrontalCortex*>(_Base::ice_batchDatagram().get());
01818     #else
01819         return dynamic_cast<PrefrontalCortex*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
01820     #endif
01821     }
01822 
01823     ::IceInternal::ProxyHandle<PrefrontalCortex> ice_compress(bool __compress) const
01824     {
01825     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01826         typedef ::IceProxy::Ice::Object _Base;
01827         return dynamic_cast<PrefrontalCortex*>(_Base::ice_compress(__compress).get());
01828     #else
01829         return dynamic_cast<PrefrontalCortex*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
01830     #endif
01831     }
01832 
01833     ::IceInternal::ProxyHandle<PrefrontalCortex> ice_timeout(int __timeout) const
01834     {
01835     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01836         typedef ::IceProxy::Ice::Object _Base;
01837         return dynamic_cast<PrefrontalCortex*>(_Base::ice_timeout(__timeout).get());
01838     #else
01839         return dynamic_cast<PrefrontalCortex*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
01840     #endif
01841     }
01842 
01843     ::IceInternal::ProxyHandle<PrefrontalCortex> ice_connectionId(const std::string& __id) const
01844     {
01845     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01846         typedef ::IceProxy::Ice::Object _Base;
01847         return dynamic_cast<PrefrontalCortex*>(_Base::ice_connectionId(__id).get());
01848     #else
01849         return dynamic_cast<PrefrontalCortex*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
01850     #endif
01851     }
01852 
01853     static const ::std::string& ice_staticId();
01854 
01855 private:
01856 
01857     virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
01858     virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
01859     virtual ::IceProxy::Ice::Object* __newInstance() const;
01860 };
01861 
01862 class InferotemporalCortex : virtual public ::IceProxy::RobotSimEvents::Events
01863 {
01864 public:
01865 
01866     ::IceInternal::ProxyHandle<InferotemporalCortex> ice_context(const ::Ice::Context& __context) const
01867     {
01868     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01869         typedef ::IceProxy::Ice::Object _Base;
01870         return dynamic_cast<InferotemporalCortex*>(_Base::ice_context(__context).get());
01871     #else
01872         return dynamic_cast<InferotemporalCortex*>(::IceProxy::Ice::Object::ice_context(__context).get());
01873     #endif
01874     }
01875 
01876     ::IceInternal::ProxyHandle<InferotemporalCortex> ice_adapterId(const std::string& __id) const
01877     {
01878     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01879         typedef ::IceProxy::Ice::Object _Base;
01880         return dynamic_cast<InferotemporalCortex*>(_Base::ice_adapterId(__id).get());
01881     #else
01882         return dynamic_cast<InferotemporalCortex*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
01883     #endif
01884     }
01885 
01886     ::IceInternal::ProxyHandle<InferotemporalCortex> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
01887     {
01888     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01889         typedef ::IceProxy::Ice::Object _Base;
01890         return dynamic_cast<InferotemporalCortex*>(_Base::ice_endpoints(__endpoints).get());
01891     #else
01892         return dynamic_cast<InferotemporalCortex*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
01893     #endif
01894     }
01895 
01896     ::IceInternal::ProxyHandle<InferotemporalCortex> ice_locatorCacheTimeout(int __timeout) const
01897     {
01898     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01899         typedef ::IceProxy::Ice::Object _Base;
01900         return dynamic_cast<InferotemporalCortex*>(_Base::ice_locatorCacheTimeout(__timeout).get());
01901     #else
01902         return dynamic_cast<InferotemporalCortex*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
01903     #endif
01904     }
01905 
01906     ::IceInternal::ProxyHandle<InferotemporalCortex> ice_connectionCached(bool __cached) const
01907     {
01908     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01909         typedef ::IceProxy::Ice::Object _Base;
01910         return dynamic_cast<InferotemporalCortex*>(_Base::ice_connectionCached(__cached).get());
01911     #else
01912         return dynamic_cast<InferotemporalCortex*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
01913     #endif
01914     }
01915 
01916     ::IceInternal::ProxyHandle<InferotemporalCortex> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
01917     {
01918     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01919         typedef ::IceProxy::Ice::Object _Base;
01920         return dynamic_cast<InferotemporalCortex*>(_Base::ice_endpointSelection(__est).get());
01921     #else
01922         return dynamic_cast<InferotemporalCortex*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
01923     #endif
01924     }
01925 
01926     ::IceInternal::ProxyHandle<InferotemporalCortex> ice_secure(bool __secure) const
01927     {
01928     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01929         typedef ::IceProxy::Ice::Object _Base;
01930         return dynamic_cast<InferotemporalCortex*>(_Base::ice_secure(__secure).get());
01931     #else
01932         return dynamic_cast<InferotemporalCortex*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
01933     #endif
01934     }
01935 
01936     ::IceInternal::ProxyHandle<InferotemporalCortex> ice_preferSecure(bool __preferSecure) const
01937     {
01938     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01939         typedef ::IceProxy::Ice::Object _Base;
01940         return dynamic_cast<InferotemporalCortex*>(_Base::ice_preferSecure(__preferSecure).get());
01941     #else
01942         return dynamic_cast<InferotemporalCortex*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
01943     #endif
01944     }
01945 
01946     ::IceInternal::ProxyHandle<InferotemporalCortex> ice_router(const ::Ice::RouterPrx& __router) const
01947     {
01948     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01949         typedef ::IceProxy::Ice::Object _Base;
01950         return dynamic_cast<InferotemporalCortex*>(_Base::ice_router(__router).get());
01951     #else
01952         return dynamic_cast<InferotemporalCortex*>(::IceProxy::Ice::Object::ice_router(__router).get());
01953     #endif
01954     }
01955 
01956     ::IceInternal::ProxyHandle<InferotemporalCortex> ice_locator(const ::Ice::LocatorPrx& __locator) const
01957     {
01958     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01959         typedef ::IceProxy::Ice::Object _Base;
01960         return dynamic_cast<InferotemporalCortex*>(_Base::ice_locator(__locator).get());
01961     #else
01962         return dynamic_cast<InferotemporalCortex*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
01963     #endif
01964     }
01965 
01966     ::IceInternal::ProxyHandle<InferotemporalCortex> ice_collocationOptimized(bool __co) const
01967     {
01968     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01969         typedef ::IceProxy::Ice::Object _Base;
01970         return dynamic_cast<InferotemporalCortex*>(_Base::ice_collocationOptimized(__co).get());
01971     #else
01972         return dynamic_cast<InferotemporalCortex*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
01973     #endif
01974     }
01975 
01976     ::IceInternal::ProxyHandle<InferotemporalCortex> ice_twoway() const
01977     {
01978     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01979         typedef ::IceProxy::Ice::Object _Base;
01980         return dynamic_cast<InferotemporalCortex*>(_Base::ice_twoway().get());
01981     #else
01982         return dynamic_cast<InferotemporalCortex*>(::IceProxy::Ice::Object::ice_twoway().get());
01983     #endif
01984     }
01985 
01986     ::IceInternal::ProxyHandle<InferotemporalCortex> ice_oneway() const
01987     {
01988     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01989         typedef ::IceProxy::Ice::Object _Base;
01990         return dynamic_cast<InferotemporalCortex*>(_Base::ice_oneway().get());
01991     #else
01992         return dynamic_cast<InferotemporalCortex*>(::IceProxy::Ice::Object::ice_oneway().get());
01993     #endif
01994     }
01995 
01996     ::IceInternal::ProxyHandle<InferotemporalCortex> ice_batchOneway() const
01997     {
01998     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01999         typedef ::IceProxy::Ice::Object _Base;
02000         return dynamic_cast<InferotemporalCortex*>(_Base::ice_batchOneway().get());
02001     #else
02002         return dynamic_cast<InferotemporalCortex*>(::IceProxy::Ice::Object::ice_batchOneway().get());
02003     #endif
02004     }
02005 
02006     ::IceInternal::ProxyHandle<InferotemporalCortex> ice_datagram() const
02007     {
02008     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02009         typedef ::IceProxy::Ice::Object _Base;
02010         return dynamic_cast<InferotemporalCortex*>(_Base::ice_datagram().get());
02011     #else
02012         return dynamic_cast<InferotemporalCortex*>(::IceProxy::Ice::Object::ice_datagram().get());
02013     #endif
02014     }
02015 
02016     ::IceInternal::ProxyHandle<InferotemporalCortex> ice_batchDatagram() const
02017     {
02018     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02019         typedef ::IceProxy::Ice::Object _Base;
02020         return dynamic_cast<InferotemporalCortex*>(_Base::ice_batchDatagram().get());
02021     #else
02022         return dynamic_cast<InferotemporalCortex*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
02023     #endif
02024     }
02025 
02026     ::IceInternal::ProxyHandle<InferotemporalCortex> ice_compress(bool __compress) const
02027     {
02028     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02029         typedef ::IceProxy::Ice::Object _Base;
02030         return dynamic_cast<InferotemporalCortex*>(_Base::ice_compress(__compress).get());
02031     #else
02032         return dynamic_cast<InferotemporalCortex*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
02033     #endif
02034     }
02035 
02036     ::IceInternal::ProxyHandle<InferotemporalCortex> ice_timeout(int __timeout) const
02037     {
02038     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02039         typedef ::IceProxy::Ice::Object _Base;
02040         return dynamic_cast<InferotemporalCortex*>(_Base::ice_timeout(__timeout).get());
02041     #else
02042         return dynamic_cast<InferotemporalCortex*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
02043     #endif
02044     }
02045 
02046     ::IceInternal::ProxyHandle<InferotemporalCortex> ice_connectionId(const std::string& __id) const
02047     {
02048     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02049         typedef ::IceProxy::Ice::Object _Base;
02050         return dynamic_cast<InferotemporalCortex*>(_Base::ice_connectionId(__id).get());
02051     #else
02052         return dynamic_cast<InferotemporalCortex*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
02053     #endif
02054     }
02055 
02056     static const ::std::string& ice_staticId();
02057 
02058 private:
02059 
02060     virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
02061     virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
02062     virtual ::IceProxy::Ice::Object* __newInstance() const;
02063 };
02064 
02065 class Observer : virtual public ::IceProxy::RobotSimEvents::Events
02066 {
02067 public:
02068 
02069     ::IceInternal::ProxyHandle<Observer> ice_context(const ::Ice::Context& __context) const
02070     {
02071     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02072         typedef ::IceProxy::Ice::Object _Base;
02073         return dynamic_cast<Observer*>(_Base::ice_context(__context).get());
02074     #else
02075         return dynamic_cast<Observer*>(::IceProxy::Ice::Object::ice_context(__context).get());
02076     #endif
02077     }
02078 
02079     ::IceInternal::ProxyHandle<Observer> ice_adapterId(const std::string& __id) const
02080     {
02081     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02082         typedef ::IceProxy::Ice::Object _Base;
02083         return dynamic_cast<Observer*>(_Base::ice_adapterId(__id).get());
02084     #else
02085         return dynamic_cast<Observer*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
02086     #endif
02087     }
02088 
02089     ::IceInternal::ProxyHandle<Observer> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
02090     {
02091     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02092         typedef ::IceProxy::Ice::Object _Base;
02093         return dynamic_cast<Observer*>(_Base::ice_endpoints(__endpoints).get());
02094     #else
02095         return dynamic_cast<Observer*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
02096     #endif
02097     }
02098 
02099     ::IceInternal::ProxyHandle<Observer> ice_locatorCacheTimeout(int __timeout) const
02100     {
02101     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02102         typedef ::IceProxy::Ice::Object _Base;
02103         return dynamic_cast<Observer*>(_Base::ice_locatorCacheTimeout(__timeout).get());
02104     #else
02105         return dynamic_cast<Observer*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
02106     #endif
02107     }
02108 
02109     ::IceInternal::ProxyHandle<Observer> ice_connectionCached(bool __cached) const
02110     {
02111     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02112         typedef ::IceProxy::Ice::Object _Base;
02113         return dynamic_cast<Observer*>(_Base::ice_connectionCached(__cached).get());
02114     #else
02115         return dynamic_cast<Observer*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
02116     #endif
02117     }
02118 
02119     ::IceInternal::ProxyHandle<Observer> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
02120     {
02121     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02122         typedef ::IceProxy::Ice::Object _Base;
02123         return dynamic_cast<Observer*>(_Base::ice_endpointSelection(__est).get());
02124     #else
02125         return dynamic_cast<Observer*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
02126     #endif
02127     }
02128 
02129     ::IceInternal::ProxyHandle<Observer> ice_secure(bool __secure) const
02130     {
02131     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02132         typedef ::IceProxy::Ice::Object _Base;
02133         return dynamic_cast<Observer*>(_Base::ice_secure(__secure).get());
02134     #else
02135         return dynamic_cast<Observer*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
02136     #endif
02137     }
02138 
02139     ::IceInternal::ProxyHandle<Observer> ice_preferSecure(bool __preferSecure) const
02140     {
02141     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02142         typedef ::IceProxy::Ice::Object _Base;
02143         return dynamic_cast<Observer*>(_Base::ice_preferSecure(__preferSecure).get());
02144     #else
02145         return dynamic_cast<Observer*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
02146     #endif
02147     }
02148 
02149     ::IceInternal::ProxyHandle<Observer> ice_router(const ::Ice::RouterPrx& __router) const
02150     {
02151     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02152         typedef ::IceProxy::Ice::Object _Base;
02153         return dynamic_cast<Observer*>(_Base::ice_router(__router).get());
02154     #else
02155         return dynamic_cast<Observer*>(::IceProxy::Ice::Object::ice_router(__router).get());
02156     #endif
02157     }
02158 
02159     ::IceInternal::ProxyHandle<Observer> ice_locator(const ::Ice::LocatorPrx& __locator) const
02160     {
02161     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02162         typedef ::IceProxy::Ice::Object _Base;
02163         return dynamic_cast<Observer*>(_Base::ice_locator(__locator).get());
02164     #else
02165         return dynamic_cast<Observer*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
02166     #endif
02167     }
02168 
02169     ::IceInternal::ProxyHandle<Observer> ice_collocationOptimized(bool __co) const
02170     {
02171     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02172         typedef ::IceProxy::Ice::Object _Base;
02173         return dynamic_cast<Observer*>(_Base::ice_collocationOptimized(__co).get());
02174     #else
02175         return dynamic_cast<Observer*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
02176     #endif
02177     }
02178 
02179     ::IceInternal::ProxyHandle<Observer> ice_twoway() const
02180     {
02181     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02182         typedef ::IceProxy::Ice::Object _Base;
02183         return dynamic_cast<Observer*>(_Base::ice_twoway().get());
02184     #else
02185         return dynamic_cast<Observer*>(::IceProxy::Ice::Object::ice_twoway().get());
02186     #endif
02187     }
02188 
02189     ::IceInternal::ProxyHandle<Observer> ice_oneway() const
02190     {
02191     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02192         typedef ::IceProxy::Ice::Object _Base;
02193         return dynamic_cast<Observer*>(_Base::ice_oneway().get());
02194     #else
02195         return dynamic_cast<Observer*>(::IceProxy::Ice::Object::ice_oneway().get());
02196     #endif
02197     }
02198 
02199     ::IceInternal::ProxyHandle<Observer> ice_batchOneway() const
02200     {
02201     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02202         typedef ::IceProxy::Ice::Object _Base;
02203         return dynamic_cast<Observer*>(_Base::ice_batchOneway().get());
02204     #else
02205         return dynamic_cast<Observer*>(::IceProxy::Ice::Object::ice_batchOneway().get());
02206     #endif
02207     }
02208 
02209     ::IceInternal::ProxyHandle<Observer> ice_datagram() const
02210     {
02211     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02212         typedef ::IceProxy::Ice::Object _Base;
02213         return dynamic_cast<Observer*>(_Base::ice_datagram().get());
02214     #else
02215         return dynamic_cast<Observer*>(::IceProxy::Ice::Object::ice_datagram().get());
02216     #endif
02217     }
02218 
02219     ::IceInternal::ProxyHandle<Observer> ice_batchDatagram() const
02220     {
02221     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02222         typedef ::IceProxy::Ice::Object _Base;
02223         return dynamic_cast<Observer*>(_Base::ice_batchDatagram().get());
02224     #else
02225         return dynamic_cast<Observer*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
02226     #endif
02227     }
02228 
02229     ::IceInternal::ProxyHandle<Observer> ice_compress(bool __compress) const
02230     {
02231     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02232         typedef ::IceProxy::Ice::Object _Base;
02233         return dynamic_cast<Observer*>(_Base::ice_compress(__compress).get());
02234     #else
02235         return dynamic_cast<Observer*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
02236     #endif
02237     }
02238 
02239     ::IceInternal::ProxyHandle<Observer> ice_timeout(int __timeout) const
02240     {
02241     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02242         typedef ::IceProxy::Ice::Object _Base;
02243         return dynamic_cast<Observer*>(_Base::ice_timeout(__timeout).get());
02244     #else
02245         return dynamic_cast<Observer*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
02246     #endif
02247     }
02248 
02249     ::IceInternal::ProxyHandle<Observer> ice_connectionId(const std::string& __id) const
02250     {
02251     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02252         typedef ::IceProxy::Ice::Object _Base;
02253         return dynamic_cast<Observer*>(_Base::ice_connectionId(__id).get());
02254     #else
02255         return dynamic_cast<Observer*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
02256     #endif
02257     }
02258 
02259     static const ::std::string& ice_staticId();
02260 
02261 private:
02262 
02263     virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
02264     virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
02265     virtual ::IceProxy::Ice::Object* __newInstance() const;
02266 };
02267 
02268 }
02269 
02270 }
02271 
02272 namespace IceDelegate
02273 {
02274 
02275 namespace RobotBrainObjects
02276 {
02277 
02278 class Retina : virtual public ::IceDelegate::RobotSimEvents::Events
02279 {
02280 public:
02281 };
02282 
02283 class SaliencyModule : virtual public ::IceDelegate::RobotSimEvents::Events
02284 {
02285 public:
02286 };
02287 
02288 class PrimaryMotorCortex : virtual public ::IceDelegate::RobotSimEvents::Events
02289 {
02290 public:
02291 };
02292 
02293 class PrimarySomatosensoryCortex : virtual public ::IceDelegate::RobotSimEvents::Events
02294 {
02295 public:
02296 };
02297 
02298 class LateralGeniculateNucleus : virtual public ::IceDelegate::RobotSimEvents::Events
02299 {
02300 public:
02301 };
02302 
02303 class Hippocampus : virtual public ::IceDelegate::RobotSimEvents::Events
02304 {
02305 public:
02306 };
02307 
02308 class SupplementaryMotorArea : virtual public ::IceDelegate::RobotSimEvents::Events
02309 {
02310 public:
02311 };
02312 
02313 class PrefrontalCortex : virtual public ::IceDelegate::RobotSimEvents::Events
02314 {
02315 public:
02316 };
02317 
02318 class InferotemporalCortex : virtual public ::IceDelegate::RobotSimEvents::Events
02319 {
02320 public:
02321 };
02322 
02323 class Observer : virtual public ::IceDelegate::RobotSimEvents::Events
02324 {
02325 public:
02326 };
02327 
02328 }
02329 
02330 }
02331 
02332 namespace IceDelegateM
02333 {
02334 
02335 namespace RobotBrainObjects
02336 {
02337 
02338 class Retina : virtual public ::IceDelegate::RobotBrainObjects::Retina,
02339                virtual public ::IceDelegateM::RobotSimEvents::Events
02340 {
02341 public:
02342 };
02343 
02344 class SaliencyModule : virtual public ::IceDelegate::RobotBrainObjects::SaliencyModule,
02345                        virtual public ::IceDelegateM::RobotSimEvents::Events
02346 {
02347 public:
02348 };
02349 
02350 class PrimaryMotorCortex : virtual public ::IceDelegate::RobotBrainObjects::PrimaryMotorCortex,
02351                            virtual public ::IceDelegateM::RobotSimEvents::Events
02352 {
02353 public:
02354 };
02355 
02356 class PrimarySomatosensoryCortex : virtual public ::IceDelegate::RobotBrainObjects::PrimarySomatosensoryCortex,
02357                                    virtual public ::IceDelegateM::RobotSimEvents::Events
02358 {
02359 public:
02360 };
02361 
02362 class LateralGeniculateNucleus : virtual public ::IceDelegate::RobotBrainObjects::LateralGeniculateNucleus,
02363                                  virtual public ::IceDelegateM::RobotSimEvents::Events
02364 {
02365 public:
02366 };
02367 
02368 class Hippocampus : virtual public ::IceDelegate::RobotBrainObjects::Hippocampus,
02369                     virtual public ::IceDelegateM::RobotSimEvents::Events
02370 {
02371 public:
02372 };
02373 
02374 class SupplementaryMotorArea : virtual public ::IceDelegate::RobotBrainObjects::SupplementaryMotorArea,
02375                                virtual public ::IceDelegateM::RobotSimEvents::Events
02376 {
02377 public:
02378 };
02379 
02380 class PrefrontalCortex : virtual public ::IceDelegate::RobotBrainObjects::PrefrontalCortex,
02381                          virtual public ::IceDelegateM::RobotSimEvents::Events
02382 {
02383 public:
02384 };
02385 
02386 class InferotemporalCortex : virtual public ::IceDelegate::RobotBrainObjects::InferotemporalCortex,
02387                              virtual public ::IceDelegateM::RobotSimEvents::Events
02388 {
02389 public:
02390 };
02391 
02392 class Observer : virtual public ::IceDelegate::RobotBrainObjects::Observer,
02393                  virtual public ::IceDelegateM::RobotSimEvents::Events
02394 {
02395 public:
02396 };
02397 
02398 }
02399 
02400 }
02401 
02402 namespace IceDelegateD
02403 {
02404 
02405 namespace RobotBrainObjects
02406 {
02407 
02408 class Retina : virtual public ::IceDelegate::RobotBrainObjects::Retina,
02409                virtual public ::IceDelegateD::RobotSimEvents::Events
02410 {
02411 public:
02412 };
02413 
02414 class SaliencyModule : virtual public ::IceDelegate::RobotBrainObjects::SaliencyModule,
02415                        virtual public ::IceDelegateD::RobotSimEvents::Events
02416 {
02417 public:
02418 };
02419 
02420 class PrimaryMotorCortex : virtual public ::IceDelegate::RobotBrainObjects::PrimaryMotorCortex,
02421                            virtual public ::IceDelegateD::RobotSimEvents::Events
02422 {
02423 public:
02424 };
02425 
02426 class PrimarySomatosensoryCortex : virtual public ::IceDelegate::RobotBrainObjects::PrimarySomatosensoryCortex,
02427                                    virtual public ::IceDelegateD::RobotSimEvents::Events
02428 {
02429 public:
02430 };
02431 
02432 class LateralGeniculateNucleus : virtual public ::IceDelegate::RobotBrainObjects::LateralGeniculateNucleus,
02433                                  virtual public ::IceDelegateD::RobotSimEvents::Events
02434 {
02435 public:
02436 };
02437 
02438 class Hippocampus : virtual public ::IceDelegate::RobotBrainObjects::Hippocampus,
02439                     virtual public ::IceDelegateD::RobotSimEvents::Events
02440 {
02441 public:
02442 };
02443 
02444 class SupplementaryMotorArea : virtual public ::IceDelegate::RobotBrainObjects::SupplementaryMotorArea,
02445                                virtual public ::IceDelegateD::RobotSimEvents::Events
02446 {
02447 public:
02448 };
02449 
02450 class PrefrontalCortex : virtual public ::IceDelegate::RobotBrainObjects::PrefrontalCortex,
02451                          virtual public ::IceDelegateD::RobotSimEvents::Events
02452 {
02453 public:
02454 };
02455 
02456 class InferotemporalCortex : virtual public ::IceDelegate::RobotBrainObjects::InferotemporalCortex,
02457                              virtual public ::IceDelegateD::RobotSimEvents::Events
02458 {
02459 public:
02460 };
02461 
02462 class Observer : virtual public ::IceDelegate::RobotBrainObjects::Observer,
02463                  virtual public ::IceDelegateD::RobotSimEvents::Events
02464 {
02465 public:
02466 };
02467 
02468 }
02469 
02470 }
02471 
02472 namespace RobotBrainObjects
02473 {
02474 
02475 class Retina : virtual public ::RobotSimEvents::Events
02476 {
02477 public:
02478 
02479     typedef RetinaPrx ProxyType;
02480     typedef RetinaPtr PointerType;
02481 
02482     virtual ::Ice::ObjectPtr ice_clone() const;
02483 
02484     virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
02485     virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
02486     virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
02487     static const ::std::string& ice_staticId();
02488 
02489     virtual ::Ice::DispatchStatus __dispatch(::IceInternal::Incoming&, const ::Ice::Current&);
02490 
02491     virtual void __write(::IceInternal::BasicStream*) const;
02492     virtual void __read(::IceInternal::BasicStream*, bool);
02493     virtual void __write(const ::Ice::OutputStreamPtr&) const;
02494     virtual void __read(const ::Ice::InputStreamPtr&, bool);
02495 };
02496 
02497 class SaliencyModule : virtual public ::RobotSimEvents::Events
02498 {
02499 public:
02500 
02501     typedef SaliencyModulePrx ProxyType;
02502     typedef SaliencyModulePtr PointerType;
02503 
02504     virtual ::Ice::ObjectPtr ice_clone() const;
02505 
02506     virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
02507     virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
02508     virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
02509     static const ::std::string& ice_staticId();
02510 
02511     virtual ::Ice::DispatchStatus __dispatch(::IceInternal::Incoming&, const ::Ice::Current&);
02512 
02513     virtual void __write(::IceInternal::BasicStream*) const;
02514     virtual void __read(::IceInternal::BasicStream*, bool);
02515     virtual void __write(const ::Ice::OutputStreamPtr&) const;
02516     virtual void __read(const ::Ice::InputStreamPtr&, bool);
02517 };
02518 
02519 class PrimaryMotorCortex : virtual public ::RobotSimEvents::Events
02520 {
02521 public:
02522 
02523     typedef PrimaryMotorCortexPrx ProxyType;
02524     typedef PrimaryMotorCortexPtr PointerType;
02525 
02526     virtual ::Ice::ObjectPtr ice_clone() const;
02527 
02528     virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
02529     virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
02530     virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
02531     static const ::std::string& ice_staticId();
02532 
02533     virtual ::Ice::DispatchStatus __dispatch(::IceInternal::Incoming&, const ::Ice::Current&);
02534 
02535     virtual void __write(::IceInternal::BasicStream*) const;
02536     virtual void __read(::IceInternal::BasicStream*, bool);
02537     virtual void __write(const ::Ice::OutputStreamPtr&) const;
02538     virtual void __read(const ::Ice::InputStreamPtr&, bool);
02539 };
02540 
02541 class PrimarySomatosensoryCortex : virtual public ::RobotSimEvents::Events
02542 {
02543 public:
02544 
02545     typedef PrimarySomatosensoryCortexPrx ProxyType;
02546     typedef PrimarySomatosensoryCortexPtr PointerType;
02547 
02548     virtual ::Ice::ObjectPtr ice_clone() const;
02549 
02550     virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
02551     virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
02552     virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
02553     static const ::std::string& ice_staticId();
02554 
02555     virtual ::Ice::DispatchStatus __dispatch(::IceInternal::Incoming&, const ::Ice::Current&);
02556 
02557     virtual void __write(::IceInternal::BasicStream*) const;
02558     virtual void __read(::IceInternal::BasicStream*, bool);
02559     virtual void __write(const ::Ice::OutputStreamPtr&) const;
02560     virtual void __read(const ::Ice::InputStreamPtr&, bool);
02561 };
02562 
02563 class LateralGeniculateNucleus : virtual public ::RobotSimEvents::Events
02564 {
02565 public:
02566 
02567     typedef LateralGeniculateNucleusPrx ProxyType;
02568     typedef LateralGeniculateNucleusPtr PointerType;
02569 
02570     virtual ::Ice::ObjectPtr ice_clone() const;
02571 
02572     virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
02573     virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
02574     virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
02575     static const ::std::string& ice_staticId();
02576 
02577     virtual ::Ice::DispatchStatus __dispatch(::IceInternal::Incoming&, const ::Ice::Current&);
02578 
02579     virtual void __write(::IceInternal::BasicStream*) const;
02580     virtual void __read(::IceInternal::BasicStream*, bool);
02581     virtual void __write(const ::Ice::OutputStreamPtr&) const;
02582     virtual void __read(const ::Ice::InputStreamPtr&, bool);
02583 };
02584 
02585 class Hippocampus : virtual public ::RobotSimEvents::Events
02586 {
02587 public:
02588 
02589     typedef HippocampusPrx ProxyType;
02590     typedef HippocampusPtr PointerType;
02591 
02592     virtual ::Ice::ObjectPtr ice_clone() const;
02593 
02594     virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
02595     virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
02596     virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
02597     static const ::std::string& ice_staticId();
02598 
02599     virtual ::Ice::DispatchStatus __dispatch(::IceInternal::Incoming&, const ::Ice::Current&);
02600 
02601     virtual void __write(::IceInternal::BasicStream*) const;
02602     virtual void __read(::IceInternal::BasicStream*, bool);
02603     virtual void __write(const ::Ice::OutputStreamPtr&) const;
02604     virtual void __read(const ::Ice::InputStreamPtr&, bool);
02605 };
02606 
02607 class SupplementaryMotorArea : virtual public ::RobotSimEvents::Events
02608 {
02609 public:
02610 
02611     typedef SupplementaryMotorAreaPrx ProxyType;
02612     typedef SupplementaryMotorAreaPtr PointerType;
02613 
02614     virtual ::Ice::ObjectPtr ice_clone() const;
02615 
02616     virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
02617     virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
02618     virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
02619     static const ::std::string& ice_staticId();
02620 
02621     virtual ::Ice::DispatchStatus __dispatch(::IceInternal::Incoming&, const ::Ice::Current&);
02622 
02623     virtual void __write(::IceInternal::BasicStream*) const;
02624     virtual void __read(::IceInternal::BasicStream*, bool);
02625     virtual void __write(const ::Ice::OutputStreamPtr&) const;
02626     virtual void __read(const ::Ice::InputStreamPtr&, bool);
02627 };
02628 
02629 class PrefrontalCortex : virtual public ::RobotSimEvents::Events
02630 {
02631 public:
02632 
02633     typedef PrefrontalCortexPrx ProxyType;
02634     typedef PrefrontalCortexPtr PointerType;
02635 
02636     virtual ::Ice::ObjectPtr ice_clone() const;
02637 
02638     virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
02639     virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
02640     virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
02641     static const ::std::string& ice_staticId();
02642 
02643     virtual ::Ice::DispatchStatus __dispatch(::IceInternal::Incoming&, const ::Ice::Current&);
02644 
02645     virtual void __write(::IceInternal::BasicStream*) const;
02646     virtual void __read(::IceInternal::BasicStream*, bool);
02647     virtual void __write(const ::Ice::OutputStreamPtr&) const;
02648     virtual void __read(const ::Ice::InputStreamPtr&, bool);
02649 };
02650 
02651 class InferotemporalCortex : virtual public ::RobotSimEvents::Events
02652 {
02653 public:
02654 
02655     typedef InferotemporalCortexPrx ProxyType;
02656     typedef InferotemporalCortexPtr PointerType;
02657 
02658     virtual ::Ice::ObjectPtr ice_clone() const;
02659 
02660     virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
02661     virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
02662     virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
02663     static const ::std::string& ice_staticId();
02664 
02665     virtual ::Ice::DispatchStatus __dispatch(::IceInternal::Incoming&, const ::Ice::Current&);
02666 
02667     virtual void __write(::IceInternal::BasicStream*) const;
02668     virtual void __read(::IceInternal::BasicStream*, bool);
02669     virtual void __write(const ::Ice::OutputStreamPtr&) const;
02670     virtual void __read(const ::Ice::InputStreamPtr&, bool);
02671 };
02672 
02673 class Observer : virtual public ::RobotSimEvents::Events
02674 {
02675 public:
02676 
02677     typedef ObserverPrx ProxyType;
02678     typedef ObserverPtr PointerType;
02679 
02680     virtual ::Ice::ObjectPtr ice_clone() const;
02681 
02682     virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
02683     virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
02684     virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
02685     static const ::std::string& ice_staticId();
02686 
02687     virtual ::Ice::DispatchStatus __dispatch(::IceInternal::Incoming&, const ::Ice::Current&);
02688 
02689     virtual void __write(::IceInternal::BasicStream*) const;
02690     virtual void __read(::IceInternal::BasicStream*, bool);
02691     virtual void __write(const ::Ice::OutputStreamPtr&) const;
02692     virtual void __read(const ::Ice::InputStreamPtr&, bool);
02693 };
02694 
02695 }
02696 
02697 #endif