iLab Neuromorphic Vision Toolkit

00001 // **********************************************************************
00002 //
00003 // Copyright (c) 2003-2008 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.0
00011 // Generated from file `BrainObjects.ice'
00012 
00013 #ifndef __BrainObjects_h__
00014 #define __BrainObjects_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.h>
00029 #include <Ice/SimEvents.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 < 0
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 Segmenter;
00059 
00060 class InferotemporalCortex;
00061 
00062 class PrefrontalCortex;
00063 
00064 class SimulationViewer;
00065 
00066 }
00067 
00068 }
00069 
00070 namespace BrainObjects
00071 {
00072 
00073 class Retina;
00074 bool operator==(const Retina&, const Retina&);
00075 bool operator<(const Retina&, const Retina&);
00076 
00077 class VisualCortex;
00078 bool operator==(const VisualCortex&, const VisualCortex&);
00079 bool operator<(const VisualCortex&, const VisualCortex&);
00080 
00081 class SaliencyMap;
00082 bool operator==(const SaliencyMap&, const SaliencyMap&);
00083 bool operator<(const SaliencyMap&, const SaliencyMap&);
00084 
00085 class VisualTracker;
00086 bool operator==(const VisualTracker&, const VisualTracker&);
00087 bool operator<(const VisualTracker&, const VisualTracker&);
00088 
00089 class Segmenter;
00090 bool operator==(const Segmenter&, const Segmenter&);
00091 bool operator<(const Segmenter&, const Segmenter&);
00092 
00093 class InferotemporalCortex;
00094 bool operator==(const InferotemporalCortex&, const InferotemporalCortex&);
00095 bool operator<(const InferotemporalCortex&, const InferotemporalCortex&);
00096 
00097 class PrefrontalCortex;
00098 bool operator==(const PrefrontalCortex&, const PrefrontalCortex&);
00099 bool operator<(const PrefrontalCortex&, const PrefrontalCortex&);
00100 
00101 class SimulationViewer;
00102 bool operator==(const SimulationViewer&, const SimulationViewer&);
00103 bool operator<(const SimulationViewer&, const SimulationViewer&);
00104 
00105 }
00106 
00107 namespace IceInternal
00108 {
00109 
00110 ::Ice::Object* upCast(::BrainObjects::Retina*);
00111 ::IceProxy::Ice::Object* upCast(::IceProxy::BrainObjects::Retina*);
00112 
00113 ::Ice::Object* upCast(::BrainObjects::VisualCortex*);
00114 ::IceProxy::Ice::Object* upCast(::IceProxy::BrainObjects::VisualCortex*);
00115 
00116 ::Ice::Object* upCast(::BrainObjects::SaliencyMap*);
00117 ::IceProxy::Ice::Object* upCast(::IceProxy::BrainObjects::SaliencyMap*);
00118 
00119 ::Ice::Object* upCast(::BrainObjects::VisualTracker*);
00120 ::IceProxy::Ice::Object* upCast(::IceProxy::BrainObjects::VisualTracker*);
00121 
00122 ::Ice::Object* upCast(::BrainObjects::Segmenter*);
00123 ::IceProxy::Ice::Object* upCast(::IceProxy::BrainObjects::Segmenter*);
00124 
00125 ::Ice::Object* upCast(::BrainObjects::InferotemporalCortex*);
00126 ::IceProxy::Ice::Object* upCast(::IceProxy::BrainObjects::InferotemporalCortex*);
00127 
00128 ::Ice::Object* upCast(::BrainObjects::PrefrontalCortex*);
00129 ::IceProxy::Ice::Object* upCast(::IceProxy::BrainObjects::PrefrontalCortex*);
00130 
00131 ::Ice::Object* upCast(::BrainObjects::SimulationViewer*);
00132 ::IceProxy::Ice::Object* upCast(::IceProxy::BrainObjects::SimulationViewer*);
00133 
00134 }
00135 
00136 namespace BrainObjects
00137 {
00138 
00139 typedef ::IceInternal::Handle< ::BrainObjects::Retina> RetinaPtr;
00140 typedef ::IceInternal::ProxyHandle< ::IceProxy::BrainObjects::Retina> RetinaPrx;
00141 
00142 void __read(::IceInternal::BasicStream*, RetinaPrx&);
00143 void __patch__RetinaPtr(void*, ::Ice::ObjectPtr&);
00144 
00145 typedef ::IceInternal::Handle< ::BrainObjects::VisualCortex> VisualCortexPtr;
00146 typedef ::IceInternal::ProxyHandle< ::IceProxy::BrainObjects::VisualCortex> VisualCortexPrx;
00147 
00148 void __read(::IceInternal::BasicStream*, VisualCortexPrx&);
00149 void __patch__VisualCortexPtr(void*, ::Ice::ObjectPtr&);
00150 
00151 typedef ::IceInternal::Handle< ::BrainObjects::SaliencyMap> SaliencyMapPtr;
00152 typedef ::IceInternal::ProxyHandle< ::IceProxy::BrainObjects::SaliencyMap> SaliencyMapPrx;
00153 
00154 void __read(::IceInternal::BasicStream*, SaliencyMapPrx&);
00155 void __patch__SaliencyMapPtr(void*, ::Ice::ObjectPtr&);
00156 
00157 typedef ::IceInternal::Handle< ::BrainObjects::VisualTracker> VisualTrackerPtr;
00158 typedef ::IceInternal::ProxyHandle< ::IceProxy::BrainObjects::VisualTracker> VisualTrackerPrx;
00159 
00160 void __read(::IceInternal::BasicStream*, VisualTrackerPrx&);
00161 void __patch__VisualTrackerPtr(void*, ::Ice::ObjectPtr&);
00162 
00163 typedef ::IceInternal::Handle< ::BrainObjects::Segmenter> SegmenterPtr;
00164 typedef ::IceInternal::ProxyHandle< ::IceProxy::BrainObjects::Segmenter> SegmenterPrx;
00165 
00166 void __read(::IceInternal::BasicStream*, SegmenterPrx&);
00167 void __patch__SegmenterPtr(void*, ::Ice::ObjectPtr&);
00168 
00169 typedef ::IceInternal::Handle< ::BrainObjects::InferotemporalCortex> InferotemporalCortexPtr;
00170 typedef ::IceInternal::ProxyHandle< ::IceProxy::BrainObjects::InferotemporalCortex> InferotemporalCortexPrx;
00171 
00172 void __read(::IceInternal::BasicStream*, InferotemporalCortexPrx&);
00173 void __patch__InferotemporalCortexPtr(void*, ::Ice::ObjectPtr&);
00174 
00175 typedef ::IceInternal::Handle< ::BrainObjects::PrefrontalCortex> PrefrontalCortexPtr;
00176 typedef ::IceInternal::ProxyHandle< ::IceProxy::BrainObjects::PrefrontalCortex> PrefrontalCortexPrx;
00177 
00178 void __read(::IceInternal::BasicStream*, PrefrontalCortexPrx&);
00179 void __patch__PrefrontalCortexPtr(void*, ::Ice::ObjectPtr&);
00180 
00181 typedef ::IceInternal::Handle< ::BrainObjects::SimulationViewer> SimulationViewerPtr;
00182 typedef ::IceInternal::ProxyHandle< ::IceProxy::BrainObjects::SimulationViewer> SimulationViewerPrx;
00183 
00184 void __read(::IceInternal::BasicStream*, SimulationViewerPrx&);
00185 void __patch__SimulationViewerPtr(void*, ::Ice::ObjectPtr&);
00186 
00187 }
00188 
00189 namespace BrainObjects
00190 {
00191 
00192 const ::Ice::Int RetinaPort = 20000;
00193 
00194 const ::Ice::Int VisualCortexPort = 20001;
00195 
00196 const ::Ice::Int SaliencyMapPort = 20002;
00197 
00198 const ::Ice::Int SegmenterPort = 20003;
00199 
00200 const ::Ice::Int VisualTrackerPort = 20004;
00201 
00202 const ::Ice::Int InferoTemporalPort = 20005;
00203 
00204 const ::Ice::Int PrefrontalCortexPort = 20006;
00205 
00206 const ::Ice::Int SimulationViewerPort = 20007;
00207 
00208 }
00209 
00210 namespace IceProxy
00211 {
00212 
00213 namespace BrainObjects
00214 {
00215 
00216 class Retina : virtual public ::IceProxy::SimEvents::Events
00217 {
00218 public:
00219 
00220     ::ImageIceMod::ImageIce getOutput()
00221     {
00222         return getOutput(0);
00223     }
00224     ::ImageIceMod::ImageIce getOutput(const ::Ice::Context& __ctx)
00225     {
00226         return getOutput(&__ctx);
00227     }
00228     
00229 private:
00230 
00231     ::ImageIceMod::ImageIce getOutput(const ::Ice::Context*);
00232     
00233 public:
00234     
00235     ::IceInternal::ProxyHandle<Retina> ice_context(const ::Ice::Context& __context) const
00236     {
00237     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00238         typedef ::IceProxy::Ice::Object _Base;
00239         return dynamic_cast<Retina*>(_Base::ice_context(__context).get());
00240     #else
00241         return dynamic_cast<Retina*>(::IceProxy::Ice::Object::ice_context(__context).get());
00242     #endif
00243     }
00244     
00245     ::IceInternal::ProxyHandle<Retina> ice_adapterId(const std::string& __id) const
00246     {
00247     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00248         typedef ::IceProxy::Ice::Object _Base;
00249         return dynamic_cast<Retina*>(_Base::ice_adapterId(__id).get());
00250     #else
00251         return dynamic_cast<Retina*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
00252     #endif
00253     }
00254     
00255     ::IceInternal::ProxyHandle<Retina> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
00256     {
00257     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00258         typedef ::IceProxy::Ice::Object _Base;
00259         return dynamic_cast<Retina*>(_Base::ice_endpoints(__endpoints).get());
00260     #else
00261         return dynamic_cast<Retina*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
00262     #endif
00263     }
00264     
00265     ::IceInternal::ProxyHandle<Retina> ice_locatorCacheTimeout(int __timeout) const
00266     {
00267     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00268         typedef ::IceProxy::Ice::Object _Base;
00269         return dynamic_cast<Retina*>(_Base::ice_locatorCacheTimeout(__timeout).get());
00270     #else
00271         return dynamic_cast<Retina*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
00272     #endif
00273     }
00274     
00275     ::IceInternal::ProxyHandle<Retina> ice_connectionCached(bool __cached) const
00276     {
00277     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00278         typedef ::IceProxy::Ice::Object _Base;
00279         return dynamic_cast<Retina*>(_Base::ice_connectionCached(__cached).get());
00280     #else
00281         return dynamic_cast<Retina*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
00282     #endif
00283     }
00284     
00285     ::IceInternal::ProxyHandle<Retina> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
00286     {
00287     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00288         typedef ::IceProxy::Ice::Object _Base;
00289         return dynamic_cast<Retina*>(_Base::ice_endpointSelection(__est).get());
00290     #else
00291         return dynamic_cast<Retina*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
00292     #endif
00293     }
00294     
00295     ::IceInternal::ProxyHandle<Retina> ice_secure(bool __secure) const
00296     {
00297     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00298         typedef ::IceProxy::Ice::Object _Base;
00299         return dynamic_cast<Retina*>(_Base::ice_secure(__secure).get());
00300     #else
00301         return dynamic_cast<Retina*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
00302     #endif
00303     }
00304     
00305     ::IceInternal::ProxyHandle<Retina> ice_preferSecure(bool __preferSecure) const
00306     {
00307     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00308         typedef ::IceProxy::Ice::Object _Base;
00309         return dynamic_cast<Retina*>(_Base::ice_preferSecure(__preferSecure).get());
00310     #else
00311         return dynamic_cast<Retina*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
00312     #endif
00313     }
00314     
00315     ::IceInternal::ProxyHandle<Retina> ice_router(const ::Ice::RouterPrx& __router) const
00316     {
00317     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00318         typedef ::IceProxy::Ice::Object _Base;
00319         return dynamic_cast<Retina*>(_Base::ice_router(__router).get());
00320     #else
00321         return dynamic_cast<Retina*>(::IceProxy::Ice::Object::ice_router(__router).get());
00322     #endif
00323     }
00324     
00325     ::IceInternal::ProxyHandle<Retina> ice_locator(const ::Ice::LocatorPrx& __locator) const
00326     {
00327     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00328         typedef ::IceProxy::Ice::Object _Base;
00329         return dynamic_cast<Retina*>(_Base::ice_locator(__locator).get());
00330     #else
00331         return dynamic_cast<Retina*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
00332     #endif
00333     }
00334     
00335     ::IceInternal::ProxyHandle<Retina> ice_collocationOptimized(bool __co) const
00336     {
00337     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00338         typedef ::IceProxy::Ice::Object _Base;
00339         return dynamic_cast<Retina*>(_Base::ice_collocationOptimized(__co).get());
00340     #else
00341         return dynamic_cast<Retina*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
00342     #endif
00343     }
00344     
00345     ::IceInternal::ProxyHandle<Retina> ice_twoway() const
00346     {
00347     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00348         typedef ::IceProxy::Ice::Object _Base;
00349         return dynamic_cast<Retina*>(_Base::ice_twoway().get());
00350     #else
00351         return dynamic_cast<Retina*>(::IceProxy::Ice::Object::ice_twoway().get());
00352     #endif
00353     }
00354     
00355     ::IceInternal::ProxyHandle<Retina> ice_oneway() const
00356     {
00357     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00358         typedef ::IceProxy::Ice::Object _Base;
00359         return dynamic_cast<Retina*>(_Base::ice_oneway().get());
00360     #else
00361         return dynamic_cast<Retina*>(::IceProxy::Ice::Object::ice_oneway().get());
00362     #endif
00363     }
00364     
00365     ::IceInternal::ProxyHandle<Retina> ice_batchOneway() const
00366     {
00367     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00368         typedef ::IceProxy::Ice::Object _Base;
00369         return dynamic_cast<Retina*>(_Base::ice_batchOneway().get());
00370     #else
00371         return dynamic_cast<Retina*>(::IceProxy::Ice::Object::ice_batchOneway().get());
00372     #endif
00373     }
00374     
00375     ::IceInternal::ProxyHandle<Retina> ice_datagram() const
00376     {
00377     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00378         typedef ::IceProxy::Ice::Object _Base;
00379         return dynamic_cast<Retina*>(_Base::ice_datagram().get());
00380     #else
00381         return dynamic_cast<Retina*>(::IceProxy::Ice::Object::ice_datagram().get());
00382     #endif
00383     }
00384     
00385     ::IceInternal::ProxyHandle<Retina> ice_batchDatagram() const
00386     {
00387     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00388         typedef ::IceProxy::Ice::Object _Base;
00389         return dynamic_cast<Retina*>(_Base::ice_batchDatagram().get());
00390     #else
00391         return dynamic_cast<Retina*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
00392     #endif
00393     }
00394     
00395     ::IceInternal::ProxyHandle<Retina> ice_compress(bool __compress) const
00396     {
00397     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00398         typedef ::IceProxy::Ice::Object _Base;
00399         return dynamic_cast<Retina*>(_Base::ice_compress(__compress).get());
00400     #else
00401         return dynamic_cast<Retina*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
00402     #endif
00403     }
00404     
00405     ::IceInternal::ProxyHandle<Retina> ice_timeout(int __timeout) const
00406     {
00407     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00408         typedef ::IceProxy::Ice::Object _Base;
00409         return dynamic_cast<Retina*>(_Base::ice_timeout(__timeout).get());
00410     #else
00411         return dynamic_cast<Retina*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
00412     #endif
00413     }
00414     
00415     ::IceInternal::ProxyHandle<Retina> ice_connectionId(const std::string& __id) const
00416     {
00417     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00418         typedef ::IceProxy::Ice::Object _Base;
00419         return dynamic_cast<Retina*>(_Base::ice_connectionId(__id).get());
00420     #else
00421         return dynamic_cast<Retina*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
00422     #endif
00423     }
00424     
00425     static const ::std::string& ice_staticId();
00426 
00427 private: 
00428 
00429     virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
00430     virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
00431     virtual ::IceProxy::Ice::Object* __newInstance() const;
00432 };
00433 
00434 class VisualCortex : virtual public ::IceProxy::SimEvents::Events
00435 {
00436 public:
00437     
00438     ::IceInternal::ProxyHandle<VisualCortex> ice_context(const ::Ice::Context& __context) const
00439     {
00440     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00441         typedef ::IceProxy::Ice::Object _Base;
00442         return dynamic_cast<VisualCortex*>(_Base::ice_context(__context).get());
00443     #else
00444         return dynamic_cast<VisualCortex*>(::IceProxy::Ice::Object::ice_context(__context).get());
00445     #endif
00446     }
00447     
00448     ::IceInternal::ProxyHandle<VisualCortex> ice_adapterId(const std::string& __id) const
00449     {
00450     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00451         typedef ::IceProxy::Ice::Object _Base;
00452         return dynamic_cast<VisualCortex*>(_Base::ice_adapterId(__id).get());
00453     #else
00454         return dynamic_cast<VisualCortex*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
00455     #endif
00456     }
00457     
00458     ::IceInternal::ProxyHandle<VisualCortex> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
00459     {
00460     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00461         typedef ::IceProxy::Ice::Object _Base;
00462         return dynamic_cast<VisualCortex*>(_Base::ice_endpoints(__endpoints).get());
00463     #else
00464         return dynamic_cast<VisualCortex*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
00465     #endif
00466     }
00467     
00468     ::IceInternal::ProxyHandle<VisualCortex> ice_locatorCacheTimeout(int __timeout) const
00469     {
00470     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00471         typedef ::IceProxy::Ice::Object _Base;
00472         return dynamic_cast<VisualCortex*>(_Base::ice_locatorCacheTimeout(__timeout).get());
00473     #else
00474         return dynamic_cast<VisualCortex*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
00475     #endif
00476     }
00477     
00478     ::IceInternal::ProxyHandle<VisualCortex> ice_connectionCached(bool __cached) const
00479     {
00480     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00481         typedef ::IceProxy::Ice::Object _Base;
00482         return dynamic_cast<VisualCortex*>(_Base::ice_connectionCached(__cached).get());
00483     #else
00484         return dynamic_cast<VisualCortex*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
00485     #endif
00486     }
00487     
00488     ::IceInternal::ProxyHandle<VisualCortex> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
00489     {
00490     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00491         typedef ::IceProxy::Ice::Object _Base;
00492         return dynamic_cast<VisualCortex*>(_Base::ice_endpointSelection(__est).get());
00493     #else
00494         return dynamic_cast<VisualCortex*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
00495     #endif
00496     }
00497     
00498     ::IceInternal::ProxyHandle<VisualCortex> ice_secure(bool __secure) const
00499     {
00500     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00501         typedef ::IceProxy::Ice::Object _Base;
00502         return dynamic_cast<VisualCortex*>(_Base::ice_secure(__secure).get());
00503     #else
00504         return dynamic_cast<VisualCortex*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
00505     #endif
00506     }
00507     
00508     ::IceInternal::ProxyHandle<VisualCortex> ice_preferSecure(bool __preferSecure) const
00509     {
00510     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00511         typedef ::IceProxy::Ice::Object _Base;
00512         return dynamic_cast<VisualCortex*>(_Base::ice_preferSecure(__preferSecure).get());
00513     #else
00514         return dynamic_cast<VisualCortex*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
00515     #endif
00516     }
00517     
00518     ::IceInternal::ProxyHandle<VisualCortex> ice_router(const ::Ice::RouterPrx& __router) const
00519     {
00520     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00521         typedef ::IceProxy::Ice::Object _Base;
00522         return dynamic_cast<VisualCortex*>(_Base::ice_router(__router).get());
00523     #else
00524         return dynamic_cast<VisualCortex*>(::IceProxy::Ice::Object::ice_router(__router).get());
00525     #endif
00526     }
00527     
00528     ::IceInternal::ProxyHandle<VisualCortex> ice_locator(const ::Ice::LocatorPrx& __locator) const
00529     {
00530     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00531         typedef ::IceProxy::Ice::Object _Base;
00532         return dynamic_cast<VisualCortex*>(_Base::ice_locator(__locator).get());
00533     #else
00534         return dynamic_cast<VisualCortex*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
00535     #endif
00536     }
00537     
00538     ::IceInternal::ProxyHandle<VisualCortex> ice_collocationOptimized(bool __co) const
00539     {
00540     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00541         typedef ::IceProxy::Ice::Object _Base;
00542         return dynamic_cast<VisualCortex*>(_Base::ice_collocationOptimized(__co).get());
00543     #else
00544         return dynamic_cast<VisualCortex*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
00545     #endif
00546     }
00547     
00548     ::IceInternal::ProxyHandle<VisualCortex> ice_twoway() const
00549     {
00550     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00551         typedef ::IceProxy::Ice::Object _Base;
00552         return dynamic_cast<VisualCortex*>(_Base::ice_twoway().get());
00553     #else
00554         return dynamic_cast<VisualCortex*>(::IceProxy::Ice::Object::ice_twoway().get());
00555     #endif
00556     }
00557     
00558     ::IceInternal::ProxyHandle<VisualCortex> ice_oneway() const
00559     {
00560     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00561         typedef ::IceProxy::Ice::Object _Base;
00562         return dynamic_cast<VisualCortex*>(_Base::ice_oneway().get());
00563     #else
00564         return dynamic_cast<VisualCortex*>(::IceProxy::Ice::Object::ice_oneway().get());
00565     #endif
00566     }
00567     
00568     ::IceInternal::ProxyHandle<VisualCortex> ice_batchOneway() const
00569     {
00570     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00571         typedef ::IceProxy::Ice::Object _Base;
00572         return dynamic_cast<VisualCortex*>(_Base::ice_batchOneway().get());
00573     #else
00574         return dynamic_cast<VisualCortex*>(::IceProxy::Ice::Object::ice_batchOneway().get());
00575     #endif
00576     }
00577     
00578     ::IceInternal::ProxyHandle<VisualCortex> ice_datagram() const
00579     {
00580     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00581         typedef ::IceProxy::Ice::Object _Base;
00582         return dynamic_cast<VisualCortex*>(_Base::ice_datagram().get());
00583     #else
00584         return dynamic_cast<VisualCortex*>(::IceProxy::Ice::Object::ice_datagram().get());
00585     #endif
00586     }
00587     
00588     ::IceInternal::ProxyHandle<VisualCortex> ice_batchDatagram() const
00589     {
00590     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00591         typedef ::IceProxy::Ice::Object _Base;
00592         return dynamic_cast<VisualCortex*>(_Base::ice_batchDatagram().get());
00593     #else
00594         return dynamic_cast<VisualCortex*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
00595     #endif
00596     }
00597     
00598     ::IceInternal::ProxyHandle<VisualCortex> ice_compress(bool __compress) const
00599     {
00600     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00601         typedef ::IceProxy::Ice::Object _Base;
00602         return dynamic_cast<VisualCortex*>(_Base::ice_compress(__compress).get());
00603     #else
00604         return dynamic_cast<VisualCortex*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
00605     #endif
00606     }
00607     
00608     ::IceInternal::ProxyHandle<VisualCortex> ice_timeout(int __timeout) const
00609     {
00610     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00611         typedef ::IceProxy::Ice::Object _Base;
00612         return dynamic_cast<VisualCortex*>(_Base::ice_timeout(__timeout).get());
00613     #else
00614         return dynamic_cast<VisualCortex*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
00615     #endif
00616     }
00617     
00618     ::IceInternal::ProxyHandle<VisualCortex> ice_connectionId(const std::string& __id) const
00619     {
00620     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00621         typedef ::IceProxy::Ice::Object _Base;
00622         return dynamic_cast<VisualCortex*>(_Base::ice_connectionId(__id).get());
00623     #else
00624         return dynamic_cast<VisualCortex*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
00625     #endif
00626     }
00627     
00628     static const ::std::string& ice_staticId();
00629 
00630 private: 
00631 
00632     virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
00633     virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
00634     virtual ::IceProxy::Ice::Object* __newInstance() const;
00635 };
00636 
00637 class SaliencyMap : virtual public ::IceProxy::SimEvents::Events
00638 {
00639 public:
00640     
00641     ::IceInternal::ProxyHandle<SaliencyMap> ice_context(const ::Ice::Context& __context) const
00642     {
00643     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00644         typedef ::IceProxy::Ice::Object _Base;
00645         return dynamic_cast<SaliencyMap*>(_Base::ice_context(__context).get());
00646     #else
00647         return dynamic_cast<SaliencyMap*>(::IceProxy::Ice::Object::ice_context(__context).get());
00648     #endif
00649     }
00650     
00651     ::IceInternal::ProxyHandle<SaliencyMap> ice_adapterId(const std::string& __id) const
00652     {
00653     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00654         typedef ::IceProxy::Ice::Object _Base;
00655         return dynamic_cast<SaliencyMap*>(_Base::ice_adapterId(__id).get());
00656     #else
00657         return dynamic_cast<SaliencyMap*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
00658     #endif
00659     }
00660     
00661     ::IceInternal::ProxyHandle<SaliencyMap> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
00662     {
00663     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00664         typedef ::IceProxy::Ice::Object _Base;
00665         return dynamic_cast<SaliencyMap*>(_Base::ice_endpoints(__endpoints).get());
00666     #else
00667         return dynamic_cast<SaliencyMap*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
00668     #endif
00669     }
00670     
00671     ::IceInternal::ProxyHandle<SaliencyMap> ice_locatorCacheTimeout(int __timeout) const
00672     {
00673     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00674         typedef ::IceProxy::Ice::Object _Base;
00675         return dynamic_cast<SaliencyMap*>(_Base::ice_locatorCacheTimeout(__timeout).get());
00676     #else
00677         return dynamic_cast<SaliencyMap*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
00678     #endif
00679     }
00680     
00681     ::IceInternal::ProxyHandle<SaliencyMap> ice_connectionCached(bool __cached) const
00682     {
00683     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00684         typedef ::IceProxy::Ice::Object _Base;
00685         return dynamic_cast<SaliencyMap*>(_Base::ice_connectionCached(__cached).get());
00686     #else
00687         return dynamic_cast<SaliencyMap*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
00688     #endif
00689     }
00690     
00691     ::IceInternal::ProxyHandle<SaliencyMap> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
00692     {
00693     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00694         typedef ::IceProxy::Ice::Object _Base;
00695         return dynamic_cast<SaliencyMap*>(_Base::ice_endpointSelection(__est).get());
00696     #else
00697         return dynamic_cast<SaliencyMap*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
00698     #endif
00699     }
00700     
00701     ::IceInternal::ProxyHandle<SaliencyMap> ice_secure(bool __secure) const
00702     {
00703     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00704         typedef ::IceProxy::Ice::Object _Base;
00705         return dynamic_cast<SaliencyMap*>(_Base::ice_secure(__secure).get());
00706     #else
00707         return dynamic_cast<SaliencyMap*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
00708     #endif
00709     }
00710     
00711     ::IceInternal::ProxyHandle<SaliencyMap> ice_preferSecure(bool __preferSecure) const
00712     {
00713     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00714         typedef ::IceProxy::Ice::Object _Base;
00715         return dynamic_cast<SaliencyMap*>(_Base::ice_preferSecure(__preferSecure).get());
00716     #else
00717         return dynamic_cast<SaliencyMap*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
00718     #endif
00719     }
00720     
00721     ::IceInternal::ProxyHandle<SaliencyMap> ice_router(const ::Ice::RouterPrx& __router) const
00722     {
00723     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00724         typedef ::IceProxy::Ice::Object _Base;
00725         return dynamic_cast<SaliencyMap*>(_Base::ice_router(__router).get());
00726     #else
00727         return dynamic_cast<SaliencyMap*>(::IceProxy::Ice::Object::ice_router(__router).get());
00728     #endif
00729     }
00730     
00731     ::IceInternal::ProxyHandle<SaliencyMap> ice_locator(const ::Ice::LocatorPrx& __locator) const
00732     {
00733     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00734         typedef ::IceProxy::Ice::Object _Base;
00735         return dynamic_cast<SaliencyMap*>(_Base::ice_locator(__locator).get());
00736     #else
00737         return dynamic_cast<SaliencyMap*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
00738     #endif
00739     }
00740     
00741     ::IceInternal::ProxyHandle<SaliencyMap> ice_collocationOptimized(bool __co) const
00742     {
00743     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00744         typedef ::IceProxy::Ice::Object _Base;
00745         return dynamic_cast<SaliencyMap*>(_Base::ice_collocationOptimized(__co).get());
00746     #else
00747         return dynamic_cast<SaliencyMap*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
00748     #endif
00749     }
00750     
00751     ::IceInternal::ProxyHandle<SaliencyMap> ice_twoway() const
00752     {
00753     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00754         typedef ::IceProxy::Ice::Object _Base;
00755         return dynamic_cast<SaliencyMap*>(_Base::ice_twoway().get());
00756     #else
00757         return dynamic_cast<SaliencyMap*>(::IceProxy::Ice::Object::ice_twoway().get());
00758     #endif
00759     }
00760     
00761     ::IceInternal::ProxyHandle<SaliencyMap> ice_oneway() const
00762     {
00763     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00764         typedef ::IceProxy::Ice::Object _Base;
00765         return dynamic_cast<SaliencyMap*>(_Base::ice_oneway().get());
00766     #else
00767         return dynamic_cast<SaliencyMap*>(::IceProxy::Ice::Object::ice_oneway().get());
00768     #endif
00769     }
00770     
00771     ::IceInternal::ProxyHandle<SaliencyMap> ice_batchOneway() const
00772     {
00773     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00774         typedef ::IceProxy::Ice::Object _Base;
00775         return dynamic_cast<SaliencyMap*>(_Base::ice_batchOneway().get());
00776     #else
00777         return dynamic_cast<SaliencyMap*>(::IceProxy::Ice::Object::ice_batchOneway().get());
00778     #endif
00779     }
00780     
00781     ::IceInternal::ProxyHandle<SaliencyMap> ice_datagram() const
00782     {
00783     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00784         typedef ::IceProxy::Ice::Object _Base;
00785         return dynamic_cast<SaliencyMap*>(_Base::ice_datagram().get());
00786     #else
00787         return dynamic_cast<SaliencyMap*>(::IceProxy::Ice::Object::ice_datagram().get());
00788     #endif
00789     }
00790     
00791     ::IceInternal::ProxyHandle<SaliencyMap> ice_batchDatagram() const
00792     {
00793     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00794         typedef ::IceProxy::Ice::Object _Base;
00795         return dynamic_cast<SaliencyMap*>(_Base::ice_batchDatagram().get());
00796     #else
00797         return dynamic_cast<SaliencyMap*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
00798     #endif
00799     }
00800     
00801     ::IceInternal::ProxyHandle<SaliencyMap> ice_compress(bool __compress) const
00802     {
00803     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00804         typedef ::IceProxy::Ice::Object _Base;
00805         return dynamic_cast<SaliencyMap*>(_Base::ice_compress(__compress).get());
00806     #else
00807         return dynamic_cast<SaliencyMap*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
00808     #endif
00809     }
00810     
00811     ::IceInternal::ProxyHandle<SaliencyMap> ice_timeout(int __timeout) const
00812     {
00813     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00814         typedef ::IceProxy::Ice::Object _Base;
00815         return dynamic_cast<SaliencyMap*>(_Base::ice_timeout(__timeout).get());
00816     #else
00817         return dynamic_cast<SaliencyMap*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
00818     #endif
00819     }
00820     
00821     ::IceInternal::ProxyHandle<SaliencyMap> ice_connectionId(const std::string& __id) const
00822     {
00823     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00824         typedef ::IceProxy::Ice::Object _Base;
00825         return dynamic_cast<SaliencyMap*>(_Base::ice_connectionId(__id).get());
00826     #else
00827         return dynamic_cast<SaliencyMap*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
00828     #endif
00829     }
00830     
00831     static const ::std::string& ice_staticId();
00832 
00833 private: 
00834 
00835     virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
00836     virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
00837     virtual ::IceProxy::Ice::Object* __newInstance() const;
00838 };
00839 
00840 class VisualTracker : virtual public ::IceProxy::SimEvents::Events
00841 {
00842 public:
00843     
00844     ::IceInternal::ProxyHandle<VisualTracker> ice_context(const ::Ice::Context& __context) const
00845     {
00846     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00847         typedef ::IceProxy::Ice::Object _Base;
00848         return dynamic_cast<VisualTracker*>(_Base::ice_context(__context).get());
00849     #else
00850         return dynamic_cast<VisualTracker*>(::IceProxy::Ice::Object::ice_context(__context).get());
00851     #endif
00852     }
00853     
00854     ::IceInternal::ProxyHandle<VisualTracker> ice_adapterId(const std::string& __id) const
00855     {
00856     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00857         typedef ::IceProxy::Ice::Object _Base;
00858         return dynamic_cast<VisualTracker*>(_Base::ice_adapterId(__id).get());
00859     #else
00860         return dynamic_cast<VisualTracker*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
00861     #endif
00862     }
00863     
00864     ::IceInternal::ProxyHandle<VisualTracker> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
00865     {
00866     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00867         typedef ::IceProxy::Ice::Object _Base;
00868         return dynamic_cast<VisualTracker*>(_Base::ice_endpoints(__endpoints).get());
00869     #else
00870         return dynamic_cast<VisualTracker*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
00871     #endif
00872     }
00873     
00874     ::IceInternal::ProxyHandle<VisualTracker> ice_locatorCacheTimeout(int __timeout) const
00875     {
00876     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00877         typedef ::IceProxy::Ice::Object _Base;
00878         return dynamic_cast<VisualTracker*>(_Base::ice_locatorCacheTimeout(__timeout).get());
00879     #else
00880         return dynamic_cast<VisualTracker*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
00881     #endif
00882     }
00883     
00884     ::IceInternal::ProxyHandle<VisualTracker> ice_connectionCached(bool __cached) const
00885     {
00886     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00887         typedef ::IceProxy::Ice::Object _Base;
00888         return dynamic_cast<VisualTracker*>(_Base::ice_connectionCached(__cached).get());
00889     #else
00890         return dynamic_cast<VisualTracker*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
00891     #endif
00892     }
00893     
00894     ::IceInternal::ProxyHandle<VisualTracker> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
00895     {
00896     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00897         typedef ::IceProxy::Ice::Object _Base;
00898         return dynamic_cast<VisualTracker*>(_Base::ice_endpointSelection(__est).get());
00899     #else
00900         return dynamic_cast<VisualTracker*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
00901     #endif
00902     }
00903     
00904     ::IceInternal::ProxyHandle<VisualTracker> ice_secure(bool __secure) const
00905     {
00906     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00907         typedef ::IceProxy::Ice::Object _Base;
00908         return dynamic_cast<VisualTracker*>(_Base::ice_secure(__secure).get());
00909     #else
00910         return dynamic_cast<VisualTracker*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
00911     #endif
00912     }
00913     
00914     ::IceInternal::ProxyHandle<VisualTracker> ice_preferSecure(bool __preferSecure) const
00915     {
00916     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00917         typedef ::IceProxy::Ice::Object _Base;
00918         return dynamic_cast<VisualTracker*>(_Base::ice_preferSecure(__preferSecure).get());
00919     #else
00920         return dynamic_cast<VisualTracker*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
00921     #endif
00922     }
00923     
00924     ::IceInternal::ProxyHandle<VisualTracker> ice_router(const ::Ice::RouterPrx& __router) const
00925     {
00926     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00927         typedef ::IceProxy::Ice::Object _Base;
00928         return dynamic_cast<VisualTracker*>(_Base::ice_router(__router).get());
00929     #else
00930         return dynamic_cast<VisualTracker*>(::IceProxy::Ice::Object::ice_router(__router).get());
00931     #endif
00932     }
00933     
00934     ::IceInternal::ProxyHandle<VisualTracker> ice_locator(const ::Ice::LocatorPrx& __locator) const
00935     {
00936     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00937         typedef ::IceProxy::Ice::Object _Base;
00938         return dynamic_cast<VisualTracker*>(_Base::ice_locator(__locator).get());
00939     #else
00940         return dynamic_cast<VisualTracker*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
00941     #endif
00942     }
00943     
00944     ::IceInternal::ProxyHandle<VisualTracker> ice_collocationOptimized(bool __co) const
00945     {
00946     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00947         typedef ::IceProxy::Ice::Object _Base;
00948         return dynamic_cast<VisualTracker*>(_Base::ice_collocationOptimized(__co).get());
00949     #else
00950         return dynamic_cast<VisualTracker*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
00951     #endif
00952     }
00953     
00954     ::IceInternal::ProxyHandle<VisualTracker> ice_twoway() const
00955     {
00956     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00957         typedef ::IceProxy::Ice::Object _Base;
00958         return dynamic_cast<VisualTracker*>(_Base::ice_twoway().get());
00959     #else
00960         return dynamic_cast<VisualTracker*>(::IceProxy::Ice::Object::ice_twoway().get());
00961     #endif
00962     }
00963     
00964     ::IceInternal::ProxyHandle<VisualTracker> ice_oneway() const
00965     {
00966     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00967         typedef ::IceProxy::Ice::Object _Base;
00968         return dynamic_cast<VisualTracker*>(_Base::ice_oneway().get());
00969     #else
00970         return dynamic_cast<VisualTracker*>(::IceProxy::Ice::Object::ice_oneway().get());
00971     #endif
00972     }
00973     
00974     ::IceInternal::ProxyHandle<VisualTracker> ice_batchOneway() const
00975     {
00976     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00977         typedef ::IceProxy::Ice::Object _Base;
00978         return dynamic_cast<VisualTracker*>(_Base::ice_batchOneway().get());
00979     #else
00980         return dynamic_cast<VisualTracker*>(::IceProxy::Ice::Object::ice_batchOneway().get());
00981     #endif
00982     }
00983     
00984     ::IceInternal::ProxyHandle<VisualTracker> ice_datagram() const
00985     {
00986     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00987         typedef ::IceProxy::Ice::Object _Base;
00988         return dynamic_cast<VisualTracker*>(_Base::ice_datagram().get());
00989     #else
00990         return dynamic_cast<VisualTracker*>(::IceProxy::Ice::Object::ice_datagram().get());
00991     #endif
00992     }
00993     
00994     ::IceInternal::ProxyHandle<VisualTracker> ice_batchDatagram() const
00995     {
00996     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00997         typedef ::IceProxy::Ice::Object _Base;
00998         return dynamic_cast<VisualTracker*>(_Base::ice_batchDatagram().get());
00999     #else
01000         return dynamic_cast<VisualTracker*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
01001     #endif
01002     }
01003     
01004     ::IceInternal::ProxyHandle<VisualTracker> ice_compress(bool __compress) const
01005     {
01006     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01007         typedef ::IceProxy::Ice::Object _Base;
01008         return dynamic_cast<VisualTracker*>(_Base::ice_compress(__compress).get());
01009     #else
01010         return dynamic_cast<VisualTracker*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
01011     #endif
01012     }
01013     
01014     ::IceInternal::ProxyHandle<VisualTracker>
BrainObjects.h
