BrainObjects.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 `BrainObjects.ice'
00012 
00013 #ifndef __src_Ice__BrainObjects_ice_H__
00014 #define __src_Ice__BrainObjects_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/SimEvents.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 BrainObjects
00048 {
00049 
00050 class Retina;
00051 
00052 class VisualCortex;
00053 
00054 class SaliencyMap;
00055 
00056 class VisualTracker;
00057 
00058 class PTZ;
00059 
00060 class Segmenter;
00061 
00062 class InferotemporalCortex;
00063 
00064 class Hippocampus;
00065 
00066 class PrimaryMotorCortex;
00067 
00068 class PrefrontalCortex;
00069 
00070 class SimulationViewer;
00071 
00072 class HomeInterface;
00073 
00074 }
00075 
00076 }
00077 
00078 namespace BrainObjects
00079 {
00080 
00081 class Retina;
00082 bool operator==(const Retina&, const Retina&);
00083 bool operator<(const Retina&, const Retina&);
00084 
00085 class VisualCortex;
00086 bool operator==(const VisualCortex&, const VisualCortex&);
00087 bool operator<(const VisualCortex&, const VisualCortex&);
00088 
00089 class SaliencyMap;
00090 bool operator==(const SaliencyMap&, const SaliencyMap&);
00091 bool operator<(const SaliencyMap&, const SaliencyMap&);
00092 
00093 class VisualTracker;
00094 bool operator==(const VisualTracker&, const VisualTracker&);
00095 bool operator<(const VisualTracker&, const VisualTracker&);
00096 
00097 class PTZ;
00098 bool operator==(const PTZ&, const PTZ&);
00099 bool operator<(const PTZ&, const PTZ&);
00100 
00101 class Segmenter;
00102 bool operator==(const Segmenter&, const Segmenter&);
00103 bool operator<(const Segmenter&, const Segmenter&);
00104 
00105 class InferotemporalCortex;
00106 bool operator==(const InferotemporalCortex&, const InferotemporalCortex&);
00107 bool operator<(const InferotemporalCortex&, const InferotemporalCortex&);
00108 
00109 class Hippocampus;
00110 bool operator==(const Hippocampus&, const Hippocampus&);
00111 bool operator<(const Hippocampus&, const Hippocampus&);
00112 
00113 class PrimaryMotorCortex;
00114 bool operator==(const PrimaryMotorCortex&, const PrimaryMotorCortex&);
00115 bool operator<(const PrimaryMotorCortex&, const PrimaryMotorCortex&);
00116 
00117 class PrefrontalCortex;
00118 bool operator==(const PrefrontalCortex&, const PrefrontalCortex&);
00119 bool operator<(const PrefrontalCortex&, const PrefrontalCortex&);
00120 
00121 class SimulationViewer;
00122 bool operator==(const SimulationViewer&, const SimulationViewer&);
00123 bool operator<(const SimulationViewer&, const SimulationViewer&);
00124 
00125 class HomeInterface;
00126 bool operator==(const HomeInterface&, const HomeInterface&);
00127 bool operator<(const HomeInterface&, const HomeInterface&);
00128 
00129 }
00130 
00131 namespace IceInternal
00132 {
00133 
00134 ::Ice::Object* upCast(::BrainObjects::Retina*);
00135 ::IceProxy::Ice::Object* upCast(::IceProxy::BrainObjects::Retina*);
00136 
00137 ::Ice::Object* upCast(::BrainObjects::VisualCortex*);
00138 ::IceProxy::Ice::Object* upCast(::IceProxy::BrainObjects::VisualCortex*);
00139 
00140 ::Ice::Object* upCast(::BrainObjects::SaliencyMap*);
00141 ::IceProxy::Ice::Object* upCast(::IceProxy::BrainObjects::SaliencyMap*);
00142 
00143 ::Ice::Object* upCast(::BrainObjects::VisualTracker*);
00144 ::IceProxy::Ice::Object* upCast(::IceProxy::BrainObjects::VisualTracker*);
00145 
00146 ::Ice::Object* upCast(::BrainObjects::PTZ*);
00147 ::IceProxy::Ice::Object* upCast(::IceProxy::BrainObjects::PTZ*);
00148 
00149 ::Ice::Object* upCast(::BrainObjects::Segmenter*);
00150 ::IceProxy::Ice::Object* upCast(::IceProxy::BrainObjects::Segmenter*);
00151 
00152 ::Ice::Object* upCast(::BrainObjects::InferotemporalCortex*);
00153 ::IceProxy::Ice::Object* upCast(::IceProxy::BrainObjects::InferotemporalCortex*);
00154 
00155 ::Ice::Object* upCast(::BrainObjects::Hippocampus*);
00156 ::IceProxy::Ice::Object* upCast(::IceProxy::BrainObjects::Hippocampus*);
00157 
00158 ::Ice::Object* upCast(::BrainObjects::PrimaryMotorCortex*);
00159 ::IceProxy::Ice::Object* upCast(::IceProxy::BrainObjects::PrimaryMotorCortex*);
00160 
00161 ::Ice::Object* upCast(::BrainObjects::PrefrontalCortex*);
00162 ::IceProxy::Ice::Object* upCast(::IceProxy::BrainObjects::PrefrontalCortex*);
00163 
00164 ::Ice::Object* upCast(::BrainObjects::SimulationViewer*);
00165 ::IceProxy::Ice::Object* upCast(::IceProxy::BrainObjects::SimulationViewer*);
00166 
00167 ::Ice::Object* upCast(::BrainObjects::HomeInterface*);
00168 ::IceProxy::Ice::Object* upCast(::IceProxy::BrainObjects::HomeInterface*);
00169 
00170 }
00171 
00172 namespace BrainObjects
00173 {
00174 
00175 typedef ::IceInternal::Handle< ::BrainObjects::Retina> RetinaPtr;
00176 typedef ::IceInternal::ProxyHandle< ::IceProxy::BrainObjects::Retina> RetinaPrx;
00177 
00178 void __read(::IceInternal::BasicStream*, RetinaPrx&);
00179 void __patch__RetinaPtr(void*, ::Ice::ObjectPtr&);
00180 
00181 typedef ::IceInternal::Handle< ::BrainObjects::VisualCortex> VisualCortexPtr;
00182 typedef ::IceInternal::ProxyHandle< ::IceProxy::BrainObjects::VisualCortex> VisualCortexPrx;
00183 
00184 void __read(::IceInternal::BasicStream*, VisualCortexPrx&);
00185 void __patch__VisualCortexPtr(void*, ::Ice::ObjectPtr&);
00186 
00187 typedef ::IceInternal::Handle< ::BrainObjects::SaliencyMap> SaliencyMapPtr;
00188 typedef ::IceInternal::ProxyHandle< ::IceProxy::BrainObjects::SaliencyMap> SaliencyMapPrx;
00189 
00190 void __read(::IceInternal::BasicStream*, SaliencyMapPrx&);
00191 void __patch__SaliencyMapPtr(void*, ::Ice::ObjectPtr&);
00192 
00193 typedef ::IceInternal::Handle< ::BrainObjects::VisualTracker> VisualTrackerPtr;
00194 typedef ::IceInternal::ProxyHandle< ::IceProxy::BrainObjects::VisualTracker> VisualTrackerPrx;
00195 
00196 void __read(::IceInternal::BasicStream*, VisualTrackerPrx&);
00197 void __patch__VisualTrackerPtr(void*, ::Ice::ObjectPtr&);
00198 
00199 typedef ::IceInternal::Handle< ::BrainObjects::PTZ> PTZPtr;
00200 typedef ::IceInternal::ProxyHandle< ::IceProxy::BrainObjects::PTZ> PTZPrx;
00201 
00202 void __read(::IceInternal::BasicStream*, PTZPrx&);
00203 void __patch__PTZPtr(void*, ::Ice::ObjectPtr&);
00204 
00205 typedef ::IceInternal::Handle< ::BrainObjects::Segmenter> SegmenterPtr;
00206 typedef ::IceInternal::ProxyHandle< ::IceProxy::BrainObjects::Segmenter> SegmenterPrx;
00207 
00208 void __read(::IceInternal::BasicStream*, SegmenterPrx&);
00209 void __patch__SegmenterPtr(void*, ::Ice::ObjectPtr&);
00210 
00211 typedef ::IceInternal::Handle< ::BrainObjects::InferotemporalCortex> InferotemporalCortexPtr;
00212 typedef ::IceInternal::ProxyHandle< ::IceProxy::BrainObjects::InferotemporalCortex> InferotemporalCortexPrx;
00213 
00214 void __read(::IceInternal::BasicStream*, InferotemporalCortexPrx&);
00215 void __patch__InferotemporalCortexPtr(void*, ::Ice::ObjectPtr&);
00216 
00217 typedef ::IceInternal::Handle< ::BrainObjects::Hippocampus> HippocampusPtr;
00218 typedef ::IceInternal::ProxyHandle< ::IceProxy::BrainObjects::Hippocampus> HippocampusPrx;
00219 
00220 void __read(::IceInternal::BasicStream*, HippocampusPrx&);
00221 void __patch__HippocampusPtr(void*, ::Ice::ObjectPtr&);
00222 
00223 typedef ::IceInternal::Handle< ::BrainObjects::PrimaryMotorCortex> PrimaryMotorCortexPtr;
00224 typedef ::IceInternal::ProxyHandle< ::IceProxy::BrainObjects::PrimaryMotorCortex> PrimaryMotorCortexPrx;
00225 
00226 void __read(::IceInternal::BasicStream*, PrimaryMotorCortexPrx&);
00227 void __patch__PrimaryMotorCortexPtr(void*, ::Ice::ObjectPtr&);
00228 
00229 typedef ::IceInternal::Handle< ::BrainObjects::PrefrontalCortex> PrefrontalCortexPtr;
00230 typedef ::IceInternal::ProxyHandle< ::IceProxy::BrainObjects::PrefrontalCortex> PrefrontalCortexPrx;
00231 
00232 void __read(::IceInternal::BasicStream*, PrefrontalCortexPrx&);
00233 void __patch__PrefrontalCortexPtr(void*, ::Ice::ObjectPtr&);
00234 
00235 typedef ::IceInternal::Handle< ::BrainObjects::SimulationViewer> SimulationViewerPtr;
00236 typedef ::IceInternal::ProxyHandle< ::IceProxy::BrainObjects::SimulationViewer> SimulationViewerPrx;
00237 
00238 void __read(::IceInternal::BasicStream*, SimulationViewerPrx&);
00239 void __patch__SimulationViewerPtr(void*, ::Ice::ObjectPtr&);
00240 
00241 typedef ::IceInternal::Handle< ::BrainObjects::HomeInterface> HomeInterfacePtr;
00242 typedef ::IceInternal::ProxyHandle< ::IceProxy::BrainObjects::HomeInterface> HomeInterfacePrx;
00243 
00244 void __read(::IceInternal::BasicStream*, HomeInterfacePrx&);
00245 void __patch__HomeInterfacePtr(void*, ::Ice::ObjectPtr&);
00246 
00247 }
00248 
00249 namespace BrainObjects
00250 {
00251 
00252 const ::Ice::Int RetinaPort = 20000;
00253 
00254 const ::Ice::Int VisualCortexPort = 20001;
00255 
00256 const ::Ice::Int SaliencyMapPort = 20002;
00257 
00258 const ::Ice::Int SegmenterPort = 20003;
00259 
00260 const ::Ice::Int VisualTrackerPort = 20004;
00261 
00262 const ::Ice::Int InferoTemporalPort = 20005;
00263 
00264 const ::Ice::Int PrefrontalCortexPort = 20006;
00265 
00266 const ::Ice::Int SimulationViewerPort = 20007;
00267 
00268 const ::Ice::Int PTZPort = 20008;
00269 
00270 const ::Ice::Int HippocampusPort = 20009;
00271 
00272 const ::Ice::Int PrimaryMotorCortexPort = 20010;
00273 
00274 const ::Ice::Int HomeInterfacePort = 20011;
00275 
00276 }
00277 
00278 namespace IceProxy
00279 {
00280 
00281 namespace BrainObjects
00282 {
00283 
00284 class Retina : virtual public ::IceProxy::SimEvents::Events
00285 {
00286 public:
00287 
00288     ::ImageIceMod::ImageIce getOutput()
00289     {
00290         return getOutput(0);
00291     }
00292     ::ImageIceMod::ImageIce getOutput(const ::Ice::Context& __ctx)
00293     {
00294         return getOutput(&__ctx);
00295     }
00296 
00297 private:
00298 
00299     ::ImageIceMod::ImageIce getOutput(const ::Ice::Context*);
00300 
00301 public:
00302 
00303     ::IceInternal::ProxyHandle<Retina> ice_context(const ::Ice::Context& __context) const
00304     {
00305     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00306         typedef ::IceProxy::Ice::Object _Base;
00307         return dynamic_cast<Retina*>(_Base::ice_context(__context).get());
00308     #else
00309         return dynamic_cast<Retina*>(::IceProxy::Ice::Object::ice_context(__context).get());
00310     #endif
00311     }
00312 
00313     ::IceInternal::ProxyHandle<Retina> ice_adapterId(const std::string& __id) const
00314     {
00315     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00316         typedef ::IceProxy::Ice::Object _Base;
00317         return dynamic_cast<Retina*>(_Base::ice_adapterId(__id).get());
00318     #else
00319         return dynamic_cast<Retina*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
00320     #endif
00321     }
00322 
00323     ::IceInternal::ProxyHandle<Retina> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
00324     {
00325     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00326         typedef ::IceProxy::Ice::Object _Base;
00327         return dynamic_cast<Retina*>(_Base::ice_endpoints(__endpoints).get());
00328     #else
00329         return dynamic_cast<Retina*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
00330     #endif
00331     }
00332 
00333     ::IceInternal::ProxyHandle<Retina> ice_locatorCacheTimeout(int __timeout) const
00334     {
00335     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00336         typedef ::IceProxy::Ice::Object _Base;
00337         return dynamic_cast<Retina*>(_Base::ice_locatorCacheTimeout(__timeout).get());
00338     #else
00339         return dynamic_cast<Retina*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
00340     #endif
00341     }
00342 
00343     ::IceInternal::ProxyHandle<Retina> ice_connectionCached(bool __cached) const
00344     {
00345     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00346         typedef ::IceProxy::Ice::Object _Base;
00347         return dynamic_cast<Retina*>(_Base::ice_connectionCached(__cached).get());
00348     #else
00349         return dynamic_cast<Retina*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
00350     #endif
00351     }
00352 
00353     ::IceInternal::ProxyHandle<Retina> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
00354     {
00355     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00356         typedef ::IceProxy::Ice::Object _Base;
00357         return dynamic_cast<Retina*>(_Base::ice_endpointSelection(__est).get());
00358     #else
00359         return dynamic_cast<Retina*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
00360     #endif
00361     }
00362 
00363     ::IceInternal::ProxyHandle<Retina> ice_secure(bool __secure) const
00364     {
00365     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00366         typedef ::IceProxy::Ice::Object _Base;
00367         return dynamic_cast<Retina*>(_Base::ice_secure(__secure).get());
00368     #else
00369         return dynamic_cast<Retina*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
00370     #endif
00371     }
00372 
00373     ::IceInternal::ProxyHandle<Retina> ice_preferSecure(bool __preferSecure) const
00374     {
00375     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00376         typedef ::IceProxy::Ice::Object _Base;
00377         return dynamic_cast<Retina*>(_Base::ice_preferSecure(__preferSecure).get());
00378     #else
00379         return dynamic_cast<Retina*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
00380     #endif
00381     }
00382 
00383     ::IceInternal::ProxyHandle<Retina> ice_router(const ::Ice::RouterPrx& __router) const
00384     {
00385     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00386         typedef ::IceProxy::Ice::Object _Base;
00387         return dynamic_cast<Retina*>(_Base::ice_router(__router).get());
00388     #else
00389         return dynamic_cast<Retina*>(::IceProxy::Ice::Object::ice_router(__router).get());
00390     #endif
00391     }
00392 
00393     ::IceInternal::ProxyHandle<Retina> ice_locator(const ::Ice::LocatorPrx& __locator) const
00394     {
00395     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00396         typedef ::IceProxy::Ice::Object _Base;
00397         return dynamic_cast<Retina*>(_Base::ice_locator(__locator).get());
00398     #else
00399         return dynamic_cast<Retina*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
00400     #endif
00401     }
00402 
00403     ::IceInternal::ProxyHandle<Retina> ice_collocationOptimized(bool __co) const
00404     {
00405     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00406         typedef ::IceProxy::Ice::Object _Base;
00407         return dynamic_cast<Retina*>(_Base::ice_collocationOptimized(__co).get());
00408     #else
00409         return dynamic_cast<Retina*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
00410     #endif
00411     }
00412 
00413     ::IceInternal::ProxyHandle<Retina> ice_twoway() const
00414     {
00415     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00416         typedef ::IceProxy::Ice::Object _Base;
00417         return dynamic_cast<Retina*>(_Base::ice_twoway().get());
00418     #else
00419         return dynamic_cast<Retina*>(::IceProxy::Ice::Object::ice_twoway().get());
00420     #endif
00421     }
00422 
00423     ::IceInternal::ProxyHandle<Retina> ice_oneway() const
00424     {
00425     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00426         typedef ::IceProxy::Ice::Object _Base;
00427         return dynamic_cast<Retina*>(_Base::ice_oneway().get());
00428     #else
00429         return dynamic_cast<Retina*>(::IceProxy::Ice::Object::ice_oneway().get());
00430     #endif
00431     }
00432 
00433     ::IceInternal::ProxyHandle<Retina> ice_batchOneway() const
00434     {
00435     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00436         typedef ::IceProxy::Ice::Object _Base;
00437         return dynamic_cast<Retina*>(_Base::ice_batchOneway().get());
00438     #else
00439         return dynamic_cast<Retina*>(::IceProxy::Ice::Object::ice_batchOneway().get());
00440     #endif
00441     }
00442 
00443     ::IceInternal::ProxyHandle<Retina> ice_datagram() const
00444     {
00445     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00446         typedef ::IceProxy::Ice::Object _Base;
00447         return dynamic_cast<Retina*>(_Base::ice_datagram().get());
00448     #else
00449         return dynamic_cast<Retina*>(::IceProxy::Ice::Object::ice_datagram().get());
00450     #endif
00451     }
00452 
00453     ::IceInternal::ProxyHandle<Retina> ice_batchDatagram() const
00454     {
00455     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00456         typedef ::IceProxy::Ice::Object _Base;
00457         return dynamic_cast<Retina*>(_Base::ice_batchDatagram().get());
00458     #else
00459         return dynamic_cast<Retina*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
00460     #endif
00461     }
00462 
00463     ::IceInternal::ProxyHandle<Retina> ice_compress(bool __compress) const
00464     {
00465     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00466         typedef ::IceProxy::Ice::Object _Base;
00467         return dynamic_cast<Retina*>(_Base::ice_compress(__compress).get());
00468     #else
00469         return dynamic_cast<Retina*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
00470     #endif
00471     }
00472 
00473     ::IceInternal::ProxyHandle<Retina> ice_timeout(int __timeout) const
00474     {
00475     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00476         typedef ::IceProxy::Ice::Object _Base;
00477         return dynamic_cast<Retina*>(_Base::ice_timeout(__timeout).get());
00478     #else
00479         return dynamic_cast<Retina*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
00480     #endif
00481     }
00482 
00483     ::IceInternal::ProxyHandle<Retina> ice_connectionId(const std::string& __id) const
00484     {
00485     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00486         typedef ::IceProxy::Ice::Object _Base;
00487         return dynamic_cast<Retina*>(_Base::ice_connectionId(__id).get());
00488     #else
00489         return dynamic_cast<Retina*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
00490     #endif
00491     }
00492 
00493     static const ::std::string& ice_staticId();
00494 
00495 private:
00496 
00497     virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
00498     virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
00499     virtual ::IceProxy::Ice::Object* __newInstance() const;
00500 };
00501 
00502 class VisualCortex : virtual public ::IceProxy::SimEvents::Events
00503 {
00504 public:
00505 
00506     ::IceInternal::ProxyHandle<VisualCortex> ice_context(const ::Ice::Context& __context) const
00507     {
00508     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00509         typedef ::IceProxy::Ice::Object _Base;
00510         return dynamic_cast<VisualCortex*>(_Base::ice_context(__context).get());
00511     #else
00512         return dynamic_cast<VisualCortex*>(::IceProxy::Ice::Object::ice_context(__context).get());
00513     #endif
00514     }
00515 
00516     ::IceInternal::ProxyHandle<VisualCortex> ice_adapterId(const std::string& __id) const
00517     {
00518     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00519         typedef ::IceProxy::Ice::Object _Base;
00520         return dynamic_cast<VisualCortex*>(_Base::ice_adapterId(__id).get());
00521     #else
00522         return dynamic_cast<VisualCortex*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
00523     #endif
00524     }
00525 
00526     ::IceInternal::ProxyHandle<VisualCortex> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
00527     {
00528     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00529         typedef ::IceProxy::Ice::Object _Base;
00530         return dynamic_cast<VisualCortex*>(_Base::ice_endpoints(__endpoints).get());
00531     #else
00532         return dynamic_cast<VisualCortex*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
00533     #endif
00534     }
00535 
00536     ::IceInternal::ProxyHandle<VisualCortex> ice_locatorCacheTimeout(int __timeout) const
00537     {
00538     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00539         typedef ::IceProxy::Ice::Object _Base;
00540         return dynamic_cast<VisualCortex*>(_Base::ice_locatorCacheTimeout(__timeout).get());
00541     #else
00542         return dynamic_cast<VisualCortex*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
00543     #endif
00544     }
00545 
00546     ::IceInternal::ProxyHandle<VisualCortex> ice_connectionCached(bool __cached) const
00547     {
00548     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00549         typedef ::IceProxy::Ice::Object _Base;
00550         return dynamic_cast<VisualCortex*>(_Base::ice_connectionCached(__cached).get());
00551     #else
00552         return dynamic_cast<VisualCortex*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
00553     #endif
00554     }
00555 
00556     ::IceInternal::ProxyHandle<VisualCortex> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
00557     {
00558     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00559         typedef ::IceProxy::Ice::Object _Base;
00560         return dynamic_cast<VisualCortex*>(_Base::ice_endpointSelection(__est).get());
00561     #else
00562         return dynamic_cast<VisualCortex*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
00563     #endif
00564     }
00565 
00566     ::IceInternal::ProxyHandle<VisualCortex> ice_secure(bool __secure) const
00567     {
00568     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00569         typedef ::IceProxy::Ice::Object _Base;
00570         return dynamic_cast<VisualCortex*>(_Base::ice_secure(__secure).get());
00571     #else
00572         return dynamic_cast<VisualCortex*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
00573     #endif
00574     }
00575 
00576     ::IceInternal::ProxyHandle<VisualCortex> ice_preferSecure(bool __preferSecure) const
00577     {
00578     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00579         typedef ::IceProxy::Ice::Object _Base;
00580         return dynamic_cast<VisualCortex*>(_Base::ice_preferSecure(__preferSecure).get());
00581     #else
00582         return dynamic_cast<VisualCortex*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
00583     #endif
00584     }
00585 
00586     ::IceInternal::ProxyHandle<VisualCortex> ice_router(const ::Ice::RouterPrx& __router) const
00587     {
00588     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00589         typedef ::IceProxy::Ice::Object _Base;
00590         return dynamic_cast<VisualCortex*>(_Base::ice_router(__router).get());
00591     #else
00592         return dynamic_cast<VisualCortex*>(::IceProxy::Ice::Object::ice_router(__router).get());
00593     #endif
00594     }
00595 
00596     ::IceInternal::ProxyHandle<VisualCortex> ice_locator(const ::Ice::LocatorPrx& __locator) const
00597     {
00598     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00599         typedef ::IceProxy::Ice::Object _Base;
00600         return dynamic_cast<VisualCortex*>(_Base::ice_locator(__locator).get());
00601     #else
00602         return dynamic_cast<VisualCortex*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
00603     #endif
00604     }
00605 
00606     ::IceInternal::ProxyHandle<VisualCortex> ice_collocationOptimized(bool __co) const
00607     {
00608     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00609         typedef ::IceProxy::Ice::Object _Base;
00610         return dynamic_cast<VisualCortex*>(_Base::ice_collocationOptimized(__co).get());
00611     #else
00612         return dynamic_cast<VisualCortex*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
00613     #endif
00614     }
00615 
00616     ::IceInternal::ProxyHandle<VisualCortex> ice_twoway() const
00617     {
00618     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00619         typedef ::IceProxy::Ice::Object _Base;
00620         return dynamic_cast<VisualCortex*>(_Base::ice_twoway().get());
00621     #else
00622         return dynamic_cast<VisualCortex*>(::IceProxy::Ice::Object::ice_twoway().get());
00623     #endif
00624     }
00625 
00626     ::IceInternal::ProxyHandle<VisualCortex> ice_oneway() const
00627     {
00628     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00629         typedef ::IceProxy::Ice::Object _Base;
00630         return dynamic_cast<VisualCortex*>(_Base::ice_oneway().get());
00631     #else
00632         return dynamic_cast<VisualCortex*>(::IceProxy::Ice::Object::ice_oneway().get());
00633     #endif
00634     }
00635 
00636     ::IceInternal::ProxyHandle<VisualCortex> ice_batchOneway() const
00637     {
00638     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00639         typedef ::IceProxy::Ice::Object _Base;
00640         return dynamic_cast<VisualCortex*>(_Base::ice_batchOneway().get());
00641     #else
00642         return dynamic_cast<VisualCortex*>(::IceProxy::Ice::Object::ice_batchOneway().get());
00643     #endif
00644     }
00645 
00646     ::IceInternal::ProxyHandle<VisualCortex> ice_datagram() const
00647     {
00648     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00649         typedef ::IceProxy::Ice::Object _Base;
00650         return dynamic_cast<VisualCortex*>(_Base::ice_datagram().get());
00651     #else
00652         return dynamic_cast<VisualCortex*>(::IceProxy::Ice::Object::ice_datagram().get());
00653     #endif
00654     }
00655 
00656     ::IceInternal::ProxyHandle<VisualCortex> ice_batchDatagram() const
00657     {
00658     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00659         typedef ::IceProxy::Ice::Object _Base;
00660         return dynamic_cast<VisualCortex*>(_Base::ice_batchDatagram().get());
00661     #else
00662         return dynamic_cast<VisualCortex*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
00663     #endif
00664     }
00665 
00666     ::IceInternal::ProxyHandle<VisualCortex> ice_compress(bool __compress) const
00667     {
00668     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00669         typedef ::IceProxy::Ice::Object _Base;
00670         return dynamic_cast<VisualCortex*>(_Base::ice_compress(__compress).get());
00671     #else
00672         return dynamic_cast<VisualCortex*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
00673     #endif
00674     }
00675 
00676     ::IceInternal::ProxyHandle<VisualCortex> ice_timeout(int __timeout) const
00677     {
00678     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00679         typedef ::IceProxy::Ice::Object _Base;
00680         return dynamic_cast<VisualCortex*>(_Base::ice_timeout(__timeout).get());
00681     #else
00682         return dynamic_cast<VisualCortex*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
00683     #endif
00684     }
00685 
00686     ::IceInternal::ProxyHandle<VisualCortex> ice_connectionId(const std::string& __id) const
00687     {
00688     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00689         typedef ::IceProxy::Ice::Object _Base;
00690         return dynamic_cast<VisualCortex*>(_Base::ice_connectionId(__id).get());
00691     #else
00692         return dynamic_cast<VisualCortex*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
00693     #endif
00694     }
00695 
00696     static const ::std::string& ice_staticId();
00697 
00698 private:
00699 
00700     virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
00701     virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
00702     virtual ::IceProxy::Ice::Object* __newInstance() const;
00703 };
00704 
00705 class SaliencyMap : virtual public ::IceProxy::SimEvents::Events
00706 {
00707 public:
00708 
00709     ::IceInternal::ProxyHandle<SaliencyMap> ice_context(const ::Ice::Context& __context) const
00710     {
00711     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00712         typedef ::IceProxy::Ice::Object _Base;
00713         return dynamic_cast<SaliencyMap*>(_Base::ice_context(__context).get());
00714     #else
00715         return dynamic_cast<SaliencyMap*>(::IceProxy::Ice::Object::ice_context(__context).get());
00716     #endif
00717     }
00718 
00719     ::IceInternal::ProxyHandle<SaliencyMap> ice_adapterId(const std::string& __id) const
00720     {
00721     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00722         typedef ::IceProxy::Ice::Object _Base;
00723         return dynamic_cast<SaliencyMap*>(_Base::ice_adapterId(__id).get());
00724     #else
00725         return dynamic_cast<SaliencyMap*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
00726     #endif
00727     }
00728 
00729     ::IceInternal::ProxyHandle<SaliencyMap> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
00730     {
00731     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00732         typedef ::IceProxy::Ice::Object _Base;
00733         return dynamic_cast<SaliencyMap*>(_Base::ice_endpoints(__endpoints).get());
00734     #else
00735         return dynamic_cast<SaliencyMap*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
00736     #endif
00737     }
00738 
00739     ::IceInternal::ProxyHandle<SaliencyMap> ice_locatorCacheTimeout(int __timeout) const
00740     {
00741     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00742         typedef ::IceProxy::Ice::Object _Base;
00743         return dynamic_cast<SaliencyMap*>(_Base::ice_locatorCacheTimeout(__timeout).get());
00744     #else
00745         return dynamic_cast<SaliencyMap*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
00746     #endif
00747     }
00748 
00749     ::IceInternal::ProxyHandle<SaliencyMap> ice_connectionCached(bool __cached) const
00750     {
00751     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00752         typedef ::IceProxy::Ice::Object _Base;
00753         return dynamic_cast<SaliencyMap*>(_Base::ice_connectionCached(__cached).get());
00754     #else
00755         return dynamic_cast<SaliencyMap*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
00756     #endif
00757     }
00758 
00759     ::IceInternal::ProxyHandle<SaliencyMap> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
00760     {
00761     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00762         typedef ::IceProxy::Ice::Object _Base;
00763         return dynamic_cast<SaliencyMap*>(_Base::ice_endpointSelection(__est).get());
00764     #else
00765         return dynamic_cast<SaliencyMap*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
00766     #endif
00767     }
00768 
00769     ::IceInternal::ProxyHandle<SaliencyMap> ice_secure(bool __secure) const
00770     {
00771     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00772         typedef ::IceProxy::Ice::Object _Base;
00773         return dynamic_cast<SaliencyMap*>(_Base::ice_secure(__secure).get());
00774     #else
00775         return dynamic_cast<SaliencyMap*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
00776     #endif
00777     }
00778 
00779     ::IceInternal::ProxyHandle<SaliencyMap> ice_preferSecure(bool __preferSecure) const
00780     {
00781     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00782         typedef ::IceProxy::Ice::Object _Base;
00783         return dynamic_cast<SaliencyMap*>(_Base::ice_preferSecure(__preferSecure).get());
00784     #else
00785         return dynamic_cast<SaliencyMap*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
00786     #endif
00787     }
00788 
00789     ::IceInternal::ProxyHandle<SaliencyMap> ice_router(const ::Ice::RouterPrx& __router) const
00790     {
00791     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00792         typedef ::IceProxy::Ice::Object _Base;
00793         return dynamic_cast<SaliencyMap*>(_Base::ice_router(__router).get());
00794     #else
00795         return dynamic_cast<SaliencyMap*>(::IceProxy::Ice::Object::ice_router(__router).get());
00796     #endif
00797     }
00798 
00799     ::IceInternal::ProxyHandle<SaliencyMap> ice_locator(const ::Ice::LocatorPrx& __locator) const
00800     {
00801     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00802         typedef ::IceProxy::Ice::Object _Base;
00803         return dynamic_cast<SaliencyMap*>(_Base::ice_locator(__locator).get());
00804     #else
00805         return dynamic_cast<SaliencyMap*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
00806     #endif
00807     }
00808 
00809     ::IceInternal::ProxyHandle<SaliencyMap> ice_collocationOptimized(bool __co) const
00810     {
00811     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00812         typedef ::IceProxy::Ice::Object _Base;
00813         return dynamic_cast<SaliencyMap*>(_Base::ice_collocationOptimized(__co).get());
00814     #else
00815         return dynamic_cast<SaliencyMap*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
00816     #endif
00817     }
00818 
00819     ::IceInternal::ProxyHandle<SaliencyMap> ice_twoway() const
00820     {
00821     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00822         typedef ::IceProxy::Ice::Object _Base;
00823         return dynamic_cast<SaliencyMap*>(_Base::ice_twoway().get());
00824     #else
00825         return dynamic_cast<SaliencyMap*>(::IceProxy::Ice::Object::ice_twoway().get());
00826     #endif
00827     }
00828 
00829     ::IceInternal::ProxyHandle<SaliencyMap> ice_oneway() const
00830     {
00831     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00832         typedef ::IceProxy::Ice::Object _Base;
00833         return dynamic_cast<SaliencyMap*>(_Base::ice_oneway().get());
00834     #else
00835         return dynamic_cast<SaliencyMap*>(::IceProxy::Ice::Object::ice_oneway().get());
00836     #endif
00837     }
00838 
00839     ::IceInternal::ProxyHandle<SaliencyMap> ice_batchOneway() const
00840     {
00841     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00842         typedef ::IceProxy::Ice::Object _Base;
00843         return dynamic_cast<SaliencyMap*>(_Base::ice_batchOneway().get());
00844     #else
00845         return dynamic_cast<SaliencyMap*>(::IceProxy::Ice::Object::ice_batchOneway().get());
00846     #endif
00847     }
00848 
00849     ::IceInternal::ProxyHandle<SaliencyMap> ice_datagram() const
00850     {
00851     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00852         typedef ::IceProxy::Ice::Object _Base;
00853         return dynamic_cast<SaliencyMap*>(_Base::ice_datagram().get());
00854     #else
00855         return dynamic_cast<SaliencyMap*>(::IceProxy::Ice::Object::ice_datagram().get());
00856     #endif
00857     }
00858 
00859     ::IceInternal::ProxyHandle<SaliencyMap> ice_batchDatagram() const
00860     {
00861     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00862         typedef ::IceProxy::Ice::Object _Base;
00863         return dynamic_cast<SaliencyMap*>(_Base::ice_batchDatagram().get());
00864     #else
00865         return dynamic_cast<SaliencyMap*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
00866     #endif
00867     }
00868 
00869     ::IceInternal::ProxyHandle<SaliencyMap> ice_compress(bool __compress) const
00870     {
00871     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00872         typedef ::IceProxy::Ice::Object _Base;
00873         return dynamic_cast<SaliencyMap*>(_Base::ice_compress(__compress).get());
00874     #else
00875         return dynamic_cast<SaliencyMap*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
00876     #endif
00877     }
00878 
00879     ::IceInternal::ProxyHandle<SaliencyMap> ice_timeout(int __timeout) const
00880     {
00881     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00882         typedef ::IceProxy::Ice::Object _Base;
00883         return dynamic_cast<SaliencyMap*>(_Base::ice_timeout(__timeout).get());
00884     #else
00885         return dynamic_cast<SaliencyMap*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
00886     #endif
00887     }
00888 
00889     ::IceInternal::ProxyHandle<SaliencyMap> ice_connectionId(const std::string& __id) const
00890     {
00891     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00892         typedef ::IceProxy::Ice::Object _Base;
00893         return dynamic_cast<SaliencyMap*>(_Base::ice_connectionId(__id).get());
00894     #else
00895         return dynamic_cast<SaliencyMap*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
00896     #endif
00897     }
00898 
00899     static const ::std::string& ice_staticId();
00900 
00901 private:
00902 
00903     virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
00904     virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
00905     virtual ::IceProxy::Ice::Object* __newInstance() const;
00906 };
00907 
00908 class VisualTracker : virtual public ::IceProxy::SimEvents::Events
00909 {
00910 public:
00911 
00912     ::IceInternal::ProxyHandle<VisualTracker> ice_context(const ::Ice::Context& __context) const
00913     {
00914     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00915         typedef ::IceProxy::Ice::Object _Base;
00916         return dynamic_cast<VisualTracker*>(_Base::ice_context(__context).get());
00917     #else
00918         return dynamic_cast<VisualTracker*>(::IceProxy::Ice::Object::ice_context(__context).get());
00919     #endif
00920     }
00921 
00922     ::IceInternal::ProxyHandle<VisualTracker> ice_adapterId(const std::string& __id) const
00923     {
00924     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00925         typedef ::IceProxy::Ice::Object _Base;
00926         return dynamic_cast<VisualTracker*>(_Base::ice_adapterId(__id).get());
00927     #else
00928         return dynamic_cast<VisualTracker*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
00929     #endif
00930     }
00931 
00932     ::IceInternal::ProxyHandle<VisualTracker> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
00933     {
00934     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00935         typedef ::IceProxy::Ice::Object _Base;
00936         return dynamic_cast<VisualTracker*>(_Base::ice_endpoints(__endpoints).get());
00937     #else
00938         return dynamic_cast<VisualTracker*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
00939     #endif
00940     }
00941 
00942     ::IceInternal::ProxyHandle<VisualTracker> ice_locatorCacheTimeout(int __timeout) const
00943     {
00944     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00945         typedef ::IceProxy::Ice::Object _Base;
00946         return dynamic_cast<VisualTracker*>(_Base::ice_locatorCacheTimeout(__timeout).get());
00947     #else
00948         return dynamic_cast<VisualTracker*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
00949     #endif
00950     }
00951 
00952     ::IceInternal::ProxyHandle<VisualTracker> ice_connectionCached(bool __cached) const
00953     {
00954     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00955         typedef ::IceProxy::Ice::Object _Base;
00956         return dynamic_cast<VisualTracker*>(_Base::ice_connectionCached(__cached).get());
00957     #else
00958         return dynamic_cast<VisualTracker*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
00959     #endif
00960     }
00961 
00962     ::IceInternal::ProxyHandle<VisualTracker> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
00963     {
00964     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00965         typedef ::IceProxy::Ice::Object _Base;
00966         return dynamic_cast<VisualTracker*>(_Base::ice_endpointSelection(__est).get());
00967     #else
00968         return dynamic_cast<VisualTracker*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
00969     #endif
00970     }
00971 
00972     ::IceInternal::ProxyHandle<VisualTracker> ice_secure(bool __secure) const
00973     {
00974     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00975         typedef ::IceProxy::Ice::Object _Base;
00976         return dynamic_cast<VisualTracker*>(_Base::ice_secure(__secure).get());
00977     #else
00978         return dynamic_cast<VisualTracker*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
00979     #endif
00980     }
00981 
00982     ::IceInternal::ProxyHandle<VisualTracker> ice_preferSecure(bool __preferSecure) const
00983     {
00984     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00985         typedef ::IceProxy::Ice::Object _Base;
00986         return dynamic_cast<VisualTracker*>(_Base::ice_preferSecure(__preferSecure).get());
00987     #else
00988         return dynamic_cast<VisualTracker*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
00989     #endif
00990     }
00991 
00992     ::IceInternal::ProxyHandle<VisualTracker> ice_router(const ::Ice::RouterPrx& __router) const
00993     {
00994     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00995         typedef ::IceProxy::Ice::Object _Base;
00996         return dynamic_cast<VisualTracker*>(_Base::ice_router(__router).get());
00997     #else
00998         return dynamic_cast<VisualTracker*>(::IceProxy::Ice::Object::ice_router(__router).get());
00999     #endif
01000     }
01001 
01002     ::IceInternal::ProxyHandle<VisualTracker> ice_locator(const ::Ice::LocatorPrx& __locator) const
01003     {
01004     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01005         typedef ::IceProxy::Ice::Object _Base;
01006         return dynamic_cast<VisualTracker*>(_Base::ice_locator(__locator).get());
01007     #else
01008         return dynamic_cast<VisualTracker*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
01009     #endif
01010     }
01011 
01012     ::IceInternal::ProxyHandle<VisualTracker> ice_collocationOptimized(bool __co) const
01013     {
01014     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01015         typedef ::IceProxy::Ice::Object _Base;
01016         return dynamic_cast<VisualTracker*>(_Base::ice_collocationOptimized(__co).get());
01017     #else
01018         return dynamic_cast<VisualTracker*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
01019     #endif
01020     }
01021 
01022     ::IceInternal::ProxyHandle<VisualTracker> ice_twoway() const
01023     {
01024     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01025         typedef ::IceProxy::Ice::Object _Base;
01026         return dynamic_cast<VisualTracker*>(_Base::ice_twoway().get());
01027     #else
01028         return dynamic_cast<VisualTracker*>(::IceProxy::Ice::Object::ice_twoway().get());
01029     #endif
01030     }
01031 
01032     ::IceInternal::ProxyHandle<VisualTracker> ice_oneway() const
01033     {
01034     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01035         typedef ::IceProxy::Ice::Object _Base;
01036         return dynamic_cast<VisualTracker*>(_Base::ice_oneway().get());
01037     #else
01038         return dynamic_cast<VisualTracker*>(::IceProxy::Ice::Object::ice_oneway().get());
01039     #endif
01040     }
01041 
01042     ::IceInternal::ProxyHandle<VisualTracker> ice_batchOneway() const
01043     {
01044     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01045         typedef ::IceProxy::Ice::Object _Base;
01046         return dynamic_cast<VisualTracker*>(_Base::ice_batchOneway().get());
01047     #else
01048         return dynamic_cast<VisualTracker*>(::IceProxy::Ice::Object::ice_batchOneway().get());
01049     #endif
01050     }
01051 
01052     ::IceInternal::ProxyHandle<VisualTracker> ice_datagram() const
01053     {
01054     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01055         typedef ::IceProxy::Ice::Object _Base;
01056         return dynamic_cast<VisualTracker*>(_Base::ice_datagram().get());
01057     #else
01058         return dynamic_cast<VisualTracker*>(::IceProxy::Ice::Object::ice_datagram().get());
01059     #endif
01060     }
01061 
01062     ::IceInternal::ProxyHandle<VisualTracker> ice_batchDatagram() const
01063     {
01064     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01065         typedef ::IceProxy::Ice::Object _Base;
01066         return dynamic_cast<VisualTracker*>(_Base::ice_batchDatagram().get());
01067     #else
01068         return dynamic_cast<VisualTracker*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
01069     #endif
01070     }
01071 
01072     ::IceInternal::ProxyHandle<VisualTracker> ice_compress(bool __compress) const
01073     {
01074     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01075         typedef ::IceProxy::Ice::Object _Base;
01076         return dynamic_cast<VisualTracker*>(_Base::ice_compress(__compress).get());
01077     #else
01078         return dynamic_cast<VisualTracker*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
01079     #endif
01080     }
01081 
01082     ::IceInternal::ProxyHandle<VisualTracker> ice_timeout(int __timeout) const
01083     {
01084     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01085         typedef ::IceProxy::Ice::Object _Base;
01086         return dynamic_cast<VisualTracker*>(_Base::ice_timeout(__timeout).get());
01087     #else
01088         return dynamic_cast<VisualTracker*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
01089     #endif
01090     }
01091 
01092     ::IceInternal::ProxyHandle<VisualTracker> ice_connectionId(const std::string& __id) const
01093     {
01094     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01095         typedef ::IceProxy::Ice::Object _Base;
01096         return dynamic_cast<VisualTracker*>(_Base::ice_connectionId(__id).get());
01097     #else
01098         return dynamic_cast<VisualTracker*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
01099     #endif
01100     }
01101 
01102     static const ::std::string& ice_staticId();
01103 
01104 private:
01105 
01106     virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
01107     virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
01108     virtual ::IceProxy::Ice::Object* __newInstance() const;
01109 };
01110 
01111 class PTZ : virtual public ::IceProxy::SimEvents::Events
01112 {
01113 public:
01114 
01115     ::IceInternal::ProxyHandle<PTZ> ice_context(const ::Ice::Context& __context) const
01116     {
01117     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01118         typedef ::IceProxy::Ice::Object _Base;
01119         return dynamic_cast<PTZ*>(_Base::ice_context(__context).get());
01120     #else
01121         return dynamic_cast<PTZ*>(::IceProxy::Ice::Object::ice_context(__context).get());
01122     #endif
01123     }
01124 
01125     ::IceInternal::ProxyHandle<PTZ> ice_adapterId(const std::string& __id) const
01126     {
01127     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01128         typedef ::IceProxy::Ice::Object _Base;
01129         return dynamic_cast<PTZ*>(_Base::ice_adapterId(__id).get());
01130     #else
01131         return dynamic_cast<PTZ*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
01132     #endif
01133     }
01134 
01135     ::IceInternal::ProxyHandle<PTZ> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
01136     {
01137     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01138         typedef ::IceProxy::Ice::Object _Base;
01139         return dynamic_cast<PTZ*>(_Base::ice_endpoints(__endpoints).get());
01140     #else
01141         return dynamic_cast<PTZ*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
01142     #endif
01143     }
01144 
01145     ::IceInternal::ProxyHandle<PTZ> ice_locatorCacheTimeout(int __timeout) const
01146     {
01147     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01148         typedef ::IceProxy::Ice::Object _Base;
01149         return dynamic_cast<PTZ*>(_Base::ice_locatorCacheTimeout(__timeout).get());
01150     #else
01151         return dynamic_cast<PTZ*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
01152     #endif
01153     }
01154 
01155     ::IceInternal::ProxyHandle<PTZ> ice_connectionCached(bool __cached) const
01156     {
01157     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01158         typedef ::IceProxy::Ice::Object _Base;
01159         return dynamic_cast<PTZ*>(_Base::ice_connectionCached(__cached).get());
01160     #else
01161         return dynamic_cast<PTZ*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
01162     #endif
01163     }
01164 
01165     ::IceInternal::ProxyHandle<PTZ> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
01166     {
01167     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01168         typedef ::IceProxy::Ice::Object _Base;
01169         return dynamic_cast<PTZ*>(_Base::ice_endpointSelection(__est).get());
01170     #else
01171         return dynamic_cast<PTZ*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
01172     #endif
01173     }
01174 
01175     ::IceInternal::ProxyHandle<PTZ> ice_secure(bool __secure) const
01176     {
01177     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01178         typedef ::IceProxy::Ice::Object _Base;
01179         return dynamic_cast<PTZ*>(_Base::ice_secure(__secure).get());
01180     #else
01181         return dynamic_cast<PTZ*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
01182     #endif
01183     }
01184 
01185     ::IceInternal::ProxyHandle<PTZ> ice_preferSecure(bool __preferSecure) const
01186     {
01187     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01188         typedef ::IceProxy::Ice::Object _Base;
01189         return dynamic_cast<PTZ*>(_Base::ice_preferSecure(__preferSecure).get());
01190     #else
01191         return dynamic_cast<PTZ*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
01192     #endif
01193     }
01194 
01195     ::IceInternal::ProxyHandle<PTZ> ice_router(const ::Ice::RouterPrx& __router) const
01196     {
01197     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01198         typedef ::IceProxy::Ice::Object _Base;
01199         return dynamic_cast<PTZ*>(_Base::ice_router(__router).get());
01200     #else
01201         return dynamic_cast<PTZ*>(::IceProxy::Ice::Object::ice_router(__router).get());
01202     #endif
01203     }
01204 
01205     ::IceInternal::ProxyHandle<PTZ> ice_locator(const ::Ice::LocatorPrx& __locator) const
01206     {
01207     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01208         typedef ::IceProxy::Ice::Object _Base;
01209         return dynamic_cast<PTZ*>(_Base::ice_locator(__locator).get());
01210     #else
01211         return dynamic_cast<PTZ*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
01212     #endif
01213     }
01214 
01215     ::IceInternal::ProxyHandle<PTZ> ice_collocationOptimized(bool __co) const
01216     {
01217     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01218         typedef ::IceProxy::Ice::Object _Base;
01219         return dynamic_cast<PTZ*>(_Base::ice_collocationOptimized(__co).get());
01220     #else
01221         return dynamic_cast<PTZ*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
01222     #endif
01223     }
01224 
01225     ::IceInternal::ProxyHandle<PTZ> ice_twoway() const
01226     {
01227     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01228         typedef ::IceProxy::Ice::Object _Base;
01229         return dynamic_cast<PTZ*>(_Base::ice_twoway().get());
01230     #else
01231         return dynamic_cast<PTZ*>(::IceProxy::Ice::Object::ice_twoway().get());
01232     #endif
01233     }
01234 
01235     ::IceInternal::ProxyHandle<PTZ> ice_oneway() const
01236     {
01237     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01238         typedef ::IceProxy::Ice::Object _Base;
01239         return dynamic_cast<PTZ*>(_Base::ice_oneway().get());
01240     #else
01241         return dynamic_cast<PTZ*>(::IceProxy::Ice::Object::ice_oneway().get());
01242     #endif
01243     }
01244 
01245     ::IceInternal::ProxyHandle<PTZ> ice_batchOneway() const
01246     {
01247     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01248         typedef ::IceProxy::Ice::Object _Base;
01249         return dynamic_cast<PTZ*>(_Base::ice_batchOneway().get());
01250     #else
01251         return dynamic_cast<PTZ*>(::IceProxy::Ice::Object::ice_batchOneway().get());
01252     #endif
01253     }
01254 
01255     ::IceInternal::ProxyHandle<PTZ> ice_datagram() const
01256     {
01257     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01258         typedef ::IceProxy::Ice::Object _Base;
01259         return dynamic_cast<PTZ*>(_Base::ice_datagram().get());
01260     #else
01261         return dynamic_cast<PTZ*>(::IceProxy::Ice::Object::ice_datagram().get());
01262     #endif
01263     }
01264 
01265     ::IceInternal::ProxyHandle<PTZ> ice_batchDatagram() const
01266     {
01267     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01268         typedef ::IceProxy::Ice::Object _Base;
01269         return dynamic_cast<PTZ*>(_Base::ice_batchDatagram().get());
01270     #else
01271         return dynamic_cast<PTZ*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
01272     #endif
01273     }
01274 
01275     ::IceInternal::ProxyHandle<PTZ> ice_compress(bool __compress) const
01276     {
01277     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01278         typedef ::IceProxy::Ice::Object _Base;
01279         return dynamic_cast<PTZ*>(_Base::ice_compress(__compress).get());
01280     #else
01281         return dynamic_cast<PTZ*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
01282     #endif
01283     }
01284 
01285     ::IceInternal::ProxyHandle<PTZ> ice_timeout(int __timeout) const
01286     {
01287     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01288         typedef ::IceProxy::Ice::Object _Base;
01289         return dynamic_cast<PTZ*>(_Base::ice_timeout(__timeout).get());
01290     #else
01291         return dynamic_cast<PTZ*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
01292     #endif
01293     }
01294 
01295     ::IceInternal::ProxyHandle<PTZ> ice_connectionId(const std::string& __id) const
01296     {
01297     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01298         typedef ::IceProxy::Ice::Object _Base;
01299         return dynamic_cast<PTZ*>(_Base::ice_connectionId(__id).get());
01300     #else
01301         return dynamic_cast<PTZ*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
01302     #endif
01303     }
01304 
01305     static const ::std::string& ice_staticId();
01306 
01307 private:
01308 
01309     virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
01310     virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
01311     virtual ::IceProxy::Ice::Object* __newInstance() const;
01312 };
01313 
01314 class Segmenter : virtual public ::IceProxy::SimEvents::Events
01315 {
01316 public:
01317 
01318     ::IceInternal::ProxyHandle<Segmenter> ice_context(const ::Ice::Context& __context) const
01319     {
01320     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01321         typedef ::IceProxy::Ice::Object _Base;
01322         return dynamic_cast<Segmenter*>(_Base::ice_context(__context).get());
01323     #else
01324         return dynamic_cast<Segmenter*>(::IceProxy::Ice::Object::ice_context(__context).get());
01325     #endif
01326     }
01327 
01328     ::IceInternal::ProxyHandle<Segmenter> ice_adapterId(const std::string& __id) const
01329     {
01330     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01331         typedef ::IceProxy::Ice::Object _Base;
01332         return dynamic_cast<Segmenter*>(_Base::ice_adapterId(__id).get());
01333     #else
01334         return dynamic_cast<Segmenter*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
01335     #endif
01336     }
01337 
01338     ::IceInternal::ProxyHandle<Segmenter> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
01339     {
01340     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01341         typedef ::IceProxy::Ice::Object _Base;
01342         return dynamic_cast<Segmenter*>(_Base::ice_endpoints(__endpoints).get());
01343     #else
01344         return dynamic_cast<Segmenter*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
01345     #endif
01346     }
01347 
01348     ::IceInternal::ProxyHandle<Segmenter> ice_locatorCacheTimeout(int __timeout) const
01349     {
01350     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01351         typedef ::IceProxy::Ice::Object _Base;
01352         return dynamic_cast<Segmenter*>(_Base::ice_locatorCacheTimeout(__timeout).get());
01353     #else
01354         return dynamic_cast<Segmenter*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
01355     #endif
01356     }
01357 
01358     ::IceInternal::ProxyHandle<Segmenter> ice_connectionCached(bool __cached) const
01359     {
01360     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01361         typedef ::IceProxy::Ice::Object _Base;
01362         return dynamic_cast<Segmenter*>(_Base::ice_connectionCached(__cached).get());
01363     #else
01364         return dynamic_cast<Segmenter*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
01365     #endif
01366     }
01367 
01368     ::IceInternal::ProxyHandle<Segmenter> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
01369     {
01370     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01371         typedef ::IceProxy::Ice::Object _Base;
01372         return dynamic_cast<Segmenter*>(_Base::ice_endpointSelection(__est).get());
01373     #else
01374         return dynamic_cast<Segmenter*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
01375     #endif
01376     }
01377 
01378     ::IceInternal::ProxyHandle<Segmenter> ice_secure(bool __secure) const
01379     {
01380     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01381         typedef ::IceProxy::Ice::Object _Base;
01382         return dynamic_cast<Segmenter*>(_Base::ice_secure(__secure).get());
01383     #else
01384         return dynamic_cast<Segmenter*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
01385     #endif
01386     }
01387 
01388     ::IceInternal::ProxyHandle<Segmenter> ice_preferSecure(bool __preferSecure) const
01389     {
01390     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01391         typedef ::IceProxy::Ice::Object _Base;
01392         return dynamic_cast<Segmenter*>(_Base::ice_preferSecure(__preferSecure).get());
01393     #else
01394         return dynamic_cast<Segmenter*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
01395     #endif
01396     }
01397 
01398     ::IceInternal::ProxyHandle<Segmenter> ice_router(const ::Ice::RouterPrx& __router) const
01399     {
01400     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01401         typedef ::IceProxy::Ice::Object _Base;
01402         return dynamic_cast<Segmenter*>(_Base::ice_router(__router).get());
01403     #else
01404         return dynamic_cast<Segmenter*>(::IceProxy::Ice::Object::ice_router(__router).get());
01405     #endif
01406     }
01407 
01408     ::IceInternal::ProxyHandle<Segmenter> ice_locator(const ::Ice::LocatorPrx& __locator) const
01409     {
01410     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01411         typedef ::IceProxy::Ice::Object _Base;
01412         return dynamic_cast<Segmenter*>(_Base::ice_locator(__locator).get());
01413     #else
01414         return dynamic_cast<Segmenter*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
01415     #endif
01416     }
01417 
01418     ::IceInternal::ProxyHandle<Segmenter> ice_collocationOptimized(bool __co) const
01419     {
01420     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01421         typedef ::IceProxy::Ice::Object _Base;
01422         return dynamic_cast<Segmenter*>(_Base::ice_collocationOptimized(__co).get());
01423     #else
01424         return dynamic_cast<Segmenter*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
01425     #endif
01426     }
01427 
01428     ::IceInternal::ProxyHandle<Segmenter> ice_twoway() const
01429     {
01430     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01431         typedef ::IceProxy::Ice::Object _Base;
01432         return dynamic_cast<Segmenter*>(_Base::ice_twoway().get());
01433     #else
01434         return dynamic_cast<Segmenter*>(::IceProxy::Ice::Object::ice_twoway().get());
01435     #endif
01436     }
01437 
01438     ::IceInternal::ProxyHandle<Segmenter> ice_oneway() const
01439     {
01440     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01441         typedef ::IceProxy::Ice::Object _Base;
01442         return dynamic_cast<Segmenter*>(_Base::ice_oneway().get());
01443     #else
01444         return dynamic_cast<Segmenter*>(::IceProxy::Ice::Object::ice_oneway().get());
01445     #endif
01446     }
01447 
01448     ::IceInternal::ProxyHandle<Segmenter> ice_batchOneway() const
01449     {
01450     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01451         typedef ::IceProxy::Ice::Object _Base;
01452         return dynamic_cast<Segmenter*>(_Base::ice_batchOneway().get());
01453     #else
01454         return dynamic_cast<Segmenter*>(::IceProxy::Ice::Object::ice_batchOneway().get());
01455     #endif
01456     }
01457 
01458     ::IceInternal::ProxyHandle<Segmenter> ice_datagram() const
01459     {
01460     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01461         typedef ::IceProxy::Ice::Object _Base;
01462         return dynamic_cast<Segmenter*>(_Base::ice_datagram().get());
01463     #else
01464         return dynamic_cast<Segmenter*>(::IceProxy::Ice::Object::ice_datagram().get());
01465     #endif
01466     }
01467 
01468     ::IceInternal::ProxyHandle<Segmenter> ice_batchDatagram() const
01469     {
01470     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01471         typedef ::IceProxy::Ice::Object _Base;
01472         return dynamic_cast<Segmenter*>(_Base::ice_batchDatagram().get());
01473     #else
01474         return dynamic_cast<Segmenter*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
01475     #endif
01476     }
01477 
01478     ::IceInternal::ProxyHandle<Segmenter> ice_compress(bool __compress) const
01479     {
01480     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01481         typedef ::IceProxy::Ice::Object _Base;
01482         return dynamic_cast<Segmenter*>(_Base::ice_compress(__compress).get());
01483     #else
01484         return dynamic_cast<Segmenter*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
01485     #endif
01486     }
01487 
01488     ::IceInternal::ProxyHandle<Segmenter> ice_timeout(int __timeout) const
01489     {
01490     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01491         typedef ::IceProxy::Ice::Object _Base;
01492         return dynamic_cast<Segmenter*>(_Base::ice_timeout(__timeout).get());
01493     #else
01494         return dynamic_cast<Segmenter*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
01495     #endif
01496     }
01497 
01498     ::IceInternal::ProxyHandle<Segmenter> ice_connectionId(const std::string& __id) const
01499     {
01500     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01501         typedef ::IceProxy::Ice::Object _Base;
01502         return dynamic_cast<Segmenter*>(_Base::ice_connectionId(__id).get());
01503     #else
01504         return dynamic_cast<Segmenter*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
01505     #endif
01506     }
01507 
01508     static const ::std::string& ice_staticId();
01509 
01510 private:
01511 
01512     virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
01513     virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
01514     virtual ::IceProxy::Ice::Object* __newInstance() const;
01515 };
01516 
01517 class InferotemporalCortex : virtual public ::IceProxy::SimEvents::Events
01518 {
01519 public:
01520 
01521     ::IceInternal::ProxyHandle<InferotemporalCortex> ice_context(const ::Ice::Context& __context) const
01522     {
01523     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01524         typedef ::IceProxy::Ice::Object _Base;
01525         return dynamic_cast<InferotemporalCortex*>(_Base::ice_context(__context).get());
01526     #else
01527         return dynamic_cast<InferotemporalCortex*>(::IceProxy::Ice::Object::ice_context(__context).get());
01528     #endif
01529     }
01530 
01531     ::IceInternal::ProxyHandle<InferotemporalCortex> ice_adapterId(const std::string& __id) const
01532     {
01533     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01534         typedef ::IceProxy::Ice::Object _Base;
01535         return dynamic_cast<InferotemporalCortex*>(_Base::ice_adapterId(__id).get());
01536     #else
01537         return dynamic_cast<InferotemporalCortex*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
01538     #endif
01539     }
01540 
01541     ::IceInternal::ProxyHandle<InferotemporalCortex> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
01542     {
01543     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01544         typedef ::IceProxy::Ice::Object _Base;
01545         return dynamic_cast<InferotemporalCortex*>(_Base::ice_endpoints(__endpoints).get());
01546     #else
01547         return dynamic_cast<InferotemporalCortex*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
01548     #endif
01549     }
01550 
01551     ::IceInternal::ProxyHandle<InferotemporalCortex> ice_locatorCacheTimeout(int __timeout) const
01552     {
01553     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01554         typedef ::IceProxy::Ice::Object _Base;
01555         return dynamic_cast<InferotemporalCortex*>(_Base::ice_locatorCacheTimeout(__timeout).get());
01556     #else
01557         return dynamic_cast<InferotemporalCortex*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
01558     #endif
01559     }
01560 
01561     ::IceInternal::ProxyHandle<InferotemporalCortex> ice_connectionCached(bool __cached) const
01562     {
01563     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01564         typedef ::IceProxy::Ice::Object _Base;
01565         return dynamic_cast<InferotemporalCortex*>(_Base::ice_connectionCached(__cached).get());
01566     #else
01567         return dynamic_cast<InferotemporalCortex*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
01568     #endif
01569     }
01570 
01571     ::IceInternal::ProxyHandle<InferotemporalCortex> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
01572     {
01573     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01574         typedef ::IceProxy::Ice::Object _Base;
01575         return dynamic_cast<InferotemporalCortex*>(_Base::ice_endpointSelection(__est).get());
01576     #else
01577         return dynamic_cast<InferotemporalCortex*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
01578     #endif
01579     }
01580 
01581     ::IceInternal::ProxyHandle<InferotemporalCortex> ice_secure(bool __secure) const
01582     {
01583     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01584         typedef ::IceProxy::Ice::Object _Base;
01585         return dynamic_cast<InferotemporalCortex*>(_Base::ice_secure(__secure).get());
01586     #else
01587         return dynamic_cast<InferotemporalCortex*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
01588     #endif
01589     }
01590 
01591     ::IceInternal::ProxyHandle<InferotemporalCortex> ice_preferSecure(bool __preferSecure) const
01592     {
01593     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01594         typedef ::IceProxy::Ice::Object _Base;
01595         return dynamic_cast<InferotemporalCortex*>(_Base::ice_preferSecure(__preferSecure).get());
01596     #else
01597         return dynamic_cast<InferotemporalCortex*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
01598     #endif
01599     }
01600 
01601     ::IceInternal::ProxyHandle<InferotemporalCortex> ice_router(const ::Ice::RouterPrx& __router) const
01602     {
01603     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01604         typedef ::IceProxy::Ice::Object _Base;
01605         return dynamic_cast<InferotemporalCortex*>(_Base::ice_router(__router).get());
01606     #else
01607         return dynamic_cast<InferotemporalCortex*>(::IceProxy::Ice::Object::ice_router(__router).get());
01608     #endif
01609     }
01610 
01611     ::IceInternal::ProxyHandle<InferotemporalCortex> ice_locator(const ::Ice::LocatorPrx& __locator) const
01612     {
01613     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01614         typedef ::IceProxy::Ice::Object _Base;
01615         return dynamic_cast<InferotemporalCortex*>(_Base::ice_locator(__locator).get());
01616     #else
01617         return dynamic_cast<InferotemporalCortex*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
01618     #endif
01619     }
01620 
01621     ::IceInternal::ProxyHandle<InferotemporalCortex> ice_collocationOptimized(bool __co) const
01622     {
01623     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01624         typedef ::IceProxy::Ice::Object _Base;
01625         return dynamic_cast<InferotemporalCortex*>(_Base::ice_collocationOptimized(__co).get());
01626     #else
01627         return dynamic_cast<InferotemporalCortex*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
01628     #endif
01629     }
01630 
01631     ::IceInternal::ProxyHandle<InferotemporalCortex> ice_twoway() const
01632     {
01633     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01634         typedef ::IceProxy::Ice::Object _Base;
01635         return dynamic_cast<InferotemporalCortex*>(_Base::ice_twoway().get());
01636     #else
01637         return dynamic_cast<InferotemporalCortex*>(::IceProxy::Ice::Object::ice_twoway().get());
01638     #endif
01639     }
01640 
01641     ::IceInternal::ProxyHandle<InferotemporalCortex> ice_oneway() const
01642     {
01643     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01644         typedef ::IceProxy::Ice::Object _Base;
01645         return dynamic_cast<InferotemporalCortex*>(_Base::ice_oneway().get());
01646     #else
01647         return dynamic_cast<InferotemporalCortex*>(::IceProxy::Ice::Object::ice_oneway().get());
01648     #endif
01649     }
01650 
01651     ::IceInternal::ProxyHandle<InferotemporalCortex> ice_batchOneway() const
01652     {
01653     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01654         typedef ::IceProxy::Ice::Object _Base;
01655         return dynamic_cast<InferotemporalCortex*>(_Base::ice_batchOneway().get());
01656     #else
01657         return dynamic_cast<InferotemporalCortex*>(::IceProxy::Ice::Object::ice_batchOneway().get());
01658     #endif
01659     }
01660 
01661     ::IceInternal::ProxyHandle<InferotemporalCortex> ice_datagram() const
01662     {
01663     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01664         typedef ::IceProxy::Ice::Object _Base;
01665         return dynamic_cast<InferotemporalCortex*>(_Base::ice_datagram().get());
01666     #else
01667         return dynamic_cast<InferotemporalCortex*>(::IceProxy::Ice::Object::ice_datagram().get());
01668     #endif
01669     }
01670 
01671     ::IceInternal::ProxyHandle<InferotemporalCortex> ice_batchDatagram() const
01672     {
01673     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01674         typedef ::IceProxy::Ice::Object _Base;
01675         return dynamic_cast<InferotemporalCortex*>(_Base::ice_batchDatagram().get());
01676     #else
01677         return dynamic_cast<InferotemporalCortex*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
01678     #endif
01679     }
01680 
01681     ::IceInternal::ProxyHandle<InferotemporalCortex> ice_compress(bool __compress) const
01682     {
01683     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01684         typedef ::IceProxy::Ice::Object _Base;
01685         return dynamic_cast<InferotemporalCortex*>(_Base::ice_compress(__compress).get());
01686     #else
01687         return dynamic_cast<InferotemporalCortex*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
01688     #endif
01689     }
01690 
01691     ::IceInternal::ProxyHandle<InferotemporalCortex> ice_timeout(int __timeout) const
01692     {
01693     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01694         typedef ::IceProxy::Ice::Object _Base;
01695         return dynamic_cast<InferotemporalCortex*>(_Base::ice_timeout(__timeout).get());
01696     #else
01697         return dynamic_cast<InferotemporalCortex*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
01698     #endif
01699     }
01700 
01701     ::IceInternal::ProxyHandle<InferotemporalCortex> ice_connectionId(const std::string& __id) const
01702     {
01703     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01704         typedef ::IceProxy::Ice::Object _Base;
01705         return dynamic_cast<InferotemporalCortex*>(_Base::ice_connectionId(__id).get());
01706     #else
01707         return dynamic_cast<InferotemporalCortex*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
01708     #endif
01709     }
01710 
01711     static const ::std::string& ice_staticId();
01712 
01713 private:
01714 
01715     virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
01716     virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
01717     virtual ::IceProxy::Ice::Object* __newInstance() const;
01718 };
01719 
01720 class Hippocampus : virtual public ::IceProxy::SimEvents::Events
01721 {
01722 public:
01723 
01724     ::IceInternal::ProxyHandle<Hippocampus> ice_context(const ::Ice::Context& __context) const
01725     {
01726     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01727         typedef ::IceProxy::Ice::Object _Base;
01728         return dynamic_cast<Hippocampus*>(_Base::ice_context(__context).get());
01729     #else
01730         return dynamic_cast<Hippocampus*>(::IceProxy::Ice::Object::ice_context(__context).get());
01731     #endif
01732     }
01733 
01734     ::IceInternal::ProxyHandle<Hippocampus> ice_adapterId(const std::string& __id) const
01735     {
01736     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01737         typedef ::IceProxy::Ice::Object _Base;
01738         return dynamic_cast<Hippocampus*>(_Base::ice_adapterId(__id).get());
01739     #else
01740         return dynamic_cast<Hippocampus*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
01741     #endif
01742     }
01743 
01744     ::IceInternal::ProxyHandle<Hippocampus> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
01745     {
01746     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01747         typedef ::IceProxy::Ice::Object _Base;
01748         return dynamic_cast<Hippocampus*>(_Base::ice_endpoints(__endpoints).get());
01749     #else
01750         return dynamic_cast<Hippocampus*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
01751     #endif
01752     }
01753 
01754     ::IceInternal::ProxyHandle<Hippocampus> ice_locatorCacheTimeout(int __timeout) const
01755     {
01756     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01757         typedef ::IceProxy::Ice::Object _Base;
01758         return dynamic_cast<Hippocampus*>(_Base::ice_locatorCacheTimeout(__timeout).get());
01759     #else
01760         return dynamic_cast<Hippocampus*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
01761     #endif
01762     }
01763 
01764     ::IceInternal::ProxyHandle<Hippocampus> ice_connectionCached(bool __cached) const
01765     {
01766     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01767         typedef ::IceProxy::Ice::Object _Base;
01768         return dynamic_cast<Hippocampus*>(_Base::ice_connectionCached(__cached).get());
01769     #else
01770         return dynamic_cast<Hippocampus*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
01771     #endif
01772     }
01773 
01774     ::IceInternal::ProxyHandle<Hippocampus> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
01775     {
01776     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01777         typedef ::IceProxy::Ice::Object _Base;
01778         return dynamic_cast<Hippocampus*>(_Base::ice_endpointSelection(__est).get());
01779     #else
01780         return dynamic_cast<Hippocampus*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
01781     #endif
01782     }
01783 
01784     ::IceInternal::ProxyHandle<Hippocampus> ice_secure(bool __secure) const
01785     {
01786     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01787         typedef ::IceProxy::Ice::Object _Base;
01788         return dynamic_cast<Hippocampus*>(_Base::ice_secure(__secure).get());
01789     #else
01790         return dynamic_cast<Hippocampus*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
01791     #endif
01792     }
01793 
01794     ::IceInternal::ProxyHandle<Hippocampus> ice_preferSecure(bool __preferSecure) const
01795     {
01796     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01797         typedef ::IceProxy::Ice::Object _Base;
01798         return dynamic_cast<Hippocampus*>(_Base::ice_preferSecure(__preferSecure).get());
01799     #else
01800         return dynamic_cast<Hippocampus*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
01801     #endif
01802     }
01803 
01804     ::IceInternal::ProxyHandle<Hippocampus> ice_router(const ::Ice::RouterPrx& __router) const
01805     {
01806     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01807         typedef ::IceProxy::Ice::Object _Base;
01808         return dynamic_cast<Hippocampus*>(_Base::ice_router(__router).get());
01809     #else
01810         return dynamic_cast<Hippocampus*>(::IceProxy::Ice::Object::ice_router(__router).get());
01811     #endif
01812     }
01813 
01814     ::IceInternal::ProxyHandle<Hippocampus> ice_locator(const ::Ice::LocatorPrx& __locator) const
01815     {
01816     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01817         typedef ::IceProxy::Ice::Object _Base;
01818         return dynamic_cast<Hippocampus*>(_Base::ice_locator(__locator).get());
01819     #else
01820         return dynamic_cast<Hippocampus*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
01821     #endif
01822     }
01823 
01824     ::IceInternal::ProxyHandle<Hippocampus> ice_collocationOptimized(bool __co) const
01825     {
01826     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01827         typedef ::IceProxy::Ice::Object _Base;
01828         return dynamic_cast<Hippocampus*>(_Base::ice_collocationOptimized(__co).get());
01829     #else
01830         return dynamic_cast<Hippocampus*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
01831     #endif
01832     }
01833 
01834     ::IceInternal::ProxyHandle<Hippocampus> ice_twoway() const
01835     {
01836     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01837         typedef ::IceProxy::Ice::Object _Base;
01838         return dynamic_cast<Hippocampus*>(_Base::ice_twoway().get());
01839     #else
01840         return dynamic_cast<Hippocampus*>(::IceProxy::Ice::Object::ice_twoway().get());
01841     #endif
01842     }
01843 
01844     ::IceInternal::ProxyHandle<Hippocampus> ice_oneway() const
01845     {
01846     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01847         typedef ::IceProxy::Ice::Object _Base;
01848         return dynamic_cast<Hippocampus*>(_Base::ice_oneway().get());
01849     #else
01850         return dynamic_cast<Hippocampus*>(::IceProxy::Ice::Object::ice_oneway().get());
01851     #endif
01852     }
01853 
01854     ::IceInternal::ProxyHandle<Hippocampus> ice_batchOneway() const
01855     {
01856     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01857         typedef ::IceProxy::Ice::Object _Base;
01858         return dynamic_cast<Hippocampus*>(_Base::ice_batchOneway().get());
01859     #else
01860         return dynamic_cast<Hippocampus*>(::IceProxy::Ice::Object::ice_batchOneway().get());
01861     #endif
01862     }
01863 
01864     ::IceInternal::ProxyHandle<Hippocampus> ice_datagram() const
01865     {
01866     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01867         typedef ::IceProxy::Ice::Object _Base;
01868         return dynamic_cast<Hippocampus*>(_Base::ice_datagram().get());
01869     #else
01870         return dynamic_cast<Hippocampus*>(::IceProxy::Ice::Object::ice_datagram().get());
01871     #endif
01872     }
01873 
01874     ::IceInternal::ProxyHandle<Hippocampus> ice_batchDatagram() const
01875     {
01876     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01877         typedef ::IceProxy::Ice::Object _Base;
01878         return dynamic_cast<Hippocampus*>(_Base::ice_batchDatagram().get());
01879     #else
01880         return dynamic_cast<Hippocampus*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
01881     #endif
01882     }
01883 
01884     ::IceInternal::ProxyHandle<Hippocampus> ice_compress(bool __compress) const
01885     {
01886     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01887         typedef ::IceProxy::Ice::Object _Base;
01888         return dynamic_cast<Hippocampus*>(_Base::ice_compress(__compress).get());
01889     #else
01890         return dynamic_cast<Hippocampus*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
01891     #endif
01892     }
01893 
01894     ::IceInternal::ProxyHandle<Hippocampus> ice_timeout(int __timeout) const
01895     {
01896     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01897         typedef ::IceProxy::Ice::Object _Base;
01898         return dynamic_cast<Hippocampus*>(_Base::ice_timeout(__timeout).get());
01899     #else
01900         return dynamic_cast<Hippocampus*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
01901     #endif
01902     }
01903 
01904     ::IceInternal::ProxyHandle<Hippocampus> ice_connectionId(const std::string& __id) const
01905     {
01906     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01907         typedef ::IceProxy::Ice::Object _Base;
01908         return dynamic_cast<Hippocampus*>(_Base::ice_connectionId(__id).get());
01909     #else
01910         return dynamic_cast<Hippocampus*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
01911     #endif
01912     }
01913 
01914     static const ::std::string& ice_staticId();
01915 
01916 private:
01917 
01918     virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
01919     virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
01920     virtual ::IceProxy::Ice::Object* __newInstance() const;
01921 };
01922 
01923 class PrimaryMotorCortex : virtual public ::IceProxy::SimEvents::Events
01924 {
01925 public:
01926 
01927     ::IceInternal::ProxyHandle<PrimaryMotorCortex> ice_context(const ::Ice::Context& __context) const
01928     {
01929     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01930         typedef ::IceProxy::Ice::Object _Base;
01931         return dynamic_cast<PrimaryMotorCortex*>(_Base::ice_context(__context).get());
01932     #else
01933         return dynamic_cast<PrimaryMotorCortex*>(::IceProxy::Ice::Object::ice_context(__context).get());
01934     #endif
01935     }
01936 
01937     ::IceInternal::ProxyHandle<PrimaryMotorCortex> ice_adapterId(const std::string& __id) const
01938     {
01939     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01940         typedef ::IceProxy::Ice::Object _Base;
01941         return dynamic_cast<PrimaryMotorCortex*>(_Base::ice_adapterId(__id).get());
01942     #else
01943         return dynamic_cast<PrimaryMotorCortex*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
01944     #endif
01945     }
01946 
01947     ::IceInternal::ProxyHandle<PrimaryMotorCortex> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
01948     {
01949     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01950         typedef ::IceProxy::Ice::Object _Base;
01951         return dynamic_cast<PrimaryMotorCortex*>(_Base::ice_endpoints(__endpoints).get());
01952     #else
01953         return dynamic_cast<PrimaryMotorCortex*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
01954     #endif
01955     }
01956 
01957     ::IceInternal::ProxyHandle<PrimaryMotorCortex> ice_locatorCacheTimeout(int __timeout) const
01958     {
01959     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01960         typedef ::IceProxy::Ice::Object _Base;
01961         return dynamic_cast<PrimaryMotorCortex*>(_Base::ice_locatorCacheTimeout(__timeout).get());
01962     #else
01963         return dynamic_cast<PrimaryMotorCortex*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
01964     #endif
01965     }
01966 
01967     ::IceInternal::ProxyHandle<PrimaryMotorCortex> ice_connectionCached(bool __cached) const
01968     {
01969     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01970         typedef ::IceProxy::Ice::Object _Base;
01971         return dynamic_cast<PrimaryMotorCortex*>(_Base::ice_connectionCached(__cached).get());
01972     #else
01973         return dynamic_cast<PrimaryMotorCortex*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
01974     #endif
01975     }
01976 
01977     ::IceInternal::ProxyHandle<PrimaryMotorCortex> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
01978     {
01979     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01980         typedef ::IceProxy::Ice::Object _Base;
01981         return dynamic_cast<PrimaryMotorCortex*>(_Base::ice_endpointSelection(__est).get());
01982     #else
01983         return dynamic_cast<PrimaryMotorCortex*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
01984     #endif
01985     }
01986 
01987     ::IceInternal::ProxyHandle<PrimaryMotorCortex> ice_secure(bool __secure) const
01988     {
01989     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01990         typedef ::IceProxy::Ice::Object _Base;
01991         return dynamic_cast<PrimaryMotorCortex*>(_Base::ice_secure(__secure).get());
01992     #else
01993         return dynamic_cast<PrimaryMotorCortex*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
01994     #endif
01995     }
01996 
01997     ::IceInternal::ProxyHandle<PrimaryMotorCortex> ice_preferSecure(bool __preferSecure) const
01998     {
01999     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02000         typedef ::IceProxy::Ice::Object _Base;
02001         return dynamic_cast<PrimaryMotorCortex*>(_Base::ice_preferSecure(__preferSecure).get());
02002     #else
02003         return dynamic_cast<PrimaryMotorCortex*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
02004     #endif
02005     }
02006 
02007     ::IceInternal::ProxyHandle<PrimaryMotorCortex> ice_router(const ::Ice::RouterPrx& __router) const
02008     {
02009     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02010         typedef ::IceProxy::Ice::Object _Base;
02011         return dynamic_cast<PrimaryMotorCortex*>(_Base::ice_router(__router).get());
02012     #else
02013         return dynamic_cast<PrimaryMotorCortex*>(::IceProxy::Ice::Object::ice_router(__router).get());
02014     #endif
02015     }
02016 
02017     ::IceInternal::ProxyHandle<PrimaryMotorCortex> ice_locator(const ::Ice::LocatorPrx& __locator) const
02018     {
02019     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02020         typedef ::IceProxy::Ice::Object _Base;
02021         return dynamic_cast<PrimaryMotorCortex*>(_Base::ice_locator(__locator).get());
02022     #else
02023         return dynamic_cast<PrimaryMotorCortex*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
02024     #endif
02025     }
02026 
02027     ::IceInternal::ProxyHandle<PrimaryMotorCortex> ice_collocationOptimized(bool __co) const
02028     {
02029     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02030         typedef ::IceProxy::Ice::Object _Base;
02031         return dynamic_cast<PrimaryMotorCortex*>(_Base::ice_collocationOptimized(__co).get());
02032     #else
02033         return dynamic_cast<PrimaryMotorCortex*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
02034     #endif
02035     }
02036 
02037     ::IceInternal::ProxyHandle<PrimaryMotorCortex> ice_twoway() const
02038     {
02039     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02040         typedef ::IceProxy::Ice::Object _Base;
02041         return dynamic_cast<PrimaryMotorCortex*>(_Base::ice_twoway().get());
02042     #else
02043         return dynamic_cast<PrimaryMotorCortex*>(::IceProxy::Ice::Object::ice_twoway().get());
02044     #endif
02045     }
02046 
02047     ::IceInternal::ProxyHandle<PrimaryMotorCortex> ice_oneway() const
02048     {
02049     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02050         typedef ::IceProxy::Ice::Object _Base;
02051         return dynamic_cast<PrimaryMotorCortex*>(_Base::ice_oneway().get());
02052     #else
02053         return dynamic_cast<PrimaryMotorCortex*>(::IceProxy::Ice::Object::ice_oneway().get());
02054     #endif
02055     }
02056 
02057     ::IceInternal::ProxyHandle<PrimaryMotorCortex> ice_batchOneway() const
02058     {
02059     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02060         typedef ::IceProxy::Ice::Object _Base;
02061         return dynamic_cast<PrimaryMotorCortex*>(_Base::ice_batchOneway().get());
02062     #else
02063         return dynamic_cast<PrimaryMotorCortex*>(::IceProxy::Ice::Object::ice_batchOneway().get());
02064     #endif
02065     }
02066 
02067     ::IceInternal::ProxyHandle<PrimaryMotorCortex> ice_datagram() const
02068     {
02069     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02070         typedef ::IceProxy::Ice::Object _Base;
02071         return dynamic_cast<PrimaryMotorCortex*>(_Base::ice_datagram().get());
02072     #else
02073         return dynamic_cast<PrimaryMotorCortex*>(::IceProxy::Ice::Object::ice_datagram().get());
02074     #endif
02075     }
02076 
02077     ::IceInternal::ProxyHandle<PrimaryMotorCortex> ice_batchDatagram() const
02078     {
02079     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02080         typedef ::IceProxy::Ice::Object _Base;
02081         return dynamic_cast<PrimaryMotorCortex*>(_Base::ice_batchDatagram().get());
02082     #else
02083         return dynamic_cast<PrimaryMotorCortex*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
02084     #endif
02085     }
02086 
02087     ::IceInternal::ProxyHandle<PrimaryMotorCortex> ice_compress(bool __compress) const
02088     {
02089     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02090         typedef ::IceProxy::Ice::Object _Base;
02091         return dynamic_cast<PrimaryMotorCortex*>(_Base::ice_compress(__compress).get());
02092     #else
02093         return dynamic_cast<PrimaryMotorCortex*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
02094     #endif
02095     }
02096 
02097     ::IceInternal::ProxyHandle<PrimaryMotorCortex> ice_timeout(int __timeout) const
02098     {
02099     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02100         typedef ::IceProxy::Ice::Object _Base;
02101         return dynamic_cast<PrimaryMotorCortex*>(_Base::ice_timeout(__timeout).get());
02102     #else
02103         return dynamic_cast<PrimaryMotorCortex*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
02104     #endif
02105     }
02106 
02107     ::IceInternal::ProxyHandle<PrimaryMotorCortex> ice_connectionId(const std::string& __id) const
02108     {
02109     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02110         typedef ::IceProxy::Ice::Object _Base;
02111         return dynamic_cast<PrimaryMotorCortex*>(_Base::ice_connectionId(__id).get());
02112     #else
02113         return dynamic_cast<PrimaryMotorCortex*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
02114     #endif
02115     }
02116 
02117     static const ::std::string& ice_staticId();
02118 
02119 private:
02120 
02121     virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
02122     virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
02123     virtual ::IceProxy::Ice::Object* __newInstance() const;
02124 };
02125 
02126 class PrefrontalCortex : virtual public ::IceProxy::SimEvents::Events
02127 {
02128 public:
02129 
02130     ::IceInternal::ProxyHandle<PrefrontalCortex> ice_context(const ::Ice::Context& __context) const
02131     {
02132     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02133         typedef ::IceProxy::Ice::Object _Base;
02134         return dynamic_cast<PrefrontalCortex*>(_Base::ice_context(__context).get());
02135     #else
02136         return dynamic_cast<PrefrontalCortex*>(::IceProxy::Ice::Object::ice_context(__context).get());
02137     #endif
02138     }
02139 
02140     ::IceInternal::ProxyHandle<PrefrontalCortex> ice_adapterId(const std::string& __id) const
02141     {
02142     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02143         typedef ::IceProxy::Ice::Object _Base;
02144         return dynamic_cast<PrefrontalCortex*>(_Base::ice_adapterId(__id).get());
02145     #else
02146         return dynamic_cast<PrefrontalCortex*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
02147     #endif
02148     }
02149 
02150     ::IceInternal::ProxyHandle<PrefrontalCortex> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
02151     {
02152     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02153         typedef ::IceProxy::Ice::Object _Base;
02154         return dynamic_cast<PrefrontalCortex*>(_Base::ice_endpoints(__endpoints).get());
02155     #else
02156         return dynamic_cast<PrefrontalCortex*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
02157     #endif
02158     }
02159 
02160     ::IceInternal::ProxyHandle<PrefrontalCortex> ice_locatorCacheTimeout(int __timeout) const
02161     {
02162     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02163         typedef ::IceProxy::Ice::Object _Base;
02164         return dynamic_cast<PrefrontalCortex*>(_Base::ice_locatorCacheTimeout(__timeout).get());
02165     #else
02166         return dynamic_cast<PrefrontalCortex*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
02167     #endif
02168     }
02169 
02170     ::IceInternal::ProxyHandle<PrefrontalCortex> ice_connectionCached(bool __cached) const
02171     {
02172     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02173         typedef ::IceProxy::Ice::Object _Base;
02174         return dynamic_cast<PrefrontalCortex*>(_Base::ice_connectionCached(__cached).get());
02175     #else
02176         return dynamic_cast<PrefrontalCortex*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
02177     #endif
02178     }
02179 
02180     ::IceInternal::ProxyHandle<PrefrontalCortex> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
02181     {
02182     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02183         typedef ::IceProxy::Ice::Object _Base;
02184         return dynamic_cast<PrefrontalCortex*>(_Base::ice_endpointSelection(__est).get());
02185     #else
02186         return dynamic_cast<PrefrontalCortex*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
02187     #endif
02188     }
02189 
02190     ::IceInternal::ProxyHandle<PrefrontalCortex> ice_secure(bool __secure) const
02191     {
02192     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02193         typedef ::IceProxy::Ice::Object _Base;
02194         return dynamic_cast<PrefrontalCortex*>(_Base::ice_secure(__secure).get());
02195     #else
02196         return dynamic_cast<PrefrontalCortex*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
02197     #endif
02198     }
02199 
02200     ::IceInternal::ProxyHandle<PrefrontalCortex> ice_preferSecure(bool __preferSecure) const
02201     {
02202     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02203         typedef ::IceProxy::Ice::Object _Base;
02204         return dynamic_cast<PrefrontalCortex*>(_Base::ice_preferSecure(__preferSecure).get());
02205     #else
02206         return dynamic_cast<PrefrontalCortex*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
02207     #endif
02208     }
02209 
02210     ::IceInternal::ProxyHandle<PrefrontalCortex> ice_router(const ::Ice::RouterPrx& __router) const
02211     {
02212     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02213         typedef ::IceProxy::Ice::Object _Base;
02214         return dynamic_cast<PrefrontalCortex*>(_Base::ice_router(__router).get());
02215     #else
02216         return dynamic_cast<PrefrontalCortex*>(::IceProxy::Ice::Object::ice_router(__router).get());
02217     #endif
02218     }
02219 
02220     ::IceInternal::ProxyHandle<PrefrontalCortex> ice_locator(const ::Ice::LocatorPrx& __locator) const
02221     {
02222     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02223         typedef ::IceProxy::Ice::Object _Base;
02224         return dynamic_cast<PrefrontalCortex*>(_Base::ice_locator(__locator).get());
02225     #else
02226         return dynamic_cast<PrefrontalCortex*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
02227     #endif
02228     }
02229 
02230     ::IceInternal::ProxyHandle<PrefrontalCortex> ice_collocationOptimized(bool __co) const
02231     {
02232     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02233         typedef ::IceProxy::Ice::Object _Base;
02234         return dynamic_cast<PrefrontalCortex*>(_Base::ice_collocationOptimized(__co).get());
02235     #else
02236         return dynamic_cast<PrefrontalCortex*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
02237     #endif
02238     }
02239 
02240     ::IceInternal::ProxyHandle<PrefrontalCortex> ice_twoway() const
02241     {
02242     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02243         typedef ::IceProxy::Ice::Object _Base;
02244         return dynamic_cast<PrefrontalCortex*>(_Base::ice_twoway().get());
02245     #else
02246         return dynamic_cast<PrefrontalCortex*>(::IceProxy::Ice::Object::ice_twoway().get());
02247     #endif
02248     }
02249 
02250     ::IceInternal::ProxyHandle<PrefrontalCortex> ice_oneway() const
02251     {
02252     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02253         typedef ::IceProxy::Ice::Object _Base;
02254         return dynamic_cast<PrefrontalCortex*>(_Base::ice_oneway().get());
02255     #else
02256         return dynamic_cast<PrefrontalCortex*>(::IceProxy::Ice::Object::ice_oneway().get());
02257     #endif
02258     }
02259 
02260     ::IceInternal::ProxyHandle<PrefrontalCortex> ice_batchOneway() const
02261     {
02262     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02263         typedef ::IceProxy::Ice::Object _Base;
02264         return dynamic_cast<PrefrontalCortex*>(_Base::ice_batchOneway().get());
02265     #else
02266         return dynamic_cast<PrefrontalCortex*>(::IceProxy::Ice::Object::ice_batchOneway().get());
02267     #endif
02268     }
02269 
02270     ::IceInternal::ProxyHandle<PrefrontalCortex> ice_datagram() const
02271     {
02272     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02273         typedef ::IceProxy::Ice::Object _Base;
02274         return dynamic_cast<PrefrontalCortex*>(_Base::ice_datagram().get());
02275     #else
02276         return dynamic_cast<PrefrontalCortex*>(::IceProxy::Ice::Object::ice_datagram().get());
02277     #endif
02278     }
02279 
02280     ::IceInternal::ProxyHandle<PrefrontalCortex> ice_batchDatagram() const
02281     {
02282     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02283         typedef ::IceProxy::Ice::Object _Base;
02284         return dynamic_cast<PrefrontalCortex*>(_Base::ice_batchDatagram().get());
02285     #else
02286         return dynamic_cast<PrefrontalCortex*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
02287     #endif
02288     }
02289 
02290     ::IceInternal::ProxyHandle<PrefrontalCortex> ice_compress(bool __compress) const
02291     {
02292     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02293         typedef ::IceProxy::Ice::Object _Base;
02294         return dynamic_cast<PrefrontalCortex*>(_Base::ice_compress(__compress).get());
02295     #else
02296         return dynamic_cast<PrefrontalCortex*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
02297     #endif
02298     }
02299 
02300     ::IceInternal::ProxyHandle<PrefrontalCortex> ice_timeout(int __timeout) const
02301     {
02302     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02303         typedef ::IceProxy::Ice::Object _Base;
02304         return dynamic_cast<PrefrontalCortex*>(_Base::ice_timeout(__timeout).get());
02305     #else
02306         return dynamic_cast<PrefrontalCortex*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
02307     #endif
02308     }
02309 
02310     ::IceInternal::ProxyHandle<PrefrontalCortex> ice_connectionId(const std::string& __id) const
02311     {
02312     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02313         typedef ::IceProxy::Ice::Object _Base;
02314         return dynamic_cast<PrefrontalCortex*>(_Base::ice_connectionId(__id).get());
02315     #else
02316         return dynamic_cast<PrefrontalCortex*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
02317     #endif
02318     }
02319 
02320     static const ::std::string& ice_staticId();
02321 
02322 private:
02323 
02324     virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
02325     virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
02326     virtual ::IceProxy::Ice::Object* __newInstance() const;
02327 };
02328 
02329 class SimulationViewer : virtual public ::IceProxy::SimEvents::Events
02330 {
02331 public:
02332 
02333     ::IceInternal::ProxyHandle<SimulationViewer> ice_context(const ::Ice::Context& __context) const
02334     {
02335     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02336         typedef ::IceProxy::Ice::Object _Base;
02337         return dynamic_cast<SimulationViewer*>(_Base::ice_context(__context).get());
02338     #else
02339         return dynamic_cast<SimulationViewer*>(::IceProxy::Ice::Object::ice_context(__context).get());
02340     #endif
02341     }
02342 
02343     ::IceInternal::ProxyHandle<SimulationViewer> ice_adapterId(const std::string& __id) const
02344     {
02345     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02346         typedef ::IceProxy::Ice::Object _Base;
02347         return dynamic_cast<SimulationViewer*>(_Base::ice_adapterId(__id).get());
02348     #else
02349         return dynamic_cast<SimulationViewer*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
02350     #endif
02351     }
02352 
02353     ::IceInternal::ProxyHandle<SimulationViewer> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
02354     {
02355     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02356         typedef ::IceProxy::Ice::Object _Base;
02357         return dynamic_cast<SimulationViewer*>(_Base::ice_endpoints(__endpoints).get());
02358     #else
02359         return dynamic_cast<SimulationViewer*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
02360     #endif
02361     }
02362 
02363     ::IceInternal::ProxyHandle<SimulationViewer> ice_locatorCacheTimeout(int __timeout) const
02364     {
02365     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02366         typedef ::IceProxy::Ice::Object _Base;
02367         return dynamic_cast<SimulationViewer*>(_Base::ice_locatorCacheTimeout(__timeout).get());
02368     #else
02369         return dynamic_cast<SimulationViewer*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
02370     #endif
02371     }
02372 
02373     ::IceInternal::ProxyHandle<SimulationViewer> ice_connectionCached(bool __cached) const
02374     {
02375     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02376         typedef ::IceProxy::Ice::Object _Base;
02377         return dynamic_cast<SimulationViewer*>(_Base::ice_connectionCached(__cached).get());
02378     #else
02379         return dynamic_cast<SimulationViewer*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
02380     #endif
02381     }
02382 
02383     ::IceInternal::ProxyHandle<SimulationViewer> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
02384     {
02385     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02386         typedef ::IceProxy::Ice::Object _Base;
02387         return dynamic_cast<SimulationViewer*>(_Base::ice_endpointSelection(__est).get());
02388     #else
02389         return dynamic_cast<SimulationViewer*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
02390     #endif
02391     }
02392 
02393     ::IceInternal::ProxyHandle<SimulationViewer> ice_secure(bool __secure) const
02394     {
02395     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02396         typedef ::IceProxy::Ice::Object _Base;
02397         return dynamic_cast<SimulationViewer*>(_Base::ice_secure(__secure).get());
02398     #else
02399         return dynamic_cast<SimulationViewer*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
02400     #endif
02401     }
02402 
02403     ::IceInternal::ProxyHandle<SimulationViewer> ice_preferSecure(bool __preferSecure) const
02404     {
02405     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02406         typedef ::IceProxy::Ice::Object _Base;
02407         return dynamic_cast<SimulationViewer*>(_Base::ice_preferSecure(__preferSecure).get());
02408     #else
02409         return dynamic_cast<SimulationViewer*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
02410     #endif
02411     }
02412 
02413     ::IceInternal::ProxyHandle<SimulationViewer> ice_router(const ::Ice::RouterPrx& __router) const
02414     {
02415     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02416         typedef ::IceProxy::Ice::Object _Base;
02417         return dynamic_cast<SimulationViewer*>(_Base::ice_router(__router).get());
02418     #else
02419         return dynamic_cast<SimulationViewer*>(::IceProxy::Ice::Object::ice_router(__router).get());
02420     #endif
02421     }
02422 
02423     ::IceInternal::ProxyHandle<SimulationViewer> ice_locator(const ::Ice::LocatorPrx& __locator) const
02424     {
02425     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02426         typedef ::IceProxy::Ice::Object _Base;
02427         return dynamic_cast<SimulationViewer*>(_Base::ice_locator(__locator).get());
02428     #else
02429         return dynamic_cast<SimulationViewer*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
02430     #endif
02431     }
02432 
02433     ::IceInternal::ProxyHandle<SimulationViewer> ice_collocationOptimized(bool __co) const
02434     {
02435     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02436         typedef ::IceProxy::Ice::Object _Base;
02437         return dynamic_cast<SimulationViewer*>(_Base::ice_collocationOptimized(__co).get());
02438     #else
02439         return dynamic_cast<SimulationViewer*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
02440     #endif
02441     }
02442 
02443     ::IceInternal::ProxyHandle<SimulationViewer> ice_twoway() const
02444     {
02445     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02446         typedef ::IceProxy::Ice::Object _Base;
02447         return dynamic_cast<SimulationViewer*>(_Base::ice_twoway().get());
02448     #else
02449         return dynamic_cast<SimulationViewer*>(::IceProxy::Ice::Object::ice_twoway().get());
02450     #endif
02451     }
02452 
02453     ::IceInternal::ProxyHandle<SimulationViewer> ice_oneway() const
02454     {
02455     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02456         typedef ::IceProxy::Ice::Object _Base;
02457         return dynamic_cast<SimulationViewer*>(_Base::ice_oneway().get());
02458     #else
02459         return dynamic_cast<SimulationViewer*>(::IceProxy::Ice::Object::ice_oneway().get());
02460     #endif
02461     }
02462 
02463     ::IceInternal::ProxyHandle<SimulationViewer> ice_batchOneway() const
02464     {
02465     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02466         typedef ::IceProxy::Ice::Object _Base;
02467         return dynamic_cast<SimulationViewer*>(_Base::ice_batchOneway().get());
02468     #else
02469         return dynamic_cast<SimulationViewer*>(::IceProxy::Ice::Object::ice_batchOneway().get());
02470     #endif
02471     }
02472 
02473     ::IceInternal::ProxyHandle<SimulationViewer> ice_datagram() const
02474     {
02475     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02476         typedef ::IceProxy::Ice::Object _Base;
02477         return dynamic_cast<SimulationViewer*>(_Base::ice_datagram().get());
02478     #else
02479         return dynamic_cast<SimulationViewer*>(::IceProxy::Ice::Object::ice_datagram().get());
02480     #endif
02481     }
02482 
02483     ::IceInternal::ProxyHandle<SimulationViewer> ice_batchDatagram() const
02484     {
02485     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02486         typedef ::IceProxy::Ice::Object _Base;
02487         return dynamic_cast<SimulationViewer*>(_Base::ice_batchDatagram().get());
02488     #else
02489         return dynamic_cast<SimulationViewer*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
02490     #endif
02491     }
02492 
02493     ::IceInternal::ProxyHandle<SimulationViewer> ice_compress(bool __compress) const
02494     {
02495     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02496         typedef ::IceProxy::Ice::Object _Base;
02497         return dynamic_cast<SimulationViewer*>(_Base::ice_compress(__compress).get());
02498     #else
02499         return dynamic_cast<SimulationViewer*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
02500     #endif
02501     }
02502 
02503     ::IceInternal::ProxyHandle<SimulationViewer> ice_timeout(int __timeout) const
02504     {
02505     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02506         typedef ::IceProxy::Ice::Object _Base;
02507         return dynamic_cast<SimulationViewer*>(_Base::ice_timeout(__timeout).get());
02508     #else
02509         return dynamic_cast<SimulationViewer*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
02510     #endif
02511     }
02512 
02513     ::IceInternal::ProxyHandle<SimulationViewer> ice_connectionId(const std::string& __id) const
02514     {
02515     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02516         typedef ::IceProxy::Ice::Object _Base;
02517         return dynamic_cast<SimulationViewer*>(_Base::ice_connectionId(__id).get());
02518     #else
02519         return dynamic_cast<SimulationViewer*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
02520     #endif
02521     }
02522 
02523     static const ::std::string& ice_staticId();
02524 
02525 private:
02526 
02527     virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
02528     virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
02529     virtual ::IceProxy::Ice::Object* __newInstance() const;
02530 };
02531 
02532 class HomeInterface : virtual public ::IceProxy::SimEvents::Events
02533 {
02534 public:
02535 
02536     ::IceInternal::ProxyHandle<HomeInterface> ice_context(const ::Ice::Context& __context) const
02537     {
02538     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02539         typedef ::IceProxy::Ice::Object _Base;
02540         return dynamic_cast<HomeInterface*>(_Base::ice_context(__context).get());
02541     #else
02542         return dynamic_cast<HomeInterface*>(::IceProxy::Ice::Object::ice_context(__context).get());
02543     #endif
02544     }
02545 
02546     ::IceInternal::ProxyHandle<HomeInterface> ice_adapterId(const std::string& __id) const
02547     {
02548     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02549         typedef ::IceProxy::Ice::Object _Base;
02550         return dynamic_cast<HomeInterface*>(_Base::ice_adapterId(__id).get());
02551     #else
02552         return dynamic_cast<HomeInterface*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
02553     #endif
02554     }
02555 
02556     ::IceInternal::ProxyHandle<HomeInterface> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
02557     {
02558     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02559         typedef ::IceProxy::Ice::Object _Base;
02560         return dynamic_cast<HomeInterface*>(_Base::ice_endpoints(__endpoints).get());
02561     #else
02562         return dynamic_cast<HomeInterface*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
02563     #endif
02564     }
02565 
02566     ::IceInternal::ProxyHandle<HomeInterface> ice_locatorCacheTimeout(int __timeout) const
02567     {
02568     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02569         typedef ::IceProxy::Ice::Object _Base;
02570         return dynamic_cast<HomeInterface*>(_Base::ice_locatorCacheTimeout(__timeout).get());
02571     #else
02572         return dynamic_cast<HomeInterface*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
02573     #endif
02574     }
02575 
02576     ::IceInternal::ProxyHandle<HomeInterface> ice_connectionCached(bool __cached) const
02577     {
02578     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02579         typedef ::IceProxy::Ice::Object _Base;
02580         return dynamic_cast<HomeInterface*>(_Base::ice_connectionCached(__cached).get());
02581     #else
02582         return dynamic_cast<HomeInterface*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
02583     #endif
02584     }
02585 
02586     ::IceInternal::ProxyHandle<HomeInterface> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
02587     {
02588     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02589         typedef ::IceProxy::Ice::Object _Base;
02590         return dynamic_cast<HomeInterface*>(_Base::ice_endpointSelection(__est).get());
02591     #else
02592         return dynamic_cast<HomeInterface*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
02593     #endif
02594     }
02595 
02596     ::IceInternal::ProxyHandle<HomeInterface> ice_secure(bool __secure) const
02597     {
02598     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02599         typedef ::IceProxy::Ice::Object _Base;
02600         return dynamic_cast<HomeInterface*>(_Base::ice_secure(__secure).get());
02601     #else
02602         return dynamic_cast<HomeInterface*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
02603     #endif
02604     }
02605 
02606     ::IceInternal::ProxyHandle<HomeInterface> ice_preferSecure(bool __preferSecure) const
02607     {
02608     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02609         typedef ::IceProxy::Ice::Object _Base;
02610         return dynamic_cast<HomeInterface*>(_Base::ice_preferSecure(__preferSecure).get());
02611     #else
02612         return dynamic_cast<HomeInterface*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
02613     #endif
02614     }
02615 
02616     ::IceInternal::ProxyHandle<HomeInterface> ice_router(const ::Ice::RouterPrx& __router) const
02617     {
02618     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02619         typedef ::IceProxy::Ice::Object _Base;
02620         return dynamic_cast<HomeInterface*>(_Base::ice_router(__router).get());
02621     #else
02622         return dynamic_cast<HomeInterface*>(::IceProxy::Ice::Object::ice_router(__router).get());
02623     #endif
02624     }
02625 
02626     ::IceInternal::ProxyHandle<HomeInterface> ice_locator(const ::Ice::LocatorPrx& __locator) const
02627     {
02628     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02629         typedef ::IceProxy::Ice::Object _Base;
02630         return dynamic_cast<HomeInterface*>(_Base::ice_locator(__locator).get());
02631     #else
02632         return dynamic_cast<HomeInterface*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
02633     #endif
02634     }
02635 
02636     ::IceInternal::ProxyHandle<HomeInterface> ice_collocationOptimized(bool __co) const
02637     {
02638     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02639         typedef ::IceProxy::Ice::Object _Base;
02640         return dynamic_cast<HomeInterface*>(_Base::ice_collocationOptimized(__co).get());
02641     #else
02642         return dynamic_cast<HomeInterface*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
02643     #endif
02644     }
02645 
02646     ::IceInternal::ProxyHandle<HomeInterface> ice_twoway() const
02647     {
02648     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02649         typedef ::IceProxy::Ice::Object _Base;
02650         return dynamic_cast<HomeInterface*>(_Base::ice_twoway().get());
02651     #else
02652         return dynamic_cast<HomeInterface*>(::IceProxy::Ice::Object::ice_twoway().get());
02653     #endif
02654     }
02655 
02656     ::IceInternal::ProxyHandle<HomeInterface> ice_oneway() const
02657     {
02658     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02659         typedef ::IceProxy::Ice::Object _Base;
02660         return dynamic_cast<HomeInterface*>(_Base::ice_oneway().get());
02661     #else
02662         return dynamic_cast<HomeInterface*>(::IceProxy::Ice::Object::ice_oneway().get());
02663     #endif
02664     }
02665 
02666     ::IceInternal::ProxyHandle<HomeInterface> ice_batchOneway() const
02667     {
02668     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02669         typedef ::IceProxy::Ice::Object _Base;
02670         return dynamic_cast<HomeInterface*>(_Base::ice_batchOneway().get());
02671     #else
02672         return dynamic_cast<HomeInterface*>(::IceProxy::Ice::Object::ice_batchOneway().get());
02673     #endif
02674     }
02675 
02676     ::IceInternal::ProxyHandle<HomeInterface> ice_datagram() const
02677     {
02678     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02679         typedef ::IceProxy::Ice::Object _Base;
02680         return dynamic_cast<HomeInterface*>(_Base::ice_datagram().get());
02681     #else
02682         return dynamic_cast<HomeInterface*>(::IceProxy::Ice::Object::ice_datagram().get());
02683     #endif
02684     }
02685 
02686     ::IceInternal::ProxyHandle<HomeInterface> ice_batchDatagram() const
02687     {
02688     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02689         typedef ::IceProxy::Ice::Object _Base;
02690         return dynamic_cast<HomeInterface*>(_Base::ice_batchDatagram().get());
02691     #else
02692         return dynamic_cast<HomeInterface*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
02693     #endif
02694     }
02695 
02696     ::IceInternal::ProxyHandle<HomeInterface> ice_compress(bool __compress) const
02697     {
02698     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02699         typedef ::IceProxy::Ice::Object _Base;
02700         return dynamic_cast<HomeInterface*>(_Base::ice_compress(__compress).get());
02701     #else
02702         return dynamic_cast<HomeInterface*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
02703     #endif
02704     }
02705 
02706     ::IceInternal::ProxyHandle<HomeInterface> ice_timeout(int __timeout) const
02707     {
02708     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02709         typedef ::IceProxy::Ice::Object _Base;
02710         return dynamic_cast<HomeInterface*>(_Base::ice_timeout(__timeout).get());
02711     #else
02712         return dynamic_cast<HomeInterface*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
02713     #endif
02714     }
02715 
02716     ::IceInternal::ProxyHandle<HomeInterface> ice_connectionId(const std::string& __id) const
02717     {
02718     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02719         typedef ::IceProxy::Ice::Object _Base;
02720         return dynamic_cast<HomeInterface*>(_Base::ice_connectionId(__id).get());
02721     #else
02722         return dynamic_cast<HomeInterface*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
02723     #endif
02724     }
02725 
02726     static const ::std::string& ice_staticId();
02727 
02728 private:
02729 
02730     virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
02731     virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
02732     virtual ::IceProxy::Ice::Object* __newInstance() const;
02733 };
02734 
02735 }
02736 
02737 }
02738 
02739 namespace IceDelegate
02740 {
02741 
02742 namespace BrainObjects
02743 {
02744 
02745 class Retina : virtual public ::IceDelegate::SimEvents::Events
02746 {
02747 public:
02748 
02749     virtual ::ImageIceMod::ImageIce getOutput(const ::Ice::Context*) = 0;
02750 };
02751 
02752 class VisualCortex : virtual public ::IceDelegate::SimEvents::Events
02753 {
02754 public:
02755 };
02756 
02757 class SaliencyMap : virtual public ::IceDelegate::SimEvents::Events
02758 {
02759 public:
02760 };
02761 
02762 class VisualTracker : virtual public ::IceDelegate::SimEvents::Events
02763 {
02764 public:
02765 };
02766 
02767 class PTZ : virtual public ::IceDelegate::SimEvents::Events
02768 {
02769 public:
02770 };
02771 
02772 class Segmenter : virtual public ::IceDelegate::SimEvents::Events
02773 {
02774 public:
02775 };
02776 
02777 class InferotemporalCortex : virtual public ::IceDelegate::SimEvents::Events
02778 {
02779 public:
02780 };
02781 
02782 class Hippocampus : virtual public ::IceDelegate::SimEvents::Events
02783 {
02784 public:
02785 };
02786 
02787 class PrimaryMotorCortex : virtual public ::IceDelegate::SimEvents::Events
02788 {
02789 public:
02790 };
02791 
02792 class PrefrontalCortex : virtual public ::IceDelegate::SimEvents::Events
02793 {
02794 public:
02795 };
02796 
02797 class SimulationViewer : virtual public ::IceDelegate::SimEvents::Events
02798 {
02799 public:
02800 };
02801 
02802 class HomeInterface : virtual public ::IceDelegate::SimEvents::Events
02803 {
02804 public:
02805 };
02806 
02807 }
02808 
02809 }
02810 
02811 namespace IceDelegateM
02812 {
02813 
02814 namespace BrainObjects
02815 {
02816 
02817 class Retina : virtual public ::IceDelegate::BrainObjects::Retina,
02818                virtual public ::IceDelegateM::SimEvents::Events
02819 {
02820 public:
02821 
02822     virtual ::ImageIceMod::ImageIce getOutput(const ::Ice::Context*);
02823 };
02824 
02825 class VisualCortex : virtual public ::IceDelegate::BrainObjects::VisualCortex,
02826                      virtual public ::IceDelegateM::SimEvents::Events
02827 {
02828 public:
02829 };
02830 
02831 class SaliencyMap : virtual public ::IceDelegate::BrainObjects::SaliencyMap,
02832                     virtual public ::IceDelegateM::SimEvents::Events
02833 {
02834 public:
02835 };
02836 
02837 class VisualTracker : virtual public ::IceDelegate::BrainObjects::VisualTracker,
02838                       virtual public ::IceDelegateM::SimEvents::Events
02839 {
02840 public:
02841 };
02842 
02843 class PTZ : virtual public ::IceDelegate::BrainObjects::PTZ,
02844             virtual public ::IceDelegateM::SimEvents::Events
02845 {
02846 public:
02847 };
02848 
02849 class Segmenter : virtual public ::IceDelegate::BrainObjects::Segmenter,
02850                   virtual public ::IceDelegateM::SimEvents::Events
02851 {
02852 public:
02853 };
02854 
02855 class InferotemporalCortex : virtual public ::IceDelegate::BrainObjects::InferotemporalCortex,
02856                              virtual public ::IceDelegateM::SimEvents::Events
02857 {
02858 public:
02859 };
02860 
02861 class Hippocampus : virtual public ::IceDelegate::BrainObjects::Hippocampus,
02862                     virtual public ::IceDelegateM::SimEvents::Events
02863 {
02864 public:
02865 };
02866 
02867 class PrimaryMotorCortex : virtual public ::IceDelegate::BrainObjects::PrimaryMotorCortex,
02868                            virtual public ::IceDelegateM::SimEvents::Events
02869 {
02870 public:
02871 };
02872 
02873 class PrefrontalCortex : virtual public ::IceDelegate::BrainObjects::PrefrontalCortex,
02874                          virtual public ::IceDelegateM::SimEvents::Events
02875 {
02876 public:
02877 };
02878 
02879 class SimulationViewer : virtual public ::IceDelegate::BrainObjects::SimulationViewer,
02880                          virtual public ::IceDelegateM::SimEvents::Events
02881 {
02882 public:
02883 };
02884 
02885 class HomeInterface : virtual public ::IceDelegate::BrainObjects::HomeInterface,
02886                       virtual public ::IceDelegateM::SimEvents::Events
02887 {
02888 public:
02889 };
02890 
02891 }
02892 
02893 }
02894 
02895 namespace IceDelegateD
02896 {
02897 
02898 namespace BrainObjects
02899 {
02900 
02901 class Retina : virtual public ::IceDelegate::BrainObjects::Retina,
02902                virtual public ::IceDelegateD::SimEvents::Events
02903 {
02904 public:
02905 
02906     virtual ::ImageIceMod::ImageIce getOutput(const ::Ice::Context*);
02907 };
02908 
02909 class VisualCortex : virtual public ::IceDelegate::BrainObjects::VisualCortex,
02910                      virtual public ::IceDelegateD::SimEvents::Events
02911 {
02912 public:
02913 };
02914 
02915 class SaliencyMap : virtual public ::IceDelegate::BrainObjects::SaliencyMap,
02916                     virtual public ::IceDelegateD::SimEvents::Events
02917 {
02918 public:
02919 };
02920 
02921 class VisualTracker : virtual public ::IceDelegate::BrainObjects::VisualTracker,
02922                       virtual public ::IceDelegateD::SimEvents::Events
02923 {
02924 public:
02925 };
02926 
02927 class PTZ : virtual public ::IceDelegate::BrainObjects::PTZ,
02928             virtual public ::IceDelegateD::SimEvents::Events
02929 {
02930 public:
02931 };
02932 
02933 class Segmenter : virtual public ::IceDelegate::BrainObjects::Segmenter,
02934                   virtual public ::IceDelegateD::SimEvents::Events
02935 {
02936 public:
02937 };
02938 
02939 class InferotemporalCortex : virtual public ::IceDelegate::BrainObjects::InferotemporalCortex,
02940                              virtual public ::IceDelegateD::SimEvents::Events
02941 {
02942 public:
02943 };
02944 
02945 class Hippocampus : virtual public ::IceDelegate::BrainObjects::Hippocampus,
02946                     virtual public ::IceDelegateD::SimEvents::Events
02947 {
02948 public:
02949 };
02950 
02951 class PrimaryMotorCortex : virtual public ::IceDelegate::BrainObjects::PrimaryMotorCortex,
02952                            virtual public ::IceDelegateD::SimEvents::Events
02953 {
02954 public:
02955 };
02956 
02957 class PrefrontalCortex : virtual public ::IceDelegate::BrainObjects::PrefrontalCortex,
02958                          virtual public ::IceDelegateD::SimEvents::Events
02959 {
02960 public:
02961 };
02962 
02963 class SimulationViewer : virtual public ::IceDelegate::BrainObjects::SimulationViewer,
02964                          virtual public ::IceDelegateD::SimEvents::Events
02965 {
02966 public:
02967 };
02968 
02969 class HomeInterface : virtual public ::IceDelegate::BrainObjects::HomeInterface,
02970                       virtual public ::IceDelegateD::SimEvents::Events
02971 {
02972 public:
02973 };
02974 
02975 }
02976 
02977 }
02978 
02979 namespace BrainObjects
02980 {
02981 
02982 class Retina : virtual public ::SimEvents::Events
02983 {
02984 public:
02985 
02986     typedef RetinaPrx ProxyType;
02987     typedef RetinaPtr PointerType;
02988 
02989     virtual ::Ice::ObjectPtr ice_clone() const;
02990 
02991     virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
02992     virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
02993     virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
02994     static const ::std::string& ice_staticId();
02995 
02996     virtual ::ImageIceMod::ImageIce getOutput(const ::Ice::Current& = ::Ice::Current()) = 0;
02997     ::Ice::DispatchStatus ___getOutput(::IceInternal::Incoming&, const ::Ice::Current&);
02998 
02999     virtual ::Ice::DispatchStatus __dispatch(::IceInternal::Incoming&, const ::Ice::Current&);
03000 
03001     virtual void __write(::IceInternal::BasicStream*) const;
03002     virtual void __read(::IceInternal::BasicStream*, bool);
03003     virtual void __write(const ::Ice::OutputStreamPtr&) const;
03004     virtual void __read(const ::Ice::InputStreamPtr&, bool);
03005 };
03006 
03007 class VisualCortex : virtual public ::SimEvents::Events
03008 {
03009 public:
03010 
03011     typedef VisualCortexPrx ProxyType;
03012     typedef VisualCortexPtr PointerType;
03013 
03014     virtual ::Ice::ObjectPtr ice_clone() const;
03015 
03016     virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
03017     virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
03018     virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
03019     static const ::std::string& ice_staticId();
03020 
03021     virtual ::Ice::DispatchStatus __dispatch(::IceInternal::Incoming&, const ::Ice::Current&);
03022 
03023     virtual void __write(::IceInternal::BasicStream*) const;
03024     virtual void __read(::IceInternal::BasicStream*, bool);
03025     virtual void __write(const ::Ice::OutputStreamPtr&) const;
03026     virtual void __read(const ::Ice::InputStreamPtr&, bool);
03027 };
03028 
03029 class SaliencyMap : virtual public ::SimEvents::Events
03030 {
03031 public:
03032 
03033     typedef SaliencyMapPrx ProxyType;
03034     typedef SaliencyMapPtr PointerType;
03035 
03036     virtual ::Ice::ObjectPtr ice_clone() const;
03037 
03038     virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
03039     virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
03040     virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
03041     static const ::std::string& ice_staticId();
03042 
03043     virtual ::Ice::DispatchStatus __dispatch(::IceInternal::Incoming&, const ::Ice::Current&);
03044 
03045     virtual void __write(::IceInternal::BasicStream*) const;
03046     virtual void __read(::IceInternal::BasicStream*, bool);
03047     virtual void __write(const ::Ice::OutputStreamPtr&) const;
03048     virtual void __read(const ::Ice::InputStreamPtr&, bool);
03049 };
03050 
03051 class VisualTracker : virtual public ::SimEvents::Events
03052 {
03053 public:
03054 
03055     typedef VisualTrackerPrx ProxyType;
03056     typedef VisualTrackerPtr PointerType;
03057 
03058     virtual ::Ice::ObjectPtr ice_clone() const;
03059 
03060     virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
03061     virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
03062     virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
03063     static const ::std::string& ice_staticId();
03064 
03065     virtual ::Ice::DispatchStatus __dispatch(::IceInternal::Incoming&, const ::Ice::Current&);
03066 
03067     virtual void __write(::IceInternal::BasicStream*) const;
03068     virtual void __read(::IceInternal::BasicStream*, bool);
03069     virtual void __write(const ::Ice::OutputStreamPtr&) const;
03070     virtual void __read(const ::Ice::InputStreamPtr&, bool);
03071 };
03072 
03073 class PTZ : virtual public ::SimEvents::Events
03074 {
03075 public:
03076 
03077     typedef PTZPrx ProxyType;
03078     typedef PTZPtr PointerType;
03079 
03080     virtual ::Ice::ObjectPtr ice_clone() const;
03081 
03082     virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
03083     virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
03084     virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
03085     static const ::std::string& ice_staticId();
03086 
03087     virtual ::Ice::DispatchStatus __dispatch(::IceInternal::Incoming&, const ::Ice::Current&);
03088 
03089     virtual void __write(::IceInternal::BasicStream*) const;
03090     virtual void __read(::IceInternal::BasicStream*, bool);
03091     virtual void __write(const ::Ice::OutputStreamPtr&) const;
03092     virtual void __read(const ::Ice::InputStreamPtr&, bool);
03093 };
03094 
03095 class Segmenter : virtual public ::SimEvents::Events
03096 {
03097 public:
03098 
03099     typedef SegmenterPrx ProxyType;
03100     typedef SegmenterPtr PointerType;
03101 
03102     virtual ::Ice::ObjectPtr ice_clone() const;
03103 
03104     virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
03105     virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
03106     virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
03107     static const ::std::string& ice_staticId();
03108 
03109     virtual ::Ice::DispatchStatus __dispatch(::IceInternal::Incoming&, const ::Ice::Current&);
03110 
03111     virtual void __write(::IceInternal::BasicStream*) const;
03112     virtual void __read(::IceInternal::BasicStream*, bool);
03113     virtual void __write(const ::Ice::OutputStreamPtr&) const;
03114     virtual void __read(const ::Ice::InputStreamPtr&, bool);
03115 };
03116 
03117 class InferotemporalCortex : virtual public ::SimEvents::Events
03118 {
03119 public:
03120 
03121     typedef InferotemporalCortexPrx ProxyType;
03122     typedef InferotemporalCortexPtr PointerType;
03123 
03124     virtual ::Ice::ObjectPtr ice_clone() const;
03125 
03126     virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
03127     virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
03128     virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
03129     static const ::std::string& ice_staticId();
03130 
03131     virtual ::Ice::DispatchStatus __dispatch(::IceInternal::Incoming&, const ::Ice::Current&);
03132 
03133     virtual void __write(::IceInternal::BasicStream*) const;
03134     virtual void __read(::IceInternal::BasicStream*, bool);
03135     virtual void __write(const ::Ice::OutputStreamPtr&) const;
03136     virtual void __read(const ::Ice::InputStreamPtr&, bool);
03137 };
03138 
03139 class Hippocampus : virtual public ::SimEvents::Events
03140 {
03141 public:
03142 
03143     typedef HippocampusPrx ProxyType;
03144     typedef HippocampusPtr PointerType;
03145 
03146     virtual ::Ice::ObjectPtr ice_clone() const;
03147 
03148     virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
03149     virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
03150     virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
03151     static const ::std::string& ice_staticId();
03152 
03153     virtual ::Ice::DispatchStatus __dispatch(::IceInternal::Incoming&, const ::Ice::Current&);
03154 
03155     virtual void __write(::IceInternal::BasicStream*) const;
03156     virtual void __read(::IceInternal::BasicStream*, bool);
03157     virtual void __write(const ::Ice::OutputStreamPtr&) const;
03158     virtual void __read(const ::Ice::InputStreamPtr&, bool);
03159 };
03160 
03161 class PrimaryMotorCortex : virtual public ::SimEvents::Events
03162 {
03163 public:
03164 
03165     typedef PrimaryMotorCortexPrx ProxyType;
03166     typedef PrimaryMotorCortexPtr PointerType;
03167 
03168     virtual ::Ice::ObjectPtr ice_clone() const;
03169 
03170     virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
03171     virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
03172     virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
03173     static const ::std::string& ice_staticId();
03174 
03175     virtual ::Ice::DispatchStatus __dispatch(::IceInternal::Incoming&, const ::Ice::Current&);
03176 
03177     virtual void __write(::IceInternal::BasicStream*) const;
03178     virtual void __read(::IceInternal::BasicStream*, bool);
03179     virtual void __write(const ::Ice::OutputStreamPtr&) const;
03180     virtual void __read(const ::Ice::InputStreamPtr&, bool);
03181 };
03182 
03183 class PrefrontalCortex : virtual public ::SimEvents::Events
03184 {
03185 public:
03186 
03187     typedef PrefrontalCortexPrx ProxyType;
03188     typedef PrefrontalCortexPtr PointerType;
03189 
03190     virtual ::Ice::ObjectPtr ice_clone() const;
03191 
03192     virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
03193     virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
03194     virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
03195     static const ::std::string& ice_staticId();
03196 
03197     virtual ::Ice::DispatchStatus __dispatch(::IceInternal::Incoming&, const ::Ice::Current&);
03198 
03199     virtual void __write(::IceInternal::BasicStream*) const;
03200     virtual void __read(::IceInternal::BasicStream*, bool);
03201     virtual void __write(const ::Ice::OutputStreamPtr&) const;
03202     virtual void __read(const ::Ice::InputStreamPtr&, bool);
03203 };
03204 
03205 class SimulationViewer : virtual public ::SimEvents::Events
03206 {
03207 public:
03208 
03209     typedef SimulationViewerPrx ProxyType;
03210     typedef SimulationViewerPtr PointerType;
03211 
03212     virtual ::Ice::ObjectPtr ice_clone() const;
03213 
03214     virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
03215     virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
03216     virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
03217     static const ::std::string& ice_staticId();
03218 
03219     virtual ::Ice::DispatchStatus __dispatch(::IceInternal::Incoming&, const ::Ice::Current&);
03220 
03221     virtual void __write(::IceInternal::BasicStream*) const;
03222     virtual void __read(::IceInternal::BasicStream*, bool);
03223     virtual void __write(const ::Ice::OutputStreamPtr&) const;
03224     virtual void __read(const ::Ice::InputStreamPtr&, bool);
03225 };
03226 
03227 class HomeInterface : virtual public ::SimEvents::Events
03228 {
03229 public:
03230 
03231     typedef HomeInterfacePrx ProxyType;
03232     typedef HomeInterfacePtr PointerType;
03233 
03234     virtual ::Ice::ObjectPtr ice_clone() const;
03235 
03236     virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
03237     virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
03238     virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
03239     static const ::std::string& ice_staticId();
03240 
03241     virtual ::Ice::DispatchStatus __dispatch(::IceInternal::Incoming&, const ::Ice::Current&);
03242 
03243     virtual void __write(::IceInternal::BasicStream*) const;
03244     virtual void __read(::IceInternal::BasicStream*, bool);
03245     virtual void __write(const ::Ice::OutputStreamPtr&) const;
03246     virtual void __read(const ::Ice::InputStreamPtr&, bool);
03247 };
03248 
03249 }
03250 
03251 #endif