RobotBrainObjects.ice.C

00001 // **********************************************************************
00002 //
00003 // Copyright (c) 2003-2009 ZeroC, Inc. All rights reserved.
00004 //
00005 // This copy of Ice is licensed to you under the terms described in the
00006 // ICE_LICENSE file included in this distribution.
00007 //
00008 // **********************************************************************
00009 
00010 // Ice version 3.3.1
00011 // Generated from file `RobotBrainObjects.ice'
00012 
00013 #include <RobotBrainObjects.ice.H>
00014 #include <Ice/LocalException.h>
00015 #include <Ice/ObjectFactory.h>
00016 #include <Ice/BasicStream.h>
00017 #include <IceUtil/Iterator.h>
00018 #include <IceUtil/ScopedArray.h>
00019 
00020 #ifndef ICE_IGNORE_VERSION
00021 #   if ICE_INT_VERSION / 100 != 303
00022 #       error Ice version mismatch!
00023 #   endif
00024 #   if ICE_INT_VERSION % 100 > 50
00025 #       error Beta header file detected
00026 #   endif
00027 #   if ICE_INT_VERSION % 100 < 1
00028 #       error Ice patch level mismatch!
00029 #   endif
00030 #endif
00031 
00032 ::Ice::Object* IceInternal::upCast(::RobotBrainObjects::Retina* p) { return p; }
00033 ::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::RobotBrainObjects::Retina* p) { return p; }
00034 
00035 ::Ice::Object* IceInternal::upCast(::RobotBrainObjects::SaliencyModule* p) { return p; }
00036 ::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::RobotBrainObjects::SaliencyModule* p) { return p; }
00037 
00038 ::Ice::Object* IceInternal::upCast(::RobotBrainObjects::PrimaryMotorCortex* p) { return p; }
00039 ::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::RobotBrainObjects::PrimaryMotorCortex* p) { return p; }
00040 
00041 ::Ice::Object* IceInternal::upCast(::RobotBrainObjects::PrimarySomatosensoryCortex* p) { return p; }
00042 ::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::RobotBrainObjects::PrimarySomatosensoryCortex* p) { return p; }
00043 
00044 ::Ice::Object* IceInternal::upCast(::RobotBrainObjects::LateralGeniculateNucleus* p) { return p; }
00045 ::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::RobotBrainObjects::LateralGeniculateNucleus* p) { return p; }
00046 
00047 ::Ice::Object* IceInternal::upCast(::RobotBrainObjects::Hippocampus* p) { return p; }
00048 ::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::RobotBrainObjects::Hippocampus* p) { return p; }
00049 
00050 ::Ice::Object* IceInternal::upCast(::RobotBrainObjects::SupplementaryMotorArea* p) { return p; }
00051 ::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::RobotBrainObjects::SupplementaryMotorArea* p) { return p; }
00052 
00053 ::Ice::Object* IceInternal::upCast(::RobotBrainObjects::PrefrontalCortex* p) { return p; }
00054 ::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::RobotBrainObjects::PrefrontalCortex* p) { return p; }
00055 
00056 ::Ice::Object* IceInternal::upCast(::RobotBrainObjects::InferotemporalCortex* p) { return p; }
00057 ::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::RobotBrainObjects::InferotemporalCortex* p) { return p; }
00058 
00059 ::Ice::Object* IceInternal::upCast(::RobotBrainObjects::Observer* p) { return p; }
00060 ::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::RobotBrainObjects::Observer* p) { return p; }
00061 
00062 void
00063 RobotBrainObjects::__read(::IceInternal::BasicStream* __is, ::RobotBrainObjects::RetinaPrx& v)
00064 {
00065     ::Ice::ObjectPrx proxy;
00066     __is->read(proxy);
00067     if(!proxy)
00068     {
00069         v = 0;
00070     }
00071     else
00072     {
00073         v = new ::IceProxy::RobotBrainObjects::Retina;
00074         v->__copyFrom(proxy);
00075     }
00076 }
00077 
00078 void
00079 RobotBrainObjects::__read(::IceInternal::BasicStream* __is, ::RobotBrainObjects::SaliencyModulePrx& v)
00080 {
00081     ::Ice::ObjectPrx proxy;
00082     __is->read(proxy);
00083     if(!proxy)
00084     {
00085         v = 0;
00086     }
00087     else
00088     {
00089         v = new ::IceProxy::RobotBrainObjects::SaliencyModule;
00090         v->__copyFrom(proxy);
00091     }
00092 }
00093 
00094 void
00095 RobotBrainObjects::__read(::IceInternal::BasicStream* __is, ::RobotBrainObjects::PrimaryMotorCortexPrx& v)
00096 {
00097     ::Ice::ObjectPrx proxy;
00098     __is->read(proxy);
00099     if(!proxy)
00100     {
00101         v = 0;
00102     }
00103     else
00104     {
00105         v = new ::IceProxy::RobotBrainObjects::PrimaryMotorCortex;
00106         v->__copyFrom(proxy);
00107     }
00108 }
00109 
00110 void
00111 RobotBrainObjects::__read(::IceInternal::BasicStream* __is, ::RobotBrainObjects::PrimarySomatosensoryCortexPrx& v)
00112 {
00113     ::Ice::ObjectPrx proxy;
00114     __is->read(proxy);
00115     if(!proxy)
00116     {
00117         v = 0;
00118     }
00119     else
00120     {
00121         v = new ::IceProxy::RobotBrainObjects::PrimarySomatosensoryCortex;
00122         v->__copyFrom(proxy);
00123     }
00124 }
00125 
00126 void
00127 RobotBrainObjects::__read(::IceInternal::BasicStream* __is, ::RobotBrainObjects::LateralGeniculateNucleusPrx& v)
00128 {
00129     ::Ice::ObjectPrx proxy;
00130     __is->read(proxy);
00131     if(!proxy)
00132     {
00133         v = 0;
00134     }
00135     else
00136     {
00137         v = new ::IceProxy::RobotBrainObjects::LateralGeniculateNucleus;
00138         v->__copyFrom(proxy);
00139     }
00140 }
00141 
00142 void
00143 RobotBrainObjects::__read(::IceInternal::BasicStream* __is, ::RobotBrainObjects::HippocampusPrx& v)
00144 {
00145     ::Ice::ObjectPrx proxy;
00146     __is->read(proxy);
00147     if(!proxy)
00148     {
00149         v = 0;
00150     }
00151     else
00152     {
00153         v = new ::IceProxy::RobotBrainObjects::Hippocampus;
00154         v->__copyFrom(proxy);
00155     }
00156 }
00157 
00158 void
00159 RobotBrainObjects::__read(::IceInternal::BasicStream* __is, ::RobotBrainObjects::SupplementaryMotorAreaPrx& v)
00160 {
00161     ::Ice::ObjectPrx proxy;
00162     __is->read(proxy);
00163     if(!proxy)
00164     {
00165         v = 0;
00166     }
00167     else
00168     {
00169         v = new ::IceProxy::RobotBrainObjects::SupplementaryMotorArea;
00170         v->__copyFrom(proxy);
00171     }
00172 }
00173 
00174 void
00175 RobotBrainObjects::__read(::IceInternal::BasicStream* __is, ::RobotBrainObjects::PrefrontalCortexPrx& v)
00176 {
00177     ::Ice::ObjectPrx proxy;
00178     __is->read(proxy);
00179     if(!proxy)
00180     {
00181         v = 0;
00182     }
00183     else
00184     {
00185         v = new ::IceProxy::RobotBrainObjects::PrefrontalCortex;
00186         v->__copyFrom(proxy);
00187     }
00188 }
00189 
00190 void
00191 RobotBrainObjects::__read(::IceInternal::BasicStream* __is, ::RobotBrainObjects::InferotemporalCortexPrx& v)
00192 {
00193     ::Ice::ObjectPrx proxy;
00194     __is->read(proxy);
00195     if(!proxy)
00196     {
00197         v = 0;
00198     }
00199     else
00200     {
00201         v = new ::IceProxy::RobotBrainObjects::InferotemporalCortex;
00202         v->__copyFrom(proxy);
00203     }
00204 }
00205 
00206 void
00207 RobotBrainObjects::__read(::IceInternal::BasicStream* __is, ::RobotBrainObjects::ObserverPrx& v)
00208 {
00209     ::Ice::ObjectPrx proxy;
00210     __is->read(proxy);
00211     if(!proxy)
00212     {
00213         v = 0;
00214     }
00215     else
00216     {
00217         v = new ::IceProxy::RobotBrainObjects::Observer;
00218         v->__copyFrom(proxy);
00219     }
00220 }
00221 
00222 const ::std::string&
00223 IceProxy::RobotBrainObjects::Retina::ice_staticId()
00224 {
00225     return ::RobotBrainObjects::Retina::ice_staticId();
00226 }
00227 
00228 ::IceInternal::Handle< ::IceDelegateM::Ice::Object>
00229 IceProxy::RobotBrainObjects::Retina::__createDelegateM()
00230 {
00231     return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::RobotBrainObjects::Retina);
00232 }
00233 
00234 ::IceInternal::Handle< ::IceDelegateD::Ice::Object>
00235 IceProxy::RobotBrainObjects::Retina::__createDelegateD()
00236 {
00237     return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::RobotBrainObjects::Retina);
00238 }
00239 
00240 ::IceProxy::Ice::Object*
00241 IceProxy::RobotBrainObjects::Retina::__newInstance() const
00242 {
00243     return new Retina;
00244 }
00245 
00246 const ::std::string&
00247 IceProxy::RobotBrainObjects::SaliencyModule::ice_staticId()
00248 {
00249     return ::RobotBrainObjects::SaliencyModule::ice_staticId();
00250 }
00251 
00252 ::IceInternal::Handle< ::IceDelegateM::Ice::Object>
00253 IceProxy::RobotBrainObjects::SaliencyModule::__createDelegateM()
00254 {
00255     return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::RobotBrainObjects::SaliencyModule);
00256 }
00257 
00258 ::IceInternal::Handle< ::IceDelegateD::Ice::Object>
00259 IceProxy::RobotBrainObjects::SaliencyModule::__createDelegateD()
00260 {
00261     return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::RobotBrainObjects::SaliencyModule);
00262 }
00263 
00264 ::IceProxy::Ice::Object*
00265 IceProxy::RobotBrainObjects::SaliencyModule::__newInstance() const
00266 {
00267     return new SaliencyModule;
00268 }
00269 
00270 const ::std::string&
00271 IceProxy::RobotBrainObjects::PrimaryMotorCortex::ice_staticId()
00272 {
00273     return ::RobotBrainObjects::PrimaryMotorCortex::ice_staticId();
00274 }
00275 
00276 ::IceInternal::Handle< ::IceDelegateM::Ice::Object>
00277 IceProxy::RobotBrainObjects::PrimaryMotorCortex::__createDelegateM()
00278 {
00279     return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::RobotBrainObjects::PrimaryMotorCortex);
00280 }
00281 
00282 ::IceInternal::Handle< ::IceDelegateD::Ice::Object>
00283 IceProxy::RobotBrainObjects::PrimaryMotorCortex::__createDelegateD()
00284 {
00285     return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::RobotBrainObjects::PrimaryMotorCortex);
00286 }
00287 
00288 ::IceProxy::Ice::Object*
00289 IceProxy::RobotBrainObjects::PrimaryMotorCortex::__newInstance() const
00290 {
00291     return new PrimaryMotorCortex;
00292 }
00293 
00294 const ::std::string&
00295 IceProxy::RobotBrainObjects::PrimarySomatosensoryCortex::ice_staticId()
00296 {
00297     return ::RobotBrainObjects::PrimarySomatosensoryCortex::ice_staticId();
00298 }
00299 
00300 ::IceInternal::Handle< ::IceDelegateM::Ice::Object>
00301 IceProxy::RobotBrainObjects::PrimarySomatosensoryCortex::__createDelegateM()
00302 {
00303     return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::RobotBrainObjects::PrimarySomatosensoryCortex);
00304 }
00305 
00306 ::IceInternal::Handle< ::IceDelegateD::Ice::Object>
00307 IceProxy::RobotBrainObjects::PrimarySomatosensoryCortex::__createDelegateD()
00308 {
00309     return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::RobotBrainObjects::PrimarySomatosensoryCortex);
00310 }
00311 
00312 ::IceProxy::Ice::Object*
00313 IceProxy::RobotBrainObjects::PrimarySomatosensoryCortex::__newInstance() const
00314 {
00315     return new PrimarySomatosensoryCortex;
00316 }
00317 
00318 const ::std::string&
00319 IceProxy::RobotBrainObjects::LateralGeniculateNucleus::ice_staticId()
00320 {
00321     return ::RobotBrainObjects::LateralGeniculateNucleus::ice_staticId();
00322 }
00323 
00324 ::IceInternal::Handle< ::IceDelegateM::Ice::Object>
00325 IceProxy::RobotBrainObjects::LateralGeniculateNucleus::__createDelegateM()
00326 {
00327     return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::RobotBrainObjects::LateralGeniculateNucleus);
00328 }
00329 
00330 ::IceInternal::Handle< ::IceDelegateD::Ice::Object>
00331 IceProxy::RobotBrainObjects::LateralGeniculateNucleus::__createDelegateD()
00332 {
00333     return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::RobotBrainObjects::LateralGeniculateNucleus);
00334 }
00335 
00336 ::IceProxy::Ice::Object*
00337 IceProxy::RobotBrainObjects::LateralGeniculateNucleus::__newInstance() const
00338 {
00339     return new LateralGeniculateNucleus;
00340 }
00341 
00342 const ::std::string&
00343 IceProxy::RobotBrainObjects::Hippocampus::ice_staticId()
00344 {
00345     return ::RobotBrainObjects::Hippocampus::ice_staticId();
00346 }
00347 
00348 ::IceInternal::Handle< ::IceDelegateM::Ice::Object>
00349 IceProxy::RobotBrainObjects::Hippocampus::__createDelegateM()
00350 {
00351     return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::RobotBrainObjects::Hippocampus);
00352 }
00353 
00354 ::IceInternal::Handle< ::IceDelegateD::Ice::Object>
00355 IceProxy::RobotBrainObjects::Hippocampus::__createDelegateD()
00356 {
00357     return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::RobotBrainObjects::Hippocampus);
00358 }
00359 
00360 ::IceProxy::Ice::Object*
00361 IceProxy::RobotBrainObjects::Hippocampus::__newInstance() const
00362 {
00363     return new Hippocampus;
00364 }
00365 
00366 const ::std::string&
00367 IceProxy::RobotBrainObjects::SupplementaryMotorArea::ice_staticId()
00368 {
00369     return ::RobotBrainObjects::SupplementaryMotorArea::ice_staticId();
00370 }
00371 
00372 ::IceInternal::Handle< ::IceDelegateM::Ice::Object>
00373 IceProxy::RobotBrainObjects::SupplementaryMotorArea::__createDelegateM()
00374 {
00375     return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::RobotBrainObjects::SupplementaryMotorArea);
00376 }
00377 
00378 ::IceInternal::Handle< ::IceDelegateD::Ice::Object>
00379 IceProxy::RobotBrainObjects::SupplementaryMotorArea::__createDelegateD()
00380 {
00381     return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::RobotBrainObjects::SupplementaryMotorArea);
00382 }
00383 
00384 ::IceProxy::Ice::Object*
00385 IceProxy::RobotBrainObjects::SupplementaryMotorArea::__newInstance() const
00386 {
00387     return new SupplementaryMotorArea;
00388 }
00389 
00390 const ::std::string&
00391 IceProxy::RobotBrainObjects::PrefrontalCortex::ice_staticId()
00392 {
00393     return ::RobotBrainObjects::PrefrontalCortex::ice_staticId();
00394 }
00395 
00396 ::IceInternal::Handle< ::IceDelegateM::Ice::Object>
00397 IceProxy::RobotBrainObjects::PrefrontalCortex::__createDelegateM()
00398 {
00399     return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::RobotBrainObjects::PrefrontalCortex);
00400 }
00401 
00402 ::IceInternal::Handle< ::IceDelegateD::Ice::Object>
00403 IceProxy::RobotBrainObjects::PrefrontalCortex::__createDelegateD()
00404 {
00405     return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::RobotBrainObjects::PrefrontalCortex);
00406 }
00407 
00408 ::IceProxy::Ice::Object*
00409 IceProxy::RobotBrainObjects::PrefrontalCortex::__newInstance() const
00410 {
00411     return new PrefrontalCortex;
00412 }
00413 
00414 const ::std::string&
00415 IceProxy::RobotBrainObjects::InferotemporalCortex::ice_staticId()
00416 {
00417     return ::RobotBrainObjects::InferotemporalCortex::ice_staticId();
00418 }
00419 
00420 ::IceInternal::Handle< ::IceDelegateM::Ice::Object>
00421 IceProxy::RobotBrainObjects::InferotemporalCortex::__createDelegateM()
00422 {
00423     return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::RobotBrainObjects::InferotemporalCortex);
00424 }
00425 
00426 ::IceInternal::Handle< ::IceDelegateD::Ice::Object>
00427 IceProxy::RobotBrainObjects::InferotemporalCortex::__createDelegateD()
00428 {
00429     return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::RobotBrainObjects::InferotemporalCortex);
00430 }
00431 
00432 ::IceProxy::Ice::Object*
00433 IceProxy::RobotBrainObjects::InferotemporalCortex::__newInstance() const
00434 {
00435     return new InferotemporalCortex;
00436 }
00437 
00438 const ::std::string&
00439 IceProxy::RobotBrainObjects::Observer::ice_staticId()
00440 {
00441     return ::RobotBrainObjects::Observer::ice_staticId();
00442 }
00443 
00444 ::IceInternal::Handle< ::IceDelegateM::Ice::Object>
00445 IceProxy::RobotBrainObjects::Observer::__createDelegateM()
00446 {
00447     return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::RobotBrainObjects::Observer);
00448 }
00449 
00450 ::IceInternal::Handle< ::IceDelegateD::Ice::Object>
00451 IceProxy::RobotBrainObjects::Observer::__createDelegateD()
00452 {
00453     return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::RobotBrainObjects::Observer);
00454 }
00455 
00456 ::IceProxy::Ice::Object*
00457 IceProxy::RobotBrainObjects::Observer::__newInstance() const
00458 {
00459     return new Observer;
00460 }
00461 
00462 ::Ice::ObjectPtr
00463 RobotBrainObjects::Retina::ice_clone() const
00464 {
00465     throw ::Ice::CloneNotImplementedException(__FILE__, __LINE__);
00466     return 0; // to avoid a warning with some compilers
00467 }
00468 
00469 static const ::std::string __RobotBrainObjects__Retina_ids[3] =
00470 {
00471     "::Ice::Object",
00472     "::RobotBrainObjects::Retina",
00473     "::RobotSimEvents::Events"
00474 };
00475 
00476 bool
00477 RobotBrainObjects::Retina::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
00478 {
00479     return ::std::binary_search(__RobotBrainObjects__Retina_ids, __RobotBrainObjects__Retina_ids + 3, _s);
00480 }
00481 
00482 ::std::vector< ::std::string>
00483 RobotBrainObjects::Retina::ice_ids(const ::Ice::Current&) const
00484 {
00485     return ::std::vector< ::std::string>(&__RobotBrainObjects__Retina_ids[0], &__RobotBrainObjects__Retina_ids[3]);
00486 }
00487 
00488 const ::std::string&
00489 RobotBrainObjects::Retina::ice_id(const ::Ice::Current&) const
00490 {
00491     return __RobotBrainObjects__Retina_ids[1];
00492 }
00493 
00494 const ::std::string&
00495 RobotBrainObjects::Retina::ice_staticId()
00496 {
00497     return __RobotBrainObjects__Retina_ids[1];
00498 }
00499 
00500 static ::std::string __RobotBrainObjects__Retina_all[] =
00501 {
00502     "ice_id",
00503     "ice_ids",
00504     "ice_isA",
00505     "ice_ping",
00506     "updateMessage"
00507 };
00508 
00509 ::Ice::DispatchStatus
00510 RobotBrainObjects::Retina::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
00511 {
00512     ::std::pair< ::std::string*, ::std::string*> r = ::std::equal_range(__RobotBrainObjects__Retina_all, __RobotBrainObjects__Retina_all + 5, current.operation);
00513     if(r.first == r.second)
00514     {
00515         throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
00516     }
00517 
00518     switch(r.first - __RobotBrainObjects__Retina_all)
00519     {
00520         case 0:
00521         {
00522             return ___ice_id(in, current);
00523         }
00524         case 1:
00525         {
00526             return ___ice_ids(in, current);
00527         }
00528         case 2:
00529         {
00530             return ___ice_isA(in, current);
00531         }
00532         case 3:
00533         {
00534             return ___ice_ping(in, current);
00535         }
00536         case 4:
00537         {
00538             return ___updateMessage(in, current);
00539         }
00540     }
00541 
00542     assert(false);
00543     throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
00544 }
00545 
00546 void
00547 RobotBrainObjects::Retina::__write(::IceInternal::BasicStream* __os) const
00548 {
00549     __os->writeTypeId(ice_staticId());
00550     __os->startWriteSlice();
00551     __os->endWriteSlice();
00552 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00553     Object::__write(__os);
00554 #else
00555     ::Ice::Object::__write(__os);
00556 #endif
00557 }
00558 
00559 void
00560 RobotBrainObjects::Retina::__read(::IceInternal::BasicStream* __is, bool __rid)
00561 {
00562     if(__rid)
00563     {
00564         ::std::string myId;
00565         __is->readTypeId(myId);
00566     }
00567     __is->startReadSlice();
00568     __is->endReadSlice();
00569 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00570     Object::__read(__is, true);
00571 #else
00572     ::Ice::Object::__read(__is, true);
00573 #endif
00574 }
00575 
00576 void
00577 RobotBrainObjects::Retina::__write(const ::Ice::OutputStreamPtr&) const
00578 {
00579     Ice::MarshalException ex(__FILE__, __LINE__);
00580     ex.reason = "type RobotBrainObjects::Retina was not generated with stream support";
00581     throw ex;
00582 }
00583 
00584 void
00585 RobotBrainObjects::Retina::__read(const ::Ice::InputStreamPtr&, bool)
00586 {
00587     Ice::MarshalException ex(__FILE__, __LINE__);
00588     ex.reason = "type RobotBrainObjects::Retina was not generated with stream support";
00589     throw ex;
00590 }
00591 
00592 void
00593 RobotBrainObjects::__patch__RetinaPtr(void* __addr, ::Ice::ObjectPtr& v)
00594 {
00595     ::RobotBrainObjects::RetinaPtr* p = static_cast< ::RobotBrainObjects::RetinaPtr*>(__addr);
00596     assert(p);
00597     *p = ::RobotBrainObjects::RetinaPtr::dynamicCast(v);
00598     if(v && !*p)
00599     {
00600         IceInternal::Ex::throwUOE(::RobotBrainObjects::Retina::ice_staticId(), v->ice_id());
00601     }
00602 }
00603 
00604 bool
00605 RobotBrainObjects::operator==(const ::RobotBrainObjects::Retina& l, const ::RobotBrainObjects::Retina& r)
00606 {
00607     return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
00608 }
00609 
00610 bool
00611 RobotBrainObjects::operator<(const ::RobotBrainObjects::Retina& l, const ::RobotBrainObjects::Retina& r)
00612 {
00613     return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
00614 }
00615 
00616 ::Ice::ObjectPtr
00617 RobotBrainObjects::SaliencyModule::ice_clone() const
00618 {
00619     throw ::Ice::CloneNotImplementedException(__FILE__, __LINE__);
00620     return 0; // to avoid a warning with some compilers
00621 }
00622 
00623 static const ::std::string __RobotBrainObjects__SaliencyModule_ids[3] =
00624 {
00625     "::Ice::Object",
00626     "::RobotBrainObjects::SaliencyModule",
00627     "::RobotSimEvents::Events"
00628 };
00629 
00630 bool
00631 RobotBrainObjects::SaliencyModule::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
00632 {
00633     return ::std::binary_search(__RobotBrainObjects__SaliencyModule_ids, __RobotBrainObjects__SaliencyModule_ids + 3, _s);
00634 }
00635 
00636 ::std::vector< ::std::string>
00637 RobotBrainObjects::SaliencyModule::ice_ids(const ::Ice::Current&) const
00638 {
00639     return ::std::vector< ::std::string>(&__RobotBrainObjects__SaliencyModule_ids[0], &__RobotBrainObjects__SaliencyModule_ids[3]);
00640 }
00641 
00642 const ::std::string&
00643 RobotBrainObjects::SaliencyModule::ice_id(const ::Ice::Current&) const
00644 {
00645     return __RobotBrainObjects__SaliencyModule_ids[1];
00646 }
00647 
00648 const ::std::string&
00649 RobotBrainObjects::SaliencyModule::ice_staticId()
00650 {
00651     return __RobotBrainObjects__SaliencyModule_ids[1];
00652 }
00653 
00654 static ::std::string __RobotBrainObjects__SaliencyModule_all[] =
00655 {
00656     "ice_id",
00657     "ice_ids",
00658     "ice_isA",
00659     "ice_ping",
00660     "updateMessage"
00661 };
00662 
00663 ::Ice::DispatchStatus
00664 RobotBrainObjects::SaliencyModule::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
00665 {
00666     ::std::pair< ::std::string*, ::std::string*> r = ::std::equal_range(__RobotBrainObjects__SaliencyModule_all, __RobotBrainObjects__SaliencyModule_all + 5, current.operation);
00667     if(r.first == r.second)
00668     {
00669         throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
00670     }
00671 
00672     switch(r.first - __RobotBrainObjects__SaliencyModule_all)
00673     {
00674         case 0:
00675         {
00676             return ___ice_id(in, current);
00677         }
00678         case 1:
00679         {
00680             return ___ice_ids(in, current);
00681         }
00682         case 2:
00683         {
00684             return ___ice_isA(in, current);
00685         }
00686         case 3:
00687         {
00688             return ___ice_ping(in, current);
00689         }
00690         case 4:
00691         {
00692             return ___updateMessage(in, current);
00693         }
00694     }
00695 
00696     assert(false);
00697     throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
00698 }
00699 
00700 void
00701 RobotBrainObjects::SaliencyModule::__write(::IceInternal::BasicStream* __os) const
00702 {
00703     __os->writeTypeId(ice_staticId());
00704     __os->startWriteSlice();
00705     __os->endWriteSlice();
00706 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00707     Object::__write(__os);
00708 #else
00709     ::Ice::Object::__write(__os);
00710 #endif
00711 }
00712 
00713 void
00714 RobotBrainObjects::SaliencyModule::__read(::IceInternal::BasicStream* __is, bool __rid)
00715 {
00716     if(__rid)
00717     {
00718         ::std::string myId;
00719         __is->readTypeId(myId);
00720     }
00721     __is->startReadSlice();
00722     __is->endReadSlice();
00723 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00724     Object::__read(__is, true);
00725 #else
00726     ::Ice::Object::__read(__is, true);
00727 #endif
00728 }
00729 
00730 void
00731 RobotBrainObjects::SaliencyModule::__write(const ::Ice::OutputStreamPtr&) const
00732 {
00733     Ice::MarshalException ex(__FILE__, __LINE__);
00734     ex.reason = "type RobotBrainObjects::SaliencyModule was not generated with stream support";
00735     throw ex;
00736 }
00737 
00738 void
00739 RobotBrainObjects::SaliencyModule::__read(const ::Ice::InputStreamPtr&, bool)
00740 {
00741     Ice::MarshalException ex(__FILE__, __LINE__);
00742     ex.reason = "type RobotBrainObjects::SaliencyModule was not generated with stream support";
00743     throw ex;
00744 }
00745 
00746 void
00747 RobotBrainObjects::__patch__SaliencyModulePtr(void* __addr, ::Ice::ObjectPtr& v)
00748 {
00749     ::RobotBrainObjects::SaliencyModulePtr* p = static_cast< ::RobotBrainObjects::SaliencyModulePtr*>(__addr);
00750     assert(p);
00751     *p = ::RobotBrainObjects::SaliencyModulePtr::dynamicCast(v);
00752     if(v && !*p)
00753     {
00754         IceInternal::Ex::throwUOE(::RobotBrainObjects::SaliencyModule::ice_staticId(), v->ice_id());
00755     }
00756 }
00757 
00758 bool
00759 RobotBrainObjects::operator==(const ::RobotBrainObjects::SaliencyModule& l, const ::RobotBrainObjects::SaliencyModule& r)
00760 {
00761     return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
00762 }
00763 
00764 bool
00765 RobotBrainObjects::operator<(const ::RobotBrainObjects::SaliencyModule& l, const ::RobotBrainObjects::SaliencyModule& r)
00766 {
00767     return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
00768 }
00769 
00770 ::Ice::ObjectPtr
00771 RobotBrainObjects::PrimaryMotorCortex::ice_clone() const
00772 {
00773     throw ::Ice::CloneNotImplementedException(__FILE__, __LINE__);
00774     return 0; // to avoid a warning with some compilers
00775 }
00776 
00777 static const ::std::string __RobotBrainObjects__PrimaryMotorCortex_ids[3] =
00778 {
00779     "::Ice::Object",
00780     "::RobotBrainObjects::PrimaryMotorCortex",
00781     "::RobotSimEvents::Events"
00782 };
00783 
00784 bool
00785 RobotBrainObjects::PrimaryMotorCortex::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
00786 {
00787     return ::std::binary_search(__RobotBrainObjects__PrimaryMotorCortex_ids, __RobotBrainObjects__PrimaryMotorCortex_ids + 3, _s);
00788 }
00789 
00790 ::std::vector< ::std::string>
00791 RobotBrainObjects::PrimaryMotorCortex::ice_ids(const ::Ice::Current&) const
00792 {
00793     return ::std::vector< ::std::string>(&__RobotBrainObjects__PrimaryMotorCortex_ids[0], &__RobotBrainObjects__PrimaryMotorCortex_ids[3]);
00794 }
00795 
00796 const ::std::string&
00797 RobotBrainObjects::PrimaryMotorCortex::ice_id(const ::Ice::Current&) const
00798 {
00799     return __RobotBrainObjects__PrimaryMotorCortex_ids[1];
00800 }
00801 
00802 const ::std::string&
00803 RobotBrainObjects::PrimaryMotorCortex::ice_staticId()
00804 {
00805     return __RobotBrainObjects__PrimaryMotorCortex_ids[1];
00806 }
00807 
00808 static ::std::string __RobotBrainObjects__PrimaryMotorCortex_all[] =
00809 {
00810     "ice_id",
00811     "ice_ids",
00812     "ice_isA",
00813     "ice_ping",
00814     "updateMessage"
00815 };
00816 
00817 ::Ice::DispatchStatus
00818 RobotBrainObjects::PrimaryMotorCortex::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
00819 {
00820     ::std::pair< ::std::string*, ::std::string*> r = ::std::equal_range(__RobotBrainObjects__PrimaryMotorCortex_all, __RobotBrainObjects__PrimaryMotorCortex_all + 5, current.operation);
00821     if(r.first == r.second)
00822     {
00823         throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
00824     }
00825 
00826     switch(r.first - __RobotBrainObjects__PrimaryMotorCortex_all)
00827     {
00828         case 0:
00829         {
00830             return ___ice_id(in, current);
00831         }
00832         case 1:
00833         {
00834             return ___ice_ids(in, current);
00835         }
00836         case 2:
00837         {
00838             return ___ice_isA(in, current);
00839         }
00840         case 3:
00841         {
00842             return ___ice_ping(in, current);
00843         }
00844         case 4:
00845         {
00846             return ___updateMessage(in, current);
00847         }
00848     }
00849 
00850     assert(false);
00851     throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
00852 }
00853 
00854 void
00855 RobotBrainObjects::PrimaryMotorCortex::__write(::IceInternal::BasicStream* __os) const
00856 {
00857     __os->writeTypeId(ice_staticId());
00858     __os->startWriteSlice();
00859     __os->endWriteSlice();
00860 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00861     Object::__write(__os);
00862 #else
00863     ::Ice::Object::__write(__os);
00864 #endif
00865 }
00866 
00867 void
00868 RobotBrainObjects::PrimaryMotorCortex::__read(::IceInternal::BasicStream* __is, bool __rid)
00869 {
00870     if(__rid)
00871     {
00872         ::std::string myId;
00873         __is->readTypeId(myId);
00874     }
00875     __is->startReadSlice();
00876     __is->endReadSlice();
00877 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00878     Object::__read(__is, true);
00879 #else
00880     ::Ice::Object::__read(__is, true);
00881 #endif
00882 }
00883 
00884 void
00885 RobotBrainObjects::PrimaryMotorCortex::__write(const ::Ice::OutputStreamPtr&) const
00886 {
00887     Ice::MarshalException ex(__FILE__, __LINE__);
00888     ex.reason = "type RobotBrainObjects::PrimaryMotorCortex was not generated with stream support";
00889     throw ex;
00890 }
00891 
00892 void
00893 RobotBrainObjects::PrimaryMotorCortex::__read(const ::Ice::InputStreamPtr&, bool)
00894 {
00895     Ice::MarshalException ex(__FILE__, __LINE__);
00896     ex.reason = "type RobotBrainObjects::PrimaryMotorCortex was not generated with stream support";
00897     throw ex;
00898 }
00899 
00900 void
00901 RobotBrainObjects::__patch__PrimaryMotorCortexPtr(void* __addr, ::Ice::ObjectPtr& v)
00902 {
00903     ::RobotBrainObjects::PrimaryMotorCortexPtr* p = static_cast< ::RobotBrainObjects::PrimaryMotorCortexPtr*>(__addr);
00904     assert(p);
00905     *p = ::RobotBrainObjects::PrimaryMotorCortexPtr::dynamicCast(v);
00906     if(v && !*p)
00907     {
00908         IceInternal::Ex::throwUOE(::RobotBrainObjects::PrimaryMotorCortex::ice_staticId(), v->ice_id());
00909     }
00910 }
00911 
00912 bool
00913 RobotBrainObjects::operator==(const ::RobotBrainObjects::PrimaryMotorCortex& l, const ::RobotBrainObjects::PrimaryMotorCortex& r)
00914 {
00915     return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
00916 }
00917 
00918 bool
00919 RobotBrainObjects::operator<(const ::RobotBrainObjects::PrimaryMotorCortex& l, const ::RobotBrainObjects::PrimaryMotorCortex& r)
00920 {
00921     return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
00922 }
00923 
00924 ::Ice::ObjectPtr
00925 RobotBrainObjects::PrimarySomatosensoryCortex::ice_clone() const
00926 {
00927     throw ::Ice::CloneNotImplementedException(__FILE__, __LINE__);
00928     return 0; // to avoid a warning with some compilers
00929 }
00930 
00931 static const ::std::string __RobotBrainObjects__PrimarySomatosensoryCortex_ids[3] =
00932 {
00933     "::Ice::Object",
00934     "::RobotBrainObjects::PrimarySomatosensoryCortex",
00935     "::RobotSimEvents::Events"
00936 };
00937 
00938 bool
00939 RobotBrainObjects::PrimarySomatosensoryCortex::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
00940 {
00941     return ::std::binary_search(__RobotBrainObjects__PrimarySomatosensoryCortex_ids, __RobotBrainObjects__PrimarySomatosensoryCortex_ids + 3, _s);
00942 }
00943 
00944 ::std::vector< ::std::string>
00945 RobotBrainObjects::PrimarySomatosensoryCortex::ice_ids(const ::Ice::Current&) const
00946 {
00947     return ::std::vector< ::std::string>(&__RobotBrainObjects__PrimarySomatosensoryCortex_ids[0], &__RobotBrainObjects__PrimarySomatosensoryCortex_ids[3]);
00948 }
00949 
00950 const ::std::string&
00951 RobotBrainObjects::PrimarySomatosensoryCortex::ice_id(const ::Ice::Current&) const
00952 {
00953     return __RobotBrainObjects__PrimarySomatosensoryCortex_ids[1];
00954 }
00955 
00956 const ::std::string&
00957 RobotBrainObjects::PrimarySomatosensoryCortex::ice_staticId()
00958 {
00959     return __RobotBrainObjects__PrimarySomatosensoryCortex_ids[1];
00960 }
00961 
00962 static ::std::string __RobotBrainObjects__PrimarySomatosensoryCortex_all[] =
00963 {
00964     "ice_id",
00965     "ice_ids",
00966     "ice_isA",
00967     "ice_ping",
00968     "updateMessage"
00969 };
00970 
00971 ::Ice::DispatchStatus
00972 RobotBrainObjects::PrimarySomatosensoryCortex::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
00973 {
00974     ::std::pair< ::std::string*, ::std::string*> r = ::std::equal_range(__RobotBrainObjects__PrimarySomatosensoryCortex_all, __RobotBrainObjects__PrimarySomatosensoryCortex_all + 5, current.operation);
00975     if(r.first == r.second)
00976     {
00977         throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
00978     }
00979 
00980     switch(r.first - __RobotBrainObjects__PrimarySomatosensoryCortex_all)
00981     {
00982         case 0:
00983         {
00984             return ___ice_id(in, current);
00985         }
00986         case 1:
00987         {
00988             return ___ice_ids(in, current);
00989         }
00990         case 2:
00991         {
00992             return ___ice_isA(in, current);
00993         }
00994         case 3:
00995         {
00996             return ___ice_ping(in, current);
00997         }
00998         case 4:
00999         {
01000             return ___updateMessage(in, current);
01001         }
01002     }
01003 
01004     assert(false);
01005     throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
01006 }
01007 
01008 void
01009 RobotBrainObjects::PrimarySomatosensoryCortex::__write(::IceInternal::BasicStream* __os) const
01010 {
01011     __os->writeTypeId(ice_staticId());
01012     __os->startWriteSlice();
01013     __os->endWriteSlice();
01014 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01015     Object::__write(__os);
01016 #else
01017     ::Ice::Object::__write(__os);
01018 #endif
01019 }
01020 
01021 void
01022 RobotBrainObjects::PrimarySomatosensoryCortex::__read(::IceInternal::BasicStream* __is, bool __rid)
01023 {
01024     if(__rid)
01025     {
01026         ::std::string myId;
01027         __is->readTypeId(myId);
01028     }
01029     __is->startReadSlice();
01030     __is->endReadSlice();
01031 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01032     Object::__read(__is, true);
01033 #else
01034     ::Ice::Object::__read(__is, true);
01035 #endif
01036 }
01037 
01038 void
01039 RobotBrainObjects::PrimarySomatosensoryCortex::__write(const ::Ice::OutputStreamPtr&) const
01040 {
01041     Ice::MarshalException ex(__FILE__, __LINE__);
01042     ex.reason = "type RobotBrainObjects::PrimarySomatosensoryCortex was not generated with stream support";
01043     throw ex;
01044 }
01045 
01046 void
01047 RobotBrainObjects::PrimarySomatosensoryCortex::__read(const ::Ice::InputStreamPtr&, bool)
01048 {
01049     Ice::MarshalException ex(__FILE__, __LINE__);
01050     ex.reason = "type RobotBrainObjects::PrimarySomatosensoryCortex was not generated with stream support";
01051     throw ex;
01052 }
01053 
01054 void
01055 RobotBrainObjects::__patch__PrimarySomatosensoryCortexPtr(void* __addr, ::Ice::ObjectPtr& v)
01056 {
01057     ::RobotBrainObjects::PrimarySomatosensoryCortexPtr* p = static_cast< ::RobotBrainObjects::PrimarySomatosensoryCortexPtr*>(__addr);
01058     assert(p);
01059     *p = ::RobotBrainObjects::PrimarySomatosensoryCortexPtr::dynamicCast(v);
01060     if(v && !*p)
01061     {
01062         IceInternal::Ex::throwUOE(::RobotBrainObjects::PrimarySomatosensoryCortex::ice_staticId(), v->ice_id());
01063     }
01064 }
01065 
01066 bool
01067 RobotBrainObjects::operator==(const ::RobotBrainObjects::PrimarySomatosensoryCortex& l, const ::RobotBrainObjects::PrimarySomatosensoryCortex& r)
01068 {
01069     return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
01070 }
01071 
01072 bool
01073 RobotBrainObjects::operator<(const ::RobotBrainObjects::PrimarySomatosensoryCortex& l, const ::RobotBrainObjects::PrimarySomatosensoryCortex& r)
01074 {
01075     return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
01076 }
01077 
01078 ::Ice::ObjectPtr
01079 RobotBrainObjects::LateralGeniculateNucleus::ice_clone() const
01080 {
01081     throw ::Ice::CloneNotImplementedException(__FILE__, __LINE__);
01082     return 0; // to avoid a warning with some compilers
01083 }
01084 
01085 static const ::std::string __RobotBrainObjects__LateralGeniculateNucleus_ids[3] =
01086 {
01087     "::Ice::Object",
01088     "::RobotBrainObjects::LateralGeniculateNucleus",
01089     "::RobotSimEvents::Events"
01090 };
01091 
01092 bool
01093 RobotBrainObjects::LateralGeniculateNucleus::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
01094 {
01095     return ::std::binary_search(__RobotBrainObjects__LateralGeniculateNucleus_ids, __RobotBrainObjects__LateralGeniculateNucleus_ids + 3, _s);
01096 }
01097 
01098 ::std::vector< ::std::string>
01099 RobotBrainObjects::LateralGeniculateNucleus::ice_ids(const ::Ice::Current&) const
01100 {
01101     return ::std::vector< ::std::string>(&__RobotBrainObjects__LateralGeniculateNucleus_ids[0], &__RobotBrainObjects__LateralGeniculateNucleus_ids[3]);
01102 }
01103 
01104 const ::std::string&
01105 RobotBrainObjects::LateralGeniculateNucleus::ice_id(const ::Ice::Current&) const
01106 {
01107     return __RobotBrainObjects__LateralGeniculateNucleus_ids[1];
01108 }
01109 
01110 const ::std::string&
01111 RobotBrainObjects::LateralGeniculateNucleus::ice_staticId()
01112 {
01113     return __RobotBrainObjects__LateralGeniculateNucleus_ids[1];
01114 }
01115 
01116 static ::std::string __RobotBrainObjects__LateralGeniculateNucleus_all[] =
01117 {
01118     "ice_id",
01119     "ice_ids",
01120     "ice_isA",
01121     "ice_ping",
01122     "updateMessage"
01123 };
01124 
01125 ::Ice::DispatchStatus
01126 RobotBrainObjects::LateralGeniculateNucleus::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
01127 {
01128     ::std::pair< ::std::string*, ::std::string*> r = ::std::equal_range(__RobotBrainObjects__LateralGeniculateNucleus_all, __RobotBrainObjects__LateralGeniculateNucleus_all + 5, current.operation);
01129     if(r.first == r.second)
01130     {
01131         throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
01132     }
01133 
01134     switch(r.first - __RobotBrainObjects__LateralGeniculateNucleus_all)
01135     {
01136         case 0:
01137         {
01138             return ___ice_id(in, current);
01139         }
01140         case 1:
01141         {
01142             return ___ice_ids(in, current);
01143         }
01144         case 2:
01145         {
01146             return ___ice_isA(in, current);
01147         }
01148         case 3:
01149         {
01150             return ___ice_ping(in, current);
01151         }
01152         case 4:
01153         {
01154             return ___updateMessage(in, current);
01155         }
01156     }
01157 
01158     assert(false);
01159     throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
01160 }
01161 
01162 void
01163 RobotBrainObjects::LateralGeniculateNucleus::__write(::IceInternal::BasicStream* __os) const
01164 {
01165     __os->writeTypeId(ice_staticId());
01166     __os->startWriteSlice();
01167     __os->endWriteSlice();
01168 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01169     Object::__write(__os);
01170 #else
01171     ::Ice::Object::__write(__os);
01172 #endif
01173 }
01174 
01175 void
01176 RobotBrainObjects::LateralGeniculateNucleus::__read(::IceInternal::BasicStream* __is, bool __rid)
01177 {
01178     if(__rid)
01179     {
01180         ::std::string myId;
01181         __is->readTypeId(myId);
01182     }
01183     __is->startReadSlice();
01184     __is->endReadSlice();
01185 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01186     Object::__read(__is, true);
01187 #else
01188     ::Ice::Object::__read(__is, true);
01189 #endif
01190 }
01191 
01192 void
01193 RobotBrainObjects::LateralGeniculateNucleus::__write(const ::Ice::OutputStreamPtr&) const
01194 {
01195     Ice::MarshalException ex(__FILE__, __LINE__);
01196     ex.reason = "type RobotBrainObjects::LateralGeniculateNucleus was not generated with stream support";
01197     throw ex;
01198 }
01199 
01200 void
01201 RobotBrainObjects::LateralGeniculateNucleus::__read(const ::Ice::InputStreamPtr&, bool)
01202 {
01203     Ice::MarshalException ex(__FILE__, __LINE__);
01204     ex.reason = "type RobotBrainObjects::LateralGeniculateNucleus was not generated with stream support";
01205     throw ex;
01206 }
01207 
01208 void
01209 RobotBrainObjects::__patch__LateralGeniculateNucleusPtr(void* __addr, ::Ice::ObjectPtr& v)
01210 {
01211     ::RobotBrainObjects::LateralGeniculateNucleusPtr* p = static_cast< ::RobotBrainObjects::LateralGeniculateNucleusPtr*>(__addr);
01212     assert(p);
01213     *p = ::RobotBrainObjects::LateralGeniculateNucleusPtr::dynamicCast(v);
01214     if(v && !*p)
01215     {
01216         IceInternal::Ex::throwUOE(::RobotBrainObjects::LateralGeniculateNucleus::ice_staticId(), v->ice_id());
01217     }
01218 }
01219 
01220 bool
01221 RobotBrainObjects::operator==(const ::RobotBrainObjects::LateralGeniculateNucleus& l, const ::RobotBrainObjects::LateralGeniculateNucleus& r)
01222 {
01223     return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
01224 }
01225 
01226 bool
01227 RobotBrainObjects::operator<(const ::RobotBrainObjects::LateralGeniculateNucleus& l, const ::RobotBrainObjects::LateralGeniculateNucleus& r)
01228 {
01229     return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
01230 }
01231 
01232 ::Ice::ObjectPtr
01233 RobotBrainObjects::Hippocampus::ice_clone() const
01234 {
01235     throw ::Ice::CloneNotImplementedException(__FILE__, __LINE__);
01236     return 0; // to avoid a warning with some compilers
01237 }
01238 
01239 static const ::std::string __RobotBrainObjects__Hippocampus_ids[3] =
01240 {
01241     "::Ice::Object",
01242     "::RobotBrainObjects::Hippocampus",
01243     "::RobotSimEvents::Events"
01244 };
01245 
01246 bool
01247 RobotBrainObjects::Hippocampus::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
01248 {
01249     return ::std::binary_search(__RobotBrainObjects__Hippocampus_ids, __RobotBrainObjects__Hippocampus_ids + 3, _s);
01250 }
01251 
01252 ::std::vector< ::std::string>
01253 RobotBrainObjects::Hippocampus::ice_ids(const ::Ice::Current&) const
01254 {
01255     return ::std::vector< ::std::string>(&__RobotBrainObjects__Hippocampus_ids[0], &__RobotBrainObjects__Hippocampus_ids[3]);
01256 }
01257 
01258 const ::std::string&
01259 RobotBrainObjects::Hippocampus::ice_id(const ::Ice::Current&) const
01260 {
01261     return __RobotBrainObjects__Hippocampus_ids[1];
01262 }
01263 
01264 const ::std::string&
01265 RobotBrainObjects::Hippocampus::ice_staticId()
01266 {
01267     return __RobotBrainObjects__Hippocampus_ids[1];
01268 }
01269 
01270 static ::std::string __RobotBrainObjects__Hippocampus_all[] =
01271 {
01272     "ice_id",
01273     "ice_ids",
01274     "ice_isA",
01275     "ice_ping",
01276     "updateMessage"
01277 };
01278 
01279 ::Ice::DispatchStatus
01280 RobotBrainObjects::Hippocampus::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
01281 {
01282     ::std::pair< ::std::string*, ::std::string*> r = ::std::equal_range(__RobotBrainObjects__Hippocampus_all, __RobotBrainObjects__Hippocampus_all + 5, current.operation);
01283     if(r.first == r.second)
01284     {
01285         throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
01286     }
01287 
01288     switch(r.first - __RobotBrainObjects__Hippocampus_all)
01289     {
01290         case 0:
01291         {
01292             return ___ice_id(in, current);
01293         }
01294         case 1:
01295         {
01296             return ___ice_ids(in, current);
01297         }
01298         case 2:
01299         {
01300             return ___ice_isA(in, current);
01301         }
01302         case 3:
01303         {
01304             return ___ice_ping(in, current);
01305         }
01306         case 4:
01307         {
01308             return ___updateMessage(in, current);
01309         }
01310     }
01311 
01312     assert(false);
01313     throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
01314 }
01315 
01316 void
01317 RobotBrainObjects::Hippocampus::__write(::IceInternal::BasicStream* __os) const
01318 {
01319     __os->writeTypeId(ice_staticId());
01320     __os->startWriteSlice();
01321     __os->endWriteSlice();
01322 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01323     Object::__write(__os);
01324 #else
01325     ::Ice::Object::__write(__os);
01326 #endif
01327 }
01328 
01329 void
01330 RobotBrainObjects::Hippocampus::__read(::IceInternal::BasicStream* __is, bool __rid)
01331 {
01332     if(__rid)
01333     {
01334         ::std::string myId;
01335         __is->readTypeId(myId);
01336     }
01337     __is->startReadSlice();
01338     __is->endReadSlice();
01339 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01340     Object::__read(__is, true);
01341 #else
01342     ::Ice::Object::__read(__is, true);
01343 #endif
01344 }
01345 
01346 void
01347 RobotBrainObjects::Hippocampus::__write(const ::Ice::OutputStreamPtr&) const
01348 {
01349     Ice::MarshalException ex(__FILE__, __LINE__);
01350     ex.reason = "type RobotBrainObjects::Hippocampus was not generated with stream support";
01351     throw ex;
01352 }
01353 
01354 void
01355 RobotBrainObjects::Hippocampus::__read(const ::Ice::InputStreamPtr&, bool)
01356 {
01357     Ice::MarshalException ex(__FILE__, __LINE__);
01358     ex.reason = "type RobotBrainObjects::Hippocampus was not generated with stream support";
01359     throw ex;
01360 }
01361 
01362 void
01363 RobotBrainObjects::__patch__HippocampusPtr(void* __addr, ::Ice::ObjectPtr& v)
01364 {
01365     ::RobotBrainObjects::HippocampusPtr* p = static_cast< ::RobotBrainObjects::HippocampusPtr*>(__addr);
01366     assert(p);
01367     *p = ::RobotBrainObjects::HippocampusPtr::dynamicCast(v);
01368     if(v && !*p)
01369     {
01370         IceInternal::Ex::throwUOE(::RobotBrainObjects::Hippocampus::ice_staticId(), v->ice_id());
01371     }
01372 }
01373 
01374 bool
01375 RobotBrainObjects::operator==(const ::RobotBrainObjects::Hippocampus& l, const ::RobotBrainObjects::Hippocampus& r)
01376 {
01377     return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
01378 }
01379 
01380 bool
01381 RobotBrainObjects::operator<(const ::RobotBrainObjects::Hippocampus& l, const ::RobotBrainObjects::Hippocampus& r)
01382 {
01383     return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
01384 }
01385 
01386 ::Ice::ObjectPtr
01387 RobotBrainObjects::SupplementaryMotorArea::ice_clone() const
01388 {
01389     throw ::Ice::CloneNotImplementedException(__FILE__, __LINE__);
01390     return 0; // to avoid a warning with some compilers
01391 }
01392 
01393 static const ::std::string __RobotBrainObjects__SupplementaryMotorArea_ids[3] =
01394 {
01395     "::Ice::Object",
01396     "::RobotBrainObjects::SupplementaryMotorArea",
01397     "::RobotSimEvents::Events"
01398 };
01399 
01400 bool
01401 RobotBrainObjects::SupplementaryMotorArea::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
01402 {
01403     return ::std::binary_search(__RobotBrainObjects__SupplementaryMotorArea_ids, __RobotBrainObjects__SupplementaryMotorArea_ids + 3, _s);
01404 }
01405 
01406 ::std::vector< ::std::string>
01407 RobotBrainObjects::SupplementaryMotorArea::ice_ids(const ::Ice::Current&) const
01408 {
01409     return ::std::vector< ::std::string>(&__RobotBrainObjects__SupplementaryMotorArea_ids[0], &__RobotBrainObjects__SupplementaryMotorArea_ids[3]);
01410 }
01411 
01412 const ::std::string&
01413 RobotBrainObjects::SupplementaryMotorArea::ice_id(const ::Ice::Current&) const
01414 {
01415     return __RobotBrainObjects__SupplementaryMotorArea_ids[1];
01416 }
01417 
01418 const ::std::string&
01419 RobotBrainObjects::SupplementaryMotorArea::ice_staticId()
01420 {
01421     return __RobotBrainObjects__SupplementaryMotorArea_ids[1];
01422 }
01423 
01424 static ::std::string __RobotBrainObjects__SupplementaryMotorArea_all[] =
01425 {
01426     "ice_id",
01427     "ice_ids",
01428     "ice_isA",
01429     "ice_ping",
01430     "updateMessage"
01431 };
01432 
01433 ::Ice::DispatchStatus
01434 RobotBrainObjects::SupplementaryMotorArea::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
01435 {
01436     ::std::pair< ::std::string*, ::std::string*> r = ::std::equal_range(__RobotBrainObjects__SupplementaryMotorArea_all, __RobotBrainObjects__SupplementaryMotorArea_all + 5, current.operation);
01437     if(r.first == r.second)
01438     {
01439         throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
01440     }
01441 
01442     switch(r.first - __RobotBrainObjects__SupplementaryMotorArea_all)
01443     {
01444         case 0:
01445         {
01446             return ___ice_id(in, current);
01447         }
01448         case 1:
01449         {
01450             return ___ice_ids(in, current);
01451         }
01452         case 2:
01453         {
01454             return ___ice_isA(in, current);
01455         }
01456         case 3:
01457         {
01458             return ___ice_ping(in, current);
01459         }
01460         case 4:
01461         {
01462             return ___updateMessage(in, current);
01463         }
01464     }
01465 
01466     assert(false);
01467     throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
01468 }
01469 
01470 void
01471 RobotBrainObjects::SupplementaryMotorArea::__write(::IceInternal::BasicStream* __os) const
01472 {
01473     __os->writeTypeId(ice_staticId());
01474     __os->startWriteSlice();
01475     __os->endWriteSlice();
01476 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01477     Object::__write(__os);
01478 #else
01479     ::Ice::Object::__write(__os);
01480 #endif
01481 }
01482 
01483 void
01484 RobotBrainObjects::SupplementaryMotorArea::__read(::IceInternal::BasicStream* __is, bool __rid)
01485 {
01486     if(__rid)
01487     {
01488         ::std::string myId;
01489         __is->readTypeId(myId);
01490     }
01491     __is->startReadSlice();
01492     __is->endReadSlice();
01493 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01494     Object::__read(__is, true);
01495 #else
01496     ::Ice::Object::__read(__is, true);
01497 #endif
01498 }
01499 
01500 void
01501 RobotBrainObjects::SupplementaryMotorArea::__write(const ::Ice::OutputStreamPtr&) const
01502 {
01503     Ice::MarshalException ex(__FILE__, __LINE__);
01504     ex.reason = "type RobotBrainObjects::SupplementaryMotorArea was not generated with stream support";
01505     throw ex;
01506 }
01507 
01508 void
01509 RobotBrainObjects::SupplementaryMotorArea::__read(const ::Ice::InputStreamPtr&, bool)
01510 {
01511     Ice::MarshalException ex(__FILE__, __LINE__);
01512     ex.reason = "type RobotBrainObjects::SupplementaryMotorArea was not generated with stream support";
01513     throw ex;
01514 }
01515 
01516 void
01517 RobotBrainObjects::__patch__SupplementaryMotorAreaPtr(void* __addr, ::Ice::ObjectPtr& v)
01518 {
01519     ::RobotBrainObjects::SupplementaryMotorAreaPtr* p = static_cast< ::RobotBrainObjects::SupplementaryMotorAreaPtr*>(__addr);
01520     assert(p);
01521     *p = ::RobotBrainObjects::SupplementaryMotorAreaPtr::dynamicCast(v);
01522     if(v && !*p)
01523     {
01524         IceInternal::Ex::throwUOE(::RobotBrainObjects::SupplementaryMotorArea::ice_staticId(), v->ice_id());
01525     }
01526 }
01527 
01528 bool
01529 RobotBrainObjects::operator==(const ::RobotBrainObjects::SupplementaryMotorArea& l, const ::RobotBrainObjects::SupplementaryMotorArea& r)
01530 {
01531     return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
01532 }
01533 
01534 bool
01535 RobotBrainObjects::operator<(const ::RobotBrainObjects::SupplementaryMotorArea& l, const ::RobotBrainObjects::SupplementaryMotorArea& r)
01536 {
01537     return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
01538 }
01539 
01540 ::Ice::ObjectPtr
01541 RobotBrainObjects::PrefrontalCortex::ice_clone() const
01542 {
01543     throw ::Ice::CloneNotImplementedException(__FILE__, __LINE__);
01544     return 0; // to avoid a warning with some compilers
01545 }
01546 
01547 static const ::std::string __RobotBrainObjects__PrefrontalCortex_ids[3] =
01548 {
01549     "::Ice::Object",
01550     "::RobotBrainObjects::PrefrontalCortex",
01551     "::RobotSimEvents::Events"
01552 };
01553 
01554 bool
01555 RobotBrainObjects::PrefrontalCortex::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
01556 {
01557     return ::std::binary_search(__RobotBrainObjects__PrefrontalCortex_ids, __RobotBrainObjects__PrefrontalCortex_ids + 3, _s);
01558 }
01559 
01560 ::std::vector< ::std::string>
01561 RobotBrainObjects::PrefrontalCortex::ice_ids(const ::Ice::Current&) const
01562 {
01563     return ::std::vector< ::std::string>(&__RobotBrainObjects__PrefrontalCortex_ids[0], &__RobotBrainObjects__PrefrontalCortex_ids[3]);
01564 }
01565 
01566 const ::std::string&
01567 RobotBrainObjects::PrefrontalCortex::ice_id(const ::Ice::Current&) const
01568 {
01569     return __RobotBrainObjects__PrefrontalCortex_ids[1];
01570 }
01571 
01572 const ::std::string&
01573 RobotBrainObjects::PrefrontalCortex::ice_staticId()
01574 {
01575     return __RobotBrainObjects__PrefrontalCortex_ids[1];
01576 }
01577 
01578 static ::std::string __RobotBrainObjects__PrefrontalCortex_all[] =
01579 {
01580     "ice_id",
01581     "ice_ids",
01582     "ice_isA",
01583     "ice_ping",
01584     "updateMessage"
01585 };
01586 
01587 ::Ice::DispatchStatus
01588 RobotBrainObjects::PrefrontalCortex::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
01589 {
01590     ::std::pair< ::std::string*, ::std::string*> r = ::std::equal_range(__RobotBrainObjects__PrefrontalCortex_all, __RobotBrainObjects__PrefrontalCortex_all + 5, current.operation);
01591     if(r.first == r.second)
01592     {
01593         throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
01594     }
01595 
01596     switch(r.first - __RobotBrainObjects__PrefrontalCortex_all)
01597     {
01598         case 0:
01599         {
01600             return ___ice_id(in, current);
01601         }
01602         case 1:
01603         {
01604             return ___ice_ids(in, current);
01605         }
01606         case 2:
01607         {
01608             return ___ice_isA(in, current);
01609         }
01610         case 3:
01611         {
01612             return ___ice_ping(in, current);
01613         }
01614         case 4:
01615         {
01616             return ___updateMessage(in, current);
01617         }
01618     }
01619 
01620     assert(false);
01621     throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
01622 }
01623 
01624 void
01625 RobotBrainObjects::PrefrontalCortex::__write(::IceInternal::BasicStream* __os) const
01626 {
01627     __os->writeTypeId(ice_staticId());
01628     __os->startWriteSlice();
01629     __os->endWriteSlice();
01630 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01631     Object::__write(__os);
01632 #else
01633     ::Ice::Object::__write(__os);
01634 #endif
01635 }
01636 
01637 void
01638 RobotBrainObjects::PrefrontalCortex::__read(::IceInternal::BasicStream* __is, bool __rid)
01639 {
01640     if(__rid)
01641     {
01642         ::std::string myId;
01643         __is->readTypeId(myId);
01644     }
01645     __is->startReadSlice();
01646     __is->endReadSlice();
01647 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01648     Object::__read(__is, true);
01649 #else
01650     ::Ice::Object::__read(__is, true);
01651 #endif
01652 }
01653 
01654 void
01655 RobotBrainObjects::PrefrontalCortex::__write(const ::Ice::OutputStreamPtr&) const
01656 {
01657     Ice::MarshalException ex(__FILE__, __LINE__);
01658     ex.reason = "type RobotBrainObjects::PrefrontalCortex was not generated with stream support";
01659     throw ex;
01660 }
01661 
01662 void
01663 RobotBrainObjects::PrefrontalCortex::__read(const ::Ice::InputStreamPtr&, bool)
01664 {
01665     Ice::MarshalException ex(__FILE__, __LINE__);
01666     ex.reason = "type RobotBrainObjects::PrefrontalCortex was not generated with stream support";
01667     throw ex;
01668 }
01669 
01670 void
01671 RobotBrainObjects::__patch__PrefrontalCortexPtr(void* __addr, ::Ice::ObjectPtr& v)
01672 {
01673     ::RobotBrainObjects::PrefrontalCortexPtr* p = static_cast< ::RobotBrainObjects::PrefrontalCortexPtr*>(__addr);
01674     assert(p);
01675     *p = ::RobotBrainObjects::PrefrontalCortexPtr::dynamicCast(v);
01676     if(v && !*p)
01677     {
01678         IceInternal::Ex::throwUOE(::RobotBrainObjects::PrefrontalCortex::ice_staticId(), v->ice_id());
01679     }
01680 }
01681 
01682 bool
01683 RobotBrainObjects::operator==(const ::RobotBrainObjects::PrefrontalCortex& l, const ::RobotBrainObjects::PrefrontalCortex& r)
01684 {
01685     return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
01686 }
01687 
01688 bool
01689 RobotBrainObjects::operator<(const ::RobotBrainObjects::PrefrontalCortex& l, const ::RobotBrainObjects::PrefrontalCortex& r)
01690 {
01691     return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
01692 }
01693 
01694 ::Ice::ObjectPtr
01695 RobotBrainObjects::InferotemporalCortex::ice_clone() const
01696 {
01697     throw ::Ice::CloneNotImplementedException(__FILE__, __LINE__);
01698     return 0; // to avoid a warning with some compilers
01699 }
01700 
01701 static const ::std::string __RobotBrainObjects__InferotemporalCortex_ids[3] =
01702 {
01703     "::Ice::Object",
01704     "::RobotBrainObjects::InferotemporalCortex",
01705     "::RobotSimEvents::Events"
01706 };
01707 
01708 bool
01709 RobotBrainObjects::InferotemporalCortex::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
01710 {
01711     return ::std::binary_search(__RobotBrainObjects__InferotemporalCortex_ids, __RobotBrainObjects__InferotemporalCortex_ids + 3, _s);
01712 }
01713 
01714 ::std::vector< ::std::string>
01715 RobotBrainObjects::InferotemporalCortex::ice_ids(const ::Ice::Current&) const
01716 {
01717     return ::std::vector< ::std::string>(&__RobotBrainObjects__InferotemporalCortex_ids[0], &__RobotBrainObjects__InferotemporalCortex_ids[3]);
01718 }
01719 
01720 const ::std::string&
01721 RobotBrainObjects::InferotemporalCortex::ice_id(const ::Ice::Current&) const
01722 {
01723     return __RobotBrainObjects__InferotemporalCortex_ids[1];
01724 }
01725 
01726 const ::std::string&
01727 RobotBrainObjects::InferotemporalCortex::ice_staticId()
01728 {
01729     return __RobotBrainObjects__InferotemporalCortex_ids[1];
01730 }
01731 
01732 static ::std::string __RobotBrainObjects__InferotemporalCortex_all[] =
01733 {
01734     "ice_id",
01735     "ice_ids",
01736     "ice_isA",
01737     "ice_ping",
01738     "updateMessage"
01739 };
01740 
01741 ::Ice::DispatchStatus
01742 RobotBrainObjects::InferotemporalCortex::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
01743 {
01744     ::std::pair< ::std::string*, ::std::string*> r = ::std::equal_range(__RobotBrainObjects__InferotemporalCortex_all, __RobotBrainObjects__InferotemporalCortex_all + 5, current.operation);
01745     if(r.first == r.second)
01746     {
01747         throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
01748     }
01749 
01750     switch(r.first - __RobotBrainObjects__InferotemporalCortex_all)
01751     {
01752         case 0:
01753         {
01754             return ___ice_id(in, current);
01755         }
01756         case 1:
01757         {
01758             return ___ice_ids(in, current);
01759         }
01760         case 2:
01761         {
01762             return ___ice_isA(in, current);
01763         }
01764         case 3:
01765         {
01766             return ___ice_ping(in, current);
01767         }
01768         case 4:
01769         {
01770             return ___updateMessage(in, current);
01771         }
01772     }
01773 
01774     assert(false);
01775     throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
01776 }
01777 
01778 void
01779 RobotBrainObjects::InferotemporalCortex::__write(::IceInternal::BasicStream* __os) const
01780 {
01781     __os->writeTypeId(ice_staticId());
01782     __os->startWriteSlice();
01783     __os->endWriteSlice();
01784 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01785     Object::__write(__os);
01786 #else
01787     ::Ice::Object::__write(__os);
01788 #endif
01789 }
01790 
01791 void
01792 RobotBrainObjects::InferotemporalCortex::__read(::IceInternal::BasicStream* __is, bool __rid)
01793 {
01794     if(__rid)
01795     {
01796         ::std::string myId;
01797         __is->readTypeId(myId);
01798     }
01799     __is->startReadSlice();
01800     __is->endReadSlice();
01801 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01802     Object::__read(__is, true);
01803 #else
01804     ::Ice::Object::__read(__is, true);
01805 #endif
01806 }
01807 
01808 void
01809 RobotBrainObjects::InferotemporalCortex::__write(const ::Ice::OutputStreamPtr&) const
01810 {
01811     Ice::MarshalException ex(__FILE__, __LINE__);
01812     ex.reason = "type RobotBrainObjects::InferotemporalCortex was not generated with stream support";
01813     throw ex;
01814 }
01815 
01816 void
01817 RobotBrainObjects::InferotemporalCortex::__read(const ::Ice::InputStreamPtr&, bool)
01818 {
01819     Ice::MarshalException ex(__FILE__, __LINE__);
01820     ex.reason = "type RobotBrainObjects::InferotemporalCortex was not generated with stream support";
01821     throw ex;
01822 }
01823 
01824 void
01825 RobotBrainObjects::__patch__InferotemporalCortexPtr(void* __addr, ::Ice::ObjectPtr& v)
01826 {
01827     ::RobotBrainObjects::InferotemporalCortexPtr* p = static_cast< ::RobotBrainObjects::InferotemporalCortexPtr*>(__addr);
01828     assert(p);
01829     *p = ::RobotBrainObjects::InferotemporalCortexPtr::dynamicCast(v);
01830     if(v && !*p)
01831     {
01832         IceInternal::Ex::throwUOE(::RobotBrainObjects::InferotemporalCortex::ice_staticId(), v->ice_id());
01833     }
01834 }
01835 
01836 bool
01837 RobotBrainObjects::operator==(const ::RobotBrainObjects::InferotemporalCortex& l, const ::RobotBrainObjects::InferotemporalCortex& r)
01838 {
01839     return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
01840 }
01841 
01842 bool
01843 RobotBrainObjects::operator<(const ::RobotBrainObjects::InferotemporalCortex& l, const ::RobotBrainObjects::InferotemporalCortex& r)
01844 {
01845     return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
01846 }
01847 
01848 ::Ice::ObjectPtr
01849 RobotBrainObjects::Observer::ice_clone() const
01850 {
01851     throw ::Ice::CloneNotImplementedException(__FILE__, __LINE__);
01852     return 0; // to avoid a warning with some compilers
01853 }
01854 
01855 static const ::std::string __RobotBrainObjects__Observer_ids[3] =
01856 {
01857     "::Ice::Object",
01858     "::RobotBrainObjects::Observer",
01859     "::RobotSimEvents::Events"
01860 };
01861 
01862 bool
01863 RobotBrainObjects::Observer::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
01864 {
01865     return ::std::binary_search(__RobotBrainObjects__Observer_ids, __RobotBrainObjects__Observer_ids + 3, _s);
01866 }
01867 
01868 ::std::vector< ::std::string>
01869 RobotBrainObjects::Observer::ice_ids(const ::Ice::Current&) const
01870 {
01871     return ::std::vector< ::std::string>(&__RobotBrainObjects__Observer_ids[0], &__RobotBrainObjects__Observer_ids[3]);
01872 }
01873 
01874 const ::std::string&
01875 RobotBrainObjects::Observer::ice_id(const ::Ice::Current&) const
01876 {
01877     return __RobotBrainObjects__Observer_ids[1];
01878 }
01879 
01880 const ::std::string&
01881 RobotBrainObjects::Observer::ice_staticId()
01882 {
01883     return __RobotBrainObjects__Observer_ids[1];
01884 }
01885 
01886 static ::std::string __RobotBrainObjects__Observer_all[] =
01887 {
01888     "ice_id",
01889     "ice_ids",
01890     "ice_isA",
01891     "ice_ping",
01892     "updateMessage"
01893 };
01894 
01895 ::Ice::DispatchStatus
01896 RobotBrainObjects::Observer::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
01897 {
01898     ::std::pair< ::std::string*, ::std::string*> r = ::std::equal_range(__RobotBrainObjects__Observer_all, __RobotBrainObjects__Observer_all + 5, current.operation);
01899     if(r.first == r.second)
01900     {
01901         throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
01902     }
01903 
01904     switch(r.first - __RobotBrainObjects__Observer_all)
01905     {
01906         case 0:
01907         {
01908             return ___ice_id(in, current);
01909         }
01910         case 1:
01911         {
01912             return ___ice_ids(in, current);
01913         }
01914         case 2:
01915         {
01916             return ___ice_isA(in, current);
01917         }
01918         case 3:
01919         {
01920             return ___ice_ping(in, current);
01921         }
01922         case 4:
01923         {
01924             return ___updateMessage(in, current);
01925         }
01926     }
01927 
01928     assert(false);
01929     throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
01930 }
01931 
01932 void
01933 RobotBrainObjects::Observer::__write(::IceInternal::BasicStream* __os) const
01934 {
01935     __os->writeTypeId(ice_staticId());
01936     __os->startWriteSlice();
01937     __os->endWriteSlice();
01938 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01939     Object::__write(__os);
01940 #else
01941     ::Ice::Object::__write(__os);
01942 #endif
01943 }
01944 
01945 void
01946 RobotBrainObjects::Observer::__read(::IceInternal::BasicStream* __is, bool __rid)
01947 {
01948     if(__rid)
01949     {
01950         ::std::string myId;
01951         __is->readTypeId(myId);
01952     }
01953     __is->startReadSlice();
01954     __is->endReadSlice();
01955 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01956     Object::__read(__is, true);
01957 #else
01958     ::Ice::Object::__read(__is, true);
01959 #endif
01960 }
01961 
01962 void
01963 RobotBrainObjects::Observer::__write(const ::Ice::OutputStreamPtr&) const
01964 {
01965     Ice::MarshalException ex(__FILE__, __LINE__);
01966     ex.reason = "type RobotBrainObjects::Observer was not generated with stream support";
01967     throw ex;
01968 }
01969 
01970 void
01971 RobotBrainObjects::Observer::__read(const ::Ice::InputStreamPtr&, bool)
01972 {
01973     Ice::MarshalException ex(__FILE__, __LINE__);
01974     ex.reason = "type RobotBrainObjects::Observer was not generated with stream support";
01975     throw ex;
01976 }
01977 
01978 void
01979 RobotBrainObjects::__patch__ObserverPtr(void* __addr, ::Ice::ObjectPtr& v)
01980 {
01981     ::RobotBrainObjects::ObserverPtr* p = static_cast< ::RobotBrainObjects::ObserverPtr*>(__addr);
01982     assert(p);
01983     *p = ::RobotBrainObjects::ObserverPtr::dynamicCast(v);
01984     if(v && !*p)
01985     {
01986         IceInternal::Ex::throwUOE(::RobotBrainObjects::Observer::ice_staticId(), v->ice_id());
01987     }
01988 }
01989 
01990 bool
01991 RobotBrainObjects::operator==(const ::RobotBrainObjects::Observer& l, const ::RobotBrainObjects::Observer& r)
01992 {
01993     return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
01994 }
01995 
01996 bool
01997 RobotBrainObjects::operator<(const ::RobotBrainObjects::Observer& l, const ::RobotBrainObjects::Observer& r)
01998 {
01999     return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
02000 }
Generated on Sun May 8 08:40:45 2011 for iLab Neuromorphic Vision Toolkit by  doxygen 1.6.3