BeobotEvents.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 `BeobotEvents.ice'
00012 
00013 #include <BeobotEvents.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(::BeobotEvents::MotorMessage* p) { return p; }
00033 ::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::BeobotEvents::MotorMessage* p) { return p; }
00034 
00035 ::Ice::Object* IceInternal::upCast(::BeobotEvents::MotorRequest* p) { return p; }
00036 ::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::BeobotEvents::MotorRequest* p) { return p; }
00037 
00038 ::Ice::Object* IceInternal::upCast(::BeobotEvents::CornerMotorRequest* p) { return p; }
00039 ::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::BeobotEvents::CornerMotorRequest* p) { return p; }
00040 
00041 ::Ice::Object* IceInternal::upCast(::BeobotEvents::CornerLocationMessage* p) { return p; }
00042 ::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::BeobotEvents::CornerLocationMessage* p) { return p; }
00043 
00044 ::Ice::Object* IceInternal::upCast(::BeobotEvents::SonarMessage* p) { return p; }
00045 ::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::BeobotEvents::SonarMessage* p) { return p; }
00046 
00047 ::Ice::Object* IceInternal::upCast(::BeobotEvents::GPSMessage* p) { return p; }
00048 ::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::BeobotEvents::GPSMessage* p) { return p; }
00049 
00050 ::Ice::Object* IceInternal::upCast(::BeobotEvents::LRFMessage* p) { return p; }
00051 ::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::BeobotEvents::LRFMessage* p) { return p; }
00052 
00053 ::Ice::Object* IceInternal::upCast(::BeobotEvents::SLAMMessage* p) { return p; }
00054 ::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::BeobotEvents::SLAMMessage* p) { return p; }
00055 
00056 ::Ice::Object* IceInternal::upCast(::BeobotEvents::IMUMessage* p) { return p; }
00057 ::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::BeobotEvents::IMUMessage* p) { return p; }
00058 
00059 ::Ice::Object* IceInternal::upCast(::BeobotEvents::CameraMessage* p) { return p; }
00060 ::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::BeobotEvents::CameraMessage* p) { return p; }
00061 
00062 ::Ice::Object* IceInternal::upCast(::BeobotEvents::GistSalMessage* p) { return p; }
00063 ::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::BeobotEvents::GistSalMessage* p) { return p; }
00064 
00065 ::Ice::Object* IceInternal::upCast(::BeobotEvents::LandmarkSearchQueueMessage* p) { return p; }
00066 ::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::BeobotEvents::LandmarkSearchQueueMessage* p) { return p; }
00067 
00068 ::Ice::Object* IceInternal::upCast(::BeobotEvents::LandmarkTrackMessage* p) { return p; }
00069 ::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::BeobotEvents::LandmarkTrackMessage* p) { return p; }
00070 
00071 ::Ice::Object* IceInternal::upCast(::BeobotEvents::LandmarkSearchStatMessage* p) { return p; }
00072 ::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::BeobotEvents::LandmarkSearchStatMessage* p) { return p; }
00073 
00074 ::Ice::Object* IceInternal::upCast(::BeobotEvents::LandmarkMatchResultMessage* p) { return p; }
00075 ::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::BeobotEvents::LandmarkMatchResultMessage* p) { return p; }
00076 
00077 ::Ice::Object* IceInternal::upCast(::BeobotEvents::LandmarkDBSearchResultMessage* p) { return p; }
00078 ::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::BeobotEvents::LandmarkDBSearchResultMessage* p) { return p; }
00079 
00080 ::Ice::Object* IceInternal::upCast(::BeobotEvents::CurrentLocationMessage* p) { return p; }
00081 ::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::BeobotEvents::CurrentLocationMessage* p) { return p; }
00082 
00083 ::Ice::Object* IceInternal::upCast(::BeobotEvents::CancelSearchMessage* p) { return p; }
00084 ::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::BeobotEvents::CancelSearchMessage* p) { return p; }
00085 
00086 ::Ice::Object* IceInternal::upCast(::BeobotEvents::SearchDoneMessage* p) { return p; }
00087 ::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::BeobotEvents::SearchDoneMessage* p) { return p; }
00088 
00089 ::Ice::Object* IceInternal::upCast(::BeobotEvents::NextFrameMessage* p) { return p; }
00090 ::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::BeobotEvents::NextFrameMessage* p) { return p; }
00091 
00092 ::Ice::Object* IceInternal::upCast(::BeobotEvents::AbortMessage* p) { return p; }
00093 ::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::BeobotEvents::AbortMessage* p) { return p; }
00094 
00095 ::Ice::Object* IceInternal::upCast(::BeobotEvents::FacesMessage* p) { return p; }
00096 ::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::BeobotEvents::FacesMessage* p) { return p; }
00097 
00098 ::Ice::Object* IceInternal::upCast(::BeobotEvents::GUISpeechMessage* p) { return p; }
00099 ::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::BeobotEvents::GUISpeechMessage* p) { return p; }
00100 
00101 void
00102 BeobotEvents::__read(::IceInternal::BasicStream* __is, ::BeobotEvents::MotorMessagePrx& v)
00103 {
00104     ::Ice::ObjectPrx proxy;
00105     __is->read(proxy);
00106     if(!proxy)
00107     {
00108         v = 0;
00109     }
00110     else
00111     {
00112         v = new ::IceProxy::BeobotEvents::MotorMessage;
00113         v->__copyFrom(proxy);
00114     }
00115 }
00116 
00117 void
00118 BeobotEvents::__read(::IceInternal::BasicStream* __is, ::BeobotEvents::MotorRequestPrx& v)
00119 {
00120     ::Ice::ObjectPrx proxy;
00121     __is->read(proxy);
00122     if(!proxy)
00123     {
00124         v = 0;
00125     }
00126     else
00127     {
00128         v = new ::IceProxy::BeobotEvents::MotorRequest;
00129         v->__copyFrom(proxy);
00130     }
00131 }
00132 
00133 void
00134 BeobotEvents::__read(::IceInternal::BasicStream* __is, ::BeobotEvents::CornerMotorRequestPrx& v)
00135 {
00136     ::Ice::ObjectPrx proxy;
00137     __is->read(proxy);
00138     if(!proxy)
00139     {
00140         v = 0;
00141     }
00142     else
00143     {
00144         v = new ::IceProxy::BeobotEvents::CornerMotorRequest;
00145         v->__copyFrom(proxy);
00146     }
00147 }
00148 
00149 void
00150 BeobotEvents::__read(::IceInternal::BasicStream* __is, ::BeobotEvents::CornerLocationMessagePrx& v)
00151 {
00152     ::Ice::ObjectPrx proxy;
00153     __is->read(proxy);
00154     if(!proxy)
00155     {
00156         v = 0;
00157     }
00158     else
00159     {
00160         v = new ::IceProxy::BeobotEvents::CornerLocationMessage;
00161         v->__copyFrom(proxy);
00162     }
00163 }
00164 
00165 void
00166 BeobotEvents::__read(::IceInternal::BasicStream* __is, ::BeobotEvents::SonarMessagePrx& v)
00167 {
00168     ::Ice::ObjectPrx proxy;
00169     __is->read(proxy);
00170     if(!proxy)
00171     {
00172         v = 0;
00173     }
00174     else
00175     {
00176         v = new ::IceProxy::BeobotEvents::SonarMessage;
00177         v->__copyFrom(proxy);
00178     }
00179 }
00180 
00181 void
00182 BeobotEvents::__read(::IceInternal::BasicStream* __is, ::BeobotEvents::GPSMessagePrx& v)
00183 {
00184     ::Ice::ObjectPrx proxy;
00185     __is->read(proxy);
00186     if(!proxy)
00187     {
00188         v = 0;
00189     }
00190     else
00191     {
00192         v = new ::IceProxy::BeobotEvents::GPSMessage;
00193         v->__copyFrom(proxy);
00194     }
00195 }
00196 
00197 void
00198 BeobotEvents::__read(::IceInternal::BasicStream* __is, ::BeobotEvents::LRFMessagePrx& v)
00199 {
00200     ::Ice::ObjectPrx proxy;
00201     __is->read(proxy);
00202     if(!proxy)
00203     {
00204         v = 0;
00205     }
00206     else
00207     {
00208         v = new ::IceProxy::BeobotEvents::LRFMessage;
00209         v->__copyFrom(proxy);
00210     }
00211 }
00212 
00213 void
00214 BeobotEvents::__read(::IceInternal::BasicStream* __is, ::BeobotEvents::SLAMMessagePrx& v)
00215 {
00216     ::Ice::ObjectPrx proxy;
00217     __is->read(proxy);
00218     if(!proxy)
00219     {
00220         v = 0;
00221     }
00222     else
00223     {
00224         v = new ::IceProxy::BeobotEvents::SLAMMessage;
00225         v->__copyFrom(proxy);
00226     }
00227 }
00228 
00229 void
00230 BeobotEvents::__read(::IceInternal::BasicStream* __is, ::BeobotEvents::IMUMessagePrx& v)
00231 {
00232     ::Ice::ObjectPrx proxy;
00233     __is->read(proxy);
00234     if(!proxy)
00235     {
00236         v = 0;
00237     }
00238     else
00239     {
00240         v = new ::IceProxy::BeobotEvents::IMUMessage;
00241         v->__copyFrom(proxy);
00242     }
00243 }
00244 
00245 void
00246 BeobotEvents::__read(::IceInternal::BasicStream* __is, ::BeobotEvents::CameraMessagePrx& v)
00247 {
00248     ::Ice::ObjectPrx proxy;
00249     __is->read(proxy);
00250     if(!proxy)
00251     {
00252         v = 0;
00253     }
00254     else
00255     {
00256         v = new ::IceProxy::BeobotEvents::CameraMessage;
00257         v->__copyFrom(proxy);
00258     }
00259 }
00260 
00261 void
00262 BeobotEvents::__read(::IceInternal::BasicStream* __is, ::BeobotEvents::GistSalMessagePrx& v)
00263 {
00264     ::Ice::ObjectPrx proxy;
00265     __is->read(proxy);
00266     if(!proxy)
00267     {
00268         v = 0;
00269     }
00270     else
00271     {
00272         v = new ::IceProxy::BeobotEvents::GistSalMessage;
00273         v->__copyFrom(proxy);
00274     }
00275 }
00276 
00277 void
00278 BeobotEvents::__read(::IceInternal::BasicStream* __is, ::BeobotEvents::LandmarkSearchQueueMessagePrx& v)
00279 {
00280     ::Ice::ObjectPrx proxy;
00281     __is->read(proxy);
00282     if(!proxy)
00283     {
00284         v = 0;
00285     }
00286     else
00287     {
00288         v = new ::IceProxy::BeobotEvents::LandmarkSearchQueueMessage;
00289         v->__copyFrom(proxy);
00290     }
00291 }
00292 
00293 void
00294 BeobotEvents::__read(::IceInternal::BasicStream* __is, ::BeobotEvents::LandmarkTrackMessagePrx& v)
00295 {
00296     ::Ice::ObjectPrx proxy;
00297     __is->read(proxy);
00298     if(!proxy)
00299     {
00300         v = 0;
00301     }
00302     else
00303     {
00304         v = new ::IceProxy::BeobotEvents::LandmarkTrackMessage;
00305         v->__copyFrom(proxy);
00306     }
00307 }
00308 
00309 void
00310 BeobotEvents::__read(::IceInternal::BasicStream* __is, ::BeobotEvents::LandmarkSearchStatMessagePrx& v)
00311 {
00312     ::Ice::ObjectPrx proxy;
00313     __is->read(proxy);
00314     if(!proxy)
00315     {
00316         v = 0;
00317     }
00318     else
00319     {
00320         v = new ::IceProxy::BeobotEvents::LandmarkSearchStatMessage;
00321         v->__copyFrom(proxy);
00322     }
00323 }
00324 
00325 void
00326 BeobotEvents::__read(::IceInternal::BasicStream* __is, ::BeobotEvents::LandmarkMatchResultMessagePrx& v)
00327 {
00328     ::Ice::ObjectPrx proxy;
00329     __is->read(proxy);
00330     if(!proxy)
00331     {
00332         v = 0;
00333     }
00334     else
00335     {
00336         v = new ::IceProxy::BeobotEvents::LandmarkMatchResultMessage;
00337         v->__copyFrom(proxy);
00338     }
00339 }
00340 
00341 void
00342 BeobotEvents::__read(::IceInternal::BasicStream* __is, ::BeobotEvents::LandmarkDBSearchResultMessagePrx& v)
00343 {
00344     ::Ice::ObjectPrx proxy;
00345     __is->read(proxy);
00346     if(!proxy)
00347     {
00348         v = 0;
00349     }
00350     else
00351     {
00352         v = new ::IceProxy::BeobotEvents::LandmarkDBSearchResultMessage;
00353         v->__copyFrom(proxy);
00354     }
00355 }
00356 
00357 void
00358 BeobotEvents::__read(::IceInternal::BasicStream* __is, ::BeobotEvents::CurrentLocationMessagePrx& v)
00359 {
00360     ::Ice::ObjectPrx proxy;
00361     __is->read(proxy);
00362     if(!proxy)
00363     {
00364         v = 0;
00365     }
00366     else
00367     {
00368         v = new ::IceProxy::BeobotEvents::CurrentLocationMessage;
00369         v->__copyFrom(proxy);
00370     }
00371 }
00372 
00373 void
00374 BeobotEvents::__read(::IceInternal::BasicStream* __is, ::BeobotEvents::CancelSearchMessagePrx& v)
00375 {
00376     ::Ice::ObjectPrx proxy;
00377     __is->read(proxy);
00378     if(!proxy)
00379     {
00380         v = 0;
00381     }
00382     else
00383     {
00384         v = new ::IceProxy::BeobotEvents::CancelSearchMessage;
00385         v->__copyFrom(proxy);
00386     }
00387 }
00388 
00389 void
00390 BeobotEvents::__read(::IceInternal::BasicStream* __is, ::BeobotEvents::SearchDoneMessagePrx& v)
00391 {
00392     ::Ice::ObjectPrx proxy;
00393     __is->read(proxy);
00394     if(!proxy)
00395     {
00396         v = 0;
00397     }
00398     else
00399     {
00400         v = new ::IceProxy::BeobotEvents::SearchDoneMessage;
00401         v->__copyFrom(proxy);
00402     }
00403 }
00404 
00405 void
00406 BeobotEvents::__read(::IceInternal::BasicStream* __is, ::BeobotEvents::NextFrameMessagePrx& v)
00407 {
00408     ::Ice::ObjectPrx proxy;
00409     __is->read(proxy);
00410     if(!proxy)
00411     {
00412         v = 0;
00413     }
00414     else
00415     {
00416         v = new ::IceProxy::BeobotEvents::NextFrameMessage;
00417         v->__copyFrom(proxy);
00418     }
00419 }
00420 
00421 void
00422 BeobotEvents::__read(::IceInternal::BasicStream* __is, ::BeobotEvents::AbortMessagePrx& v)
00423 {
00424     ::Ice::ObjectPrx proxy;
00425     __is->read(proxy);
00426     if(!proxy)
00427     {
00428         v = 0;
00429     }
00430     else
00431     {
00432         v = new ::IceProxy::BeobotEvents::AbortMessage;
00433         v->__copyFrom(proxy);
00434     }
00435 }
00436 
00437 void
00438 BeobotEvents::__read(::IceInternal::BasicStream* __is, ::BeobotEvents::FacesMessagePrx& v)
00439 {
00440     ::Ice::ObjectPrx proxy;
00441     __is->read(proxy);
00442     if(!proxy)
00443     {
00444         v = 0;
00445     }
00446     else
00447     {
00448         v = new ::IceProxy::BeobotEvents::FacesMessage;
00449         v->__copyFrom(proxy);
00450     }
00451 }
00452 
00453 void
00454 BeobotEvents::__read(::IceInternal::BasicStream* __is, ::BeobotEvents::GUISpeechMessagePrx& v)
00455 {
00456     ::Ice::ObjectPrx proxy;
00457     __is->read(proxy);
00458     if(!proxy)
00459     {
00460         v = 0;
00461     }
00462     else
00463     {
00464         v = new ::IceProxy::BeobotEvents::GUISpeechMessage;
00465         v->__copyFrom(proxy);
00466     }
00467 }
00468 
00469 bool
00470 BeobotEvents::SalientRegion::operator==(const SalientRegion& __rhs) const
00471 {
00472     if(this == &__rhs)
00473     {
00474         return true;
00475     }
00476     if(salpt != __rhs.salpt)
00477     {
00478         return false;
00479     }
00480     if(objRect != __rhs.objRect)
00481     {
00482         return false;
00483     }
00484     if(salFeatures != __rhs.salFeatures)
00485     {
00486         return false;
00487     }
00488     return true;
00489 }
00490 
00491 bool
00492 BeobotEvents::SalientRegion::operator<(const SalientRegion& __rhs) const
00493 {
00494     if(this == &__rhs)
00495     {
00496         return false;
00497     }
00498     if(salpt < __rhs.salpt)
00499     {
00500         return true;
00501     }
00502     else if(__rhs.salpt < salpt)
00503     {
00504         return false;
00505     }
00506     if(objRect < __rhs.objRect)
00507     {
00508         return true;
00509     }
00510     else if(__rhs.objRect < objRect)
00511     {
00512         return false;
00513     }
00514     if(salFeatures < __rhs.salFeatures)
00515     {
00516         return true;
00517     }
00518     else if(__rhs.salFeatures < salFeatures)
00519     {
00520         return false;
00521     }
00522     return false;
00523 }
00524 
00525 void
00526 BeobotEvents::SalientRegion::__write(::IceInternal::BasicStream* __os) const
00527 {
00528     salpt.__write(__os);
00529     objRect.__write(__os);
00530     if(salFeatures.size() == 0)
00531     {
00532         __os->writeSize(0);
00533     }
00534     else
00535     {
00536         __os->write(&salFeatures[0], &salFeatures[0] + salFeatures.size());
00537     }
00538 }
00539 
00540 void
00541 BeobotEvents::SalientRegion::__read(::IceInternal::BasicStream* __is)
00542 {
00543     salpt.__read(__is);
00544     objRect.__read(__is);
00545     __is->read(salFeatures);
00546 }
00547 
00548 void
00549 BeobotEvents::__writeSalientRegionSeq(::IceInternal::BasicStream* __os, const ::BeobotEvents::SalientRegion* begin, const ::BeobotEvents::SalientRegion* end)
00550 {
00551     ::Ice::Int size = static_cast< ::Ice::Int>(end - begin);
00552     __os->writeSize(size);
00553     for(int i = 0; i < size; ++i)
00554     {
00555         begin[i].__write(__os);
00556     }
00557 }
00558 
00559 void
00560 BeobotEvents::__readSalientRegionSeq(::IceInternal::BasicStream* __is, ::BeobotEvents::SalientRegionSeq& v)
00561 {
00562     ::Ice::Int sz;
00563     __is->readSize(sz);
00564     __is->startSeq(sz, 25);
00565     v.resize(sz);
00566     for(int i = 0; i < sz; ++i)
00567     {
00568         v[i].__read(__is);
00569         __is->checkSeq();
00570         __is->endElement();
00571     }
00572     __is->endSeq(sz);
00573 }
00574 
00575 bool
00576 BeobotEvents::LandmarkSearchJob::operator==(const LandmarkSearchJob& __rhs) const
00577 {
00578     if(this == &__rhs)
00579     {
00580         return true;
00581     }
00582     if(inputSalRegID != __rhs.inputSalRegID)
00583     {
00584         return false;
00585     }
00586     if(dbSegNum != __rhs.dbSegNum)
00587     {
00588         return false;
00589     }
00590     if(dbLmkNum != __rhs.dbLmkNum)
00591     {
00592         return false;
00593     }
00594     if(dbVOStart != __rhs.dbVOStart)
00595     {
00596         return false;
00597     }
00598     if(dbVOEnd != __rhs.dbVOEnd)
00599     {
00600         return false;
00601     }
00602     return true;
00603 }
00604 
00605 bool
00606 BeobotEvents::LandmarkSearchJob::operator<(const LandmarkSearchJob& __rhs) const
00607 {
00608     if(this == &__rhs)
00609     {
00610         return false;
00611     }
00612     if(inputSalRegID < __rhs.inputSalRegID)
00613     {
00614         return true;
00615     }
00616     else if(__rhs.inputSalRegID < inputSalRegID)
00617     {
00618         return false;
00619     }
00620     if(dbSegNum < __rhs.dbSegNum)
00621     {
00622         return true;
00623     }
00624     else if(__rhs.dbSegNum < dbSegNum)
00625     {
00626         return false;
00627     }
00628     if(dbLmkNum < __rhs.dbLmkNum)
00629     {
00630         return true;
00631     }
00632     else if(__rhs.dbLmkNum < dbLmkNum)
00633     {
00634         return false;
00635     }
00636     if(dbVOStart < __rhs.dbVOStart)
00637     {
00638         return true;
00639     }
00640     else if(__rhs.dbVOStart < dbVOStart)
00641     {
00642         return false;
00643     }
00644     if(dbVOEnd < __rhs.dbVOEnd)
00645     {
00646         return true;
00647     }
00648     else if(__rhs.dbVOEnd < dbVOEnd)
00649     {
00650         return false;
00651     }
00652     return false;
00653 }
00654 
00655 void
00656 BeobotEvents::LandmarkSearchJob::__write(::IceInternal::BasicStream* __os) const
00657 {
00658     __os->write(inputSalRegID);
00659     __os->write(dbSegNum);
00660     __os->write(dbLmkNum);
00661     __os->write(dbVOStart);
00662     __os->write(dbVOEnd);
00663 }
00664 
00665 void
00666 BeobotEvents::LandmarkSearchJob::__read(::IceInternal::BasicStream* __is)
00667 {
00668     __is->read(inputSalRegID);
00669     __is->read(dbSegNum);
00670     __is->read(dbLmkNum);
00671     __is->read(dbVOStart);
00672     __is->read(dbVOEnd);
00673 }
00674 
00675 void
00676 BeobotEvents::__writeLandmarkSearchJobSeq(::IceInternal::BasicStream* __os, const ::BeobotEvents::LandmarkSearchJob* begin, const ::BeobotEvents::LandmarkSearchJob* end)
00677 {
00678     ::Ice::Int size = static_cast< ::Ice::Int>(end - begin);
00679     __os->writeSize(size);
00680     for(int i = 0; i < size; ++i)
00681     {
00682         begin[i].__write(__os);
00683     }
00684 }
00685 
00686 void
00687 BeobotEvents::__readLandmarkSearchJobSeq(::IceInternal::BasicStream* __is, ::BeobotEvents::LandmarkSearchJobSeq& v)
00688 {
00689     ::Ice::Int sz;
00690     __is->readSize(sz);
00691     __is->checkFixedSeq(sz, 20);
00692     v.resize(sz);
00693     for(int i = 0; i < sz; ++i)
00694     {
00695         v[i].__read(__is);
00696     }
00697 }
00698 
00699 void
00700 BeobotEvents::__writeRectangleIceSeq(::IceInternal::BasicStream* __os, const ::ImageIceMod::RectangleIce* begin, const ::ImageIceMod::RectangleIce* end)
00701 {
00702     ::Ice::Int size = static_cast< ::Ice::Int>(end - begin);
00703     __os->writeSize(size);
00704     for(int i = 0; i < size; ++i)
00705     {
00706         begin[i].__write(__os);
00707     }
00708 }
00709 
00710 void
00711 BeobotEvents::__readRectangleIceSeq(::IceInternal::BasicStream* __is, ::BeobotEvents::RectangleIceSeq& v)
00712 {
00713     ::Ice::Int sz;
00714     __is->readSize(sz);
00715     __is->checkFixedSeq(sz, 16);
00716     v.resize(sz);
00717     for(int i = 0; i < sz; ++i)
00718     {
00719         v[i].__read(__is);
00720     }
00721 }
00722 
00723 const ::std::string&
00724 IceProxy::BeobotEvents::MotorMessage::ice_staticId()
00725 {
00726     return ::BeobotEvents::MotorMessage::ice_staticId();
00727 }
00728 
00729 ::IceInternal::Handle< ::IceDelegateM::Ice::Object>
00730 IceProxy::BeobotEvents::MotorMessage::__createDelegateM()
00731 {
00732     return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::BeobotEvents::MotorMessage);
00733 }
00734 
00735 ::IceInternal::Handle< ::IceDelegateD::Ice::Object>
00736 IceProxy::BeobotEvents::MotorMessage::__createDelegateD()
00737 {
00738     return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::BeobotEvents::MotorMessage);
00739 }
00740 
00741 ::IceProxy::Ice::Object*
00742 IceProxy::BeobotEvents::MotorMessage::__newInstance() const
00743 {
00744     return new MotorMessage;
00745 }
00746 
00747 const ::std::string&
00748 IceProxy::BeobotEvents::MotorRequest::ice_staticId()
00749 {
00750     return ::BeobotEvents::MotorRequest::ice_staticId();
00751 }
00752 
00753 ::IceInternal::Handle< ::IceDelegateM::Ice::Object>
00754 IceProxy::BeobotEvents::MotorRequest::__createDelegateM()
00755 {
00756     return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::BeobotEvents::MotorRequest);
00757 }
00758 
00759 ::IceInternal::Handle< ::IceDelegateD::Ice::Object>
00760 IceProxy::BeobotEvents::MotorRequest::__createDelegateD()
00761 {
00762     return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::BeobotEvents::MotorRequest);
00763 }
00764 
00765 ::IceProxy::Ice::Object*
00766 IceProxy::BeobotEvents::MotorRequest::__newInstance() const
00767 {
00768     return new MotorRequest;
00769 }
00770 
00771 const ::std::string&
00772 IceProxy::BeobotEvents::CornerMotorRequest::ice_staticId()
00773 {
00774     return ::BeobotEvents::CornerMotorRequest::ice_staticId();
00775 }
00776 
00777 ::IceInternal::Handle< ::IceDelegateM::Ice::Object>
00778 IceProxy::BeobotEvents::CornerMotorRequest::__createDelegateM()
00779 {
00780     return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::BeobotEvents::CornerMotorRequest);
00781 }
00782 
00783 ::IceInternal::Handle< ::IceDelegateD::Ice::Object>
00784 IceProxy::BeobotEvents::CornerMotorRequest::__createDelegateD()
00785 {
00786     return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::BeobotEvents::CornerMotorRequest);
00787 }
00788 
00789 ::IceProxy::Ice::Object*
00790 IceProxy::BeobotEvents::CornerMotorRequest::__newInstance() const
00791 {
00792     return new CornerMotorRequest;
00793 }
00794 
00795 const ::std::string&
00796 IceProxy::BeobotEvents::CornerLocationMessage::ice_staticId()
00797 {
00798     return ::BeobotEvents::CornerLocationMessage::ice_staticId();
00799 }
00800 
00801 ::IceInternal::Handle< ::IceDelegateM::Ice::Object>
00802 IceProxy::BeobotEvents::CornerLocationMessage::__createDelegateM()
00803 {
00804     return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::BeobotEvents::CornerLocationMessage);
00805 }
00806 
00807 ::IceInternal::Handle< ::IceDelegateD::Ice::Object>
00808 IceProxy::BeobotEvents::CornerLocationMessage::__createDelegateD()
00809 {
00810     return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::BeobotEvents::CornerLocationMessage);
00811 }
00812 
00813 ::IceProxy::Ice::Object*
00814 IceProxy::BeobotEvents::CornerLocationMessage::__newInstance() const
00815 {
00816     return new CornerLocationMessage;
00817 }
00818 
00819 const ::std::string&
00820 IceProxy::BeobotEvents::SonarMessage::ice_staticId()
00821 {
00822     return ::BeobotEvents::SonarMessage::ice_staticId();
00823 }
00824 
00825 ::IceInternal::Handle< ::IceDelegateM::Ice::Object>
00826 IceProxy::BeobotEvents::SonarMessage::__createDelegateM()
00827 {
00828     return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::BeobotEvents::SonarMessage);
00829 }
00830 
00831 ::IceInternal::Handle< ::IceDelegateD::Ice::Object>
00832 IceProxy::BeobotEvents::SonarMessage::__createDelegateD()
00833 {
00834     return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::BeobotEvents::SonarMessage);
00835 }
00836 
00837 ::IceProxy::Ice::Object*
00838 IceProxy::BeobotEvents::SonarMessage::__newInstance() const
00839 {
00840     return new SonarMessage;
00841 }
00842 
00843 const ::std::string&
00844 IceProxy::BeobotEvents::GPSMessage::ice_staticId()
00845 {
00846     return ::BeobotEvents::GPSMessage::ice_staticId();
00847 }
00848 
00849 ::IceInternal::Handle< ::IceDelegateM::Ice::Object>
00850 IceProxy::BeobotEvents::GPSMessage::__createDelegateM()
00851 {
00852     return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::BeobotEvents::GPSMessage);
00853 }
00854 
00855 ::IceInternal::Handle< ::IceDelegateD::Ice::Object>
00856 IceProxy::BeobotEvents::GPSMessage::__createDelegateD()
00857 {
00858     return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::BeobotEvents::GPSMessage);
00859 }
00860 
00861 ::IceProxy::Ice::Object*
00862 IceProxy::BeobotEvents::GPSMessage::__newInstance() const
00863 {
00864     return new GPSMessage;
00865 }
00866 
00867 const ::std::string&
00868 IceProxy::BeobotEvents::LRFMessage::ice_staticId()
00869 {
00870     return ::BeobotEvents::LRFMessage::ice_staticId();
00871 }
00872 
00873 ::IceInternal::Handle< ::IceDelegateM::Ice::Object>
00874 IceProxy::BeobotEvents::LRFMessage::__createDelegateM()
00875 {
00876     return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::BeobotEvents::LRFMessage);
00877 }
00878 
00879 ::IceInternal::Handle< ::IceDelegateD::Ice::Object>
00880 IceProxy::BeobotEvents::LRFMessage::__createDelegateD()
00881 {
00882     return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::BeobotEvents::LRFMessage);
00883 }
00884 
00885 ::IceProxy::Ice::Object*
00886 IceProxy::BeobotEvents::LRFMessage::__newInstance() const
00887 {
00888     return new LRFMessage;
00889 }
00890 
00891 const ::std::string&
00892 IceProxy::BeobotEvents::SLAMMessage::ice_staticId()
00893 {
00894     return ::BeobotEvents::SLAMMessage::ice_staticId();
00895 }
00896 
00897 ::IceInternal::Handle< ::IceDelegateM::Ice::Object>
00898 IceProxy::BeobotEvents::SLAMMessage::__createDelegateM()
00899 {
00900     return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::BeobotEvents::SLAMMessage);
00901 }
00902 
00903 ::IceInternal::Handle< ::IceDelegateD::Ice::Object>
00904 IceProxy::BeobotEvents::SLAMMessage::__createDelegateD()
00905 {
00906     return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::BeobotEvents::SLAMMessage);
00907 }
00908 
00909 ::IceProxy::Ice::Object*
00910 IceProxy::BeobotEvents::SLAMMessage::__newInstance() const
00911 {
00912     return new SLAMMessage;
00913 }
00914 
00915 const ::std::string&
00916 IceProxy::BeobotEvents::IMUMessage::ice_staticId()
00917 {
00918     return ::BeobotEvents::IMUMessage::ice_staticId();
00919 }
00920 
00921 ::IceInternal::Handle< ::IceDelegateM::Ice::Object>
00922 IceProxy::BeobotEvents::IMUMessage::__createDelegateM()
00923 {
00924     return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::BeobotEvents::IMUMessage);
00925 }
00926 
00927 ::IceInternal::Handle< ::IceDelegateD::Ice::Object>
00928 IceProxy::BeobotEvents::IMUMessage::__createDelegateD()
00929 {
00930     return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::BeobotEvents::IMUMessage);
00931 }
00932 
00933 ::IceProxy::Ice::Object*
00934 IceProxy::BeobotEvents::IMUMessage::__newInstance() const
00935 {
00936     return new IMUMessage;
00937 }
00938 
00939 const ::std::string&
00940 IceProxy::BeobotEvents::CameraMessage::ice_staticId()
00941 {
00942     return ::BeobotEvents::CameraMessage::ice_staticId();
00943 }
00944 
00945 ::IceInternal::Handle< ::IceDelegateM::Ice::Object>
00946 IceProxy::BeobotEvents::CameraMessage::__createDelegateM()
00947 {
00948     return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::BeobotEvents::CameraMessage);
00949 }
00950 
00951 ::IceInternal::Handle< ::IceDelegateD::Ice::Object>
00952 IceProxy::BeobotEvents::CameraMessage::__createDelegateD()
00953 {
00954     return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::BeobotEvents::CameraMessage);
00955 }
00956 
00957 ::IceProxy::Ice::Object*
00958 IceProxy::BeobotEvents::CameraMessage::__newInstance() const
00959 {
00960     return new CameraMessage;
00961 }
00962 
00963 const ::std::string&
00964 IceProxy::BeobotEvents::GistSalMessage::ice_staticId()
00965 {
00966     return ::BeobotEvents::GistSalMessage::ice_staticId();
00967 }
00968 
00969 ::IceInternal::Handle< ::IceDelegateM::Ice::Object>
00970 IceProxy::BeobotEvents::GistSalMessage::__createDelegateM()
00971 {
00972     return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::BeobotEvents::GistSalMessage);
00973 }
00974 
00975 ::IceInternal::Handle< ::IceDelegateD::Ice::Object>
00976 IceProxy::BeobotEvents::GistSalMessage::__createDelegateD()
00977 {
00978     return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::BeobotEvents::GistSalMessage);
00979 }
00980 
00981 ::IceProxy::Ice::Object*
00982 IceProxy::BeobotEvents::GistSalMessage::__newInstance() const
00983 {
00984     return new GistSalMessage;
00985 }
00986 
00987 const ::std::string&
00988 IceProxy::BeobotEvents::LandmarkSearchQueueMessage::ice_staticId()
00989 {
00990     return ::BeobotEvents::LandmarkSearchQueueMessage::ice_staticId();
00991 }
00992 
00993 ::IceInternal::Handle< ::IceDelegateM::Ice::Object>
00994 IceProxy::BeobotEvents::LandmarkSearchQueueMessage::__createDelegateM()
00995 {
00996     return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::BeobotEvents::LandmarkSearchQueueMessage);
00997 }
00998 
00999 ::IceInternal::Handle< ::IceDelegateD::Ice::Object>
01000 IceProxy::BeobotEvents::LandmarkSearchQueueMessage::__createDelegateD()
01001 {
01002     return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::BeobotEvents::LandmarkSearchQueueMessage);
01003 }
01004 
01005 ::IceProxy::Ice::Object*
01006 IceProxy::BeobotEvents::LandmarkSearchQueueMessage::__newInstance() const
01007 {
01008     return new LandmarkSearchQueueMessage;
01009 }
01010 
01011 const ::std::string&
01012 IceProxy::BeobotEvents::LandmarkTrackMessage::ice_staticId()
01013 {
01014     return ::BeobotEvents::LandmarkTrackMessage::ice_staticId();
01015 }
01016 
01017 ::IceInternal::Handle< ::IceDelegateM::Ice::Object>
01018 IceProxy::BeobotEvents::LandmarkTrackMessage::__createDelegateM()
01019 {
01020     return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::BeobotEvents::LandmarkTrackMessage);
01021 }
01022 
01023 ::IceInternal::Handle< ::IceDelegateD::Ice::Object>
01024 IceProxy::BeobotEvents::LandmarkTrackMessage::__createDelegateD()
01025 {
01026     return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::BeobotEvents::LandmarkTrackMessage);
01027 }
01028 
01029 ::IceProxy::Ice::Object*
01030 IceProxy::BeobotEvents::LandmarkTrackMessage::__newInstance() const
01031 {
01032     return new LandmarkTrackMessage;
01033 }
01034 
01035 const ::std::string&
01036 IceProxy::BeobotEvents::LandmarkSearchStatMessage::ice_staticId()
01037 {
01038     return ::BeobotEvents::LandmarkSearchStatMessage::ice_staticId();
01039 }
01040 
01041 ::IceInternal::Handle< ::IceDelegateM::Ice::Object>
01042 IceProxy::BeobotEvents::LandmarkSearchStatMessage::__createDelegateM()
01043 {
01044     return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::BeobotEvents::LandmarkSearchStatMessage);
01045 }
01046 
01047 ::IceInternal::Handle< ::IceDelegateD::Ice::Object>
01048 IceProxy::BeobotEvents::LandmarkSearchStatMessage::__createDelegateD()
01049 {
01050     return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::BeobotEvents::LandmarkSearchStatMessage);
01051 }
01052 
01053 ::IceProxy::Ice::Object*
01054 IceProxy::BeobotEvents::LandmarkSearchStatMessage::__newInstance() const
01055 {
01056     return new LandmarkSearchStatMessage;
01057 }
01058 
01059 const ::std::string&
01060 IceProxy::BeobotEvents::LandmarkMatchResultMessage::ice_staticId()
01061 {
01062     return ::BeobotEvents::LandmarkMatchResultMessage::ice_staticId();
01063 }
01064 
01065 ::IceInternal::Handle< ::IceDelegateM::Ice::Object>
01066 IceProxy::BeobotEvents::LandmarkMatchResultMessage::__createDelegateM()
01067 {
01068     return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::BeobotEvents::LandmarkMatchResultMessage);
01069 }
01070 
01071 ::IceInternal::Handle< ::IceDelegateD::Ice::Object>
01072 IceProxy::BeobotEvents::LandmarkMatchResultMessage::__createDelegateD()
01073 {
01074     return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::BeobotEvents::LandmarkMatchResultMessage);
01075 }
01076 
01077 ::IceProxy::Ice::Object*
01078 IceProxy::BeobotEvents::LandmarkMatchResultMessage::__newInstance() const
01079 {
01080     return new LandmarkMatchResultMessage;
01081 }
01082 
01083 const ::std::string&
01084 IceProxy::BeobotEvents::LandmarkDBSearchResultMessage::ice_staticId()
01085 {
01086     return ::BeobotEvents::LandmarkDBSearchResultMessage::ice_staticId();
01087 }
01088 
01089 ::IceInternal::Handle< ::IceDelegateM::Ice::Object>
01090 IceProxy::BeobotEvents::LandmarkDBSearchResultMessage::__createDelegateM()
01091 {
01092     return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::BeobotEvents::LandmarkDBSearchResultMessage);
01093 }
01094 
01095 ::IceInternal::Handle< ::IceDelegateD::Ice::Object>
01096 IceProxy::BeobotEvents::LandmarkDBSearchResultMessage::__createDelegateD()
01097 {
01098     return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::BeobotEvents::LandmarkDBSearchResultMessage);
01099 }
01100 
01101 ::IceProxy::Ice::Object*
01102 IceProxy::BeobotEvents::LandmarkDBSearchResultMessage::__newInstance() const
01103 {
01104     return new LandmarkDBSearchResultMessage;
01105 }
01106 
01107 const ::std::string&
01108 IceProxy::BeobotEvents::CurrentLocationMessage::ice_staticId()
01109 {
01110     return ::BeobotEvents::CurrentLocationMessage::ice_staticId();
01111 }
01112 
01113 ::IceInternal::Handle< ::IceDelegateM::Ice::Object>
01114 IceProxy::BeobotEvents::CurrentLocationMessage::__createDelegateM()
01115 {
01116     return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::BeobotEvents::CurrentLocationMessage);
01117 }
01118 
01119 ::IceInternal::Handle< ::IceDelegateD::Ice::Object>
01120 IceProxy::BeobotEvents::CurrentLocationMessage::__createDelegateD()
01121 {
01122     return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::BeobotEvents::CurrentLocationMessage);
01123 }
01124 
01125 ::IceProxy::Ice::Object*
01126 IceProxy::BeobotEvents::CurrentLocationMessage::__newInstance() const
01127 {
01128     return new CurrentLocationMessage;
01129 }
01130 
01131 const ::std::string&
01132 IceProxy::BeobotEvents::CancelSearchMessage::ice_staticId()
01133 {
01134     return ::BeobotEvents::CancelSearchMessage::ice_staticId();
01135 }
01136 
01137 ::IceInternal::Handle< ::IceDelegateM::Ice::Object>
01138 IceProxy::BeobotEvents::CancelSearchMessage::__createDelegateM()
01139 {
01140     return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::BeobotEvents::CancelSearchMessage);
01141 }
01142 
01143 ::IceInternal::Handle< ::IceDelegateD::Ice::Object>
01144 IceProxy::BeobotEvents::CancelSearchMessage::__createDelegateD()
01145 {
01146     return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::BeobotEvents::CancelSearchMessage);
01147 }
01148 
01149 ::IceProxy::Ice::Object*
01150 IceProxy::BeobotEvents::CancelSearchMessage::__newInstance() const
01151 {
01152     return new CancelSearchMessage;
01153 }
01154 
01155 const ::std::string&
01156 IceProxy::BeobotEvents::SearchDoneMessage::ice_staticId()
01157 {
01158     return ::BeobotEvents::SearchDoneMessage::ice_staticId();
01159 }
01160 
01161 ::IceInternal::Handle< ::IceDelegateM::Ice::Object>
01162 IceProxy::BeobotEvents::SearchDoneMessage::__createDelegateM()
01163 {
01164     return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::BeobotEvents::SearchDoneMessage);
01165 }
01166 
01167 ::IceInternal::Handle< ::IceDelegateD::Ice::Object>
01168 IceProxy::BeobotEvents::SearchDoneMessage::__createDelegateD()
01169 {
01170     return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::BeobotEvents::SearchDoneMessage);
01171 }
01172 
01173 ::IceProxy::Ice::Object*
01174 IceProxy::BeobotEvents::SearchDoneMessage::__newInstance() const
01175 {
01176     return new SearchDoneMessage;
01177 }
01178 
01179 const ::std::string&
01180 IceProxy::BeobotEvents::NextFrameMessage::ice_staticId()
01181 {
01182     return ::BeobotEvents::NextFrameMessage::ice_staticId();
01183 }
01184 
01185 ::IceInternal::Handle< ::IceDelegateM::Ice::Object>
01186 IceProxy::BeobotEvents::NextFrameMessage::__createDelegateM()
01187 {
01188     return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::BeobotEvents::NextFrameMessage);
01189 }
01190 
01191 ::IceInternal::Handle< ::IceDelegateD::Ice::Object>
01192 IceProxy::BeobotEvents::NextFrameMessage::__createDelegateD()
01193 {
01194     return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::BeobotEvents::NextFrameMessage);
01195 }
01196 
01197 ::IceProxy::Ice::Object*
01198 IceProxy::BeobotEvents::NextFrameMessage::__newInstance() const
01199 {
01200     return new NextFrameMessage;
01201 }
01202 
01203 const ::std::string&
01204 IceProxy::BeobotEvents::AbortMessage::ice_staticId()
01205 {
01206     return ::BeobotEvents::AbortMessage::ice_staticId();
01207 }
01208 
01209 ::IceInternal::Handle< ::IceDelegateM::Ice::Object>
01210 IceProxy::BeobotEvents::AbortMessage::__createDelegateM()
01211 {
01212     return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::BeobotEvents::AbortMessage);
01213 }
01214 
01215 ::IceInternal::Handle< ::IceDelegateD::Ice::Object>
01216 IceProxy::BeobotEvents::AbortMessage::__createDelegateD()
01217 {
01218     return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::BeobotEvents::AbortMessage);
01219 }
01220 
01221 ::IceProxy::Ice::Object*
01222 IceProxy::BeobotEvents::AbortMessage::__newInstance() const
01223 {
01224     return new AbortMessage;
01225 }
01226 
01227 const ::std::string&
01228 IceProxy::BeobotEvents::FacesMessage::ice_staticId()
01229 {
01230     return ::BeobotEvents::FacesMessage::ice_staticId();
01231 }
01232 
01233 ::IceInternal::Handle< ::IceDelegateM::Ice::Object>
01234 IceProxy::BeobotEvents::FacesMessage::__createDelegateM()
01235 {
01236     return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::BeobotEvents::FacesMessage);
01237 }
01238 
01239 ::IceInternal::Handle< ::IceDelegateD::Ice::Object>
01240 IceProxy::BeobotEvents::FacesMessage::__createDelegateD()
01241 {
01242     return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::BeobotEvents::FacesMessage);
01243 }
01244 
01245 ::IceProxy::Ice::Object*
01246 IceProxy::BeobotEvents::FacesMessage::__newInstance() const
01247 {
01248     return new FacesMessage;
01249 }
01250 
01251 const ::std::string&
01252 IceProxy::BeobotEvents::GUISpeechMessage::ice_staticId()
01253 {
01254     return ::BeobotEvents::GUISpeechMessage::ice_staticId();
01255 }
01256 
01257 ::IceInternal::Handle< ::IceDelegateM::Ice::Object>
01258 IceProxy::BeobotEvents::GUISpeechMessage::__createDelegateM()
01259 {
01260     return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::BeobotEvents::GUISpeechMessage);
01261 }
01262 
01263 ::IceInternal::Handle< ::IceDelegateD::Ice::Object>
01264 IceProxy::BeobotEvents::GUISpeechMessage::__createDelegateD()
01265 {
01266     return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::BeobotEvents::GUISpeechMessage);
01267 }
01268 
01269 ::IceProxy::Ice::Object*
01270 IceProxy::BeobotEvents::GUISpeechMessage::__newInstance() const
01271 {
01272     return new GUISpeechMessage;
01273 }
01274 
01275 BeobotEvents::MotorMessage::MotorMessage(::Ice::Int __ice_rcMode, ::Ice::Int __ice_motor1, ::Ice::Int __ice_motor2, ::Ice::Double __ice_transVel, ::Ice::Double __ice_rotVel, ::Ice::Double __ice_encoderX, ::Ice::Double __ice_encoderY, ::Ice::Double __ice_encoderOri, ::Ice::Double __ice_rcTransVel, ::Ice::Double __ice_rcRotVel, ::Ice::Int __ice_RequestID) :
01276     rcMode(__ice_rcMode),
01277     motor1(__ice_motor1),
01278     motor2(__ice_motor2),
01279     transVel(__ice_transVel),
01280     rotVel(__ice_rotVel),
01281     encoderX(__ice_encoderX),
01282     encoderY(__ice_encoderY),
01283     encoderOri(__ice_encoderOri),
01284     rcTransVel(__ice_rcTransVel),
01285     rcRotVel(__ice_rcRotVel),
01286     RequestID(__ice_RequestID)
01287 {
01288 }
01289 
01290 ::Ice::ObjectPtr
01291 BeobotEvents::MotorMessage::ice_clone() const
01292 {
01293     ::BeobotEvents::MotorMessagePtr __p = new ::BeobotEvents::MotorMessage(*this);
01294     return __p;
01295 }
01296 
01297 static const ::std::string __BeobotEvents__MotorMessage_ids[3] =
01298 {
01299     "::BeobotEvents::MotorMessage",
01300     "::Ice::Object",
01301     "::RobotSimEvents::EventMessage"
01302 };
01303 
01304 bool
01305 BeobotEvents::MotorMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
01306 {
01307     return ::std::binary_search(__BeobotEvents__MotorMessage_ids, __BeobotEvents__MotorMessage_ids + 3, _s);
01308 }
01309 
01310 ::std::vector< ::std::string>
01311 BeobotEvents::MotorMessage::ice_ids(const ::Ice::Current&) const
01312 {
01313     return ::std::vector< ::std::string>(&__BeobotEvents__MotorMessage_ids[0], &__BeobotEvents__MotorMessage_ids[3]);
01314 }
01315 
01316 const ::std::string&
01317 BeobotEvents::MotorMessage::ice_id(const ::Ice::Current&) const
01318 {
01319     return __BeobotEvents__MotorMessage_ids[0];
01320 }
01321 
01322 const ::std::string&
01323 BeobotEvents::MotorMessage::ice_staticId()
01324 {
01325     return __BeobotEvents__MotorMessage_ids[0];
01326 }
01327 
01328 void
01329 BeobotEvents::MotorMessage::__write(::IceInternal::BasicStream* __os) const
01330 {
01331     __os->writeTypeId(ice_staticId());
01332     __os->startWriteSlice();
01333     __os->write(rcMode);
01334     __os->write(motor1);
01335     __os->write(motor2);
01336     __os->write(transVel);
01337     __os->write(rotVel);
01338     __os->write(encoderX);
01339     __os->write(encoderY);
01340     __os->write(encoderOri);
01341     __os->write(rcTransVel);
01342     __os->write(rcRotVel);
01343     __os->write(RequestID);
01344     __os->endWriteSlice();
01345 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01346     EventMessage::__write(__os);
01347 #else
01348     ::RobotSimEvents::EventMessage::__write(__os);
01349 #endif
01350 }
01351 
01352 void
01353 BeobotEvents::MotorMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
01354 {
01355     if(__rid)
01356     {
01357         ::std::string myId;
01358         __is->readTypeId(myId);
01359     }
01360     __is->startReadSlice();
01361     __is->read(rcMode);
01362     __is->read(motor1);
01363     __is->read(motor2);
01364     __is->read(transVel);
01365     __is->read(rotVel);
01366     __is->read(encoderX);
01367     __is->read(encoderY);
01368     __is->read(encoderOri);
01369     __is->read(rcTransVel);
01370     __is->read(rcRotVel);
01371     __is->read(RequestID);
01372     __is->endReadSlice();
01373 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01374     EventMessage::__read(__is, true);
01375 #else
01376     ::RobotSimEvents::EventMessage::__read(__is, true);
01377 #endif
01378 }
01379 
01380 void
01381 BeobotEvents::MotorMessage::__write(const ::Ice::OutputStreamPtr&) const
01382 {
01383     Ice::MarshalException ex(__FILE__, __LINE__);
01384     ex.reason = "type BeobotEvents::MotorMessage was not generated with stream support";
01385     throw ex;
01386 }
01387 
01388 void
01389 BeobotEvents::MotorMessage::__read(const ::Ice::InputStreamPtr&, bool)
01390 {
01391     Ice::MarshalException ex(__FILE__, __LINE__);
01392     ex.reason = "type BeobotEvents::MotorMessage was not generated with stream support";
01393     throw ex;
01394 }
01395 
01396 class __F__BeobotEvents__MotorMessage : public ::Ice::ObjectFactory
01397 {
01398 public:
01399 
01400     virtual ::Ice::ObjectPtr
01401     create(const ::std::string& type)
01402     {
01403         assert(type == ::BeobotEvents::MotorMessage::ice_staticId());
01404         return new ::BeobotEvents::MotorMessage;
01405     }
01406 
01407     virtual void
01408     destroy()
01409     {
01410     }
01411 };
01412 
01413 static ::Ice::ObjectFactoryPtr __F__BeobotEvents__MotorMessage_Ptr = new __F__BeobotEvents__MotorMessage;
01414 
01415 const ::Ice::ObjectFactoryPtr&
01416 BeobotEvents::MotorMessage::ice_factory()
01417 {
01418     return __F__BeobotEvents__MotorMessage_Ptr;
01419 }
01420 
01421 class __F__BeobotEvents__MotorMessage__Init
01422 {
01423 public:
01424 
01425     __F__BeobotEvents__MotorMessage__Init()
01426     {
01427         ::IceInternal::factoryTable->addObjectFactory(::BeobotEvents::MotorMessage::ice_staticId(), ::BeobotEvents::MotorMessage::ice_factory());
01428     }
01429 
01430     ~__F__BeobotEvents__MotorMessage__Init()
01431     {
01432         ::IceInternal::factoryTable->removeObjectFactory(::BeobotEvents::MotorMessage::ice_staticId());
01433     }
01434 };
01435 
01436 static __F__BeobotEvents__MotorMessage__Init __F__BeobotEvents__MotorMessage__i;
01437 
01438 #ifdef __APPLE__
01439 extern "C" { void __F__BeobotEvents__MotorMessage__initializer() {} }
01440 #endif
01441 
01442 void
01443 BeobotEvents::__patch__MotorMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
01444 {
01445     ::BeobotEvents::MotorMessagePtr* p = static_cast< ::BeobotEvents::MotorMessagePtr*>(__addr);
01446     assert(p);
01447     *p = ::BeobotEvents::MotorMessagePtr::dynamicCast(v);
01448     if(v && !*p)
01449     {
01450         IceInternal::Ex::throwUOE(::BeobotEvents::MotorMessage::ice_staticId(), v->ice_id());
01451     }
01452 }
01453 
01454 bool
01455 BeobotEvents::operator==(const ::BeobotEvents::MotorMessage& l, const ::BeobotEvents::MotorMessage& r)
01456 {
01457     return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
01458 }
01459 
01460 bool
01461 BeobotEvents::operator<(const ::BeobotEvents::MotorMessage& l, const ::BeobotEvents::MotorMessage& r)
01462 {
01463     return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
01464 }
01465 
01466 BeobotEvents::MotorRequest::MotorRequest(::Ice::Double __ice_transVel, ::Ice::Double __ice_rotVel) :
01467     transVel(__ice_transVel),
01468     rotVel(__ice_rotVel)
01469 {
01470 }
01471 
01472 ::Ice::ObjectPtr
01473 BeobotEvents::MotorRequest::ice_clone() const
01474 {
01475     ::BeobotEvents::MotorRequestPtr __p = new ::BeobotEvents::MotorRequest(*this);
01476     return __p;
01477 }
01478 
01479 static const ::std::string __BeobotEvents__MotorRequest_ids[3] =
01480 {
01481     "::BeobotEvents::MotorRequest",
01482     "::Ice::Object",
01483     "::RobotSimEvents::EventMessage"
01484 };
01485 
01486 bool
01487 BeobotEvents::MotorRequest::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
01488 {
01489     return ::std::binary_search(__BeobotEvents__MotorRequest_ids, __BeobotEvents__MotorRequest_ids + 3, _s);
01490 }
01491 
01492 ::std::vector< ::std::string>
01493 BeobotEvents::MotorRequest::ice_ids(const ::Ice::Current&) const
01494 {
01495     return ::std::vector< ::std::string>(&__BeobotEvents__MotorRequest_ids[0], &__BeobotEvents__MotorRequest_ids[3]);
01496 }
01497 
01498 const ::std::string&
01499 BeobotEvents::MotorRequest::ice_id(const ::Ice::Current&) const
01500 {
01501     return __BeobotEvents__MotorRequest_ids[0];
01502 }
01503 
01504 const ::std::string&
01505 BeobotEvents::MotorRequest::ice_staticId()
01506 {
01507     return __BeobotEvents__MotorRequest_ids[0];
01508 }
01509 
01510 void
01511 BeobotEvents::MotorRequest::__write(::IceInternal::BasicStream* __os) const
01512 {
01513     __os->writeTypeId(ice_staticId());
01514     __os->startWriteSlice();
01515     __os->write(transVel);
01516     __os->write(rotVel);
01517     __os->endWriteSlice();
01518 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01519     EventMessage::__write(__os);
01520 #else
01521     ::RobotSimEvents::EventMessage::__write(__os);
01522 #endif
01523 }
01524 
01525 void
01526 BeobotEvents::MotorRequest::__read(::IceInternal::BasicStream* __is, bool __rid)
01527 {
01528     if(__rid)
01529     {
01530         ::std::string myId;
01531         __is->readTypeId(myId);
01532     }
01533     __is->startReadSlice();
01534     __is->read(transVel);
01535     __is->read(rotVel);
01536     __is->endReadSlice();
01537 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01538     EventMessage::__read(__is, true);
01539 #else
01540     ::RobotSimEvents::EventMessage::__read(__is, true);
01541 #endif
01542 }
01543 
01544 void
01545 BeobotEvents::MotorRequest::__write(const ::Ice::OutputStreamPtr&) const
01546 {
01547     Ice::MarshalException ex(__FILE__, __LINE__);
01548     ex.reason = "type BeobotEvents::MotorRequest was not generated with stream support";
01549     throw ex;
01550 }
01551 
01552 void
01553 BeobotEvents::MotorRequest::__read(const ::Ice::InputStreamPtr&, bool)
01554 {
01555     Ice::MarshalException ex(__FILE__, __LINE__);
01556     ex.reason = "type BeobotEvents::MotorRequest was not generated with stream support";
01557     throw ex;
01558 }
01559 
01560 class __F__BeobotEvents__MotorRequest : public ::Ice::ObjectFactory
01561 {
01562 public:
01563 
01564     virtual ::Ice::ObjectPtr
01565     create(const ::std::string& type)
01566     {
01567         assert(type == ::BeobotEvents::MotorRequest::ice_staticId());
01568         return new ::BeobotEvents::MotorRequest;
01569     }
01570 
01571     virtual void
01572     destroy()
01573     {
01574     }
01575 };
01576 
01577 static ::Ice::ObjectFactoryPtr __F__BeobotEvents__MotorRequest_Ptr = new __F__BeobotEvents__MotorRequest;
01578 
01579 const ::Ice::ObjectFactoryPtr&
01580 BeobotEvents::MotorRequest::ice_factory()
01581 {
01582     return __F__BeobotEvents__MotorRequest_Ptr;
01583 }
01584 
01585 class __F__BeobotEvents__MotorRequest__Init
01586 {
01587 public:
01588 
01589     __F__BeobotEvents__MotorRequest__Init()
01590     {
01591         ::IceInternal::factoryTable->addObjectFactory(::BeobotEvents::MotorRequest::ice_staticId(), ::BeobotEvents::MotorRequest::ice_factory());
01592     }
01593 
01594     ~__F__BeobotEvents__MotorRequest__Init()
01595     {
01596         ::IceInternal::factoryTable->removeObjectFactory(::BeobotEvents::MotorRequest::ice_staticId());
01597     }
01598 };
01599 
01600 static __F__BeobotEvents__MotorRequest__Init __F__BeobotEvents__MotorRequest__i;
01601 
01602 #ifdef __APPLE__
01603 extern "C" { void __F__BeobotEvents__MotorRequest__initializer() {} }
01604 #endif
01605 
01606 void
01607 BeobotEvents::__patch__MotorRequestPtr(void* __addr, ::Ice::ObjectPtr& v)
01608 {
01609     ::BeobotEvents::MotorRequestPtr* p = static_cast< ::BeobotEvents::MotorRequestPtr*>(__addr);
01610     assert(p);
01611     *p = ::BeobotEvents::MotorRequestPtr::dynamicCast(v);
01612     if(v && !*p)
01613     {
01614         IceInternal::Ex::throwUOE(::BeobotEvents::MotorRequest::ice_staticId(), v->ice_id());
01615     }
01616 }
01617 
01618 bool
01619 BeobotEvents::operator==(const ::BeobotEvents::MotorRequest& l, const ::BeobotEvents::MotorRequest& r)
01620 {
01621     return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
01622 }
01623 
01624 bool
01625 BeobotEvents::operator<(const ::BeobotEvents::MotorRequest& l, const ::BeobotEvents::MotorRequest& r)
01626 {
01627     return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
01628 }
01629 
01630 BeobotEvents::CornerMotorRequest::CornerMotorRequest(::Ice::Double __ice_transVel, ::Ice::Double __ice_rotVel, ::Ice::Int __ice_status) :
01631     transVel(__ice_transVel),
01632     rotVel(__ice_rotVel),
01633     status(__ice_status)
01634 {
01635 }
01636 
01637 ::Ice::ObjectPtr
01638 BeobotEvents::CornerMotorRequest::ice_clone() const
01639 {
01640     ::BeobotEvents::CornerMotorRequestPtr __p = new ::BeobotEvents::CornerMotorRequest(*this);
01641     return __p;
01642 }
01643 
01644 static const ::std::string __BeobotEvents__CornerMotorRequest_ids[3] =
01645 {
01646     "::BeobotEvents::CornerMotorRequest",
01647     "::Ice::Object",
01648     "::RobotSimEvents::EventMessage"
01649 };
01650 
01651 bool
01652 BeobotEvents::CornerMotorRequest::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
01653 {
01654     return ::std::binary_search(__BeobotEvents__CornerMotorRequest_ids, __BeobotEvents__CornerMotorRequest_ids + 3, _s);
01655 }
01656 
01657 ::std::vector< ::std::string>
01658 BeobotEvents::CornerMotorRequest::ice_ids(const ::Ice::Current&) const
01659 {
01660     return ::std::vector< ::std::string>(&__BeobotEvents__CornerMotorRequest_ids[0], &__BeobotEvents__CornerMotorRequest_ids[3]);
01661 }
01662 
01663 const ::std::string&
01664 BeobotEvents::CornerMotorRequest::ice_id(const ::Ice::Current&) const
01665 {
01666     return __BeobotEvents__CornerMotorRequest_ids[0];
01667 }
01668 
01669 const ::std::string&
01670 BeobotEvents::CornerMotorRequest::ice_staticId()
01671 {
01672     return __BeobotEvents__CornerMotorRequest_ids[0];
01673 }
01674 
01675 void
01676 BeobotEvents::CornerMotorRequest::__write(::IceInternal::BasicStream* __os) const
01677 {
01678     __os->writeTypeId(ice_staticId());
01679     __os->startWriteSlice();
01680     __os->write(transVel);
01681     __os->write(rotVel);
01682     __os->write(status);
01683     __os->endWriteSlice();
01684 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01685     EventMessage::__write(__os);
01686 #else
01687     ::RobotSimEvents::EventMessage::__write(__os);
01688 #endif
01689 }
01690 
01691 void
01692 BeobotEvents::CornerMotorRequest::__read(::IceInternal::BasicStream* __is, bool __rid)
01693 {
01694     if(__rid)
01695     {
01696         ::std::string myId;
01697         __is->readTypeId(myId);
01698     }
01699     __is->startReadSlice();
01700     __is->read(transVel);
01701     __is->read(rotVel);
01702     __is->read(status);
01703     __is->endReadSlice();
01704 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01705     EventMessage::__read(__is, true);
01706 #else
01707     ::RobotSimEvents::EventMessage::__read(__is, true);
01708 #endif
01709 }
01710 
01711 void
01712 BeobotEvents::CornerMotorRequest::__write(const ::Ice::OutputStreamPtr&) const
01713 {
01714     Ice::MarshalException ex(__FILE__, __LINE__);
01715     ex.reason = "type BeobotEvents::CornerMotorRequest was not generated with stream support";
01716     throw ex;
01717 }
01718 
01719 void
01720 BeobotEvents::CornerMotorRequest::__read(const ::Ice::InputStreamPtr&, bool)
01721 {
01722     Ice::MarshalException ex(__FILE__, __LINE__);
01723     ex.reason = "type BeobotEvents::CornerMotorRequest was not generated with stream support";
01724     throw ex;
01725 }
01726 
01727 class __F__BeobotEvents__CornerMotorRequest : public ::Ice::ObjectFactory
01728 {
01729 public:
01730 
01731     virtual ::Ice::ObjectPtr
01732     create(const ::std::string& type)
01733     {
01734         assert(type == ::BeobotEvents::CornerMotorRequest::ice_staticId());
01735         return new ::BeobotEvents::CornerMotorRequest;
01736     }
01737 
01738     virtual void
01739     destroy()
01740     {
01741     }
01742 };
01743 
01744 static ::Ice::ObjectFactoryPtr __F__BeobotEvents__CornerMotorRequest_Ptr = new __F__BeobotEvents__CornerMotorRequest;
01745 
01746 const ::Ice::ObjectFactoryPtr&
01747 BeobotEvents::CornerMotorRequest::ice_factory()
01748 {
01749     return __F__BeobotEvents__CornerMotorRequest_Ptr;
01750 }
01751 
01752 class __F__BeobotEvents__CornerMotorRequest__Init
01753 {
01754 public:
01755 
01756     __F__BeobotEvents__CornerMotorRequest__Init()
01757     {
01758         ::IceInternal::factoryTable->addObjectFactory(::BeobotEvents::CornerMotorRequest::ice_staticId(), ::BeobotEvents::CornerMotorRequest::ice_factory());
01759     }
01760 
01761     ~__F__BeobotEvents__CornerMotorRequest__Init()
01762     {
01763         ::IceInternal::factoryTable->removeObjectFactory(::BeobotEvents::CornerMotorRequest::ice_staticId());
01764     }
01765 };
01766 
01767 static __F__BeobotEvents__CornerMotorRequest__Init __F__BeobotEvents__CornerMotorRequest__i;
01768 
01769 #ifdef __APPLE__
01770 extern "C" { void __F__BeobotEvents__CornerMotorRequest__initializer() {} }
01771 #endif
01772 
01773 void
01774 BeobotEvents::__patch__CornerMotorRequestPtr(void* __addr, ::Ice::ObjectPtr& v)
01775 {
01776     ::BeobotEvents::CornerMotorRequestPtr* p = static_cast< ::BeobotEvents::CornerMotorRequestPtr*>(__addr);
01777     assert(p);
01778     *p = ::BeobotEvents::CornerMotorRequestPtr::dynamicCast(v);
01779     if(v && !*p)
01780     {
01781         IceInternal::Ex::throwUOE(::BeobotEvents::CornerMotorRequest::ice_staticId(), v->ice_id());
01782     }
01783 }
01784 
01785 bool
01786 BeobotEvents::operator==(const ::BeobotEvents::CornerMotorRequest& l, const ::BeobotEvents::CornerMotorRequest& r)
01787 {
01788     return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
01789 }
01790 
01791 bool
01792 BeobotEvents::operator<(const ::BeobotEvents::CornerMotorRequest& l, const ::BeobotEvents::CornerMotorRequest& r)
01793 {
01794     return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
01795 }
01796 
01797 BeobotEvents::CornerLocationMessage::CornerLocationMessage(::Ice::Int __ice_cornerLocation) :
01798     cornerLocation(__ice_cornerLocation)
01799 {
01800 }
01801 
01802 ::Ice::ObjectPtr
01803 BeobotEvents::CornerLocationMessage::ice_clone() const
01804 {
01805     ::BeobotEvents::CornerLocationMessagePtr __p = new ::BeobotEvents::CornerLocationMessage(*this);
01806     return __p;
01807 }
01808 
01809 static const ::std::string __BeobotEvents__CornerLocationMessage_ids[3] =
01810 {
01811     "::BeobotEvents::CornerLocationMessage",
01812     "::Ice::Object",
01813     "::RobotSimEvents::EventMessage"
01814 };
01815 
01816 bool
01817 BeobotEvents::CornerLocationMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
01818 {
01819     return ::std::binary_search(__BeobotEvents__CornerLocationMessage_ids, __BeobotEvents__CornerLocationMessage_ids + 3, _s);
01820 }
01821 
01822 ::std::vector< ::std::string>
01823 BeobotEvents::CornerLocationMessage::ice_ids(const ::Ice::Current&) const
01824 {
01825     return ::std::vector< ::std::string>(&__BeobotEvents__CornerLocationMessage_ids[0], &__BeobotEvents__CornerLocationMessage_ids[3]);
01826 }
01827 
01828 const ::std::string&
01829 BeobotEvents::CornerLocationMessage::ice_id(const ::Ice::Current&) const
01830 {
01831     return __BeobotEvents__CornerLocationMessage_ids[0];
01832 }
01833 
01834 const ::std::string&
01835 BeobotEvents::CornerLocationMessage::ice_staticId()
01836 {
01837     return __BeobotEvents__CornerLocationMessage_ids[0];
01838 }
01839 
01840 void
01841 BeobotEvents::CornerLocationMessage::__write(::IceInternal::BasicStream* __os) const
01842 {
01843     __os->writeTypeId(ice_staticId());
01844     __os->startWriteSlice();
01845     __os->write(cornerLocation);
01846     __os->endWriteSlice();
01847 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01848     EventMessage::__write(__os);
01849 #else
01850     ::RobotSimEvents::EventMessage::__write(__os);
01851 #endif
01852 }
01853 
01854 void
01855 BeobotEvents::CornerLocationMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
01856 {
01857     if(__rid)
01858     {
01859         ::std::string myId;
01860         __is->readTypeId(myId);
01861     }
01862     __is->startReadSlice();
01863     __is->read(cornerLocation);
01864     __is->endReadSlice();
01865 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01866     EventMessage::__read(__is, true);
01867 #else
01868     ::RobotSimEvents::EventMessage::__read(__is, true);
01869 #endif
01870 }
01871 
01872 void
01873 BeobotEvents::CornerLocationMessage::__write(const ::Ice::OutputStreamPtr&) const
01874 {
01875     Ice::MarshalException ex(__FILE__, __LINE__);
01876     ex.reason = "type BeobotEvents::CornerLocationMessage was not generated with stream support";
01877     throw ex;
01878 }
01879 
01880 void
01881 BeobotEvents::CornerLocationMessage::__read(const ::Ice::InputStreamPtr&, bool)
01882 {
01883     Ice::MarshalException ex(__FILE__, __LINE__);
01884     ex.reason = "type BeobotEvents::CornerLocationMessage was not generated with stream support";
01885     throw ex;
01886 }
01887 
01888 class __F__BeobotEvents__CornerLocationMessage : public ::Ice::ObjectFactory
01889 {
01890 public:
01891 
01892     virtual ::Ice::ObjectPtr
01893     create(const ::std::string& type)
01894     {
01895         assert(type == ::BeobotEvents::CornerLocationMessage::ice_staticId());
01896         return new ::BeobotEvents::CornerLocationMessage;
01897     }
01898 
01899     virtual void
01900     destroy()
01901     {
01902     }
01903 };
01904 
01905 static ::Ice::ObjectFactoryPtr __F__BeobotEvents__CornerLocationMessage_Ptr = new __F__BeobotEvents__CornerLocationMessage;
01906 
01907 const ::Ice::ObjectFactoryPtr&
01908 BeobotEvents::CornerLocationMessage::ice_factory()
01909 {
01910     return __F__BeobotEvents__CornerLocationMessage_Ptr;
01911 }
01912 
01913 class __F__BeobotEvents__CornerLocationMessage__Init
01914 {
01915 public:
01916 
01917     __F__BeobotEvents__CornerLocationMessage__Init()
01918     {
01919         ::IceInternal::factoryTable->addObjectFactory(::BeobotEvents::CornerLocationMessage::ice_staticId(), ::BeobotEvents::CornerLocationMessage::ice_factory());
01920     }
01921 
01922     ~__F__BeobotEvents__CornerLocationMessage__Init()
01923     {
01924         ::IceInternal::factoryTable->removeObjectFactory(::BeobotEvents::CornerLocationMessage::ice_staticId());
01925     }
01926 };
01927 
01928 static __F__BeobotEvents__CornerLocationMessage__Init __F__BeobotEvents__CornerLocationMessage__i;
01929 
01930 #ifdef __APPLE__
01931 extern "C" { void __F__BeobotEvents__CornerLocationMessage__initializer() {} }
01932 #endif
01933 
01934 void
01935 BeobotEvents::__patch__CornerLocationMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
01936 {
01937     ::BeobotEvents::CornerLocationMessagePtr* p = static_cast< ::BeobotEvents::CornerLocationMessagePtr*>(__addr);
01938     assert(p);
01939     *p = ::BeobotEvents::CornerLocationMessagePtr::dynamicCast(v);
01940     if(v && !*p)
01941     {
01942         IceInternal::Ex::throwUOE(::BeobotEvents::CornerLocationMessage::ice_staticId(), v->ice_id());
01943     }
01944 }
01945 
01946 bool
01947 BeobotEvents::operator==(const ::BeobotEvents::CornerLocationMessage& l, const ::BeobotEvents::CornerLocationMessage& r)
01948 {
01949     return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
01950 }
01951 
01952 bool
01953 BeobotEvents::operator<(const ::BeobotEvents::CornerLocationMessage& l, const ::BeobotEvents::CornerLocationMessage& r)
01954 {
01955     return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
01956 }
01957 
01958 BeobotEvents::SonarMessage::SonarMessage(const ::BeobotEvents::DoubleSeq& __ice_distances, const ::BeobotEvents::DoubleSeq& __ice_angles) :
01959     distances(__ice_distances),
01960     angles(__ice_angles)
01961 {
01962 }
01963 
01964 ::Ice::ObjectPtr
01965 BeobotEvents::SonarMessage::ice_clone() const
01966 {
01967     ::BeobotEvents::SonarMessagePtr __p = new ::BeobotEvents::SonarMessage(*this);
01968     return __p;
01969 }
01970 
01971 static const ::std::string __BeobotEvents__SonarMessage_ids[3] =
01972 {
01973     "::BeobotEvents::SonarMessage",
01974     "::Ice::Object",
01975     "::RobotSimEvents::EventMessage"
01976 };
01977 
01978 bool
01979 BeobotEvents::SonarMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
01980 {
01981     return ::std::binary_search(__BeobotEvents__SonarMessage_ids, __BeobotEvents__SonarMessage_ids + 3, _s);
01982 }
01983 
01984 ::std::vector< ::std::string>
01985 BeobotEvents::SonarMessage::ice_ids(const ::Ice::Current&) const
01986 {
01987     return ::std::vector< ::std::string>(&__BeobotEvents__SonarMessage_ids[0], &__BeobotEvents__SonarMessage_ids[3]);
01988 }
01989 
01990 const ::std::string&
01991 BeobotEvents::SonarMessage::ice_id(const ::Ice::Current&) const
01992 {
01993     return __BeobotEvents__SonarMessage_ids[0];
01994 }
01995 
01996 const ::std::string&
01997 BeobotEvents::SonarMessage::ice_staticId()
01998 {
01999     return __BeobotEvents__SonarMessage_ids[0];
02000 }
02001 
02002 void
02003 BeobotEvents::SonarMessage::__write(::IceInternal::BasicStream* __os) const
02004 {
02005     __os->writeTypeId(ice_staticId());
02006     __os->startWriteSlice();
02007     if(distances.size() == 0)
02008     {
02009         __os->writeSize(0);
02010     }
02011     else
02012     {
02013         __os->write(&distances[0], &distances[0] + distances.size());
02014     }
02015     if(angles.size() == 0)
02016     {
02017         __os->writeSize(0);
02018     }
02019     else
02020     {
02021         __os->write(&angles[0], &angles[0] + angles.size());
02022     }
02023     __os->endWriteSlice();
02024 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02025     EventMessage::__write(__os);
02026 #else
02027     ::RobotSimEvents::EventMessage::__write(__os);
02028 #endif
02029 }
02030 
02031 void
02032 BeobotEvents::SonarMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
02033 {
02034     if(__rid)
02035     {
02036         ::std::string myId;
02037         __is->readTypeId(myId);
02038     }
02039     __is->startReadSlice();
02040     __is->read(distances);
02041     __is->read(angles);
02042     __is->endReadSlice();
02043 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02044     EventMessage::__read(__is, true);
02045 #else
02046     ::RobotSimEvents::EventMessage::__read(__is, true);
02047 #endif
02048 }
02049 
02050 void
02051 BeobotEvents::SonarMessage::__write(const ::Ice::OutputStreamPtr&) const
02052 {
02053     Ice::MarshalException ex(__FILE__, __LINE__);
02054     ex.reason = "type BeobotEvents::SonarMessage was not generated with stream support";
02055     throw ex;
02056 }
02057 
02058 void
02059 BeobotEvents::SonarMessage::__read(const ::Ice::InputStreamPtr&, bool)
02060 {
02061     Ice::MarshalException ex(__FILE__, __LINE__);
02062     ex.reason = "type BeobotEvents::SonarMessage was not generated with stream support";
02063     throw ex;
02064 }
02065 
02066 class __F__BeobotEvents__SonarMessage : public ::Ice::ObjectFactory
02067 {
02068 public:
02069 
02070     virtual ::Ice::ObjectPtr
02071     create(const ::std::string& type)
02072     {
02073         assert(type == ::BeobotEvents::SonarMessage::ice_staticId());
02074         return new ::BeobotEvents::SonarMessage;
02075     }
02076 
02077     virtual void
02078     destroy()
02079     {
02080     }
02081 };
02082 
02083 static ::Ice::ObjectFactoryPtr __F__BeobotEvents__SonarMessage_Ptr = new __F__BeobotEvents__SonarMessage;
02084 
02085 const ::Ice::ObjectFactoryPtr&
02086 BeobotEvents::SonarMessage::ice_factory()
02087 {
02088     return __F__BeobotEvents__SonarMessage_Ptr;
02089 }
02090 
02091 class __F__BeobotEvents__SonarMessage__Init
02092 {
02093 public:
02094 
02095     __F__BeobotEvents__SonarMessage__Init()
02096     {
02097         ::IceInternal::factoryTable->addObjectFactory(::BeobotEvents::SonarMessage::ice_staticId(), ::BeobotEvents::SonarMessage::ice_factory());
02098     }
02099 
02100     ~__F__BeobotEvents__SonarMessage__Init()
02101     {
02102         ::IceInternal::factoryTable->removeObjectFactory(::BeobotEvents::SonarMessage::ice_staticId());
02103     }
02104 };
02105 
02106 static __F__BeobotEvents__SonarMessage__Init __F__BeobotEvents__SonarMessage__i;
02107 
02108 #ifdef __APPLE__
02109 extern "C" { void __F__BeobotEvents__SonarMessage__initializer() {} }
02110 #endif
02111 
02112 void
02113 BeobotEvents::__patch__SonarMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
02114 {
02115     ::BeobotEvents::SonarMessagePtr* p = static_cast< ::BeobotEvents::SonarMessagePtr*>(__addr);
02116     assert(p);
02117     *p = ::BeobotEvents::SonarMessagePtr::dynamicCast(v);
02118     if(v && !*p)
02119     {
02120         IceInternal::Ex::throwUOE(::BeobotEvents::SonarMessage::ice_staticId(), v->ice_id());
02121     }
02122 }
02123 
02124 bool
02125 BeobotEvents::operator==(const ::BeobotEvents::SonarMessage& l, const ::BeobotEvents::SonarMessage& r)
02126 {
02127     return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
02128 }
02129 
02130 bool
02131 BeobotEvents::operator<(const ::BeobotEvents::SonarMessage& l, const ::BeobotEvents::SonarMessage& r)
02132 {
02133     return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
02134 }
02135 
02136 BeobotEvents::GPSMessage::GPSMessage(::Ice::Double __ice_latitude, ::Ice::Double __ice_longitude, ::Ice::Int __ice_precision, ::Ice::Int __ice_satNum, ::Ice::Int __ice_RequestID) :
02137     latitude(__ice_latitude),
02138     longitude(__ice_longitude),
02139     precision(__ice_precision),
02140     satNum(__ice_satNum),
02141     RequestID(__ice_RequestID)
02142 {
02143 }
02144 
02145 ::Ice::ObjectPtr
02146 BeobotEvents::GPSMessage::ice_clone() const
02147 {
02148     ::BeobotEvents::GPSMessagePtr __p = new ::BeobotEvents::GPSMessage(*this);
02149     return __p;
02150 }
02151 
02152 static const ::std::string __BeobotEvents__GPSMessage_ids[3] =
02153 {
02154     "::BeobotEvents::GPSMessage",
02155     "::Ice::Object",
02156     "::RobotSimEvents::EventMessage"
02157 };
02158 
02159 bool
02160 BeobotEvents::GPSMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
02161 {
02162     return ::std::binary_search(__BeobotEvents__GPSMessage_ids, __BeobotEvents__GPSMessage_ids + 3, _s);
02163 }
02164 
02165 ::std::vector< ::std::string>
02166 BeobotEvents::GPSMessage::ice_ids(const ::Ice::Current&) const
02167 {
02168     return ::std::vector< ::std::string>(&__BeobotEvents__GPSMessage_ids[0], &__BeobotEvents__GPSMessage_ids[3]);
02169 }
02170 
02171 const ::std::string&
02172 BeobotEvents::GPSMessage::ice_id(const ::Ice::Current&) const
02173 {
02174     return __BeobotEvents__GPSMessage_ids[0];
02175 }
02176 
02177 const ::std::string&
02178 BeobotEvents::GPSMessage::ice_staticId()
02179 {
02180     return __BeobotEvents__GPSMessage_ids[0];
02181 }
02182 
02183 void
02184 BeobotEvents::GPSMessage::__write(::IceInternal::BasicStream* __os) const
02185 {
02186     __os->writeTypeId(ice_staticId());
02187     __os->startWriteSlice();
02188     __os->write(latitude);
02189     __os->write(longitude);
02190     __os->write(precision);
02191     __os->write(satNum);
02192     __os->write(RequestID);
02193     __os->endWriteSlice();
02194 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02195     EventMessage::__write(__os);
02196 #else
02197     ::RobotSimEvents::EventMessage::__write(__os);
02198 #endif
02199 }
02200 
02201 void
02202 BeobotEvents::GPSMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
02203 {
02204     if(__rid)
02205     {
02206         ::std::string myId;
02207         __is->readTypeId(myId);
02208     }
02209     __is->startReadSlice();
02210     __is->read(latitude);
02211     __is->read(longitude);
02212     __is->read(precision);
02213     __is->read(satNum);
02214     __is->read(RequestID);
02215     __is->endReadSlice();
02216 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02217     EventMessage::__read(__is, true);
02218 #else
02219     ::RobotSimEvents::EventMessage::__read(__is, true);
02220 #endif
02221 }
02222 
02223 void
02224 BeobotEvents::GPSMessage::__write(const ::Ice::OutputStreamPtr&) const
02225 {
02226     Ice::MarshalException ex(__FILE__, __LINE__);
02227     ex.reason = "type BeobotEvents::GPSMessage was not generated with stream support";
02228     throw ex;
02229 }
02230 
02231 void
02232 BeobotEvents::GPSMessage::__read(const ::Ice::InputStreamPtr&, bool)
02233 {
02234     Ice::MarshalException ex(__FILE__, __LINE__);
02235     ex.reason = "type BeobotEvents::GPSMessage was not generated with stream support";
02236     throw ex;
02237 }
02238 
02239 class __F__BeobotEvents__GPSMessage : public ::Ice::ObjectFactory
02240 {
02241 public:
02242 
02243     virtual ::Ice::ObjectPtr
02244     create(const ::std::string& type)
02245     {
02246         assert(type == ::BeobotEvents::GPSMessage::ice_staticId());
02247         return new ::BeobotEvents::GPSMessage;
02248     }
02249 
02250     virtual void
02251     destroy()
02252     {
02253     }
02254 };
02255 
02256 static ::Ice::ObjectFactoryPtr __F__BeobotEvents__GPSMessage_Ptr = new __F__BeobotEvents__GPSMessage;
02257 
02258 const ::Ice::ObjectFactoryPtr&
02259 BeobotEvents::GPSMessage::ice_factory()
02260 {
02261     return __F__BeobotEvents__GPSMessage_Ptr;
02262 }
02263 
02264 class __F__BeobotEvents__GPSMessage__Init
02265 {
02266 public:
02267 
02268     __F__BeobotEvents__GPSMessage__Init()
02269     {
02270         ::IceInternal::factoryTable->addObjectFactory(::BeobotEvents::GPSMessage::ice_staticId(), ::BeobotEvents::GPSMessage::ice_factory());
02271     }
02272 
02273     ~__F__BeobotEvents__GPSMessage__Init()
02274     {
02275         ::IceInternal::factoryTable->removeObjectFactory(::BeobotEvents::GPSMessage::ice_staticId());
02276     }
02277 };
02278 
02279 static __F__BeobotEvents__GPSMessage__Init __F__BeobotEvents__GPSMessage__i;
02280 
02281 #ifdef __APPLE__
02282 extern "C" { void __F__BeobotEvents__GPSMessage__initializer() {} }
02283 #endif
02284 
02285 void
02286 BeobotEvents::__patch__GPSMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
02287 {
02288     ::BeobotEvents::GPSMessagePtr* p = static_cast< ::BeobotEvents::GPSMessagePtr*>(__addr);
02289     assert(p);
02290     *p = ::BeobotEvents::GPSMessagePtr::dynamicCast(v);
02291     if(v && !*p)
02292     {
02293         IceInternal::Ex::throwUOE(::BeobotEvents::GPSMessage::ice_staticId(), v->ice_id());
02294     }
02295 }
02296 
02297 bool
02298 BeobotEvents::operator==(const ::BeobotEvents::GPSMessage& l, const ::BeobotEvents::GPSMessage& r)
02299 {
02300     return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
02301 }
02302 
02303 bool
02304 BeobotEvents::operator<(const ::BeobotEvents::GPSMessage& l, const ::BeobotEvents::GPSMessage& r)
02305 {
02306     return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
02307 }
02308 
02309 BeobotEvents::LRFMessage::LRFMessage(const ::BeobotEvents::DoubleSeq& __ice_distances, const ::BeobotEvents::DoubleSeq& __ice_angles, ::Ice::Int __ice_RequestID) :
02310     distances(__ice_distances),
02311     angles(__ice_angles),
02312     RequestID(__ice_RequestID)
02313 {
02314 }
02315 
02316 ::Ice::ObjectPtr
02317 BeobotEvents::LRFMessage::ice_clone() const
02318 {
02319     ::BeobotEvents::LRFMessagePtr __p = new ::BeobotEvents::LRFMessage(*this);
02320     return __p;
02321 }
02322 
02323 static const ::std::string __BeobotEvents__LRFMessage_ids[3] =
02324 {
02325     "::BeobotEvents::LRFMessage",
02326     "::Ice::Object",
02327     "::RobotSimEvents::EventMessage"
02328 };
02329 
02330 bool
02331 BeobotEvents::LRFMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
02332 {
02333     return ::std::binary_search(__BeobotEvents__LRFMessage_ids, __BeobotEvents__LRFMessage_ids + 3, _s);
02334 }
02335 
02336 ::std::vector< ::std::string>
02337 BeobotEvents::LRFMessage::ice_ids(const ::Ice::Current&) const
02338 {
02339     return ::std::vector< ::std::string>(&__BeobotEvents__LRFMessage_ids[0], &__BeobotEvents__LRFMessage_ids[3]);
02340 }
02341 
02342 const ::std::string&
02343 BeobotEvents::LRFMessage::ice_id(const ::Ice::Current&) const
02344 {
02345     return __BeobotEvents__LRFMessage_ids[0];
02346 }
02347 
02348 const ::std::string&
02349 BeobotEvents::LRFMessage::ice_staticId()
02350 {
02351     return __BeobotEvents__LRFMessage_ids[0];
02352 }
02353 
02354 void
02355 BeobotEvents::LRFMessage::__write(::IceInternal::BasicStream* __os) const
02356 {
02357     __os->writeTypeId(ice_staticId());
02358     __os->startWriteSlice();
02359     if(distances.size() == 0)
02360     {
02361         __os->writeSize(0);
02362     }
02363     else
02364     {
02365         __os->write(&distances[0], &distances[0] + distances.size());
02366     }
02367     if(angles.size() == 0)
02368     {
02369         __os->writeSize(0);
02370     }
02371     else
02372     {
02373         __os->write(&angles[0], &angles[0] + angles.size());
02374     }
02375     __os->write(RequestID);
02376     __os->endWriteSlice();
02377 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02378     EventMessage::__write(__os);
02379 #else
02380     ::RobotSimEvents::EventMessage::__write(__os);
02381 #endif
02382 }
02383 
02384 void
02385 BeobotEvents::LRFMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
02386 {
02387     if(__rid)
02388     {
02389         ::std::string myId;
02390         __is->readTypeId(myId);
02391     }
02392     __is->startReadSlice();
02393     __is->read(distances);
02394     __is->read(angles);
02395     __is->read(RequestID);
02396     __is->endReadSlice();
02397 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02398     EventMessage::__read(__is, true);
02399 #else
02400     ::RobotSimEvents::EventMessage::__read(__is, true);
02401 #endif
02402 }
02403 
02404 void
02405 BeobotEvents::LRFMessage::__write(const ::Ice::OutputStreamPtr&) const
02406 {
02407     Ice::MarshalException ex(__FILE__, __LINE__);
02408     ex.reason = "type BeobotEvents::LRFMessage was not generated with stream support";
02409     throw ex;
02410 }
02411 
02412 void
02413 BeobotEvents::LRFMessage::__read(const ::Ice::InputStreamPtr&, bool)
02414 {
02415     Ice::MarshalException ex(__FILE__, __LINE__);
02416     ex.reason = "type BeobotEvents::LRFMessage was not generated with stream support";
02417     throw ex;
02418 }
02419 
02420 class __F__BeobotEvents__LRFMessage : public ::Ice::ObjectFactory
02421 {
02422 public:
02423 
02424     virtual ::Ice::ObjectPtr
02425     create(const ::std::string& type)
02426     {
02427         assert(type == ::BeobotEvents::LRFMessage::ice_staticId());
02428         return new ::BeobotEvents::LRFMessage;
02429     }
02430 
02431     virtual void
02432     destroy()
02433     {
02434     }
02435 };
02436 
02437 static ::Ice::ObjectFactoryPtr __F__BeobotEvents__LRFMessage_Ptr = new __F__BeobotEvents__LRFMessage;
02438 
02439 const ::Ice::ObjectFactoryPtr&
02440 BeobotEvents::LRFMessage::ice_factory()
02441 {
02442     return __F__BeobotEvents__LRFMessage_Ptr;
02443 }
02444 
02445 class __F__BeobotEvents__LRFMessage__Init
02446 {
02447 public:
02448 
02449     __F__BeobotEvents__LRFMessage__Init()
02450     {
02451         ::IceInternal::factoryTable->addObjectFactory(::BeobotEvents::LRFMessage::ice_staticId(), ::BeobotEvents::LRFMessage::ice_factory());
02452     }
02453 
02454     ~__F__BeobotEvents__LRFMessage__Init()
02455     {
02456         ::IceInternal::factoryTable->removeObjectFactory(::BeobotEvents::LRFMessage::ice_staticId());
02457     }
02458 };
02459 
02460 static __F__BeobotEvents__LRFMessage__Init __F__BeobotEvents__LRFMessage__i;
02461 
02462 #ifdef __APPLE__
02463 extern "C" { void __F__BeobotEvents__LRFMessage__initializer() {} }
02464 #endif
02465 
02466 void
02467 BeobotEvents::__patch__LRFMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
02468 {
02469     ::BeobotEvents::LRFMessagePtr* p = static_cast< ::BeobotEvents::LRFMessagePtr*>(__addr);
02470     assert(p);
02471     *p = ::BeobotEvents::LRFMessagePtr::dynamicCast(v);
02472     if(v && !*p)
02473     {
02474         IceInternal::Ex::throwUOE(::BeobotEvents::LRFMessage::ice_staticId(), v->ice_id());
02475     }
02476 }
02477 
02478 bool
02479 BeobotEvents::operator==(const ::BeobotEvents::LRFMessage& l, const ::BeobotEvents::LRFMessage& r)
02480 {
02481     return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
02482 }
02483 
02484 bool
02485 BeobotEvents::operator<(const ::BeobotEvents::LRFMessage& l, const ::BeobotEvents::LRFMessage& r)
02486 {
02487     return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
02488 }
02489 
02490 BeobotEvents::SLAMMessage::SLAMMessage(::Ice::Double __ice_mapResolution, ::Ice::Double __ice_robotX, ::Ice::Double __ice_robotY, ::Ice::Double __ice_robotOri, ::Ice::Int __ice_RequestID) :
02491     mapResolution(__ice_mapResolution),
02492     robotX(__ice_robotX),
02493     robotY(__ice_robotY),
02494     robotOri(__ice_robotOri),
02495     RequestID(__ice_RequestID)
02496 {
02497 }
02498 
02499 ::Ice::ObjectPtr
02500 BeobotEvents::SLAMMessage::ice_clone() const
02501 {
02502     ::BeobotEvents::SLAMMessagePtr __p = new ::BeobotEvents::SLAMMessage(*this);
02503     return __p;
02504 }
02505 
02506 static const ::std::string __BeobotEvents__SLAMMessage_ids[3] =
02507 {
02508     "::BeobotEvents::SLAMMessage",
02509     "::Ice::Object",
02510     "::RobotSimEvents::EventMessage"
02511 };
02512 
02513 bool
02514 BeobotEvents::SLAMMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
02515 {
02516     return ::std::binary_search(__BeobotEvents__SLAMMessage_ids, __BeobotEvents__SLAMMessage_ids + 3, _s);
02517 }
02518 
02519 ::std::vector< ::std::string>
02520 BeobotEvents::SLAMMessage::ice_ids(const ::Ice::Current&) const
02521 {
02522     return ::std::vector< ::std::string>(&__BeobotEvents__SLAMMessage_ids[0], &__BeobotEvents__SLAMMessage_ids[3]);
02523 }
02524 
02525 const ::std::string&
02526 BeobotEvents::SLAMMessage::ice_id(const ::Ice::Current&) const
02527 {
02528     return __BeobotEvents__SLAMMessage_ids[0];
02529 }
02530 
02531 const ::std::string&
02532 BeobotEvents::SLAMMessage::ice_staticId()
02533 {
02534     return __BeobotEvents__SLAMMessage_ids[0];
02535 }
02536 
02537 void
02538 BeobotEvents::SLAMMessage::__write(::IceInternal::BasicStream* __os) const
02539 {
02540     __os->writeTypeId(ice_staticId());
02541     __os->startWriteSlice();
02542     __os->write(mapResolution);
02543     __os->write(robotX);
02544     __os->write(robotY);
02545     __os->write(robotOri);
02546     __os->write(RequestID);
02547     __os->endWriteSlice();
02548 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02549     EventMessage::__write(__os);
02550 #else
02551     ::RobotSimEvents::EventMessage::__write(__os);
02552 #endif
02553 }
02554 
02555 void
02556 BeobotEvents::SLAMMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
02557 {
02558     if(__rid)
02559     {
02560         ::std::string myId;
02561         __is->readTypeId(myId);
02562     }
02563     __is->startReadSlice();
02564     __is->read(mapResolution);
02565     __is->read(robotX);
02566     __is->read(robotY);
02567     __is->read(robotOri);
02568     __is->read(RequestID);
02569     __is->endReadSlice();
02570 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02571     EventMessage::__read(__is, true);
02572 #else
02573     ::RobotSimEvents::EventMessage::__read(__is, true);
02574 #endif
02575 }
02576 
02577 void
02578 BeobotEvents::SLAMMessage::__write(const ::Ice::OutputStreamPtr&) const
02579 {
02580     Ice::MarshalException ex(__FILE__, __LINE__);
02581     ex.reason = "type BeobotEvents::SLAMMessage was not generated with stream support";
02582     throw ex;
02583 }
02584 
02585 void
02586 BeobotEvents::SLAMMessage::__read(const ::Ice::InputStreamPtr&, bool)
02587 {
02588     Ice::MarshalException ex(__FILE__, __LINE__);
02589     ex.reason = "type BeobotEvents::SLAMMessage was not generated with stream support";
02590     throw ex;
02591 }
02592 
02593 class __F__BeobotEvents__SLAMMessage : public ::Ice::ObjectFactory
02594 {
02595 public:
02596 
02597     virtual ::Ice::ObjectPtr
02598     create(const ::std::string& type)
02599     {
02600         assert(type == ::BeobotEvents::SLAMMessage::ice_staticId());
02601         return new ::BeobotEvents::SLAMMessage;
02602     }
02603 
02604     virtual void
02605     destroy()
02606     {
02607     }
02608 };
02609 
02610 static ::Ice::ObjectFactoryPtr __F__BeobotEvents__SLAMMessage_Ptr = new __F__BeobotEvents__SLAMMessage;
02611 
02612 const ::Ice::ObjectFactoryPtr&
02613 BeobotEvents::SLAMMessage::ice_factory()
02614 {
02615     return __F__BeobotEvents__SLAMMessage_Ptr;
02616 }
02617 
02618 class __F__BeobotEvents__SLAMMessage__Init
02619 {
02620 public:
02621 
02622     __F__BeobotEvents__SLAMMessage__Init()
02623     {
02624         ::IceInternal::factoryTable->addObjectFactory(::BeobotEvents::SLAMMessage::ice_staticId(), ::BeobotEvents::SLAMMessage::ice_factory());
02625     }
02626 
02627     ~__F__BeobotEvents__SLAMMessage__Init()
02628     {
02629         ::IceInternal::factoryTable->removeObjectFactory(::BeobotEvents::SLAMMessage::ice_staticId());
02630     }
02631 };
02632 
02633 static __F__BeobotEvents__SLAMMessage__Init __F__BeobotEvents__SLAMMessage__i;
02634 
02635 #ifdef __APPLE__
02636 extern "C" { void __F__BeobotEvents__SLAMMessage__initializer() {} }
02637 #endif
02638 
02639 void
02640 BeobotEvents::__patch__SLAMMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
02641 {
02642     ::BeobotEvents::SLAMMessagePtr* p = static_cast< ::BeobotEvents::SLAMMessagePtr*>(__addr);
02643     assert(p);
02644     *p = ::BeobotEvents::SLAMMessagePtr::dynamicCast(v);
02645     if(v && !*p)
02646     {
02647         IceInternal::Ex::throwUOE(::BeobotEvents::SLAMMessage::ice_staticId(), v->ice_id());
02648     }
02649 }
02650 
02651 bool
02652 BeobotEvents::operator==(const ::BeobotEvents::SLAMMessage& l, const ::BeobotEvents::SLAMMessage& r)
02653 {
02654     return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
02655 }
02656 
02657 bool
02658 BeobotEvents::operator<(const ::BeobotEvents::SLAMMessage& l, const ::BeobotEvents::SLAMMessage& r)
02659 {
02660     return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
02661 }
02662 
02663 BeobotEvents::IMUMessage::IMUMessage(bool __ice_validAccAndAng, ::Ice::Float __ice_accelX, ::Ice::Float __ice_accelY, ::Ice::Float __ice_accelZ, ::Ice::Float __ice_angRateX, ::Ice::Float __ice_angRateY, ::Ice::Float __ice_angRateZ, bool __ice_validRollPitchYaw, ::Ice::Float __ice_roll, ::Ice::Float __ice_pitch, ::Ice::Float __ice_yaw, bool __ice_validMagnetometer, ::Ice::Float __ice_magX, ::Ice::Float __ice_magY, ::Ice::Float __ice_magZ, ::Ice::Int __ice_RequestID) :
02664     validAccAndAng(__ice_validAccAndAng),
02665     accelX(__ice_accelX),
02666     accelY(__ice_accelY),
02667     accelZ(__ice_accelZ),
02668     angRateX(__ice_angRateX),
02669     angRateY(__ice_angRateY),
02670     angRateZ(__ice_angRateZ),
02671     validRollPitchYaw(__ice_validRollPitchYaw),
02672     roll(__ice_roll),
02673     pitch(__ice_pitch),
02674     yaw(__ice_yaw),
02675     validMagnetometer(__ice_validMagnetometer),
02676     magX(__ice_magX),
02677     magY(__ice_magY),
02678     magZ(__ice_magZ),
02679     RequestID(__ice_RequestID)
02680 {
02681 }
02682 
02683 ::Ice::ObjectPtr
02684 BeobotEvents::IMUMessage::ice_clone() const
02685 {
02686     ::BeobotEvents::IMUMessagePtr __p = new ::BeobotEvents::IMUMessage(*this);
02687     return __p;
02688 }
02689 
02690 static const ::std::string __BeobotEvents__IMUMessage_ids[3] =
02691 {
02692     "::BeobotEvents::IMUMessage",
02693     "::Ice::Object",
02694     "::RobotSimEvents::EventMessage"
02695 };
02696 
02697 bool
02698 BeobotEvents::IMUMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
02699 {
02700     return ::std::binary_search(__BeobotEvents__IMUMessage_ids, __BeobotEvents__IMUMessage_ids + 3, _s);
02701 }
02702 
02703 ::std::vector< ::std::string>
02704 BeobotEvents::IMUMessage::ice_ids(const ::Ice::Current&) const
02705 {
02706     return ::std::vector< ::std::string>(&__BeobotEvents__IMUMessage_ids[0], &__BeobotEvents__IMUMessage_ids[3]);
02707 }
02708 
02709 const ::std::string&
02710 BeobotEvents::IMUMessage::ice_id(const ::Ice::Current&) const
02711 {
02712     return __BeobotEvents__IMUMessage_ids[0];
02713 }
02714 
02715 const ::std::string&
02716 BeobotEvents::IMUMessage::ice_staticId()
02717 {
02718     return __BeobotEvents__IMUMessage_ids[0];
02719 }
02720 
02721 void
02722 BeobotEvents::IMUMessage::__write(::IceInternal::BasicStream* __os) const
02723 {
02724     __os->writeTypeId(ice_staticId());
02725     __os->startWriteSlice();
02726     __os->write(validAccAndAng);
02727     __os->write(accelX);
02728     __os->write(accelY);
02729     __os->write(accelZ);
02730     __os->write(angRateX);
02731     __os->write(angRateY);
02732     __os->write(angRateZ);
02733     __os->write(validRollPitchYaw);
02734     __os->write(roll);
02735     __os->write(pitch);
02736     __os->write(yaw);
02737     __os->write(validMagnetometer);
02738     __os->write(magX);
02739     __os->write(magY);
02740     __os->write(magZ);
02741     __os->write(RequestID);
02742     __os->endWriteSlice();
02743 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02744     EventMessage::__write(__os);
02745 #else
02746     ::RobotSimEvents::EventMessage::__write(__os);
02747 #endif
02748 }
02749 
02750 void
02751 BeobotEvents::IMUMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
02752 {
02753     if(__rid)
02754     {
02755         ::std::string myId;
02756         __is->readTypeId(myId);
02757     }
02758     __is->startReadSlice();
02759     __is->read(validAccAndAng);
02760     __is->read(accelX);
02761     __is->read(accelY);
02762     __is->read(accelZ);
02763     __is->read(angRateX);
02764     __is->read(angRateY);
02765     __is->read(angRateZ);
02766     __is->read(validRollPitchYaw);
02767     __is->read(roll);
02768     __is->read(pitch);
02769     __is->read(yaw);
02770     __is->read(validMagnetometer);
02771     __is->read(magX);
02772     __is->read(magY);
02773     __is->read(magZ);
02774     __is->read(RequestID);
02775     __is->endReadSlice();
02776 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02777     EventMessage::__read(__is, true);
02778 #else
02779     ::RobotSimEvents::EventMessage::__read(__is, true);
02780 #endif
02781 }
02782 
02783 void
02784 BeobotEvents::IMUMessage::__write(const ::Ice::OutputStreamPtr&) const
02785 {
02786     Ice::MarshalException ex(__FILE__, __LINE__);
02787     ex.reason = "type BeobotEvents::IMUMessage was not generated with stream support";
02788     throw ex;
02789 }
02790 
02791 void
02792 BeobotEvents::IMUMessage::__read(const ::Ice::InputStreamPtr&, bool)
02793 {
02794     Ice::MarshalException ex(__FILE__, __LINE__);
02795     ex.reason = "type BeobotEvents::IMUMessage was not generated with stream support";
02796     throw ex;
02797 }
02798 
02799 class __F__BeobotEvents__IMUMessage : public ::Ice::ObjectFactory
02800 {
02801 public:
02802 
02803     virtual ::Ice::ObjectPtr
02804     create(const ::std::string& type)
02805     {
02806         assert(type == ::BeobotEvents::IMUMessage::ice_staticId());
02807         return new ::BeobotEvents::IMUMessage;
02808     }
02809 
02810     virtual void
02811     destroy()
02812     {
02813     }
02814 };
02815 
02816 static ::Ice::ObjectFactoryPtr __F__BeobotEvents__IMUMessage_Ptr = new __F__BeobotEvents__IMUMessage;
02817 
02818 const ::Ice::ObjectFactoryPtr&
02819 BeobotEvents::IMUMessage::ice_factory()
02820 {
02821     return __F__BeobotEvents__IMUMessage_Ptr;
02822 }
02823 
02824 class __F__BeobotEvents__IMUMessage__Init
02825 {
02826 public:
02827 
02828     __F__BeobotEvents__IMUMessage__Init()
02829     {
02830         ::IceInternal::factoryTable->addObjectFactory(::BeobotEvents::IMUMessage::ice_staticId(), ::BeobotEvents::IMUMessage::ice_factory());
02831     }
02832 
02833     ~__F__BeobotEvents__IMUMessage__Init()
02834     {
02835         ::IceInternal::factoryTable->removeObjectFactory(::BeobotEvents::IMUMessage::ice_staticId());
02836     }
02837 };
02838 
02839 static __F__BeobotEvents__IMUMessage__Init __F__BeobotEvents__IMUMessage__i;
02840 
02841 #ifdef __APPLE__
02842 extern "C" { void __F__BeobotEvents__IMUMessage__initializer() {} }
02843 #endif
02844 
02845 void
02846 BeobotEvents::__patch__IMUMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
02847 {
02848     ::BeobotEvents::IMUMessagePtr* p = static_cast< ::BeobotEvents::IMUMessagePtr*>(__addr);
02849     assert(p);
02850     *p = ::BeobotEvents::IMUMessagePtr::dynamicCast(v);
02851     if(v && !*p)
02852     {
02853         IceInternal::Ex::throwUOE(::BeobotEvents::IMUMessage::ice_staticId(), v->ice_id());
02854     }
02855 }
02856 
02857 bool
02858 BeobotEvents::operator==(const ::BeobotEvents::IMUMessage& l, const ::BeobotEvents::IMUMessage& r)
02859 {
02860     return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
02861 }
02862 
02863 bool
02864 BeobotEvents::operator<(const ::BeobotEvents::IMUMessage& l, const ::BeobotEvents::IMUMessage& r)
02865 {
02866     return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
02867 }
02868 
02869 BeobotEvents::CameraMessage::CameraMessage(const ::ImageIceMod::ImageIce& __ice_image, ::Ice::Int __ice_RequestID) :
02870     image(__ice_image),
02871     RequestID(__ice_RequestID)
02872 {
02873 }
02874 
02875 ::Ice::ObjectPtr
02876 BeobotEvents::CameraMessage::ice_clone() const
02877 {
02878     ::BeobotEvents::CameraMessagePtr __p = new ::BeobotEvents::CameraMessage(*this);
02879     return __p;
02880 }
02881 
02882 static const ::std::string __BeobotEvents__CameraMessage_ids[3] =
02883 {
02884     "::BeobotEvents::CameraMessage",
02885     "::Ice::Object",
02886     "::RobotSimEvents::EventMessage"
02887 };
02888 
02889 bool
02890 BeobotEvents::CameraMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
02891 {
02892     return ::std::binary_search(__BeobotEvents__CameraMessage_ids, __BeobotEvents__CameraMessage_ids + 3, _s);
02893 }
02894 
02895 ::std::vector< ::std::string>
02896 BeobotEvents::CameraMessage::ice_ids(const ::Ice::Current&) const
02897 {
02898     return ::std::vector< ::std::string>(&__BeobotEvents__CameraMessage_ids[0], &__BeobotEvents__CameraMessage_ids[3]);
02899 }
02900 
02901 const ::std::string&
02902 BeobotEvents::CameraMessage::ice_id(const ::Ice::Current&) const
02903 {
02904     return __BeobotEvents__CameraMessage_ids[0];
02905 }
02906 
02907 const ::std::string&
02908 BeobotEvents::CameraMessage::ice_staticId()
02909 {
02910     return __BeobotEvents__CameraMessage_ids[0];
02911 }
02912 
02913 void
02914 BeobotEvents::CameraMessage::__write(::IceInternal::BasicStream* __os) const
02915 {
02916     __os->writeTypeId(ice_staticId());
02917     __os->startWriteSlice();
02918     image.__write(__os);
02919     __os->write(RequestID);
02920     __os->endWriteSlice();
02921 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02922     EventMessage::__write(__os);
02923 #else
02924     ::RobotSimEvents::EventMessage::__write(__os);
02925 #endif
02926 }
02927 
02928 void
02929 BeobotEvents::CameraMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
02930 {
02931     if(__rid)
02932     {
02933         ::std::string myId;
02934         __is->readTypeId(myId);
02935     }
02936     __is->startReadSlice();
02937     image.__read(__is);
02938     __is->read(RequestID);
02939     __is->endReadSlice();
02940 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02941     EventMessage::__read(__is, true);
02942 #else
02943     ::RobotSimEvents::EventMessage::__read(__is, true);
02944 #endif
02945 }
02946 
02947 void
02948 BeobotEvents::CameraMessage::__write(const ::Ice::OutputStreamPtr&) const
02949 {
02950     Ice::MarshalException ex(__FILE__, __LINE__);
02951     ex.reason = "type BeobotEvents::CameraMessage was not generated with stream support";
02952     throw ex;
02953 }
02954 
02955 void
02956 BeobotEvents::CameraMessage::__read(const ::Ice::InputStreamPtr&, bool)
02957 {
02958     Ice::MarshalException ex(__FILE__, __LINE__);
02959     ex.reason = "type BeobotEvents::CameraMessage was not generated with stream support";
02960     throw ex;
02961 }
02962 
02963 class __F__BeobotEvents__CameraMessage : public ::Ice::ObjectFactory
02964 {
02965 public:
02966 
02967     virtual ::Ice::ObjectPtr
02968     create(const ::std::string& type)
02969     {
02970         assert(type == ::BeobotEvents::CameraMessage::ice_staticId());
02971         return new ::BeobotEvents::CameraMessage;
02972     }
02973 
02974     virtual void
02975     destroy()
02976     {
02977     }
02978 };
02979 
02980 static ::Ice::ObjectFactoryPtr __F__BeobotEvents__CameraMessage_Ptr = new __F__BeobotEvents__CameraMessage;
02981 
02982 const ::Ice::ObjectFactoryPtr&
02983 BeobotEvents::CameraMessage::ice_factory()
02984 {
02985     return __F__BeobotEvents__CameraMessage_Ptr;
02986 }
02987 
02988 class __F__BeobotEvents__CameraMessage__Init
02989 {
02990 public:
02991 
02992     __F__BeobotEvents__CameraMessage__Init()
02993     {
02994         ::IceInternal::factoryTable->addObjectFactory(::BeobotEvents::CameraMessage::ice_staticId(), ::BeobotEvents::CameraMessage::ice_factory());
02995     }
02996 
02997     ~__F__BeobotEvents__CameraMessage__Init()
02998     {
02999         ::IceInternal::factoryTable->removeObjectFactory(::BeobotEvents::CameraMessage::ice_staticId());
03000     }
03001 };
03002 
03003 static __F__BeobotEvents__CameraMessage__Init __F__BeobotEvents__CameraMessage__i;
03004 
03005 #ifdef __APPLE__
03006 extern "C" { void __F__BeobotEvents__CameraMessage__initializer() {} }
03007 #endif
03008 
03009 void
03010 BeobotEvents::__patch__CameraMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
03011 {
03012     ::BeobotEvents::CameraMessagePtr* p = static_cast< ::BeobotEvents::CameraMessagePtr*>(__addr);
03013     assert(p);
03014     *p = ::BeobotEvents::CameraMessagePtr::dynamicCast(v);
03015     if(v && !*p)
03016     {
03017         IceInternal::Ex::throwUOE(::BeobotEvents::CameraMessage::ice_staticId(), v->ice_id());
03018     }
03019 }
03020 
03021 bool
03022 BeobotEvents::operator==(const ::BeobotEvents::CameraMessage& l, const ::BeobotEvents::CameraMessage& r)
03023 {
03024     return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
03025 }
03026 
03027 bool
03028 BeobotEvents::operator<(const ::BeobotEvents::CameraMessage& l, const ::BeobotEvents::CameraMessage& r)
03029 {
03030     return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
03031 }
03032 
03033 BeobotEvents::GistSalMessage::GistSalMessage(const ::ImageIceMod::ImageIce& __ice_currIma, const ::BeobotEvents::DoubleSeq& __ice_gistFeatures, const ::BeobotEvents::SalientRegionSeq& __ice_salientRegions, const ::ImageIceMod::ImageIceSeq& __ice_conspicuityMaps, ::Ice::Int __ice_RequestID) :
03034     currIma(__ice_currIma),
03035     gistFeatures(__ice_gistFeatures),
03036     salientRegions(__ice_salientRegions),
03037     conspicuityMaps(__ice_conspicuityMaps),
03038     RequestID(__ice_RequestID)
03039 {
03040 }
03041 
03042 ::Ice::ObjectPtr
03043 BeobotEvents::GistSalMessage::ice_clone() const
03044 {
03045     ::BeobotEvents::GistSalMessagePtr __p = new ::BeobotEvents::GistSalMessage(*this);
03046     return __p;
03047 }
03048 
03049 static const ::std::string __BeobotEvents__GistSalMessage_ids[3] =
03050 {
03051     "::BeobotEvents::GistSalMessage",
03052     "::Ice::Object",
03053     "::RobotSimEvents::EventMessage"
03054 };
03055 
03056 bool
03057 BeobotEvents::GistSalMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
03058 {
03059     return ::std::binary_search(__BeobotEvents__GistSalMessage_ids, __BeobotEvents__GistSalMessage_ids + 3, _s);
03060 }
03061 
03062 ::std::vector< ::std::string>
03063 BeobotEvents::GistSalMessage::ice_ids(const ::Ice::Current&) const
03064 {
03065     return ::std::vector< ::std::string>(&__BeobotEvents__GistSalMessage_ids[0], &__BeobotEvents__GistSalMessage_ids[3]);
03066 }
03067 
03068 const ::std::string&
03069 BeobotEvents::GistSalMessage::ice_id(const ::Ice::Current&) const
03070 {
03071     return __BeobotEvents__GistSalMessage_ids[0];
03072 }
03073 
03074 const ::std::string&
03075 BeobotEvents::GistSalMessage::ice_staticId()
03076 {
03077     return __BeobotEvents__GistSalMessage_ids[0];
03078 }
03079 
03080 void
03081 BeobotEvents::GistSalMessage::__write(::IceInternal::BasicStream* __os) const
03082 {
03083     __os->writeTypeId(ice_staticId());
03084     __os->startWriteSlice();
03085     currIma.__write(__os);
03086     if(gistFeatures.size() == 0)
03087     {
03088         __os->writeSize(0);
03089     }
03090     else
03091     {
03092         __os->write(&gistFeatures[0], &gistFeatures[0] + gistFeatures.size());
03093     }
03094     if(salientRegions.size() == 0)
03095     {
03096         __os->writeSize(0);
03097     }
03098     else
03099     {
03100         ::BeobotEvents::__writeSalientRegionSeq(__os, &salientRegions[0], &salientRegions[0] + salientRegions.size());
03101     }
03102     if(conspicuityMaps.size() == 0)
03103     {
03104         __os->writeSize(0);
03105     }
03106     else
03107     {
03108         ::ImageIceMod::__writeImageIceSeq(__os, &conspicuityMaps[0], &conspicuityMaps[0] + conspicuityMaps.size());
03109     }
03110     __os->write(RequestID);
03111     __os->endWriteSlice();
03112 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03113     EventMessage::__write(__os);
03114 #else
03115     ::RobotSimEvents::EventMessage::__write(__os);
03116 #endif
03117 }
03118 
03119 void
03120 BeobotEvents::GistSalMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
03121 {
03122     if(__rid)
03123     {
03124         ::std::string myId;
03125         __is->readTypeId(myId);
03126     }
03127     __is->startReadSlice();
03128     currIma.__read(__is);
03129     __is->read(gistFeatures);
03130     ::BeobotEvents::__readSalientRegionSeq(__is, salientRegions);
03131     ::ImageIceMod::__readImageIceSeq(__is, conspicuityMaps);
03132     __is->read(RequestID);
03133     __is->endReadSlice();
03134 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03135     EventMessage::__read(__is, true);
03136 #else
03137     ::RobotSimEvents::EventMessage::__read(__is, true);
03138 #endif
03139 }
03140 
03141 void
03142 BeobotEvents::GistSalMessage::__write(const ::Ice::OutputStreamPtr&) const
03143 {
03144     Ice::MarshalException ex(__FILE__, __LINE__);
03145     ex.reason = "type BeobotEvents::GistSalMessage was not generated with stream support";
03146     throw ex;
03147 }
03148 
03149 void
03150 BeobotEvents::GistSalMessage::__read(const ::Ice::InputStreamPtr&, bool)
03151 {
03152     Ice::MarshalException ex(__FILE__, __LINE__);
03153     ex.reason = "type BeobotEvents::GistSalMessage was not generated with stream support";
03154     throw ex;
03155 }
03156 
03157 class __F__BeobotEvents__GistSalMessage : public ::Ice::ObjectFactory
03158 {
03159 public:
03160 
03161     virtual ::Ice::ObjectPtr
03162     create(const ::std::string& type)
03163     {
03164         assert(type == ::BeobotEvents::GistSalMessage::ice_staticId());
03165         return new ::BeobotEvents::GistSalMessage;
03166     }
03167 
03168     virtual void
03169     destroy()
03170     {
03171     }
03172 };
03173 
03174 static ::Ice::ObjectFactoryPtr __F__BeobotEvents__GistSalMessage_Ptr = new __F__BeobotEvents__GistSalMessage;
03175 
03176 const ::Ice::ObjectFactoryPtr&
03177 BeobotEvents::GistSalMessage::ice_factory()
03178 {
03179     return __F__BeobotEvents__GistSalMessage_Ptr;
03180 }
03181 
03182 class __F__BeobotEvents__GistSalMessage__Init
03183 {
03184 public:
03185 
03186     __F__BeobotEvents__GistSalMessage__Init()
03187     {
03188         ::IceInternal::factoryTable->addObjectFactory(::BeobotEvents::GistSalMessage::ice_staticId(), ::BeobotEvents::GistSalMessage::ice_factory());
03189     }
03190 
03191     ~__F__BeobotEvents__GistSalMessage__Init()
03192     {
03193         ::IceInternal::factoryTable->removeObjectFactory(::BeobotEvents::GistSalMessage::ice_staticId());
03194     }
03195 };
03196 
03197 static __F__BeobotEvents__GistSalMessage__Init __F__BeobotEvents__GistSalMessage__i;
03198 
03199 #ifdef __APPLE__
03200 extern "C" { void __F__BeobotEvents__GistSalMessage__initializer() {} }
03201 #endif
03202 
03203 void
03204 BeobotEvents::__patch__GistSalMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
03205 {
03206     ::BeobotEvents::GistSalMessagePtr* p = static_cast< ::BeobotEvents::GistSalMessagePtr*>(__addr);
03207     assert(p);
03208     *p = ::BeobotEvents::GistSalMessagePtr::dynamicCast(v);
03209     if(v && !*p)
03210     {
03211         IceInternal::Ex::throwUOE(::BeobotEvents::GistSalMessage::ice_staticId(), v->ice_id());
03212     }
03213 }
03214 
03215 bool
03216 BeobotEvents::operator==(const ::BeobotEvents::GistSalMessage& l, const ::BeobotEvents::GistSalMessage& r)
03217 {
03218     return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
03219 }
03220 
03221 bool
03222 BeobotEvents::operator<(const ::BeobotEvents::GistSalMessage& l, const ::BeobotEvents::GistSalMessage& r)
03223 {
03224     return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
03225 }
03226 
03227 BeobotEvents::LandmarkSearchQueueMessage::LandmarkSearchQueueMessage(const ::ImageIceMod::ImageIce& __ice_currIma, const ::BeobotEvents::SalientRegionSeq& __ice_salientRegions, const ::BeobotEvents::LandmarkSearchJobSeq& __ice_jobs, ::Ice::Int __ice_RequestID) :
03228     currIma(__ice_currIma),
03229     salientRegions(__ice_salientRegions),
03230     jobs(__ice_jobs),
03231     RequestID(__ice_RequestID)
03232 {
03233 }
03234 
03235 ::Ice::ObjectPtr
03236 BeobotEvents::LandmarkSearchQueueMessage::ice_clone() const
03237 {
03238     ::BeobotEvents::LandmarkSearchQueueMessagePtr __p = new ::BeobotEvents::LandmarkSearchQueueMessage(*this);
03239     return __p;
03240 }
03241 
03242 static const ::std::string __BeobotEvents__LandmarkSearchQueueMessage_ids[3] =
03243 {
03244     "::BeobotEvents::LandmarkSearchQueueMessage",
03245     "::Ice::Object",
03246     "::RobotSimEvents::EventMessage"
03247 };
03248 
03249 bool
03250 BeobotEvents::LandmarkSearchQueueMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
03251 {
03252     return ::std::binary_search(__BeobotEvents__LandmarkSearchQueueMessage_ids, __BeobotEvents__LandmarkSearchQueueMessage_ids + 3, _s);
03253 }
03254 
03255 ::std::vector< ::std::string>
03256 BeobotEvents::LandmarkSearchQueueMessage::ice_ids(const ::Ice::Current&) const
03257 {
03258     return ::std::vector< ::std::string>(&__BeobotEvents__LandmarkSearchQueueMessage_ids[0], &__BeobotEvents__LandmarkSearchQueueMessage_ids[3]);
03259 }
03260 
03261 const ::std::string&
03262 BeobotEvents::LandmarkSearchQueueMessage::ice_id(const ::Ice::Current&) const
03263 {
03264     return __BeobotEvents__LandmarkSearchQueueMessage_ids[0];
03265 }
03266 
03267 const ::std::string&
03268 BeobotEvents::LandmarkSearchQueueMessage::ice_staticId()
03269 {
03270     return __BeobotEvents__LandmarkSearchQueueMessage_ids[0];
03271 }
03272 
03273 void
03274 BeobotEvents::LandmarkSearchQueueMessage::__write(::IceInternal::BasicStream* __os) const
03275 {
03276     __os->writeTypeId(ice_staticId());
03277     __os->startWriteSlice();
03278     currIma.__write(__os);
03279     if(salientRegions.size() == 0)
03280     {
03281         __os->writeSize(0);
03282     }
03283     else
03284     {
03285         ::BeobotEvents::__writeSalientRegionSeq(__os, &salientRegions[0], &salientRegions[0] + salientRegions.size());
03286     }
03287     if(jobs.size() == 0)
03288     {
03289         __os->writeSize(0);
03290     }
03291     else
03292     {
03293         ::BeobotEvents::__writeLandmarkSearchJobSeq(__os, &jobs[0], &jobs[0] + jobs.size());
03294     }
03295     __os->write(RequestID);
03296     __os->endWriteSlice();
03297 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03298     EventMessage::__write(__os);
03299 #else
03300     ::RobotSimEvents::EventMessage::__write(__os);
03301 #endif
03302 }
03303 
03304 void
03305 BeobotEvents::LandmarkSearchQueueMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
03306 {
03307     if(__rid)
03308     {
03309         ::std::string myId;
03310         __is->readTypeId(myId);
03311     }
03312     __is->startReadSlice();
03313     currIma.__read(__is);
03314     ::BeobotEvents::__readSalientRegionSeq(__is, salientRegions);
03315     ::BeobotEvents::__readLandmarkSearchJobSeq(__is, jobs);
03316     __is->read(RequestID);
03317     __is->endReadSlice();
03318 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03319     EventMessage::__read(__is, true);
03320 #else
03321     ::RobotSimEvents::EventMessage::__read(__is, true);
03322 #endif
03323 }
03324 
03325 void
03326 BeobotEvents::LandmarkSearchQueueMessage::__write(const ::Ice::OutputStreamPtr&) const
03327 {
03328     Ice::MarshalException ex(__FILE__, __LINE__);
03329     ex.reason = "type BeobotEvents::LandmarkSearchQueueMessage was not generated with stream support";
03330     throw ex;
03331 }
03332 
03333 void
03334 BeobotEvents::LandmarkSearchQueueMessage::__read(const ::Ice::InputStreamPtr&, bool)
03335 {
03336     Ice::MarshalException ex(__FILE__, __LINE__);
03337     ex.reason = "type BeobotEvents::LandmarkSearchQueueMessage was not generated with stream support";
03338     throw ex;
03339 }
03340 
03341 class __F__BeobotEvents__LandmarkSearchQueueMessage : public ::Ice::ObjectFactory
03342 {
03343 public:
03344 
03345     virtual ::Ice::ObjectPtr
03346     create(const ::std::string& type)
03347     {
03348         assert(type == ::BeobotEvents::LandmarkSearchQueueMessage::ice_staticId());
03349         return new ::BeobotEvents::LandmarkSearchQueueMessage;
03350     }
03351 
03352     virtual void
03353     destroy()
03354     {
03355     }
03356 };
03357 
03358 static ::Ice::ObjectFactoryPtr __F__BeobotEvents__LandmarkSearchQueueMessage_Ptr = new __F__BeobotEvents__LandmarkSearchQueueMessage;
03359 
03360 const ::Ice::ObjectFactoryPtr&
03361 BeobotEvents::LandmarkSearchQueueMessage::ice_factory()
03362 {
03363     return __F__BeobotEvents__LandmarkSearchQueueMessage_Ptr;
03364 }
03365 
03366 class __F__BeobotEvents__LandmarkSearchQueueMessage__Init
03367 {
03368 public:
03369 
03370     __F__BeobotEvents__LandmarkSearchQueueMessage__Init()
03371     {
03372         ::IceInternal::factoryTable->addObjectFactory(::BeobotEvents::LandmarkSearchQueueMessage::ice_staticId(), ::BeobotEvents::LandmarkSearchQueueMessage::ice_factory());
03373     }
03374 
03375     ~__F__BeobotEvents__LandmarkSearchQueueMessage__Init()
03376     {
03377         ::IceInternal::factoryTable->removeObjectFactory(::BeobotEvents::LandmarkSearchQueueMessage::ice_staticId());
03378     }
03379 };
03380 
03381 static __F__BeobotEvents__LandmarkSearchQueueMessage__Init __F__BeobotEvents__LandmarkSearchQueueMessage__i;
03382 
03383 #ifdef __APPLE__
03384 extern "C" { void __F__BeobotEvents__LandmarkSearchQueueMessage__initializer() {} }
03385 #endif
03386 
03387 void
03388 BeobotEvents::__patch__LandmarkSearchQueueMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
03389 {
03390     ::BeobotEvents::LandmarkSearchQueueMessagePtr* p = static_cast< ::BeobotEvents::LandmarkSearchQueueMessagePtr*>(__addr);
03391     assert(p);
03392     *p = ::BeobotEvents::LandmarkSearchQueueMessagePtr::dynamicCast(v);
03393     if(v && !*p)
03394     {
03395         IceInternal::Ex::throwUOE(::BeobotEvents::LandmarkSearchQueueMessage::ice_staticId(), v->ice_id());
03396     }
03397 }
03398 
03399 bool
03400 BeobotEvents::operator==(const ::BeobotEvents::LandmarkSearchQueueMessage& l, const ::BeobotEvents::LandmarkSearchQueueMessage& r)
03401 {
03402     return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
03403 }
03404 
03405 bool
03406 BeobotEvents::operator<(const ::BeobotEvents::LandmarkSearchQueueMessage& l, const ::BeobotEvents::LandmarkSearchQueueMessage& r)
03407 {
03408     return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
03409 }
03410 
03411 BeobotEvents::LandmarkTrackMessage::LandmarkTrackMessage(const ::ImageIceMod::ImageIce& __ice_currIma, const ::BeobotEvents::DoubleSeq& __ice_gistFeatures, const ::BeobotEvents::SalientRegionSeq& __ice_salientRegions, const ::ImageIceMod::ImageIceSeq& __ice_conspicuityMaps, bool __ice_resetTracker, ::Ice::Int __ice_RequestID) :
03412     currIma(__ice_currIma),
03413     gistFeatures(__ice_gistFeatures),
03414     salientRegions(__ice_salientRegions),
03415     conspicuityMaps(__ice_conspicuityMaps),
03416     resetTracker(__ice_resetTracker),
03417     RequestID(__ice_RequestID)
03418 {
03419 }
03420 
03421 ::Ice::ObjectPtr
03422 BeobotEvents::LandmarkTrackMessage::ice_clone() const
03423 {
03424     ::BeobotEvents::LandmarkTrackMessagePtr __p = new ::BeobotEvents::LandmarkTrackMessage(*this);
03425     return __p;
03426 }
03427 
03428 static const ::std::string __BeobotEvents__LandmarkTrackMessage_ids[3] =
03429 {
03430     "::BeobotEvents::LandmarkTrackMessage",
03431     "::Ice::Object",
03432     "::RobotSimEvents::EventMessage"
03433 };
03434 
03435 bool
03436 BeobotEvents::LandmarkTrackMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
03437 {
03438     return ::std::binary_search(__BeobotEvents__LandmarkTrackMessage_ids, __BeobotEvents__LandmarkTrackMessage_ids + 3, _s);
03439 }
03440 
03441 ::std::vector< ::std::string>
03442 BeobotEvents::LandmarkTrackMessage::ice_ids(const ::Ice::Current&) const
03443 {
03444     return ::std::vector< ::std::string>(&__BeobotEvents__LandmarkTrackMessage_ids[0], &__BeobotEvents__LandmarkTrackMessage_ids[3]);
03445 }
03446 
03447 const ::std::string&
03448 BeobotEvents::LandmarkTrackMessage::ice_id(const ::Ice::Current&) const
03449 {
03450     return __BeobotEvents__LandmarkTrackMessage_ids[0];
03451 }
03452 
03453 const ::std::string&
03454 BeobotEvents::LandmarkTrackMessage::ice_staticId()
03455 {
03456     return __BeobotEvents__LandmarkTrackMessage_ids[0];
03457 }
03458 
03459 void
03460 BeobotEvents::LandmarkTrackMessage::__write(::IceInternal::BasicStream* __os) const
03461 {
03462     __os->writeTypeId(ice_staticId());
03463     __os->startWriteSlice();
03464     currIma.__write(__os);
03465     if(gistFeatures.size() == 0)
03466     {
03467         __os->writeSize(0);
03468     }
03469     else
03470     {
03471         __os->write(&gistFeatures[0], &gistFeatures[0] + gistFeatures.size());
03472     }
03473     if(salientRegions.size() == 0)
03474     {
03475         __os->writeSize(0);
03476     }
03477     else
03478     {
03479         ::BeobotEvents::__writeSalientRegionSeq(__os, &salientRegions[0], &salientRegions[0] + salientRegions.size());
03480     }
03481     if(conspicuityMaps.size() == 0)
03482     {
03483         __os->writeSize(0);
03484     }
03485     else
03486     {
03487         ::ImageIceMod::__writeImageIceSeq(__os, &conspicuityMaps[0], &conspicuityMaps[0] + conspicuityMaps.size());
03488     }
03489     __os->write(resetTracker);
03490     __os->write(RequestID);
03491     __os->endWriteSlice();
03492 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03493     EventMessage::__write(__os);
03494 #else
03495     ::RobotSimEvents::EventMessage::__write(__os);
03496 #endif
03497 }
03498 
03499 void
03500 BeobotEvents::LandmarkTrackMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
03501 {
03502     if(__rid)
03503     {
03504         ::std::string myId;
03505         __is->readTypeId(myId);
03506     }
03507     __is->startReadSlice();
03508     currIma.__read(__is);
03509     __is->read(gistFeatures);
03510     ::BeobotEvents::__readSalientRegionSeq(__is, salientRegions);
03511     ::ImageIceMod::__readImageIceSeq(__is, conspicuityMaps);
03512     __is->read(resetTracker);
03513     __is->read(RequestID);
03514     __is->endReadSlice();
03515 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03516     EventMessage::__read(__is, true);
03517 #else
03518     ::RobotSimEvents::EventMessage::__read(__is, true);
03519 #endif
03520 }
03521 
03522 void
03523 BeobotEvents::LandmarkTrackMessage::__write(const ::Ice::OutputStreamPtr&) const
03524 {
03525     Ice::MarshalException ex(__FILE__, __LINE__);
03526     ex.reason = "type BeobotEvents::LandmarkTrackMessage was not generated with stream support";
03527     throw ex;
03528 }
03529 
03530 void
03531 BeobotEvents::LandmarkTrackMessage::__read(const ::Ice::InputStreamPtr&, bool)
03532 {
03533     Ice::MarshalException ex(__FILE__, __LINE__);
03534     ex.reason = "type BeobotEvents::LandmarkTrackMessage was not generated with stream support";
03535     throw ex;
03536 }
03537 
03538 class __F__BeobotEvents__LandmarkTrackMessage : public ::Ice::ObjectFactory
03539 {
03540 public:
03541 
03542     virtual ::Ice::ObjectPtr
03543     create(const ::std::string& type)
03544     {
03545         assert(type == ::BeobotEvents::LandmarkTrackMessage::ice_staticId());
03546         return new ::BeobotEvents::LandmarkTrackMessage;
03547     }
03548 
03549     virtual void
03550     destroy()
03551     {
03552     }
03553 };
03554 
03555 static ::Ice::ObjectFactoryPtr __F__BeobotEvents__LandmarkTrackMessage_Ptr = new __F__BeobotEvents__LandmarkTrackMessage;
03556 
03557 const ::Ice::ObjectFactoryPtr&
03558 BeobotEvents::LandmarkTrackMessage::ice_factory()
03559 {
03560     return __F__BeobotEvents__LandmarkTrackMessage_Ptr;
03561 }
03562 
03563 class __F__BeobotEvents__LandmarkTrackMessage__Init
03564 {
03565 public:
03566 
03567     __F__BeobotEvents__LandmarkTrackMessage__Init()
03568     {
03569         ::IceInternal::factoryTable->addObjectFactory(::BeobotEvents::LandmarkTrackMessage::ice_staticId(), ::BeobotEvents::LandmarkTrackMessage::ice_factory());
03570     }
03571 
03572     ~__F__BeobotEvents__LandmarkTrackMessage__Init()
03573     {
03574         ::IceInternal::factoryTable->removeObjectFactory(::BeobotEvents::LandmarkTrackMessage::ice_staticId());
03575     }
03576 };
03577 
03578 static __F__BeobotEvents__LandmarkTrackMessage__Init __F__BeobotEvents__LandmarkTrackMessage__i;
03579 
03580 #ifdef __APPLE__
03581 extern "C" { void __F__BeobotEvents__LandmarkTrackMessage__initializer() {} }
03582 #endif
03583 
03584 void
03585 BeobotEvents::__patch__LandmarkTrackMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
03586 {
03587     ::BeobotEvents::LandmarkTrackMessagePtr* p = static_cast< ::BeobotEvents::LandmarkTrackMessagePtr*>(__addr);
03588     assert(p);
03589     *p = ::BeobotEvents::LandmarkTrackMessagePtr::dynamicCast(v);
03590     if(v && !*p)
03591     {
03592         IceInternal::Ex::throwUOE(::BeobotEvents::LandmarkTrackMessage::ice_staticId(), v->ice_id());
03593     }
03594 }
03595 
03596 bool
03597 BeobotEvents::operator==(const ::BeobotEvents::LandmarkTrackMessage& l, const ::BeobotEvents::LandmarkTrackMessage& r)
03598 {
03599     return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
03600 }
03601 
03602 bool
03603 BeobotEvents::operator<(const ::BeobotEvents::LandmarkTrackMessage& l, const ::BeobotEvents::LandmarkTrackMessage& r)
03604 {
03605     return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
03606 }
03607 
03608 BeobotEvents::LandmarkSearchStatMessage::LandmarkSearchStatMessage(::Ice::Int __ice_inputSalRegID, ::Ice::Int __ice_numObjSearch, bool __ice_found, ::Ice::Int __ice_RequestID) :
03609     inputSalRegID(__ice_inputSalRegID),
03610     numObjSearch(__ice_numObjSearch),
03611     found(__ice_found),
03612     RequestID(__ice_RequestID)
03613 {
03614 }
03615 
03616 ::Ice::ObjectPtr
03617 BeobotEvents::LandmarkSearchStatMessage::ice_clone() const
03618 {
03619     ::BeobotEvents::LandmarkSearchStatMessagePtr __p = new ::BeobotEvents::LandmarkSearchStatMessage(*this);
03620     return __p;
03621 }
03622 
03623 static const ::std::string __BeobotEvents__LandmarkSearchStatMessage_ids[3] =
03624 {
03625     "::BeobotEvents::LandmarkSearchStatMessage",
03626     "::Ice::Object",
03627     "::RobotSimEvents::EventMessage"
03628 };
03629 
03630 bool
03631 BeobotEvents::LandmarkSearchStatMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
03632 {
03633     return ::std::binary_search(__BeobotEvents__LandmarkSearchStatMessage_ids, __BeobotEvents__LandmarkSearchStatMessage_ids + 3, _s);
03634 }
03635 
03636 ::std::vector< ::std::string>
03637 BeobotEvents::LandmarkSearchStatMessage::ice_ids(const ::Ice::Current&) const
03638 {
03639     return ::std::vector< ::std::string>(&__BeobotEvents__LandmarkSearchStatMessage_ids[0], &__BeobotEvents__LandmarkSearchStatMessage_ids[3]);
03640 }
03641 
03642 const ::std::string&
03643 BeobotEvents::LandmarkSearchStatMessage::ice_id(const ::Ice::Current&) const
03644 {
03645     return __BeobotEvents__LandmarkSearchStatMessage_ids[0];
03646 }
03647 
03648 const ::std::string&
03649 BeobotEvents::LandmarkSearchStatMessage::ice_staticId()
03650 {
03651     return __BeobotEvents__LandmarkSearchStatMessage_ids[0];
03652 }
03653 
03654 void
03655 BeobotEvents::LandmarkSearchStatMessage::__write(::IceInternal::BasicStream* __os) const
03656 {
03657     __os->writeTypeId(ice_staticId());
03658     __os->startWriteSlice();
03659     __os->write(inputSalRegID);
03660     __os->write(numObjSearch);
03661     __os->write(found);
03662     __os->write(RequestID);
03663     __os->endWriteSlice();
03664 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03665     EventMessage::__write(__os);
03666 #else
03667     ::RobotSimEvents::EventMessage::__write(__os);
03668 #endif
03669 }
03670 
03671 void
03672 BeobotEvents::LandmarkSearchStatMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
03673 {
03674     if(__rid)
03675     {
03676         ::std::string myId;
03677         __is->readTypeId(myId);
03678     }
03679     __is->startReadSlice();
03680     __is->read(inputSalRegID);
03681     __is->read(numObjSearch);
03682     __is->read(found);
03683     __is->read(RequestID);
03684     __is->endReadSlice();
03685 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03686     EventMessage::__read(__is, true);
03687 #else
03688     ::RobotSimEvents::EventMessage::__read(__is, true);
03689 #endif
03690 }
03691 
03692 void
03693 BeobotEvents::LandmarkSearchStatMessage::__write(const ::Ice::OutputStreamPtr&) const
03694 {
03695     Ice::MarshalException ex(__FILE__, __LINE__);
03696     ex.reason = "type BeobotEvents::LandmarkSearchStatMessage was not generated with stream support";
03697     throw ex;
03698 }
03699 
03700 void
03701 BeobotEvents::LandmarkSearchStatMessage::__read(const ::Ice::InputStreamPtr&, bool)
03702 {
03703     Ice::MarshalException ex(__FILE__, __LINE__);
03704     ex.reason = "type BeobotEvents::LandmarkSearchStatMessage was not generated with stream support";
03705     throw ex;
03706 }
03707 
03708 class __F__BeobotEvents__LandmarkSearchStatMessage : public ::Ice::ObjectFactory
03709 {
03710 public:
03711 
03712     virtual ::Ice::ObjectPtr
03713     create(const ::std::string& type)
03714     {
03715         assert(type == ::BeobotEvents::LandmarkSearchStatMessage::ice_staticId());
03716         return new ::BeobotEvents::LandmarkSearchStatMessage;
03717     }
03718 
03719     virtual void
03720     destroy()
03721     {
03722     }
03723 };
03724 
03725 static ::Ice::ObjectFactoryPtr __F__BeobotEvents__LandmarkSearchStatMessage_Ptr = new __F__BeobotEvents__LandmarkSearchStatMessage;
03726 
03727 const ::Ice::ObjectFactoryPtr&
03728 BeobotEvents::LandmarkSearchStatMessage::ice_factory()
03729 {
03730     return __F__BeobotEvents__LandmarkSearchStatMessage_Ptr;
03731 }
03732 
03733 class __F__BeobotEvents__LandmarkSearchStatMessage__Init
03734 {
03735 public:
03736 
03737     __F__BeobotEvents__LandmarkSearchStatMessage__Init()
03738     {
03739         ::IceInternal::factoryTable->addObjectFactory(::BeobotEvents::LandmarkSearchStatMessage::ice_staticId(), ::BeobotEvents::LandmarkSearchStatMessage::ice_factory());
03740     }
03741 
03742     ~__F__BeobotEvents__LandmarkSearchStatMessage__Init()
03743     {
03744         ::IceInternal::factoryTable->removeObjectFactory(::BeobotEvents::LandmarkSearchStatMessage::ice_staticId());
03745     }
03746 };
03747 
03748 static __F__BeobotEvents__LandmarkSearchStatMessage__Init __F__BeobotEvents__LandmarkSearchStatMessage__i;
03749 
03750 #ifdef __APPLE__
03751 extern "C" { void __F__BeobotEvents__LandmarkSearchStatMessage__initializer() {} }
03752 #endif
03753 
03754 void
03755 BeobotEvents::__patch__LandmarkSearchStatMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
03756 {
03757     ::BeobotEvents::LandmarkSearchStatMessagePtr* p = static_cast< ::BeobotEvents::LandmarkSearchStatMessagePtr*>(__addr);
03758     assert(p);
03759     *p = ::BeobotEvents::LandmarkSearchStatMessagePtr::dynamicCast(v);
03760     if(v && !*p)
03761     {
03762         IceInternal::Ex::throwUOE(::BeobotEvents::LandmarkSearchStatMessage::ice_staticId(), v->ice_id());
03763     }
03764 }
03765 
03766 bool
03767 BeobotEvents::operator==(const ::BeobotEvents::LandmarkSearchStatMessage& l, const ::BeobotEvents::LandmarkSearchStatMessage& r)
03768 {
03769     return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
03770 }
03771 
03772 bool
03773 BeobotEvents::operator<(const ::BeobotEvents::LandmarkSearchStatMessage& l, const ::BeobotEvents::LandmarkSearchStatMessage& r)
03774 {
03775     return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
03776 }
03777 
03778 BeobotEvents::LandmarkMatchResultMessage::LandmarkMatchResultMessage(::Ice::Int __ice_RequestID, const ::ImageIceMod::ImageIce& __ice_voMatchImage, const ::BeobotEvents::LandmarkSearchJob& __ice_matchInfo, ::Ice::Int __ice_segNumMatch, ::Ice::Float __ice_lenTravMatch, ::Ice::Float __ice_MatchScore) :
03779     RequestID(__ice_RequestID),
03780     voMatchImage(__ice_voMatchImage),
03781     matchInfo(__ice_matchInfo),
03782     segNumMatch(__ice_segNumMatch),
03783     lenTravMatch(__ice_lenTravMatch),
03784     MatchScore(__ice_MatchScore)
03785 {
03786 }
03787 
03788 ::Ice::ObjectPtr
03789 BeobotEvents::LandmarkMatchResultMessage::ice_clone() const
03790 {
03791     ::BeobotEvents::LandmarkMatchResultMessagePtr __p = new ::BeobotEvents::LandmarkMatchResultMessage(*this);
03792     return __p;
03793 }
03794 
03795 static const ::std::string __BeobotEvents__LandmarkMatchResultMessage_ids[3] =
03796 {
03797     "::BeobotEvents::LandmarkMatchResultMessage",
03798     "::Ice::Object",
03799     "::RobotSimEvents::EventMessage"
03800 };
03801 
03802 bool
03803 BeobotEvents::LandmarkMatchResultMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
03804 {
03805     return ::std::binary_search(__BeobotEvents__LandmarkMatchResultMessage_ids, __BeobotEvents__LandmarkMatchResultMessage_ids + 3, _s);
03806 }
03807 
03808 ::std::vector< ::std::string>
03809 BeobotEvents::LandmarkMatchResultMessage::ice_ids(const ::Ice::Current&) const
03810 {
03811     return ::std::vector< ::std::string>(&__BeobotEvents__LandmarkMatchResultMessage_ids[0], &__BeobotEvents__LandmarkMatchResultMessage_ids[3]);
03812 }
03813 
03814 const ::std::string&
03815 BeobotEvents::LandmarkMatchResultMessage::ice_id(const ::Ice::Current&) const
03816 {
03817     return __BeobotEvents__LandmarkMatchResultMessage_ids[0];
03818 }
03819 
03820 const ::std::string&
03821 BeobotEvents::LandmarkMatchResultMessage::ice_staticId()
03822 {
03823     return __BeobotEvents__LandmarkMatchResultMessage_ids[0];
03824 }
03825 
03826 void
03827 BeobotEvents::LandmarkMatchResultMessage::__write(::IceInternal::BasicStream* __os) const
03828 {
03829     __os->writeTypeId(ice_staticId());
03830     __os->startWriteSlice();
03831     __os->write(RequestID);
03832     voMatchImage.__write(__os);
03833     matchInfo.__write(__os);
03834     __os->write(segNumMatch);
03835     __os->write(lenTravMatch);
03836     __os->write(MatchScore);
03837     __os->endWriteSlice();
03838 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03839     EventMessage::__write(__os);
03840 #else
03841     ::RobotSimEvents::EventMessage::__write(__os);
03842 #endif
03843 }
03844 
03845 void
03846 BeobotEvents::LandmarkMatchResultMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
03847 {
03848     if(__rid)
03849     {
03850         ::std::string myId;
03851         __is->readTypeId(myId);
03852     }
03853     __is->startReadSlice();
03854     __is->read(RequestID);
03855     voMatchImage.__read(__is);
03856     matchInfo.__read(__is);
03857     __is->read(segNumMatch);
03858     __is->read(lenTravMatch);
03859     __is->read(MatchScore);
03860     __is->endReadSlice();
03861 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03862     EventMessage::__read(__is, true);
03863 #else
03864     ::RobotSimEvents::EventMessage::__read(__is, true);
03865 #endif
03866 }
03867 
03868 void
03869 BeobotEvents::LandmarkMatchResultMessage::__write(const ::Ice::OutputStreamPtr&) const
03870 {
03871     Ice::MarshalException ex(__FILE__, __LINE__);
03872     ex.reason = "type BeobotEvents::LandmarkMatchResultMessage was not generated with stream support";
03873     throw ex;
03874 }
03875 
03876 void
03877 BeobotEvents::LandmarkMatchResultMessage::__read(const ::Ice::InputStreamPtr&, bool)
03878 {
03879     Ice::MarshalException ex(__FILE__, __LINE__);
03880     ex.reason = "type BeobotEvents::LandmarkMatchResultMessage was not generated with stream support";
03881     throw ex;
03882 }
03883 
03884 class __F__BeobotEvents__LandmarkMatchResultMessage : public ::Ice::ObjectFactory
03885 {
03886 public:
03887 
03888     virtual ::Ice::ObjectPtr
03889     create(const ::std::string& type)
03890     {
03891         assert(type == ::BeobotEvents::LandmarkMatchResultMessage::ice_staticId());
03892         return new ::BeobotEvents::LandmarkMatchResultMessage;
03893     }
03894 
03895     virtual void
03896     destroy()
03897     {
03898     }
03899 };
03900 
03901 static ::Ice::ObjectFactoryPtr __F__BeobotEvents__LandmarkMatchResultMessage_Ptr = new __F__BeobotEvents__LandmarkMatchResultMessage;
03902 
03903 const ::Ice::ObjectFactoryPtr&
03904 BeobotEvents::LandmarkMatchResultMessage::ice_factory()
03905 {
03906     return __F__BeobotEvents__LandmarkMatchResultMessage_Ptr;
03907 }
03908 
03909 class __F__BeobotEvents__LandmarkMatchResultMessage__Init
03910 {
03911 public:
03912 
03913     __F__BeobotEvents__LandmarkMatchResultMessage__Init()
03914     {
03915         ::IceInternal::factoryTable->addObjectFactory(::BeobotEvents::LandmarkMatchResultMessage::ice_staticId(), ::BeobotEvents::LandmarkMatchResultMessage::ice_factory());
03916     }
03917 
03918     ~__F__BeobotEvents__LandmarkMatchResultMessage__Init()
03919     {
03920         ::IceInternal::factoryTable->removeObjectFactory(::BeobotEvents::LandmarkMatchResultMessage::ice_staticId());
03921     }
03922 };
03923 
03924 static __F__BeobotEvents__LandmarkMatchResultMessage__Init __F__BeobotEvents__LandmarkMatchResultMessage__i;
03925 
03926 #ifdef __APPLE__
03927 extern "C" { void __F__BeobotEvents__LandmarkMatchResultMessage__initializer() {} }
03928 #endif
03929 
03930 void
03931 BeobotEvents::__patch__LandmarkMatchResultMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
03932 {
03933     ::BeobotEvents::LandmarkMatchResultMessagePtr* p = static_cast< ::BeobotEvents::LandmarkMatchResultMessagePtr*>(__addr);
03934     assert(p);
03935     *p = ::BeobotEvents::LandmarkMatchResultMessagePtr::dynamicCast(v);
03936     if(v && !*p)
03937     {
03938         IceInternal::Ex::throwUOE(::BeobotEvents::LandmarkMatchResultMessage::ice_staticId(), v->ice_id());
03939     }
03940 }
03941 
03942 bool
03943 BeobotEvents::operator==(const ::BeobotEvents::LandmarkMatchResultMessage& l, const ::BeobotEvents::LandmarkMatchResultMessage& r)
03944 {
03945     return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
03946 }
03947 
03948 bool
03949 BeobotEvents::operator<(const ::BeobotEvents::LandmarkMatchResultMessage& l, const ::BeobotEvents::LandmarkMatchResultMessage& r)
03950 {
03951     return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
03952 }
03953 
03954 BeobotEvents::LandmarkDBSearchResultMessage::LandmarkDBSearchResultMessage(::Ice::Int __ice_RequestID, const ::BeobotEvents::LandmarkSearchJobSeq& __ice_matches) :
03955     RequestID(__ice_RequestID),
03956     matches(__ice_matches)
03957 {
03958 }
03959 
03960 ::Ice::ObjectPtr
03961 BeobotEvents::LandmarkDBSearchResultMessage::ice_clone() const
03962 {
03963     ::BeobotEvents::LandmarkDBSearchResultMessagePtr __p = new ::BeobotEvents::LandmarkDBSearchResultMessage(*this);
03964     return __p;
03965 }
03966 
03967 static const ::std::string __BeobotEvents__LandmarkDBSearchResultMessage_ids[3] =
03968 {
03969     "::BeobotEvents::LandmarkDBSearchResultMessage",
03970     "::Ice::Object",
03971     "::RobotSimEvents::EventMessage"
03972 };
03973 
03974 bool
03975 BeobotEvents::LandmarkDBSearchResultMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
03976 {
03977     return ::std::binary_search(__BeobotEvents__LandmarkDBSearchResultMessage_ids, __BeobotEvents__LandmarkDBSearchResultMessage_ids + 3, _s);
03978 }
03979 
03980 ::std::vector< ::std::string>
03981 BeobotEvents::LandmarkDBSearchResultMessage::ice_ids(const ::Ice::Current&) const
03982 {
03983     return ::std::vector< ::std::string>(&__BeobotEvents__LandmarkDBSearchResultMessage_ids[0], &__BeobotEvents__LandmarkDBSearchResultMessage_ids[3]);
03984 }
03985 
03986 const ::std::string&
03987 BeobotEvents::LandmarkDBSearchResultMessage::ice_id(const ::Ice::Current&) const
03988 {
03989     return __BeobotEvents__LandmarkDBSearchResultMessage_ids[0];
03990 }
03991 
03992 const ::std::string&
03993 BeobotEvents::LandmarkDBSearchResultMessage::ice_staticId()
03994 {
03995     return __BeobotEvents__LandmarkDBSearchResultMessage_ids[0];
03996 }
03997 
03998 void
03999 BeobotEvents::LandmarkDBSearchResultMessage::__write(::IceInternal::BasicStream* __os) const
04000 {
04001     __os->writeTypeId(ice_staticId());
04002     __os->startWriteSlice();
04003     __os->write(RequestID);
04004     if(matches.size() == 0)
04005     {
04006         __os->writeSize(0);
04007     }
04008     else
04009     {
04010         ::BeobotEvents::__writeLandmarkSearchJobSeq(__os, &matches[0], &matches[0] + matches.size());
04011     }
04012     __os->endWriteSlice();
04013 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04014     EventMessage::__write(__os);
04015 #else
04016     ::RobotSimEvents::EventMessage::__write(__os);
04017 #endif
04018 }
04019 
04020 void
04021 BeobotEvents::LandmarkDBSearchResultMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
04022 {
04023     if(__rid)
04024     {
04025         ::std::string myId;
04026         __is->readTypeId(myId);
04027     }
04028     __is->startReadSlice();
04029     __is->read(RequestID);
04030     ::BeobotEvents::__readLandmarkSearchJobSeq(__is, matches);
04031     __is->endReadSlice();
04032 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04033     EventMessage::__read(__is, true);
04034 #else
04035     ::RobotSimEvents::EventMessage::__read(__is, true);
04036 #endif
04037 }
04038 
04039 void
04040 BeobotEvents::LandmarkDBSearchResultMessage::__write(const ::Ice::OutputStreamPtr&) const
04041 {
04042     Ice::MarshalException ex(__FILE__, __LINE__);
04043     ex.reason = "type BeobotEvents::LandmarkDBSearchResultMessage was not generated with stream support";
04044     throw ex;
04045 }
04046 
04047 void
04048 BeobotEvents::LandmarkDBSearchResultMessage::__read(const ::Ice::InputStreamPtr&, bool)
04049 {
04050     Ice::MarshalException ex(__FILE__, __LINE__);
04051     ex.reason = "type BeobotEvents::LandmarkDBSearchResultMessage was not generated with stream support";
04052     throw ex;
04053 }
04054 
04055 class __F__BeobotEvents__LandmarkDBSearchResultMessage : public ::Ice::ObjectFactory
04056 {
04057 public:
04058 
04059     virtual ::Ice::ObjectPtr
04060     create(const ::std::string& type)
04061     {
04062         assert(type == ::BeobotEvents::LandmarkDBSearchResultMessage::ice_staticId());
04063         return new ::BeobotEvents::LandmarkDBSearchResultMessage;
04064     }
04065 
04066     virtual void
04067     destroy()
04068     {
04069     }
04070 };
04071 
04072 static ::Ice::ObjectFactoryPtr __F__BeobotEvents__LandmarkDBSearchResultMessage_Ptr = new __F__BeobotEvents__LandmarkDBSearchResultMessage;
04073 
04074 const ::Ice::ObjectFactoryPtr&
04075 BeobotEvents::LandmarkDBSearchResultMessage::ice_factory()
04076 {
04077     return __F__BeobotEvents__LandmarkDBSearchResultMessage_Ptr;
04078 }
04079 
04080 class __F__BeobotEvents__LandmarkDBSearchResultMessage__Init
04081 {
04082 public:
04083 
04084     __F__BeobotEvents__LandmarkDBSearchResultMessage__Init()
04085     {
04086         ::IceInternal::factoryTable->addObjectFactory(::BeobotEvents::LandmarkDBSearchResultMessage::ice_staticId(), ::BeobotEvents::LandmarkDBSearchResultMessage::ice_factory());
04087     }
04088 
04089     ~__F__BeobotEvents__LandmarkDBSearchResultMessage__Init()
04090     {
04091         ::IceInternal::factoryTable->removeObjectFactory(::BeobotEvents::LandmarkDBSearchResultMessage::ice_staticId());
04092     }
04093 };
04094 
04095 static __F__BeobotEvents__LandmarkDBSearchResultMessage__Init __F__BeobotEvents__LandmarkDBSearchResultMessage__i;
04096 
04097 #ifdef __APPLE__
04098 extern "C" { void __F__BeobotEvents__LandmarkDBSearchResultMessage__initializer() {} }
04099 #endif
04100 
04101 void
04102 BeobotEvents::__patch__LandmarkDBSearchResultMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
04103 {
04104     ::BeobotEvents::LandmarkDBSearchResultMessagePtr* p = static_cast< ::BeobotEvents::LandmarkDBSearchResultMessagePtr*>(__addr);
04105     assert(p);
04106     *p = ::BeobotEvents::LandmarkDBSearchResultMessagePtr::dynamicCast(v);
04107     if(v && !*p)
04108     {
04109         IceInternal::Ex::throwUOE(::BeobotEvents::LandmarkDBSearchResultMessage::ice_staticId(), v->ice_id());
04110     }
04111 }
04112 
04113 bool
04114 BeobotEvents::operator==(const ::BeobotEvents::LandmarkDBSearchResultMessage& l, const ::BeobotEvents::LandmarkDBSearchResultMessage& r)
04115 {
04116     return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
04117 }
04118 
04119 bool
04120 BeobotEvents::operator<(const ::BeobotEvents::LandmarkDBSearchResultMessage& l, const ::BeobotEvents::LandmarkDBSearchResultMessage& r)
04121 {
04122     return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
04123 }
04124 
04125 BeobotEvents::CurrentLocationMessage::CurrentLocationMessage(::Ice::Int __ice_RequestID, ::Ice::Int __ice_segNum, ::Ice::Float __ice_lenTrav) :
04126     RequestID(__ice_RequestID),
04127     segNum(__ice_segNum),
04128     lenTrav(__ice_lenTrav)
04129 {
04130 }
04131 
04132 ::Ice::ObjectPtr
04133 BeobotEvents::CurrentLocationMessage::ice_clone() const
04134 {
04135     ::BeobotEvents::CurrentLocationMessagePtr __p = new ::BeobotEvents::CurrentLocationMessage(*this);
04136     return __p;
04137 }
04138 
04139 static const ::std::string __BeobotEvents__CurrentLocationMessage_ids[3] =
04140 {
04141     "::BeobotEvents::CurrentLocationMessage",
04142     "::Ice::Object",
04143     "::RobotSimEvents::EventMessage"
04144 };
04145 
04146 bool
04147 BeobotEvents::CurrentLocationMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
04148 {
04149     return ::std::binary_search(__BeobotEvents__CurrentLocationMessage_ids, __BeobotEvents__CurrentLocationMessage_ids + 3, _s);
04150 }
04151 
04152 ::std::vector< ::std::string>
04153 BeobotEvents::CurrentLocationMessage::ice_ids(const ::Ice::Current&) const
04154 {
04155     return ::std::vector< ::std::string>(&__BeobotEvents__CurrentLocationMessage_ids[0], &__BeobotEvents__CurrentLocationMessage_ids[3]);
04156 }
04157 
04158 const ::std::string&
04159 BeobotEvents::CurrentLocationMessage::ice_id(const ::Ice::Current&) const
04160 {
04161     return __BeobotEvents__CurrentLocationMessage_ids[0];
04162 }
04163 
04164 const ::std::string&
04165 BeobotEvents::CurrentLocationMessage::ice_staticId()
04166 {
04167     return __BeobotEvents__CurrentLocationMessage_ids[0];
04168 }
04169 
04170 void
04171 BeobotEvents::CurrentLocationMessage::__write(::IceInternal::BasicStream* __os) const
04172 {
04173     __os->writeTypeId(ice_staticId());
04174     __os->startWriteSlice();
04175     __os->write(RequestID);
04176     __os->write(segNum);
04177     __os->write(lenTrav);
04178     __os->endWriteSlice();
04179 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04180     EventMessage::__write(__os);
04181 #else
04182     ::RobotSimEvents::EventMessage::__write(__os);
04183 #endif
04184 }
04185 
04186 void
04187 BeobotEvents::CurrentLocationMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
04188 {
04189     if(__rid)
04190     {
04191         ::std::string myId;
04192         __is->readTypeId(myId);
04193     }
04194     __is->startReadSlice();
04195     __is->read(RequestID);
04196     __is->read(segNum);
04197     __is->read(lenTrav);
04198     __is->endReadSlice();
04199 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04200     EventMessage::__read(__is, true);
04201 #else
04202     ::RobotSimEvents::EventMessage::__read(__is, true);
04203 #endif
04204 }
04205 
04206 void
04207 BeobotEvents::CurrentLocationMessage::__write(const ::Ice::OutputStreamPtr&) const
04208 {
04209     Ice::MarshalException ex(__FILE__, __LINE__);
04210     ex.reason = "type BeobotEvents::CurrentLocationMessage was not generated with stream support";
04211     throw ex;
04212 }
04213 
04214 void
04215 BeobotEvents::CurrentLocationMessage::__read(const ::Ice::InputStreamPtr&, bool)
04216 {
04217     Ice::MarshalException ex(__FILE__, __LINE__);
04218     ex.reason = "type BeobotEvents::CurrentLocationMessage was not generated with stream support";
04219     throw ex;
04220 }
04221 
04222 class __F__BeobotEvents__CurrentLocationMessage : public ::Ice::ObjectFactory
04223 {
04224 public:
04225 
04226     virtual ::Ice::ObjectPtr
04227     create(const ::std::string& type)
04228     {
04229         assert(type == ::BeobotEvents::CurrentLocationMessage::ice_staticId());
04230         return new ::BeobotEvents::CurrentLocationMessage;
04231     }
04232 
04233     virtual void
04234     destroy()
04235     {
04236     }
04237 };
04238 
04239 static ::Ice::ObjectFactoryPtr __F__BeobotEvents__CurrentLocationMessage_Ptr = new __F__BeobotEvents__CurrentLocationMessage;
04240 
04241 const ::Ice::ObjectFactoryPtr&
04242 BeobotEvents::CurrentLocationMessage::ice_factory()
04243 {
04244     return __F__BeobotEvents__CurrentLocationMessage_Ptr;
04245 }
04246 
04247 class __F__BeobotEvents__CurrentLocationMessage__Init
04248 {
04249 public:
04250 
04251     __F__BeobotEvents__CurrentLocationMessage__Init()
04252     {
04253         ::IceInternal::factoryTable->addObjectFactory(::BeobotEvents::CurrentLocationMessage::ice_staticId(), ::BeobotEvents::CurrentLocationMessage::ice_factory());
04254     }
04255 
04256     ~__F__BeobotEvents__CurrentLocationMessage__Init()
04257     {
04258         ::IceInternal::factoryTable->removeObjectFactory(::BeobotEvents::CurrentLocationMessage::ice_staticId());
04259     }
04260 };
04261 
04262 static __F__BeobotEvents__CurrentLocationMessage__Init __F__BeobotEvents__CurrentLocationMessage__i;
04263 
04264 #ifdef __APPLE__
04265 extern "C" { void __F__BeobotEvents__CurrentLocationMessage__initializer() {} }
04266 #endif
04267 
04268 void
04269 BeobotEvents::__patch__CurrentLocationMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
04270 {
04271     ::BeobotEvents::CurrentLocationMessagePtr* p = static_cast< ::BeobotEvents::CurrentLocationMessagePtr*>(__addr);
04272     assert(p);
04273     *p = ::BeobotEvents::CurrentLocationMessagePtr::dynamicCast(v);
04274     if(v && !*p)
04275     {
04276         IceInternal::Ex::throwUOE(::BeobotEvents::CurrentLocationMessage::ice_staticId(), v->ice_id());
04277     }
04278 }
04279 
04280 bool
04281 BeobotEvents::operator==(const ::BeobotEvents::CurrentLocationMessage& l, const ::BeobotEvents::CurrentLocationMessage& r)
04282 {
04283     return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
04284 }
04285 
04286 bool
04287 BeobotEvents::operator<(const ::BeobotEvents::CurrentLocationMessage& l, const ::BeobotEvents::CurrentLocationMessage& r)
04288 {
04289     return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
04290 }
04291 
04292 BeobotEvents::CancelSearchMessage::CancelSearchMessage(::Ice::Int __ice_RequestID, bool __ice_abort) :
04293     RequestID(__ice_RequestID),
04294     abort(__ice_abort)
04295 {
04296 }
04297 
04298 ::Ice::ObjectPtr
04299 BeobotEvents::CancelSearchMessage::ice_clone() const
04300 {
04301     ::BeobotEvents::CancelSearchMessagePtr __p = new ::BeobotEvents::CancelSearchMessage(*this);
04302     return __p;
04303 }
04304 
04305 static const ::std::string __BeobotEvents__CancelSearchMessage_ids[3] =
04306 {
04307     "::BeobotEvents::CancelSearchMessage",
04308     "::Ice::Object",
04309     "::RobotSimEvents::EventMessage"
04310 };
04311 
04312 bool
04313 BeobotEvents::CancelSearchMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
04314 {
04315     return ::std::binary_search(__BeobotEvents__CancelSearchMessage_ids, __BeobotEvents__CancelSearchMessage_ids + 3, _s);
04316 }
04317 
04318 ::std::vector< ::std::string>
04319 BeobotEvents::CancelSearchMessage::ice_ids(const ::Ice::Current&) const
04320 {
04321     return ::std::vector< ::std::string>(&__BeobotEvents__CancelSearchMessage_ids[0], &__BeobotEvents__CancelSearchMessage_ids[3]);
04322 }
04323 
04324 const ::std::string&
04325 BeobotEvents::CancelSearchMessage::ice_id(const ::Ice::Current&) const
04326 {
04327     return __BeobotEvents__CancelSearchMessage_ids[0];
04328 }
04329 
04330 const ::std::string&
04331 BeobotEvents::CancelSearchMessage::ice_staticId()
04332 {
04333     return __BeobotEvents__CancelSearchMessage_ids[0];
04334 }
04335 
04336 void
04337 BeobotEvents::CancelSearchMessage::__write(::IceInternal::BasicStream* __os) const
04338 {
04339     __os->writeTypeId(ice_staticId());
04340     __os->startWriteSlice();
04341     __os->write(RequestID);
04342     __os->write(abort);
04343     __os->endWriteSlice();
04344 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04345     EventMessage::__write(__os);
04346 #else
04347     ::RobotSimEvents::EventMessage::__write(__os);
04348 #endif
04349 }
04350 
04351 void
04352 BeobotEvents::CancelSearchMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
04353 {
04354     if(__rid)
04355     {
04356         ::std::string myId;
04357         __is->readTypeId(myId);
04358     }
04359     __is->startReadSlice();
04360     __is->read(RequestID);
04361     __is->read(abort);
04362     __is->endReadSlice();
04363 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04364     EventMessage::__read(__is, true);
04365 #else
04366     ::RobotSimEvents::EventMessage::__read(__is, true);
04367 #endif
04368 }
04369 
04370 void
04371 BeobotEvents::CancelSearchMessage::__write(const ::Ice::OutputStreamPtr&) const
04372 {
04373     Ice::MarshalException ex(__FILE__, __LINE__);
04374     ex.reason = "type BeobotEvents::CancelSearchMessage was not generated with stream support";
04375     throw ex;
04376 }
04377 
04378 void
04379 BeobotEvents::CancelSearchMessage::__read(const ::Ice::InputStreamPtr&, bool)
04380 {
04381     Ice::MarshalException ex(__FILE__, __LINE__);
04382     ex.reason = "type BeobotEvents::CancelSearchMessage was not generated with stream support";
04383     throw ex;
04384 }
04385 
04386 class __F__BeobotEvents__CancelSearchMessage : public ::Ice::ObjectFactory
04387 {
04388 public:
04389 
04390     virtual ::Ice::ObjectPtr
04391     create(const ::std::string& type)
04392     {
04393         assert(type == ::BeobotEvents::CancelSearchMessage::ice_staticId());
04394         return new ::BeobotEvents::CancelSearchMessage;
04395     }
04396 
04397     virtual void
04398     destroy()
04399     {
04400     }
04401 };
04402 
04403 static ::Ice::ObjectFactoryPtr __F__BeobotEvents__CancelSearchMessage_Ptr = new __F__BeobotEvents__CancelSearchMessage;
04404 
04405 const ::Ice::ObjectFactoryPtr&
04406 BeobotEvents::CancelSearchMessage::ice_factory()
04407 {
04408     return __F__BeobotEvents__CancelSearchMessage_Ptr;
04409 }
04410 
04411 class __F__BeobotEvents__CancelSearchMessage__Init
04412 {
04413 public:
04414 
04415     __F__BeobotEvents__CancelSearchMessage__Init()
04416     {
04417         ::IceInternal::factoryTable->addObjectFactory(::BeobotEvents::CancelSearchMessage::ice_staticId(), ::BeobotEvents::CancelSearchMessage::ice_factory());
04418     }
04419 
04420     ~__F__BeobotEvents__CancelSearchMessage__Init()
04421     {
04422         ::IceInternal::factoryTable->removeObjectFactory(::BeobotEvents::CancelSearchMessage::ice_staticId());
04423     }
04424 };
04425 
04426 static __F__BeobotEvents__CancelSearchMessage__Init __F__BeobotEvents__CancelSearchMessage__i;
04427 
04428 #ifdef __APPLE__
04429 extern "C" { void __F__BeobotEvents__CancelSearchMessage__initializer() {} }
04430 #endif
04431 
04432 void
04433 BeobotEvents::__patch__CancelSearchMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
04434 {
04435     ::BeobotEvents::CancelSearchMessagePtr* p = static_cast< ::BeobotEvents::CancelSearchMessagePtr*>(__addr);
04436     assert(p);
04437     *p = ::BeobotEvents::CancelSearchMessagePtr::dynamicCast(v);
04438     if(v && !*p)
04439     {
04440         IceInternal::Ex::throwUOE(::BeobotEvents::CancelSearchMessage::ice_staticId(), v->ice_id());
04441     }
04442 }
04443 
04444 bool
04445 BeobotEvents::operator==(const ::BeobotEvents::CancelSearchMessage& l, const ::BeobotEvents::CancelSearchMessage& r)
04446 {
04447     return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
04448 }
04449 
04450 bool
04451 BeobotEvents::operator<(const ::BeobotEvents::CancelSearchMessage& l, const ::BeobotEvents::CancelSearchMessage& r)
04452 {
04453     return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
04454 }
04455 
04456 BeobotEvents::SearchDoneMessage::SearchDoneMessage(::Ice::Int __ice_RequestID) :
04457     RequestID(__ice_RequestID)
04458 {
04459 }
04460 
04461 ::Ice::ObjectPtr
04462 BeobotEvents::SearchDoneMessage::ice_clone() const
04463 {
04464     ::BeobotEvents::SearchDoneMessagePtr __p = new ::BeobotEvents::SearchDoneMessage(*this);
04465     return __p;
04466 }
04467 
04468 static const ::std::string __BeobotEvents__SearchDoneMessage_ids[3] =
04469 {
04470     "::BeobotEvents::SearchDoneMessage",
04471     "::Ice::Object",
04472     "::RobotSimEvents::EventMessage"
04473 };
04474 
04475 bool
04476 BeobotEvents::SearchDoneMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
04477 {
04478     return ::std::binary_search(__BeobotEvents__SearchDoneMessage_ids, __BeobotEvents__SearchDoneMessage_ids + 3, _s);
04479 }
04480 
04481 ::std::vector< ::std::string>
04482 BeobotEvents::SearchDoneMessage::ice_ids(const ::Ice::Current&) const
04483 {
04484     return ::std::vector< ::std::string>(&__BeobotEvents__SearchDoneMessage_ids[0], &__BeobotEvents__SearchDoneMessage_ids[3]);
04485 }
04486 
04487 const ::std::string&
04488 BeobotEvents::SearchDoneMessage::ice_id(const ::Ice::Current&) const
04489 {
04490     return __BeobotEvents__SearchDoneMessage_ids[0];
04491 }
04492 
04493 const ::std::string&
04494 BeobotEvents::SearchDoneMessage::ice_staticId()
04495 {
04496     return __BeobotEvents__SearchDoneMessage_ids[0];
04497 }
04498 
04499 void
04500 BeobotEvents::SearchDoneMessage::__write(::IceInternal::BasicStream* __os) const
04501 {
04502     __os->writeTypeId(ice_staticId());
04503     __os->startWriteSlice();
04504     __os->write(RequestID);
04505     __os->endWriteSlice();
04506 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04507     EventMessage::__write(__os);
04508 #else
04509     ::RobotSimEvents::EventMessage::__write(__os);
04510 #endif
04511 }
04512 
04513 void
04514 BeobotEvents::SearchDoneMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
04515 {
04516     if(__rid)
04517     {
04518         ::std::string myId;
04519         __is->readTypeId(myId);
04520     }
04521     __is->startReadSlice();
04522     __is->read(RequestID);
04523     __is->endReadSlice();
04524 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04525     EventMessage::__read(__is, true);
04526 #else
04527     ::RobotSimEvents::EventMessage::__read(__is, true);
04528 #endif
04529 }
04530 
04531 void
04532 BeobotEvents::SearchDoneMessage::__write(const ::Ice::OutputStreamPtr&) const
04533 {
04534     Ice::MarshalException ex(__FILE__, __LINE__);
04535     ex.reason = "type BeobotEvents::SearchDoneMessage was not generated with stream support";
04536     throw ex;
04537 }
04538 
04539 void
04540 BeobotEvents::SearchDoneMessage::__read(const ::Ice::InputStreamPtr&, bool)
04541 {
04542     Ice::MarshalException ex(__FILE__, __LINE__);
04543     ex.reason = "type BeobotEvents::SearchDoneMessage was not generated with stream support";
04544     throw ex;
04545 }
04546 
04547 class __F__BeobotEvents__SearchDoneMessage : public ::Ice::ObjectFactory
04548 {
04549 public:
04550 
04551     virtual ::Ice::ObjectPtr
04552     create(const ::std::string& type)
04553     {
04554         assert(type == ::BeobotEvents::SearchDoneMessage::ice_staticId());
04555         return new ::BeobotEvents::SearchDoneMessage;
04556     }
04557 
04558     virtual void
04559     destroy()
04560     {
04561     }
04562 };
04563 
04564 static ::Ice::ObjectFactoryPtr __F__BeobotEvents__SearchDoneMessage_Ptr = new __F__BeobotEvents__SearchDoneMessage;
04565 
04566 const ::Ice::ObjectFactoryPtr&
04567 BeobotEvents::SearchDoneMessage::ice_factory()
04568 {
04569     return __F__BeobotEvents__SearchDoneMessage_Ptr;
04570 }
04571 
04572 class __F__BeobotEvents__SearchDoneMessage__Init
04573 {
04574 public:
04575 
04576     __F__BeobotEvents__SearchDoneMessage__Init()
04577     {
04578         ::IceInternal::factoryTable->addObjectFactory(::BeobotEvents::SearchDoneMessage::ice_staticId(), ::BeobotEvents::SearchDoneMessage::ice_factory());
04579     }
04580 
04581     ~__F__BeobotEvents__SearchDoneMessage__Init()
04582     {
04583         ::IceInternal::factoryTable->removeObjectFactory(::BeobotEvents::SearchDoneMessage::ice_staticId());
04584     }
04585 };
04586 
04587 static __F__BeobotEvents__SearchDoneMessage__Init __F__BeobotEvents__SearchDoneMessage__i;
04588 
04589 #ifdef __APPLE__
04590 extern "C" { void __F__BeobotEvents__SearchDoneMessage__initializer() {} }
04591 #endif
04592 
04593 void
04594 BeobotEvents::__patch__SearchDoneMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
04595 {
04596     ::BeobotEvents::SearchDoneMessagePtr* p = static_cast< ::BeobotEvents::SearchDoneMessagePtr*>(__addr);
04597     assert(p);
04598     *p = ::BeobotEvents::SearchDoneMessagePtr::dynamicCast(v);
04599     if(v && !*p)
04600     {
04601         IceInternal::Ex::throwUOE(::BeobotEvents::SearchDoneMessage::ice_staticId(), v->ice_id());
04602     }
04603 }
04604 
04605 bool
04606 BeobotEvents::operator==(const ::BeobotEvents::SearchDoneMessage& l, const ::BeobotEvents::SearchDoneMessage& r)
04607 {
04608     return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
04609 }
04610 
04611 bool
04612 BeobotEvents::operator<(const ::BeobotEvents::SearchDoneMessage& l, const ::BeobotEvents::SearchDoneMessage& r)
04613 {
04614     return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
04615 }
04616 
04617 BeobotEvents::NextFrameMessage::NextFrameMessage(::Ice::Int __ice_RequestID) :
04618     RequestID(__ice_RequestID)
04619 {
04620 }
04621 
04622 ::Ice::ObjectPtr
04623 BeobotEvents::NextFrameMessage::ice_clone() const
04624 {
04625     ::BeobotEvents::NextFrameMessagePtr __p = new ::BeobotEvents::NextFrameMessage(*this);
04626     return __p;
04627 }
04628 
04629 static const ::std::string __BeobotEvents__NextFrameMessage_ids[3] =
04630 {
04631     "::BeobotEvents::NextFrameMessage",
04632     "::Ice::Object",
04633     "::RobotSimEvents::EventMessage"
04634 };
04635 
04636 bool
04637 BeobotEvents::NextFrameMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
04638 {
04639     return ::std::binary_search(__BeobotEvents__NextFrameMessage_ids, __BeobotEvents__NextFrameMessage_ids + 3, _s);
04640 }
04641 
04642 ::std::vector< ::std::string>
04643 BeobotEvents::NextFrameMessage::ice_ids(const ::Ice::Current&) const
04644 {
04645     return ::std::vector< ::std::string>(&__BeobotEvents__NextFrameMessage_ids[0], &__BeobotEvents__NextFrameMessage_ids[3]);
04646 }
04647 
04648 const ::std::string&
04649 BeobotEvents::NextFrameMessage::ice_id(const ::Ice::Current&) const
04650 {
04651     return __BeobotEvents__NextFrameMessage_ids[0];
04652 }
04653 
04654 const ::std::string&
04655 BeobotEvents::NextFrameMessage::ice_staticId()
04656 {
04657     return __BeobotEvents__NextFrameMessage_ids[0];
04658 }
04659 
04660 void
04661 BeobotEvents::NextFrameMessage::__write(::IceInternal::BasicStream* __os) const
04662 {
04663     __os->writeTypeId(ice_staticId());
04664     __os->startWriteSlice();
04665     __os->write(RequestID);
04666     __os->endWriteSlice();
04667 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04668     EventMessage::__write(__os);
04669 #else
04670     ::RobotSimEvents::EventMessage::__write(__os);
04671 #endif
04672 }
04673 
04674 void
04675 BeobotEvents::NextFrameMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
04676 {
04677     if(__rid)
04678     {
04679         ::std::string myId;
04680         __is->readTypeId(myId);
04681     }
04682     __is->startReadSlice();
04683     __is->read(RequestID);
04684     __is->endReadSlice();
04685 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04686     EventMessage::__read(__is, true);
04687 #else
04688     ::RobotSimEvents::EventMessage::__read(__is, true);
04689 #endif
04690 }
04691 
04692 void
04693 BeobotEvents::NextFrameMessage::__write(const ::Ice::OutputStreamPtr&) const
04694 {
04695     Ice::MarshalException ex(__FILE__, __LINE__);
04696     ex.reason = "type BeobotEvents::NextFrameMessage was not generated with stream support";
04697     throw ex;
04698 }
04699 
04700 void
04701 BeobotEvents::NextFrameMessage::__read(const ::Ice::InputStreamPtr&, bool)
04702 {
04703     Ice::MarshalException ex(__FILE__, __LINE__);
04704     ex.reason = "type BeobotEvents::NextFrameMessage was not generated with stream support";
04705     throw ex;
04706 }
04707 
04708 class __F__BeobotEvents__NextFrameMessage : public ::Ice::ObjectFactory
04709 {
04710 public:
04711 
04712     virtual ::Ice::ObjectPtr
04713     create(const ::std::string& type)
04714     {
04715         assert(type == ::BeobotEvents::NextFrameMessage::ice_staticId());
04716         return new ::BeobotEvents::NextFrameMessage;
04717     }
04718 
04719     virtual void
04720     destroy()
04721     {
04722     }
04723 };
04724 
04725 static ::Ice::ObjectFactoryPtr __F__BeobotEvents__NextFrameMessage_Ptr = new __F__BeobotEvents__NextFrameMessage;
04726 
04727 const ::Ice::ObjectFactoryPtr&
04728 BeobotEvents::NextFrameMessage::ice_factory()
04729 {
04730     return __F__BeobotEvents__NextFrameMessage_Ptr;
04731 }
04732 
04733 class __F__BeobotEvents__NextFrameMessage__Init
04734 {
04735 public:
04736 
04737     __F__BeobotEvents__NextFrameMessage__Init()
04738     {
04739         ::IceInternal::factoryTable->addObjectFactory(::BeobotEvents::NextFrameMessage::ice_staticId(), ::BeobotEvents::NextFrameMessage::ice_factory());
04740     }
04741 
04742     ~__F__BeobotEvents__NextFrameMessage__Init()
04743     {
04744         ::IceInternal::factoryTable->removeObjectFactory(::BeobotEvents::NextFrameMessage::ice_staticId());
04745     }
04746 };
04747 
04748 static __F__BeobotEvents__NextFrameMessage__Init __F__BeobotEvents__NextFrameMessage__i;
04749 
04750 #ifdef __APPLE__
04751 extern "C" { void __F__BeobotEvents__NextFrameMessage__initializer() {} }
04752 #endif
04753 
04754 void
04755 BeobotEvents::__patch__NextFrameMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
04756 {
04757     ::BeobotEvents::NextFrameMessagePtr* p = static_cast< ::BeobotEvents::NextFrameMessagePtr*>(__addr);
04758     assert(p);
04759     *p = ::BeobotEvents::NextFrameMessagePtr::dynamicCast(v);
04760     if(v && !*p)
04761     {
04762         IceInternal::Ex::throwUOE(::BeobotEvents::NextFrameMessage::ice_staticId(), v->ice_id());
04763     }
04764 }
04765 
04766 bool
04767 BeobotEvents::operator==(const ::BeobotEvents::NextFrameMessage& l, const ::BeobotEvents::NextFrameMessage& r)
04768 {
04769     return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
04770 }
04771 
04772 bool
04773 BeobotEvents::operator<(const ::BeobotEvents::NextFrameMessage& l, const ::BeobotEvents::NextFrameMessage& r)
04774 {
04775     return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
04776 }
04777 
04778 BeobotEvents::AbortMessage::AbortMessage(::Ice::Int __ice_RequestID) :
04779     RequestID(__ice_RequestID)
04780 {
04781 }
04782 
04783 ::Ice::ObjectPtr
04784 BeobotEvents::AbortMessage::ice_clone() const
04785 {
04786     ::BeobotEvents::AbortMessagePtr __p = new ::BeobotEvents::AbortMessage(*this);
04787     return __p;
04788 }
04789 
04790 static const ::std::string __BeobotEvents__AbortMessage_ids[3] =
04791 {
04792     "::BeobotEvents::AbortMessage",
04793     "::Ice::Object",
04794     "::RobotSimEvents::EventMessage"
04795 };
04796 
04797 bool
04798 BeobotEvents::AbortMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
04799 {
04800     return ::std::binary_search(__BeobotEvents__AbortMessage_ids, __BeobotEvents__AbortMessage_ids + 3, _s);
04801 }
04802 
04803 ::std::vector< ::std::string>
04804 BeobotEvents::AbortMessage::ice_ids(const ::Ice::Current&) const
04805 {
04806     return ::std::vector< ::std::string>(&__BeobotEvents__AbortMessage_ids[0], &__BeobotEvents__AbortMessage_ids[3]);
04807 }
04808 
04809 const ::std::string&
04810 BeobotEvents::AbortMessage::ice_id(const ::Ice::Current&) const
04811 {
04812     return __BeobotEvents__AbortMessage_ids[0];
04813 }
04814 
04815 const ::std::string&
04816 BeobotEvents::AbortMessage::ice_staticId()
04817 {
04818     return __BeobotEvents__AbortMessage_ids[0];
04819 }
04820 
04821 void
04822 BeobotEvents::AbortMessage::__write(::IceInternal::BasicStream* __os) const
04823 {
04824     __os->writeTypeId(ice_staticId());
04825     __os->startWriteSlice();
04826     __os->write(RequestID);
04827     __os->endWriteSlice();
04828 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04829     EventMessage::__write(__os);
04830 #else
04831     ::RobotSimEvents::EventMessage::__write(__os);
04832 #endif
04833 }
04834 
04835 void
04836 BeobotEvents::AbortMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
04837 {
04838     if(__rid)
04839     {
04840         ::std::string myId;
04841         __is->readTypeId(myId);
04842     }
04843     __is->startReadSlice();
04844     __is->read(RequestID);
04845     __is->endReadSlice();
04846 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04847     EventMessage::__read(__is, true);
04848 #else
04849     ::RobotSimEvents::EventMessage::__read(__is, true);
04850 #endif
04851 }
04852 
04853 void
04854 BeobotEvents::AbortMessage::__write(const ::Ice::OutputStreamPtr&) const
04855 {
04856     Ice::MarshalException ex(__FILE__, __LINE__);
04857     ex.reason = "type BeobotEvents::AbortMessage was not generated with stream support";
04858     throw ex;
04859 }
04860 
04861 void
04862 BeobotEvents::AbortMessage::__read(const ::Ice::InputStreamPtr&, bool)
04863 {
04864     Ice::MarshalException ex(__FILE__, __LINE__);
04865     ex.reason = "type BeobotEvents::AbortMessage was not generated with stream support";
04866     throw ex;
04867 }
04868 
04869 class __F__BeobotEvents__AbortMessage : public ::Ice::ObjectFactory
04870 {
04871 public:
04872 
04873     virtual ::Ice::ObjectPtr
04874     create(const ::std::string& type)
04875     {
04876         assert(type == ::BeobotEvents::AbortMessage::ice_staticId());
04877         return new ::BeobotEvents::AbortMessage;
04878     }
04879 
04880     virtual void
04881     destroy()
04882     {
04883     }
04884 };
04885 
04886 static ::Ice::ObjectFactoryPtr __F__BeobotEvents__AbortMessage_Ptr = new __F__BeobotEvents__AbortMessage;
04887 
04888 const ::Ice::ObjectFactoryPtr&
04889 BeobotEvents::AbortMessage::ice_factory()
04890 {
04891     return __F__BeobotEvents__AbortMessage_Ptr;
04892 }
04893 
04894 class __F__BeobotEvents__AbortMessage__Init
04895 {
04896 public:
04897 
04898     __F__BeobotEvents__AbortMessage__Init()
04899     {
04900         ::IceInternal::factoryTable->addObjectFactory(::BeobotEvents::AbortMessage::ice_staticId(), ::BeobotEvents::AbortMessage::ice_factory());
04901     }
04902 
04903     ~__F__BeobotEvents__AbortMessage__Init()
04904     {
04905         ::IceInternal::factoryTable->removeObjectFactory(::BeobotEvents::AbortMessage::ice_staticId());
04906     }
04907 };
04908 
04909 static __F__BeobotEvents__AbortMessage__Init __F__BeobotEvents__AbortMessage__i;
04910 
04911 #ifdef __APPLE__
04912 extern "C" { void __F__BeobotEvents__AbortMessage__initializer() {} }
04913 #endif
04914 
04915 void
04916 BeobotEvents::__patch__AbortMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
04917 {
04918     ::BeobotEvents::AbortMessagePtr* p = static_cast< ::BeobotEvents::AbortMessagePtr*>(__addr);
04919     assert(p);
04920     *p = ::BeobotEvents::AbortMessagePtr::dynamicCast(v);
04921     if(v && !*p)
04922     {
04923         IceInternal::Ex::throwUOE(::BeobotEvents::AbortMessage::ice_staticId(), v->ice_id());
04924     }
04925 }
04926 
04927 bool
04928 BeobotEvents::operator==(const ::BeobotEvents::AbortMessage& l, const ::BeobotEvents::AbortMessage& r)
04929 {
04930     return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
04931 }
04932 
04933 bool
04934 BeobotEvents::operator<(const ::BeobotEvents::AbortMessage& l, const ::BeobotEvents::AbortMessage& r)
04935 {
04936     return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
04937 }
04938 
04939 BeobotEvents::FacesMessage::FacesMessage(const ::BeobotEvents::RectangleIceSeq& __ice_faces, ::Ice::Int __ice_RequestID) :
04940     faces(__ice_faces),
04941     RequestID(__ice_RequestID)
04942 {
04943 }
04944 
04945 ::Ice::ObjectPtr
04946 BeobotEvents::FacesMessage::ice_clone() const
04947 {
04948     ::BeobotEvents::FacesMessagePtr __p = new ::BeobotEvents::FacesMessage(*this);
04949     return __p;
04950 }
04951 
04952 static const ::std::string __BeobotEvents__FacesMessage_ids[3] =
04953 {
04954     "::BeobotEvents::FacesMessage",
04955     "::Ice::Object",
04956     "::RobotSimEvents::EventMessage"
04957 };
04958 
04959 bool
04960 BeobotEvents::FacesMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
04961 {
04962     return ::std::binary_search(__BeobotEvents__FacesMessage_ids, __BeobotEvents__FacesMessage_ids + 3, _s);
04963 }
04964 
04965 ::std::vector< ::std::string>
04966 BeobotEvents::FacesMessage::ice_ids(const ::Ice::Current&) const
04967 {
04968     return ::std::vector< ::std::string>(&__BeobotEvents__FacesMessage_ids[0], &__BeobotEvents__FacesMessage_ids[3]);
04969 }
04970 
04971 const ::std::string&
04972 BeobotEvents::FacesMessage::ice_id(const ::Ice::Current&) const
04973 {
04974     return __BeobotEvents__FacesMessage_ids[0];
04975 }
04976 
04977 const ::std::string&
04978 BeobotEvents::FacesMessage::ice_staticId()
04979 {
04980     return __BeobotEvents__FacesMessage_ids[0];
04981 }
04982 
04983 void
04984 BeobotEvents::FacesMessage::__write(::IceInternal::BasicStream* __os) const
04985 {
04986     __os->writeTypeId(ice_staticId());
04987     __os->startWriteSlice();
04988     if(faces.size() == 0)
04989     {
04990         __os->writeSize(0);
04991     }
04992     else
04993     {
04994         ::BeobotEvents::__writeRectangleIceSeq(__os, &faces[0], &faces[0] + faces.size());
04995     }
04996     __os->write(RequestID);
04997     __os->endWriteSlice();
04998 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04999     EventMessage::__write(__os);
05000 #else
05001     ::RobotSimEvents::EventMessage::__write(__os);
05002 #endif
05003 }
05004 
05005 void
05006 BeobotEvents::FacesMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
05007 {
05008     if(__rid)
05009     {
05010         ::std::string myId;
05011         __is->readTypeId(myId);
05012     }
05013     __is->startReadSlice();
05014     ::BeobotEvents::__readRectangleIceSeq(__is, faces);
05015     __is->read(RequestID);
05016     __is->endReadSlice();
05017 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05018     EventMessage::__read(__is, true);
05019 #else
05020     ::RobotSimEvents::EventMessage::__read(__is, true);
05021 #endif
05022 }
05023 
05024 void
05025 BeobotEvents::FacesMessage::__write(const ::Ice::OutputStreamPtr&) const
05026 {
05027     Ice::MarshalException ex(__FILE__, __LINE__);
05028     ex.reason = "type BeobotEvents::FacesMessage was not generated with stream support";
05029     throw ex;
05030 }
05031 
05032 void
05033 BeobotEvents::FacesMessage::__read(const ::Ice::InputStreamPtr&, bool)
05034 {
05035     Ice::MarshalException ex(__FILE__, __LINE__);
05036     ex.reason = "type BeobotEvents::FacesMessage was not generated with stream support";
05037     throw ex;
05038 }
05039 
05040 class __F__BeobotEvents__FacesMessage : public ::Ice::ObjectFactory
05041 {
05042 public:
05043 
05044     virtual ::Ice::ObjectPtr
05045     create(const ::std::string& type)
05046     {
05047         assert(type == ::BeobotEvents::FacesMessage::ice_staticId());
05048         return new ::BeobotEvents::FacesMessage;
05049     }
05050 
05051     virtual void
05052     destroy()
05053     {
05054     }
05055 };
05056 
05057 static ::Ice::ObjectFactoryPtr __F__BeobotEvents__FacesMessage_Ptr = new __F__BeobotEvents__FacesMessage;
05058 
05059 const ::Ice::ObjectFactoryPtr&
05060 BeobotEvents::FacesMessage::ice_factory()
05061 {
05062     return __F__BeobotEvents__FacesMessage_Ptr;
05063 }
05064 
05065 class __F__BeobotEvents__FacesMessage__Init
05066 {
05067 public:
05068 
05069     __F__BeobotEvents__FacesMessage__Init()
05070     {
05071         ::IceInternal::factoryTable->addObjectFactory(::BeobotEvents::FacesMessage::ice_staticId(), ::BeobotEvents::FacesMessage::ice_factory());
05072     }
05073 
05074     ~__F__BeobotEvents__FacesMessage__Init()
05075     {
05076         ::IceInternal::factoryTable->removeObjectFactory(::BeobotEvents::FacesMessage::ice_staticId());
05077     }
05078 };
05079 
05080 static __F__BeobotEvents__FacesMessage__Init __F__BeobotEvents__FacesMessage__i;
05081 
05082 #ifdef __APPLE__
05083 extern "C" { void __F__BeobotEvents__FacesMessage__initializer() {} }
05084 #endif
05085 
05086 void
05087 BeobotEvents::__patch__FacesMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
05088 {
05089     ::BeobotEvents::FacesMessagePtr* p = static_cast< ::BeobotEvents::FacesMessagePtr*>(__addr);
05090     assert(p);
05091     *p = ::BeobotEvents::FacesMessagePtr::dynamicCast(v);
05092     if(v && !*p)
05093     {
05094         IceInternal::Ex::throwUOE(::BeobotEvents::FacesMessage::ice_staticId(), v->ice_id());
05095     }
05096 }
05097 
05098 bool
05099 BeobotEvents::operator==(const ::BeobotEvents::FacesMessage& l, const ::BeobotEvents::FacesMessage& r)
05100 {
05101     return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
05102 }
05103 
05104 bool
05105 BeobotEvents::operator<(const ::BeobotEvents::FacesMessage& l, const ::BeobotEvents::FacesMessage& r)
05106 {
05107     return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
05108 }
05109 
05110 BeobotEvents::GUISpeechMessage::GUISpeechMessage(::Ice::Int __ice_RequestID, const ::std::string& __ice_itsMessage, ::Ice::Int __ice_itsCommand) :
05111     RequestID(__ice_RequestID),
05112     itsMessage(__ice_itsMessage),
05113     itsCommand(__ice_itsCommand)
05114 {
05115 }
05116 
05117 ::Ice::ObjectPtr
05118 BeobotEvents::GUISpeechMessage::ice_clone() const
05119 {
05120     ::BeobotEvents::GUISpeechMessagePtr __p = new ::BeobotEvents::GUISpeechMessage(*this);
05121     return __p;
05122 }
05123 
05124 static const ::std::string __BeobotEvents__GUISpeechMessage_ids[3] =
05125 {
05126     "::BeobotEvents::GUISpeechMessage",
05127     "::Ice::Object",
05128     "::RobotSimEvents::EventMessage"
05129 };
05130 
05131 bool
05132 BeobotEvents::GUISpeechMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
05133 {
05134     return ::std::binary_search(__BeobotEvents__GUISpeechMessage_ids, __BeobotEvents__GUISpeechMessage_ids + 3, _s);
05135 }
05136 
05137 ::std::vector< ::std::string>
05138 BeobotEvents::GUISpeechMessage::ice_ids(const ::Ice::Current&) const
05139 {
05140     return ::std::vector< ::std::string>(&__BeobotEvents__GUISpeechMessage_ids[0], &__BeobotEvents__GUISpeechMessage_ids[3]);
05141 }
05142 
05143 const ::std::string&
05144 BeobotEvents::GUISpeechMessage::ice_id(const ::Ice::Current&) const
05145 {
05146     return __BeobotEvents__GUISpeechMessage_ids[0];
05147 }
05148 
05149 const ::std::string&
05150 BeobotEvents::GUISpeechMessage::ice_staticId()
05151 {
05152     return __BeobotEvents__GUISpeechMessage_ids[0];
05153 }
05154 
05155 void
05156 BeobotEvents::GUISpeechMessage::__write(::IceInternal::BasicStream* __os) const
05157 {
05158     __os->writeTypeId(ice_staticId());
05159     __os->startWriteSlice();
05160     __os->write(RequestID);
05161     __os->write(itsMessage);
05162     __os->write(itsCommand);
05163     __os->endWriteSlice();
05164 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05165     EventMessage::__write(__os);
05166 #else
05167     ::RobotSimEvents::EventMessage::__write(__os);
05168 #endif
05169 }
05170 
05171 void
05172 BeobotEvents::GUISpeechMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
05173 {
05174     if(__rid)
05175     {
05176         ::std::string myId;
05177         __is->readTypeId(myId);
05178     }
05179     __is->startReadSlice();
05180     __is->read(RequestID);
05181     __is->read(itsMessage);
05182     __is->read(itsCommand);
05183     __is->endReadSlice();
05184 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05185     EventMessage::__read(__is, true);
05186 #else
05187     ::RobotSimEvents::EventMessage::__read(__is, true);
05188 #endif
05189 }
05190 
05191 void
05192 BeobotEvents::GUISpeechMessage::__write(const ::Ice::OutputStreamPtr&) const
05193 {
05194     Ice::MarshalException ex(__FILE__, __LINE__);
05195     ex.reason = "type BeobotEvents::GUISpeechMessage was not generated with stream support";
05196     throw ex;
05197 }
05198 
05199 void
05200 BeobotEvents::GUISpeechMessage::__read(const ::Ice::InputStreamPtr&, bool)
05201 {
05202     Ice::MarshalException ex(__FILE__, __LINE__);
05203     ex.reason = "type BeobotEvents::GUISpeechMessage was not generated with stream support";
05204     throw ex;
05205 }
05206 
05207 class __F__BeobotEvents__GUISpeechMessage : public ::Ice::ObjectFactory
05208 {
05209 public:
05210 
05211     virtual ::Ice::ObjectPtr
05212     create(const ::std::string& type)
05213     {
05214         assert(type == ::BeobotEvents::GUISpeechMessage::ice_staticId());
05215         return new ::BeobotEvents::GUISpeechMessage;
05216     }
05217 
05218     virtual void
05219     destroy()
05220     {
05221     }
05222 };
05223 
05224 static ::Ice::ObjectFactoryPtr __F__BeobotEvents__GUISpeechMessage_Ptr = new __F__BeobotEvents__GUISpeechMessage;
05225 
05226 const ::Ice::ObjectFactoryPtr&
05227 BeobotEvents::GUISpeechMessage::ice_factory()
05228 {
05229     return __F__BeobotEvents__GUISpeechMessage_Ptr;
05230 }
05231 
05232 class __F__BeobotEvents__GUISpeechMessage__Init
05233 {
05234 public:
05235 
05236     __F__BeobotEvents__GUISpeechMessage__Init()
05237     {
05238         ::IceInternal::factoryTable->addObjectFactory(::BeobotEvents::GUISpeechMessage::ice_staticId(), ::BeobotEvents::GUISpeechMessage::ice_factory());
05239     }
05240 
05241     ~__F__BeobotEvents__GUISpeechMessage__Init()
05242     {
05243         ::IceInternal::factoryTable->removeObjectFactory(::BeobotEvents::GUISpeechMessage::ice_staticId());
05244     }
05245 };
05246 
05247 static __F__BeobotEvents__GUISpeechMessage__Init __F__BeobotEvents__GUISpeechMessage__i;
05248 
05249 #ifdef __APPLE__
05250 extern "C" { void __F__BeobotEvents__GUISpeechMessage__initializer() {} }
05251 #endif
05252 
05253 void
05254 BeobotEvents::__patch__GUISpeechMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
05255 {
05256     ::BeobotEvents::GUISpeechMessagePtr* p = static_cast< ::BeobotEvents::GUISpeechMessagePtr*>(__addr);
05257     assert(p);
05258     *p = ::BeobotEvents::GUISpeechMessagePtr::dynamicCast(v);
05259     if(v && !*p)
05260     {
05261         IceInternal::Ex::throwUOE(::BeobotEvents::GUISpeechMessage::ice_staticId(), v->ice_id());
05262     }
05263 }
05264 
05265 bool
05266 BeobotEvents::operator==(const ::BeobotEvents::GUISpeechMessage& l, const ::BeobotEvents::GUISpeechMessage& r)
05267 {
05268     return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
05269 }
05270 
05271 bool
05272 BeobotEvents::operator<(const ::BeobotEvents::GUISpeechMessage& l, const ::BeobotEvents::GUISpeechMessage& r)
05273 {
05274     return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
05275 }
Generated on Sun May 8 08:40:42 2011 for iLab Neuromorphic Vision Toolkit by  doxygen 1.6.3