BeobotEvents.ice.H

00001 // **********************************************************************
00002 //
00003 // Copyright (c) 2003-2009 ZeroC, Inc. All rights reserved.
00004 //
00005 // This copy of Ice is licensed to you under the terms described in the
00006 // ICE_LICENSE file included in this distribution.
00007 //
00008 // **********************************************************************
00009 
00010 // Ice version 3.3.1
00011 // Generated from file `BeobotEvents.ice'
00012 
00013 #ifndef __src_Ice__BeobotEvents_ice_H__
00014 #define __src_Ice__BeobotEvents_ice_H__
00015 
00016 #include <Ice/LocalObjectF.h>
00017 #include <Ice/ProxyF.h>
00018 #include <Ice/ObjectF.h>
00019 #include <Ice/Exception.h>
00020 #include <Ice/LocalObject.h>
00021 #include <Ice/Proxy.h>
00022 #include <Ice/Object.h>
00023 #include <Ice/Outgoing.h>
00024 #include <Ice/Incoming.h>
00025 #include <Ice/Direct.h>
00026 #include <Ice/FactoryTable.h>
00027 #include <Ice/StreamF.h>
00028 #include <Ice/ImageIce.ice.H>
00029 #include <Ice/RobotSimEvents.ice.H>
00030 #include <Ice/UndefSysMacros.h>
00031 
00032 #ifndef ICE_IGNORE_VERSION
00033 #   if ICE_INT_VERSION / 100 != 303
00034 #       error Ice version mismatch!
00035 #   endif
00036 #   if ICE_INT_VERSION % 100 > 50
00037 #       error Beta header file detected
00038 #   endif
00039 #   if ICE_INT_VERSION % 100 < 1
00040 #       error Ice patch level mismatch!
00041 #   endif
00042 #endif
00043 
00044 namespace IceProxy
00045 {
00046 
00047 namespace BeobotEvents
00048 {
00049 
00050 class MotorMessage;
00051 
00052 class MotorRequest;
00053 
00054 class CornerMotorRequest;
00055 
00056 class CornerLocationMessage;
00057 
00058 class SonarMessage;
00059 
00060 class GPSMessage;
00061 
00062 class LRFMessage;
00063 
00064 class SLAMMessage;
00065 
00066 class IMUMessage;
00067 
00068 class CameraMessage;
00069 
00070 class GistSalMessage;
00071 
00072 class LandmarkSearchQueueMessage;
00073 
00074 class LandmarkTrackMessage;
00075 
00076 class LandmarkSearchStatMessage;
00077 
00078 class LandmarkMatchResultMessage;
00079 
00080 class LandmarkDBSearchResultMessage;
00081 
00082 class CurrentLocationMessage;
00083 
00084 class CancelSearchMessage;
00085 
00086 class SearchDoneMessage;
00087 
00088 class NextFrameMessage;
00089 
00090 class AbortMessage;
00091 
00092 class FacesMessage;
00093 
00094 class GUISpeechMessage;
00095 
00096 }
00097 
00098 }
00099 
00100 namespace BeobotEvents
00101 {
00102 
00103 class MotorMessage;
00104 bool operator==(const MotorMessage&, const MotorMessage&);
00105 bool operator<(const MotorMessage&, const MotorMessage&);
00106 
00107 class MotorRequest;
00108 bool operator==(const MotorRequest&, const MotorRequest&);
00109 bool operator<(const MotorRequest&, const MotorRequest&);
00110 
00111 class CornerMotorRequest;
00112 bool operator==(const CornerMotorRequest&, const CornerMotorRequest&);
00113 bool operator<(const CornerMotorRequest&, const CornerMotorRequest&);
00114 
00115 class CornerLocationMessage;
00116 bool operator==(const CornerLocationMessage&, const CornerLocationMessage&);
00117 bool operator<(const CornerLocationMessage&, const CornerLocationMessage&);
00118 
00119 class SonarMessage;
00120 bool operator==(const SonarMessage&, const SonarMessage&);
00121 bool operator<(const SonarMessage&, const SonarMessage&);
00122 
00123 class GPSMessage;
00124 bool operator==(const GPSMessage&, const GPSMessage&);
00125 bool operator<(const GPSMessage&, const GPSMessage&);
00126 
00127 class LRFMessage;
00128 bool operator==(const LRFMessage&, const LRFMessage&);
00129 bool operator<(const LRFMessage&, const LRFMessage&);
00130 
00131 class SLAMMessage;
00132 bool operator==(const SLAMMessage&, const SLAMMessage&);
00133 bool operator<(const SLAMMessage&, const SLAMMessage&);
00134 
00135 class IMUMessage;
00136 bool operator==(const IMUMessage&, const IMUMessage&);
00137 bool operator<(const IMUMessage&, const IMUMessage&);
00138 
00139 class CameraMessage;
00140 bool operator==(const CameraMessage&, const CameraMessage&);
00141 bool operator<(const CameraMessage&, const CameraMessage&);
00142 
00143 class GistSalMessage;
00144 bool operator==(const GistSalMessage&, const GistSalMessage&);
00145 bool operator<(const GistSalMessage&, const GistSalMessage&);
00146 
00147 class LandmarkSearchQueueMessage;
00148 bool operator==(const LandmarkSearchQueueMessage&, const LandmarkSearchQueueMessage&);
00149 bool operator<(const LandmarkSearchQueueMessage&, const LandmarkSearchQueueMessage&);
00150 
00151 class LandmarkTrackMessage;
00152 bool operator==(const LandmarkTrackMessage&, const LandmarkTrackMessage&);
00153 bool operator<(const LandmarkTrackMessage&, const LandmarkTrackMessage&);
00154 
00155 class LandmarkSearchStatMessage;
00156 bool operator==(const LandmarkSearchStatMessage&, const LandmarkSearchStatMessage&);
00157 bool operator<(const LandmarkSearchStatMessage&, const LandmarkSearchStatMessage&);
00158 
00159 class LandmarkMatchResultMessage;
00160 bool operator==(const LandmarkMatchResultMessage&, const LandmarkMatchResultMessage&);
00161 bool operator<(const LandmarkMatchResultMessage&, const LandmarkMatchResultMessage&);
00162 
00163 class LandmarkDBSearchResultMessage;
00164 bool operator==(const LandmarkDBSearchResultMessage&, const LandmarkDBSearchResultMessage&);
00165 bool operator<(const LandmarkDBSearchResultMessage&, const LandmarkDBSearchResultMessage&);
00166 
00167 class CurrentLocationMessage;
00168 bool operator==(const CurrentLocationMessage&, const CurrentLocationMessage&);
00169 bool operator<(const CurrentLocationMessage&, const CurrentLocationMessage&);
00170 
00171 class CancelSearchMessage;
00172 bool operator==(const CancelSearchMessage&, const CancelSearchMessage&);
00173 bool operator<(const CancelSearchMessage&, const CancelSearchMessage&);
00174 
00175 class SearchDoneMessage;
00176 bool operator==(const SearchDoneMessage&, const SearchDoneMessage&);
00177 bool operator<(const SearchDoneMessage&, const SearchDoneMessage&);
00178 
00179 class NextFrameMessage;
00180 bool operator==(const NextFrameMessage&, const NextFrameMessage&);
00181 bool operator<(const NextFrameMessage&, const NextFrameMessage&);
00182 
00183 class AbortMessage;
00184 bool operator==(const AbortMessage&, const AbortMessage&);
00185 bool operator<(const AbortMessage&, const AbortMessage&);
00186 
00187 class FacesMessage;
00188 bool operator==(const FacesMessage&, const FacesMessage&);
00189 bool operator<(const FacesMessage&, const FacesMessage&);
00190 
00191 class GUISpeechMessage;
00192 bool operator==(const GUISpeechMessage&, const GUISpeechMessage&);
00193 bool operator<(const GUISpeechMessage&, const GUISpeechMessage&);
00194 
00195 }
00196 
00197 namespace IceInternal
00198 {
00199 
00200 ::Ice::Object* upCast(::BeobotEvents::MotorMessage*);
00201 ::IceProxy::Ice::Object* upCast(::IceProxy::BeobotEvents::MotorMessage*);
00202 
00203 ::Ice::Object* upCast(::BeobotEvents::MotorRequest*);
00204 ::IceProxy::Ice::Object* upCast(::IceProxy::BeobotEvents::MotorRequest*);
00205 
00206 ::Ice::Object* upCast(::BeobotEvents::CornerMotorRequest*);
00207 ::IceProxy::Ice::Object* upCast(::IceProxy::BeobotEvents::CornerMotorRequest*);
00208 
00209 ::Ice::Object* upCast(::BeobotEvents::CornerLocationMessage*);
00210 ::IceProxy::Ice::Object* upCast(::IceProxy::BeobotEvents::CornerLocationMessage*);
00211 
00212 ::Ice::Object* upCast(::BeobotEvents::SonarMessage*);
00213 ::IceProxy::Ice::Object* upCast(::IceProxy::BeobotEvents::SonarMessage*);
00214 
00215 ::Ice::Object* upCast(::BeobotEvents::GPSMessage*);
00216 ::IceProxy::Ice::Object* upCast(::IceProxy::BeobotEvents::GPSMessage*);
00217 
00218 ::Ice::Object* upCast(::BeobotEvents::LRFMessage*);
00219 ::IceProxy::Ice::Object* upCast(::IceProxy::BeobotEvents::LRFMessage*);
00220 
00221 ::Ice::Object* upCast(::BeobotEvents::SLAMMessage*);
00222 ::IceProxy::Ice::Object* upCast(::IceProxy::BeobotEvents::SLAMMessage*);
00223 
00224 ::Ice::Object* upCast(::BeobotEvents::IMUMessage*);
00225 ::IceProxy::Ice::Object* upCast(::IceProxy::BeobotEvents::IMUMessage*);
00226 
00227 ::Ice::Object* upCast(::BeobotEvents::CameraMessage*);
00228 ::IceProxy::Ice::Object* upCast(::IceProxy::BeobotEvents::CameraMessage*);
00229 
00230 ::Ice::Object* upCast(::BeobotEvents::GistSalMessage*);
00231 ::IceProxy::Ice::Object* upCast(::IceProxy::BeobotEvents::GistSalMessage*);
00232 
00233 ::Ice::Object* upCast(::BeobotEvents::LandmarkSearchQueueMessage*);
00234 ::IceProxy::Ice::Object* upCast(::IceProxy::BeobotEvents::LandmarkSearchQueueMessage*);
00235 
00236 ::Ice::Object* upCast(::BeobotEvents::LandmarkTrackMessage*);
00237 ::IceProxy::Ice::Object* upCast(::IceProxy::BeobotEvents::LandmarkTrackMessage*);
00238 
00239 ::Ice::Object* upCast(::BeobotEvents::LandmarkSearchStatMessage*);
00240 ::IceProxy::Ice::Object* upCast(::IceProxy::BeobotEvents::LandmarkSearchStatMessage*);
00241 
00242 ::Ice::Object* upCast(::BeobotEvents::LandmarkMatchResultMessage*);
00243 ::IceProxy::Ice::Object* upCast(::IceProxy::BeobotEvents::LandmarkMatchResultMessage*);
00244 
00245 ::Ice::Object* upCast(::BeobotEvents::LandmarkDBSearchResultMessage*);
00246 ::IceProxy::Ice::Object* upCast(::IceProxy::BeobotEvents::LandmarkDBSearchResultMessage*);
00247 
00248 ::Ice::Object* upCast(::BeobotEvents::CurrentLocationMessage*);
00249 ::IceProxy::Ice::Object* upCast(::IceProxy::BeobotEvents::CurrentLocationMessage*);
00250 
00251 ::Ice::Object* upCast(::BeobotEvents::CancelSearchMessage*);
00252 ::IceProxy::Ice::Object* upCast(::IceProxy::BeobotEvents::CancelSearchMessage*);
00253 
00254 ::Ice::Object* upCast(::BeobotEvents::SearchDoneMessage*);
00255 ::IceProxy::Ice::Object* upCast(::IceProxy::BeobotEvents::SearchDoneMessage*);
00256 
00257 ::Ice::Object* upCast(::BeobotEvents::NextFrameMessage*);
00258 ::IceProxy::Ice::Object* upCast(::IceProxy::BeobotEvents::NextFrameMessage*);
00259 
00260 ::Ice::Object* upCast(::BeobotEvents::AbortMessage*);
00261 ::IceProxy::Ice::Object* upCast(::IceProxy::BeobotEvents::AbortMessage*);
00262 
00263 ::Ice::Object* upCast(::BeobotEvents::FacesMessage*);
00264 ::IceProxy::Ice::Object* upCast(::IceProxy::BeobotEvents::FacesMessage*);
00265 
00266 ::Ice::Object* upCast(::BeobotEvents::GUISpeechMessage*);
00267 ::IceProxy::Ice::Object* upCast(::IceProxy::BeobotEvents::GUISpeechMessage*);
00268 
00269 }
00270 
00271 namespace BeobotEvents
00272 {
00273 
00274 typedef ::IceInternal::Handle< ::BeobotEvents::MotorMessage> MotorMessagePtr;
00275 typedef ::IceInternal::ProxyHandle< ::IceProxy::BeobotEvents::MotorMessage> MotorMessagePrx;
00276 
00277 void __read(::IceInternal::BasicStream*, MotorMessagePrx&);
00278 void __patch__MotorMessagePtr(void*, ::Ice::ObjectPtr&);
00279 
00280 typedef ::IceInternal::Handle< ::BeobotEvents::MotorRequest> MotorRequestPtr;
00281 typedef ::IceInternal::ProxyHandle< ::IceProxy::BeobotEvents::MotorRequest> MotorRequestPrx;
00282 
00283 void __read(::IceInternal::BasicStream*, MotorRequestPrx&);
00284 void __patch__MotorRequestPtr(void*, ::Ice::ObjectPtr&);
00285 
00286 typedef ::IceInternal::Handle< ::BeobotEvents::CornerMotorRequest> CornerMotorRequestPtr;
00287 typedef ::IceInternal::ProxyHandle< ::IceProxy::BeobotEvents::CornerMotorRequest> CornerMotorRequestPrx;
00288 
00289 void __read(::IceInternal::BasicStream*, CornerMotorRequestPrx&);
00290 void __patch__CornerMotorRequestPtr(void*, ::Ice::ObjectPtr&);
00291 
00292 typedef ::IceInternal::Handle< ::BeobotEvents::CornerLocationMessage> CornerLocationMessagePtr;
00293 typedef ::IceInternal::ProxyHandle< ::IceProxy::BeobotEvents::CornerLocationMessage> CornerLocationMessagePrx;
00294 
00295 void __read(::IceInternal::BasicStream*, CornerLocationMessagePrx&);
00296 void __patch__CornerLocationMessagePtr(void*, ::Ice::ObjectPtr&);
00297 
00298 typedef ::IceInternal::Handle< ::BeobotEvents::SonarMessage> SonarMessagePtr;
00299 typedef ::IceInternal::ProxyHandle< ::IceProxy::BeobotEvents::SonarMessage> SonarMessagePrx;
00300 
00301 void __read(::IceInternal::BasicStream*, SonarMessagePrx&);
00302 void __patch__SonarMessagePtr(void*, ::Ice::ObjectPtr&);
00303 
00304 typedef ::IceInternal::Handle< ::BeobotEvents::GPSMessage> GPSMessagePtr;
00305 typedef ::IceInternal::ProxyHandle< ::IceProxy::BeobotEvents::GPSMessage> GPSMessagePrx;
00306 
00307 void __read(::IceInternal::BasicStream*, GPSMessagePrx&);
00308 void __patch__GPSMessagePtr(void*, ::Ice::ObjectPtr&);
00309 
00310 typedef ::IceInternal::Handle< ::BeobotEvents::LRFMessage> LRFMessagePtr;
00311 typedef ::IceInternal::ProxyHandle< ::IceProxy::BeobotEvents::LRFMessage> LRFMessagePrx;
00312 
00313 void __read(::IceInternal::BasicStream*, LRFMessagePrx&);
00314 void __patch__LRFMessagePtr(void*, ::Ice::ObjectPtr&);
00315 
00316 typedef ::IceInternal::Handle< ::BeobotEvents::SLAMMessage> SLAMMessagePtr;
00317 typedef ::IceInternal::ProxyHandle< ::IceProxy::BeobotEvents::SLAMMessage> SLAMMessagePrx;
00318 
00319 void __read(::IceInternal::BasicStream*, SLAMMessagePrx&);
00320 void __patch__SLAMMessagePtr(void*, ::Ice::ObjectPtr&);
00321 
00322 typedef ::IceInternal::Handle< ::BeobotEvents::IMUMessage> IMUMessagePtr;
00323 typedef ::IceInternal::ProxyHandle< ::IceProxy::BeobotEvents::IMUMessage> IMUMessagePrx;
00324 
00325 void __read(::IceInternal::BasicStream*, IMUMessagePrx&);
00326 void __patch__IMUMessagePtr(void*, ::Ice::ObjectPtr&);
00327 
00328 typedef ::IceInternal::Handle< ::BeobotEvents::CameraMessage> CameraMessagePtr;
00329 typedef ::IceInternal::ProxyHandle< ::IceProxy::BeobotEvents::CameraMessage> CameraMessagePrx;
00330 
00331 void __read(::IceInternal::BasicStream*, CameraMessagePrx&);
00332 void __patch__CameraMessagePtr(void*, ::Ice::ObjectPtr&);
00333 
00334 typedef ::IceInternal::Handle< ::BeobotEvents::GistSalMessage> GistSalMessagePtr;
00335 typedef ::IceInternal::ProxyHandle< ::IceProxy::BeobotEvents::GistSalMessage> GistSalMessagePrx;
00336 
00337 void __read(::IceInternal::BasicStream*, GistSalMessagePrx&);
00338 void __patch__GistSalMessagePtr(void*, ::Ice::ObjectPtr&);
00339 
00340 typedef ::IceInternal::Handle< ::BeobotEvents::LandmarkSearchQueueMessage> LandmarkSearchQueueMessagePtr;
00341 typedef ::IceInternal::ProxyHandle< ::IceProxy::BeobotEvents::LandmarkSearchQueueMessage> LandmarkSearchQueueMessagePrx;
00342 
00343 void __read(::IceInternal::BasicStream*, LandmarkSearchQueueMessagePrx&);
00344 void __patch__LandmarkSearchQueueMessagePtr(void*, ::Ice::ObjectPtr&);
00345 
00346 typedef ::IceInternal::Handle< ::BeobotEvents::LandmarkTrackMessage> LandmarkTrackMessagePtr;
00347 typedef ::IceInternal::ProxyHandle< ::IceProxy::BeobotEvents::LandmarkTrackMessage> LandmarkTrackMessagePrx;
00348 
00349 void __read(::IceInternal::BasicStream*, LandmarkTrackMessagePrx&);
00350 void __patch__LandmarkTrackMessagePtr(void*, ::Ice::ObjectPtr&);
00351 
00352 typedef ::IceInternal::Handle< ::BeobotEvents::LandmarkSearchStatMessage> LandmarkSearchStatMessagePtr;
00353 typedef ::IceInternal::ProxyHandle< ::IceProxy::BeobotEvents::LandmarkSearchStatMessage> LandmarkSearchStatMessagePrx;
00354 
00355 void __read(::IceInternal::BasicStream*, LandmarkSearchStatMessagePrx&);
00356 void __patch__LandmarkSearchStatMessagePtr(void*, ::Ice::ObjectPtr&);
00357 
00358 typedef ::IceInternal::Handle< ::BeobotEvents::LandmarkMatchResultMessage> LandmarkMatchResultMessagePtr;
00359 typedef ::IceInternal::ProxyHandle< ::IceProxy::BeobotEvents::LandmarkMatchResultMessage> LandmarkMatchResultMessagePrx;
00360 
00361 void __read(::IceInternal::BasicStream*, LandmarkMatchResultMessagePrx&);
00362 void __patch__LandmarkMatchResultMessagePtr(void*, ::Ice::ObjectPtr&);
00363 
00364 typedef ::IceInternal::Handle< ::BeobotEvents::LandmarkDBSearchResultMessage> LandmarkDBSearchResultMessagePtr;
00365 typedef ::IceInternal::ProxyHandle< ::IceProxy::BeobotEvents::LandmarkDBSearchResultMessage> LandmarkDBSearchResultMessagePrx;
00366 
00367 void __read(::IceInternal::BasicStream*, LandmarkDBSearchResultMessagePrx&);
00368 void __patch__LandmarkDBSearchResultMessagePtr(void*, ::Ice::ObjectPtr&);
00369 
00370 typedef ::IceInternal::Handle< ::BeobotEvents::CurrentLocationMessage> CurrentLocationMessagePtr;
00371 typedef ::IceInternal::ProxyHandle< ::IceProxy::BeobotEvents::CurrentLocationMessage> CurrentLocationMessagePrx;
00372 
00373 void __read(::IceInternal::BasicStream*, CurrentLocationMessagePrx&);
00374 void __patch__CurrentLocationMessagePtr(void*, ::Ice::ObjectPtr&);
00375 
00376 typedef ::IceInternal::Handle< ::BeobotEvents::CancelSearchMessage> CancelSearchMessagePtr;
00377 typedef ::IceInternal::ProxyHandle< ::IceProxy::BeobotEvents::CancelSearchMessage> CancelSearchMessagePrx;
00378 
00379 void __read(::IceInternal::BasicStream*, CancelSearchMessagePrx&);
00380 void __patch__CancelSearchMessagePtr(void*, ::Ice::ObjectPtr&);
00381 
00382 typedef ::IceInternal::Handle< ::BeobotEvents::SearchDoneMessage> SearchDoneMessagePtr;
00383 typedef ::IceInternal::ProxyHandle< ::IceProxy::BeobotEvents::SearchDoneMessage> SearchDoneMessagePrx;
00384 
00385 void __read(::IceInternal::BasicStream*, SearchDoneMessagePrx&);
00386 void __patch__SearchDoneMessagePtr(void*, ::Ice::ObjectPtr&);
00387 
00388 typedef ::IceInternal::Handle< ::BeobotEvents::NextFrameMessage> NextFrameMessagePtr;
00389 typedef ::IceInternal::ProxyHandle< ::IceProxy::BeobotEvents::NextFrameMessage> NextFrameMessagePrx;
00390 
00391 void __read(::IceInternal::BasicStream*, NextFrameMessagePrx&);
00392 void __patch__NextFrameMessagePtr(void*, ::Ice::ObjectPtr&);
00393 
00394 typedef ::IceInternal::Handle< ::BeobotEvents::AbortMessage> AbortMessagePtr;
00395 typedef ::IceInternal::ProxyHandle< ::IceProxy::BeobotEvents::AbortMessage> AbortMessagePrx;
00396 
00397 void __read(::IceInternal::BasicStream*, AbortMessagePrx&);
00398 void __patch__AbortMessagePtr(void*, ::Ice::ObjectPtr&);
00399 
00400 typedef ::IceInternal::Handle< ::BeobotEvents::FacesMessage> FacesMessagePtr;
00401 typedef ::IceInternal::ProxyHandle< ::IceProxy::BeobotEvents::FacesMessage> FacesMessagePrx;
00402 
00403 void __read(::IceInternal::BasicStream*, FacesMessagePrx&);
00404 void __patch__FacesMessagePtr(void*, ::Ice::ObjectPtr&);
00405 
00406 typedef ::IceInternal::Handle< ::BeobotEvents::GUISpeechMessage> GUISpeechMessagePtr;
00407 typedef ::IceInternal::ProxyHandle< ::IceProxy::BeobotEvents::GUISpeechMessage> GUISpeechMessagePrx;
00408 
00409 void __read(::IceInternal::BasicStream*, GUISpeechMessagePrx&);
00410 void __patch__GUISpeechMessagePtr(void*, ::Ice::ObjectPtr&);
00411 
00412 }
00413 
00414 namespace BeobotEvents
00415 {
00416 
00417 typedef ::std::vector< ::Ice::Double> DoubleSeq;
00418 
00419 struct SalientRegion
00420 {
00421     ::ImageIceMod::Point2DIce salpt;
00422     ::ImageIceMod::RectangleIce objRect;
00423     ::BeobotEvents::DoubleSeq salFeatures;
00424 
00425     bool operator==(const SalientRegion&) const;
00426     bool operator<(const SalientRegion&) const;
00427     bool operator!=(const SalientRegion& __rhs) const
00428     {
00429         return !operator==(__rhs);
00430     }
00431     bool operator<=(const SalientRegion& __rhs) const
00432     {
00433         return operator<(__rhs) || operator==(__rhs);
00434     }
00435     bool operator>(const SalientRegion& __rhs) const
00436     {
00437         return !operator<(__rhs) && !operator==(__rhs);
00438     }
00439     bool operator>=(const SalientRegion& __rhs) const
00440     {
00441         return !operator<(__rhs);
00442     }
00443 
00444     void __write(::IceInternal::BasicStream*) const;
00445     void __read(::IceInternal::BasicStream*);
00446 };
00447 
00448 typedef ::std::vector< ::BeobotEvents::SalientRegion> SalientRegionSeq;
00449 void __writeSalientRegionSeq(::IceInternal::BasicStream*, const ::BeobotEvents::SalientRegion*, const ::BeobotEvents::SalientRegion*);
00450 void __readSalientRegionSeq(::IceInternal::BasicStream*, SalientRegionSeq&);
00451 
00452 struct LandmarkSearchJob
00453 {
00454     ::Ice::Int inputSalRegID;
00455     ::Ice::Int dbSegNum;
00456     ::Ice::Int dbLmkNum;
00457     ::Ice::Int dbVOStart;
00458     ::Ice::Int dbVOEnd;
00459 
00460     bool operator==(const LandmarkSearchJob&) const;
00461     bool operator<(const LandmarkSearchJob&) const;
00462     bool operator!=(const LandmarkSearchJob& __rhs) const
00463     {
00464         return !operator==(__rhs);
00465     }
00466     bool operator<=(const LandmarkSearchJob& __rhs) const
00467     {
00468         return operator<(__rhs) || operator==(__rhs);
00469     }
00470     bool operator>(const LandmarkSearchJob& __rhs) const
00471     {
00472         return !operator<(__rhs) && !operator==(__rhs);
00473     }
00474     bool operator>=(const LandmarkSearchJob& __rhs) const
00475     {
00476         return !operator<(__rhs);
00477     }
00478 
00479     void __write(::IceInternal::BasicStream*) const;
00480     void __read(::IceInternal::BasicStream*);
00481 };
00482 
00483 typedef ::std::vector< ::BeobotEvents::LandmarkSearchJob> LandmarkSearchJobSeq;
00484 void __writeLandmarkSearchJobSeq(::IceInternal::BasicStream*, const ::BeobotEvents::LandmarkSearchJob*, const ::BeobotEvents::LandmarkSearchJob*);
00485 void __readLandmarkSearchJobSeq(::IceInternal::BasicStream*, LandmarkSearchJobSeq&);
00486 
00487 typedef ::std::vector< ::ImageIceMod::RectangleIce> RectangleIceSeq;
00488 void __writeRectangleIceSeq(::IceInternal::BasicStream*, const ::ImageIceMod::RectangleIce*, const ::ImageIceMod::RectangleIce*);
00489 void __readRectangleIceSeq(::IceInternal::BasicStream*, RectangleIceSeq&);
00490 
00491 }
00492 
00493 namespace IceProxy
00494 {
00495 
00496 namespace BeobotEvents
00497 {
00498 
00499 class MotorMessage : virtual public ::IceProxy::RobotSimEvents::EventMessage
00500 {
00501 public:
00502 
00503     ::IceInternal::ProxyHandle<MotorMessage> ice_context(const ::Ice::Context& __context) const
00504     {
00505     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00506         typedef ::IceProxy::Ice::Object _Base;
00507         return dynamic_cast<MotorMessage*>(_Base::ice_context(__context).get());
00508     #else
00509         return dynamic_cast<MotorMessage*>(::IceProxy::Ice::Object::ice_context(__context).get());
00510     #endif
00511     }
00512 
00513     ::IceInternal::ProxyHandle<MotorMessage> ice_adapterId(const std::string& __id) const
00514     {
00515     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00516         typedef ::IceProxy::Ice::Object _Base;
00517         return dynamic_cast<MotorMessage*>(_Base::ice_adapterId(__id).get());
00518     #else
00519         return dynamic_cast<MotorMessage*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
00520     #endif
00521     }
00522 
00523     ::IceInternal::ProxyHandle<MotorMessage> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
00524     {
00525     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00526         typedef ::IceProxy::Ice::Object _Base;
00527         return dynamic_cast<MotorMessage*>(_Base::ice_endpoints(__endpoints).get());
00528     #else
00529         return dynamic_cast<MotorMessage*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
00530     #endif
00531     }
00532 
00533     ::IceInternal::ProxyHandle<MotorMessage> ice_locatorCacheTimeout(int __timeout) const
00534     {
00535     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00536         typedef ::IceProxy::Ice::Object _Base;
00537         return dynamic_cast<MotorMessage*>(_Base::ice_locatorCacheTimeout(__timeout).get());
00538     #else
00539         return dynamic_cast<MotorMessage*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
00540     #endif
00541     }
00542 
00543     ::IceInternal::ProxyHandle<MotorMessage> ice_connectionCached(bool __cached) const
00544     {
00545     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00546         typedef ::IceProxy::Ice::Object _Base;
00547         return dynamic_cast<MotorMessage*>(_Base::ice_connectionCached(__cached).get());
00548     #else
00549         return dynamic_cast<MotorMessage*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
00550     #endif
00551     }
00552 
00553     ::IceInternal::ProxyHandle<MotorMessage> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
00554     {
00555     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00556         typedef ::IceProxy::Ice::Object _Base;
00557         return dynamic_cast<MotorMessage*>(_Base::ice_endpointSelection(__est).get());
00558     #else
00559         return dynamic_cast<MotorMessage*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
00560     #endif
00561     }
00562 
00563     ::IceInternal::ProxyHandle<MotorMessage> ice_secure(bool __secure) const
00564     {
00565     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00566         typedef ::IceProxy::Ice::Object _Base;
00567         return dynamic_cast<MotorMessage*>(_Base::ice_secure(__secure).get());
00568     #else
00569         return dynamic_cast<MotorMessage*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
00570     #endif
00571     }
00572 
00573     ::IceInternal::ProxyHandle<MotorMessage> ice_preferSecure(bool __preferSecure) const
00574     {
00575     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00576         typedef ::IceProxy::Ice::Object _Base;
00577         return dynamic_cast<MotorMessage*>(_Base::ice_preferSecure(__preferSecure).get());
00578     #else
00579         return dynamic_cast<MotorMessage*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
00580     #endif
00581     }
00582 
00583     ::IceInternal::ProxyHandle<MotorMessage> ice_router(const ::Ice::RouterPrx& __router) const
00584     {
00585     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00586         typedef ::IceProxy::Ice::Object _Base;
00587         return dynamic_cast<MotorMessage*>(_Base::ice_router(__router).get());
00588     #else
00589         return dynamic_cast<MotorMessage*>(::IceProxy::Ice::Object::ice_router(__router).get());
00590     #endif
00591     }
00592 
00593     ::IceInternal::ProxyHandle<MotorMessage> ice_locator(const ::Ice::LocatorPrx& __locator) const
00594     {
00595     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00596         typedef ::IceProxy::Ice::Object _Base;
00597         return dynamic_cast<MotorMessage*>(_Base::ice_locator(__locator).get());
00598     #else
00599         return dynamic_cast<MotorMessage*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
00600     #endif
00601     }
00602 
00603     ::IceInternal::ProxyHandle<MotorMessage> ice_collocationOptimized(bool __co) const
00604     {
00605     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00606         typedef ::IceProxy::Ice::Object _Base;
00607         return dynamic_cast<MotorMessage*>(_Base::ice_collocationOptimized(__co).get());
00608     #else
00609         return dynamic_cast<MotorMessage*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
00610     #endif
00611     }
00612 
00613     ::IceInternal::ProxyHandle<MotorMessage> ice_twoway() const
00614     {
00615     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00616         typedef ::IceProxy::Ice::Object _Base;
00617         return dynamic_cast<MotorMessage*>(_Base::ice_twoway().get());
00618     #else
00619         return dynamic_cast<MotorMessage*>(::IceProxy::Ice::Object::ice_twoway().get());
00620     #endif
00621     }
00622 
00623     ::IceInternal::ProxyHandle<MotorMessage> ice_oneway() const
00624     {
00625     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00626         typedef ::IceProxy::Ice::Object _Base;
00627         return dynamic_cast<MotorMessage*>(_Base::ice_oneway().get());
00628     #else
00629         return dynamic_cast<MotorMessage*>(::IceProxy::Ice::Object::ice_oneway().get());
00630     #endif
00631     }
00632 
00633     ::IceInternal::ProxyHandle<MotorMessage> ice_batchOneway() const
00634     {
00635     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00636         typedef ::IceProxy::Ice::Object _Base;
00637         return dynamic_cast<MotorMessage*>(_Base::ice_batchOneway().get());
00638     #else
00639         return dynamic_cast<MotorMessage*>(::IceProxy::Ice::Object::ice_batchOneway().get());
00640     #endif
00641     }
00642 
00643     ::IceInternal::ProxyHandle<MotorMessage> ice_datagram() const
00644     {
00645     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00646         typedef ::IceProxy::Ice::Object _Base;
00647         return dynamic_cast<MotorMessage*>(_Base::ice_datagram().get());
00648     #else
00649         return dynamic_cast<MotorMessage*>(::IceProxy::Ice::Object::ice_datagram().get());
00650     #endif
00651     }
00652 
00653     ::IceInternal::ProxyHandle<MotorMessage> ice_batchDatagram() const
00654     {
00655     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00656         typedef ::IceProxy::Ice::Object _Base;
00657         return dynamic_cast<MotorMessage*>(_Base::ice_batchDatagram().get());
00658     #else
00659         return dynamic_cast<MotorMessage*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
00660     #endif
00661     }
00662 
00663     ::IceInternal::ProxyHandle<MotorMessage> ice_compress(bool __compress) const
00664     {
00665     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00666         typedef ::IceProxy::Ice::Object _Base;
00667         return dynamic_cast<MotorMessage*>(_Base::ice_compress(__compress).get());
00668     #else
00669         return dynamic_cast<MotorMessage*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
00670     #endif
00671     }
00672 
00673     ::IceInternal::ProxyHandle<MotorMessage> ice_timeout(int __timeout) const
00674     {
00675     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00676         typedef ::IceProxy::Ice::Object _Base;
00677         return dynamic_cast<MotorMessage*>(_Base::ice_timeout(__timeout).get());
00678     #else
00679         return dynamic_cast<MotorMessage*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
00680     #endif
00681     }
00682 
00683     ::IceInternal::ProxyHandle<MotorMessage> ice_connectionId(const std::string& __id) const
00684     {
00685     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00686         typedef ::IceProxy::Ice::Object _Base;
00687         return dynamic_cast<MotorMessage*>(_Base::ice_connectionId(__id).get());
00688     #else
00689         return dynamic_cast<MotorMessage*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
00690     #endif
00691     }
00692 
00693     static const ::std::string& ice_staticId();
00694 
00695 private:
00696 
00697     virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
00698     virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
00699     virtual ::IceProxy::Ice::Object* __newInstance() const;
00700 };
00701 
00702 class MotorRequest : virtual public ::IceProxy::RobotSimEvents::EventMessage
00703 {
00704 public:
00705 
00706     ::IceInternal::ProxyHandle<MotorRequest> ice_context(const ::Ice::Context& __context) const
00707     {
00708     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00709         typedef ::IceProxy::Ice::Object _Base;
00710         return dynamic_cast<MotorRequest*>(_Base::ice_context(__context).get());
00711     #else
00712         return dynamic_cast<MotorRequest*>(::IceProxy::Ice::Object::ice_context(__context).get());
00713     #endif
00714     }
00715 
00716     ::IceInternal::ProxyHandle<MotorRequest> ice_adapterId(const std::string& __id) const
00717     {
00718     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00719         typedef ::IceProxy::Ice::Object _Base;
00720         return dynamic_cast<MotorRequest*>(_Base::ice_adapterId(__id).get());
00721     #else
00722         return dynamic_cast<MotorRequest*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
00723     #endif
00724     }
00725 
00726     ::IceInternal::ProxyHandle<MotorRequest> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
00727     {
00728     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00729         typedef ::IceProxy::Ice::Object _Base;
00730         return dynamic_cast<MotorRequest*>(_Base::ice_endpoints(__endpoints).get());
00731     #else
00732         return dynamic_cast<MotorRequest*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
00733     #endif
00734     }
00735 
00736     ::IceInternal::ProxyHandle<MotorRequest> ice_locatorCacheTimeout(int __timeout) const
00737     {
00738     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00739         typedef ::IceProxy::Ice::Object _Base;
00740         return dynamic_cast<MotorRequest*>(_Base::ice_locatorCacheTimeout(__timeout).get());
00741     #else
00742         return dynamic_cast<MotorRequest*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
00743     #endif
00744     }
00745 
00746     ::IceInternal::ProxyHandle<MotorRequest> ice_connectionCached(bool __cached) const
00747     {
00748     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00749         typedef ::IceProxy::Ice::Object _Base;
00750         return dynamic_cast<MotorRequest*>(_Base::ice_connectionCached(__cached).get());
00751     #else
00752         return dynamic_cast<MotorRequest*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
00753     #endif
00754     }
00755 
00756     ::IceInternal::ProxyHandle<MotorRequest> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
00757     {
00758     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00759         typedef ::IceProxy::Ice::Object _Base;
00760         return dynamic_cast<MotorRequest*>(_Base::ice_endpointSelection(__est).get());
00761     #else
00762         return dynamic_cast<MotorRequest*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
00763     #endif
00764     }
00765 
00766     ::IceInternal::ProxyHandle<MotorRequest> ice_secure(bool __secure) const
00767     {
00768     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00769         typedef ::IceProxy::Ice::Object _Base;
00770         return dynamic_cast<MotorRequest*>(_Base::ice_secure(__secure).get());
00771     #else
00772         return dynamic_cast<MotorRequest*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
00773     #endif
00774     }
00775 
00776     ::IceInternal::ProxyHandle<MotorRequest> ice_preferSecure(bool __preferSecure) const
00777     {
00778     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00779         typedef ::IceProxy::Ice::Object _Base;
00780         return dynamic_cast<MotorRequest*>(_Base::ice_preferSecure(__preferSecure).get());
00781     #else
00782         return dynamic_cast<MotorRequest*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
00783     #endif
00784     }
00785 
00786     ::IceInternal::ProxyHandle<MotorRequest> ice_router(const ::Ice::RouterPrx& __router) const
00787     {
00788     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00789         typedef ::IceProxy::Ice::Object _Base;
00790         return dynamic_cast<MotorRequest*>(_Base::ice_router(__router).get());
00791     #else
00792         return dynamic_cast<MotorRequest*>(::IceProxy::Ice::Object::ice_router(__router).get());
00793     #endif
00794     }
00795 
00796     ::IceInternal::ProxyHandle<MotorRequest> ice_locator(const ::Ice::LocatorPrx& __locator) const
00797     {
00798     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00799         typedef ::IceProxy::Ice::Object _Base;
00800         return dynamic_cast<MotorRequest*>(_Base::ice_locator(__locator).get());
00801     #else
00802         return dynamic_cast<MotorRequest*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
00803     #endif
00804     }
00805 
00806     ::IceInternal::ProxyHandle<MotorRequest> ice_collocationOptimized(bool __co) const
00807     {
00808     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00809         typedef ::IceProxy::Ice::Object _Base;
00810         return dynamic_cast<MotorRequest*>(_Base::ice_collocationOptimized(__co).get());
00811     #else
00812         return dynamic_cast<MotorRequest*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
00813     #endif
00814     }
00815 
00816     ::IceInternal::ProxyHandle<MotorRequest> ice_twoway() const
00817     {
00818     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00819         typedef ::IceProxy::Ice::Object _Base;
00820         return dynamic_cast<MotorRequest*>(_Base::ice_twoway().get());
00821     #else
00822         return dynamic_cast<MotorRequest*>(::IceProxy::Ice::Object::ice_twoway().get());
00823     #endif
00824     }
00825 
00826     ::IceInternal::ProxyHandle<MotorRequest> ice_oneway() const
00827     {
00828     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00829         typedef ::IceProxy::Ice::Object _Base;
00830         return dynamic_cast<MotorRequest*>(_Base::ice_oneway().get());
00831     #else
00832         return dynamic_cast<MotorRequest*>(::IceProxy::Ice::Object::ice_oneway().get());
00833     #endif
00834     }
00835 
00836     ::IceInternal::ProxyHandle<MotorRequest> ice_batchOneway() const
00837     {
00838     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00839         typedef ::IceProxy::Ice::Object _Base;
00840         return dynamic_cast<MotorRequest*>(_Base::ice_batchOneway().get());
00841     #else
00842         return dynamic_cast<MotorRequest*>(::IceProxy::Ice::Object::ice_batchOneway().get());
00843     #endif
00844     }
00845 
00846     ::IceInternal::ProxyHandle<MotorRequest> ice_datagram() const
00847     {
00848     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00849         typedef ::IceProxy::Ice::Object _Base;
00850         return dynamic_cast<MotorRequest*>(_Base::ice_datagram().get());
00851     #else
00852         return dynamic_cast<MotorRequest*>(::IceProxy::Ice::Object::ice_datagram().get());
00853     #endif
00854     }
00855 
00856     ::IceInternal::ProxyHandle<MotorRequest> ice_batchDatagram() const
00857     {
00858     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00859         typedef ::IceProxy::Ice::Object _Base;
00860         return dynamic_cast<MotorRequest*>(_Base::ice_batchDatagram().get());
00861     #else
00862         return dynamic_cast<MotorRequest*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
00863     #endif
00864     }
00865 
00866     ::IceInternal::ProxyHandle<MotorRequest> ice_compress(bool __compress) const
00867     {
00868     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00869         typedef ::IceProxy::Ice::Object _Base;
00870         return dynamic_cast<MotorRequest*>(_Base::ice_compress(__compress).get());
00871     #else
00872         return dynamic_cast<MotorRequest*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
00873     #endif
00874     }
00875 
00876     ::IceInternal::ProxyHandle<MotorRequest> ice_timeout(int __timeout) const
00877     {
00878     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00879         typedef ::IceProxy::Ice::Object _Base;
00880         return dynamic_cast<MotorRequest*>(_Base::ice_timeout(__timeout).get());
00881     #else
00882         return dynamic_cast<MotorRequest*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
00883     #endif
00884     }
00885 
00886     ::IceInternal::ProxyHandle<MotorRequest> ice_connectionId(const std::string& __id) const
00887     {
00888     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00889         typedef ::IceProxy::Ice::Object _Base;
00890         return dynamic_cast<MotorRequest*>(_Base::ice_connectionId(__id).get());
00891     #else
00892         return dynamic_cast<MotorRequest*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
00893     #endif
00894     }
00895 
00896     static const ::std::string& ice_staticId();
00897 
00898 private:
00899 
00900     virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
00901     virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
00902     virtual ::IceProxy::Ice::Object* __newInstance() const;
00903 };
00904 
00905 class CornerMotorRequest : virtual public ::IceProxy::RobotSimEvents::EventMessage
00906 {
00907 public:
00908 
00909     ::IceInternal::ProxyHandle<CornerMotorRequest> ice_context(const ::Ice::Context& __context) const
00910     {
00911     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00912         typedef ::IceProxy::Ice::Object _Base;
00913         return dynamic_cast<CornerMotorRequest*>(_Base::ice_context(__context).get());
00914     #else
00915         return dynamic_cast<CornerMotorRequest*>(::IceProxy::Ice::Object::ice_context(__context).get());
00916     #endif
00917     }
00918 
00919     ::IceInternal::ProxyHandle<CornerMotorRequest> ice_adapterId(const std::string& __id) const
00920     {
00921     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00922         typedef ::IceProxy::Ice::Object _Base;
00923         return dynamic_cast<CornerMotorRequest*>(_Base::ice_adapterId(__id).get());
00924     #else
00925         return dynamic_cast<CornerMotorRequest*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
00926     #endif
00927     }
00928 
00929     ::IceInternal::ProxyHandle<CornerMotorRequest> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
00930     {
00931     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00932         typedef ::IceProxy::Ice::Object _Base;
00933         return dynamic_cast<CornerMotorRequest*>(_Base::ice_endpoints(__endpoints).get());
00934     #else
00935         return dynamic_cast<CornerMotorRequest*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
00936     #endif
00937     }
00938 
00939     ::IceInternal::ProxyHandle<CornerMotorRequest> ice_locatorCacheTimeout(int __timeout) const
00940     {
00941     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00942         typedef ::IceProxy::Ice::Object _Base;
00943         return dynamic_cast<CornerMotorRequest*>(_Base::ice_locatorCacheTimeout(__timeout).get());
00944     #else
00945         return dynamic_cast<CornerMotorRequest*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
00946     #endif
00947     }
00948 
00949     ::IceInternal::ProxyHandle<CornerMotorRequest> ice_connectionCached(bool __cached) const
00950     {
00951     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00952         typedef ::IceProxy::Ice::Object _Base;
00953         return dynamic_cast<CornerMotorRequest*>(_Base::ice_connectionCached(__cached).get());
00954     #else
00955         return dynamic_cast<CornerMotorRequest*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
00956     #endif
00957     }
00958 
00959     ::IceInternal::ProxyHandle<CornerMotorRequest> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
00960     {
00961     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00962         typedef ::IceProxy::Ice::Object _Base;
00963         return dynamic_cast<CornerMotorRequest*>(_Base::ice_endpointSelection(__est).get());
00964     #else
00965         return dynamic_cast<CornerMotorRequest*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
00966     #endif
00967     }
00968 
00969     ::IceInternal::ProxyHandle<CornerMotorRequest> ice_secure(bool __secure) const
00970     {
00971     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00972         typedef ::IceProxy::Ice::Object _Base;
00973         return dynamic_cast<CornerMotorRequest*>(_Base::ice_secure(__secure).get());
00974     #else
00975         return dynamic_cast<CornerMotorRequest*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
00976     #endif
00977     }
00978 
00979     ::IceInternal::ProxyHandle<CornerMotorRequest> ice_preferSecure(bool __preferSecure) const
00980     {
00981     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00982         typedef ::IceProxy::Ice::Object _Base;
00983         return dynamic_cast<CornerMotorRequest*>(_Base::ice_preferSecure(__preferSecure).get());
00984     #else
00985         return dynamic_cast<CornerMotorRequest*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
00986     #endif
00987     }
00988 
00989     ::IceInternal::ProxyHandle<CornerMotorRequest> ice_router(const ::Ice::RouterPrx& __router) const
00990     {
00991     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00992         typedef ::IceProxy::Ice::Object _Base;
00993         return dynamic_cast<CornerMotorRequest*>(_Base::ice_router(__router).get());
00994     #else
00995         return dynamic_cast<CornerMotorRequest*>(::IceProxy::Ice::Object::ice_router(__router).get());
00996     #endif
00997     }
00998 
00999     ::IceInternal::ProxyHandle<CornerMotorRequest> ice_locator(const ::Ice::LocatorPrx& __locator) const
01000     {
01001     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01002         typedef ::IceProxy::Ice::Object _Base;
01003         return dynamic_cast<CornerMotorRequest*>(_Base::ice_locator(__locator).get());
01004     #else
01005         return dynamic_cast<CornerMotorRequest*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
01006     #endif
01007     }
01008 
01009     ::IceInternal::ProxyHandle<CornerMotorRequest> ice_collocationOptimized(bool __co) const
01010     {
01011     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01012         typedef ::IceProxy::Ice::Object _Base;
01013         return dynamic_cast<CornerMotorRequest*>(_Base::ice_collocationOptimized(__co).get());
01014     #else
01015         return dynamic_cast<CornerMotorRequest*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
01016     #endif
01017     }
01018 
01019     ::IceInternal::ProxyHandle<CornerMotorRequest> ice_twoway() const
01020     {
01021     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01022         typedef ::IceProxy::Ice::Object _Base;
01023         return dynamic_cast<CornerMotorRequest*>(_Base::ice_twoway().get());
01024     #else
01025         return dynamic_cast<CornerMotorRequest*>(::IceProxy::Ice::Object::ice_twoway().get());
01026     #endif
01027     }
01028 
01029     ::IceInternal::ProxyHandle<CornerMotorRequest> ice_oneway() const
01030     {
01031     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01032         typedef ::IceProxy::Ice::Object _Base;
01033         return dynamic_cast<CornerMotorRequest*>(_Base::ice_oneway().get());
01034     #else
01035         return dynamic_cast<CornerMotorRequest*>(::IceProxy::Ice::Object::ice_oneway().get());
01036     #endif
01037     }
01038 
01039     ::IceInternal::ProxyHandle<CornerMotorRequest> ice_batchOneway() const
01040     {
01041     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01042         typedef ::IceProxy::Ice::Object _Base;
01043         return dynamic_cast<CornerMotorRequest*>(_Base::ice_batchOneway().get());
01044     #else
01045         return dynamic_cast<CornerMotorRequest*>(::IceProxy::Ice::Object::ice_batchOneway().get());
01046     #endif
01047     }
01048 
01049     ::IceInternal::ProxyHandle<CornerMotorRequest> ice_datagram() const
01050     {
01051     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01052         typedef ::IceProxy::Ice::Object _Base;
01053         return dynamic_cast<CornerMotorRequest*>(_Base::ice_datagram().get());
01054     #else
01055         return dynamic_cast<CornerMotorRequest*>(::IceProxy::Ice::Object::ice_datagram().get());
01056     #endif
01057     }
01058 
01059     ::IceInternal::ProxyHandle<CornerMotorRequest> ice_batchDatagram() const
01060     {
01061     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01062         typedef ::IceProxy::Ice::Object _Base;
01063         return dynamic_cast<CornerMotorRequest*>(_Base::ice_batchDatagram().get());
01064     #else
01065         return dynamic_cast<CornerMotorRequest*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
01066     #endif
01067     }
01068 
01069     ::IceInternal::ProxyHandle<CornerMotorRequest> ice_compress(bool __compress) const
01070     {
01071     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01072         typedef ::IceProxy::Ice::Object _Base;
01073         return dynamic_cast<CornerMotorRequest*>(_Base::ice_compress(__compress).get());
01074     #else
01075         return dynamic_cast<CornerMotorRequest*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
01076     #endif
01077     }
01078 
01079     ::IceInternal::ProxyHandle<CornerMotorRequest> ice_timeout(int __timeout) const
01080     {
01081     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01082         typedef ::IceProxy::Ice::Object _Base;
01083         return dynamic_cast<CornerMotorRequest*>(_Base::ice_timeout(__timeout).get());
01084     #else
01085         return dynamic_cast<CornerMotorRequest*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
01086     #endif
01087     }
01088 
01089     ::IceInternal::ProxyHandle<CornerMotorRequest> ice_connectionId(const std::string& __id) const
01090     {
01091     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01092         typedef ::IceProxy::Ice::Object _Base;
01093         return dynamic_cast<CornerMotorRequest*>(_Base::ice_connectionId(__id).get());
01094     #else
01095         return dynamic_cast<CornerMotorRequest*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
01096     #endif
01097     }
01098 
01099     static const ::std::string& ice_staticId();
01100 
01101 private:
01102 
01103     virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
01104     virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
01105     virtual ::IceProxy::Ice::Object* __newInstance() const;
01106 };
01107 
01108 class CornerLocationMessage : virtual public ::IceProxy::RobotSimEvents::EventMessage
01109 {
01110 public:
01111 
01112     ::IceInternal::ProxyHandle<CornerLocationMessage> ice_context(const ::Ice::Context& __context) const
01113     {
01114     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01115         typedef ::IceProxy::Ice::Object _Base;
01116         return dynamic_cast<CornerLocationMessage*>(_Base::ice_context(__context).get());
01117     #else
01118         return dynamic_cast<CornerLocationMessage*>(::IceProxy::Ice::Object::ice_context(__context).get());
01119     #endif
01120     }
01121 
01122     ::IceInternal::ProxyHandle<CornerLocationMessage> ice_adapterId(const std::string& __id) const
01123     {
01124     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01125         typedef ::IceProxy::Ice::Object _Base;
01126         return dynamic_cast<CornerLocationMessage*>(_Base::ice_adapterId(__id).get());
01127     #else
01128         return dynamic_cast<CornerLocationMessage*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
01129     #endif
01130     }
01131 
01132     ::IceInternal::ProxyHandle<CornerLocationMessage> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
01133     {
01134     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01135         typedef ::IceProxy::Ice::Object _Base;
01136         return dynamic_cast<CornerLocationMessage*>(_Base::ice_endpoints(__endpoints).get());
01137     #else
01138         return dynamic_cast<CornerLocationMessage*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
01139     #endif
01140     }
01141 
01142     ::IceInternal::ProxyHandle<CornerLocationMessage> ice_locatorCacheTimeout(int __timeout) const
01143     {
01144     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01145         typedef ::IceProxy::Ice::Object _Base;
01146         return dynamic_cast<CornerLocationMessage*>(_Base::ice_locatorCacheTimeout(__timeout).get());
01147     #else
01148         return dynamic_cast<CornerLocationMessage*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
01149     #endif
01150     }
01151 
01152     ::IceInternal::ProxyHandle<CornerLocationMessage> ice_connectionCached(bool __cached) const
01153     {
01154     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01155         typedef ::IceProxy::Ice::Object _Base;
01156         return dynamic_cast<CornerLocationMessage*>(_Base::ice_connectionCached(__cached).get());
01157     #else
01158         return dynamic_cast<CornerLocationMessage*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
01159     #endif
01160     }
01161 
01162     ::IceInternal::ProxyHandle<CornerLocationMessage> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
01163     {
01164     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01165         typedef ::IceProxy::Ice::Object _Base;
01166         return dynamic_cast<CornerLocationMessage*>(_Base::ice_endpointSelection(__est).get());
01167     #else
01168         return dynamic_cast<CornerLocationMessage*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
01169     #endif
01170     }
01171 
01172     ::IceInternal::ProxyHandle<CornerLocationMessage> ice_secure(bool __secure) const
01173     {
01174     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01175         typedef ::IceProxy::Ice::Object _Base;
01176         return dynamic_cast<CornerLocationMessage*>(_Base::ice_secure(__secure).get());
01177     #else
01178         return dynamic_cast<CornerLocationMessage*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
01179     #endif
01180     }
01181 
01182     ::IceInternal::ProxyHandle<CornerLocationMessage> ice_preferSecure(bool __preferSecure) const
01183     {
01184     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01185         typedef ::IceProxy::Ice::Object _Base;
01186         return dynamic_cast<CornerLocationMessage*>(_Base::ice_preferSecure(__preferSecure).get());
01187     #else
01188         return dynamic_cast<CornerLocationMessage*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
01189     #endif
01190     }
01191 
01192     ::IceInternal::ProxyHandle<CornerLocationMessage> ice_router(const ::Ice::RouterPrx& __router) const
01193     {
01194     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01195         typedef ::IceProxy::Ice::Object _Base;
01196         return dynamic_cast<CornerLocationMessage*>(_Base::ice_router(__router).get());
01197     #else
01198         return dynamic_cast<CornerLocationMessage*>(::IceProxy::Ice::Object::ice_router(__router).get());
01199     #endif
01200     }
01201 
01202     ::IceInternal::ProxyHandle<CornerLocationMessage> ice_locator(const ::Ice::LocatorPrx& __locator) const
01203     {
01204     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01205         typedef ::IceProxy::Ice::Object _Base;
01206         return dynamic_cast<CornerLocationMessage*>(_Base::ice_locator(__locator).get());
01207     #else
01208         return dynamic_cast<CornerLocationMessage*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
01209     #endif
01210     }
01211 
01212     ::IceInternal::ProxyHandle<CornerLocationMessage> ice_collocationOptimized(bool __co) const
01213     {
01214     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01215         typedef ::IceProxy::Ice::Object _Base;
01216         return dynamic_cast<CornerLocationMessage*>(_Base::ice_collocationOptimized(__co).get());
01217     #else
01218         return dynamic_cast<CornerLocationMessage*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
01219     #endif
01220     }
01221 
01222     ::IceInternal::ProxyHandle<CornerLocationMessage> ice_twoway() const
01223     {
01224     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01225         typedef ::IceProxy::Ice::Object _Base;
01226         return dynamic_cast<CornerLocationMessage*>(_Base::ice_twoway().get());
01227     #else
01228         return dynamic_cast<CornerLocationMessage*>(::IceProxy::Ice::Object::ice_twoway().get());
01229     #endif
01230     }
01231 
01232     ::IceInternal::ProxyHandle<CornerLocationMessage> ice_oneway() const
01233     {
01234     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01235         typedef ::IceProxy::Ice::Object _Base;
01236         return dynamic_cast<CornerLocationMessage*>(_Base::ice_oneway().get());
01237     #else
01238         return dynamic_cast<CornerLocationMessage*>(::IceProxy::Ice::Object::ice_oneway().get());
01239     #endif
01240     }
01241 
01242     ::IceInternal::ProxyHandle<CornerLocationMessage> ice_batchOneway() const
01243     {
01244     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01245         typedef ::IceProxy::Ice::Object _Base;
01246         return dynamic_cast<CornerLocationMessage*>(_Base::ice_batchOneway().get());
01247     #else
01248         return dynamic_cast<CornerLocationMessage*>(::IceProxy::Ice::Object::ice_batchOneway().get());
01249     #endif
01250     }
01251 
01252     ::IceInternal::ProxyHandle<CornerLocationMessage> ice_datagram() const
01253     {
01254     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01255         typedef ::IceProxy::Ice::Object _Base;
01256         return dynamic_cast<CornerLocationMessage*>(_Base::ice_datagram().get());
01257     #else
01258         return dynamic_cast<CornerLocationMessage*>(::IceProxy::Ice::Object::ice_datagram().get());
01259     #endif
01260     }
01261 
01262     ::IceInternal::ProxyHandle<CornerLocationMessage> ice_batchDatagram() const
01263     {
01264     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01265         typedef ::IceProxy::Ice::Object _Base;
01266         return dynamic_cast<CornerLocationMessage*>(_Base::ice_batchDatagram().get());
01267     #else
01268         return dynamic_cast<CornerLocationMessage*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
01269     #endif
01270     }
01271 
01272     ::IceInternal::ProxyHandle<CornerLocationMessage> ice_compress(bool __compress) const
01273     {
01274     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01275         typedef ::IceProxy::Ice::Object _Base;
01276         return dynamic_cast<CornerLocationMessage*>(_Base::ice_compress(__compress).get());
01277     #else
01278         return dynamic_cast<CornerLocationMessage*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
01279     #endif
01280     }
01281 
01282     ::IceInternal::ProxyHandle<CornerLocationMessage> ice_timeout(int __timeout) const
01283     {
01284     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01285         typedef ::IceProxy::Ice::Object _Base;
01286         return dynamic_cast<CornerLocationMessage*>(_Base::ice_timeout(__timeout).get());
01287     #else
01288         return dynamic_cast<CornerLocationMessage*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
01289     #endif
01290     }
01291 
01292     ::IceInternal::ProxyHandle<CornerLocationMessage> ice_connectionId(const std::string& __id) const
01293     {
01294     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01295         typedef ::IceProxy::Ice::Object _Base;
01296         return dynamic_cast<CornerLocationMessage*>(_Base::ice_connectionId(__id).get());
01297     #else
01298         return dynamic_cast<CornerLocationMessage*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
01299     #endif
01300     }
01301 
01302     static const ::std::string& ice_staticId();
01303 
01304 private:
01305 
01306     virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
01307     virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
01308     virtual ::IceProxy::Ice::Object* __newInstance() const;
01309 };
01310 
01311 class SonarMessage : virtual public ::IceProxy::RobotSimEvents::EventMessage
01312 {
01313 public:
01314 
01315     ::IceInternal::ProxyHandle<SonarMessage> ice_context(const ::Ice::Context& __context) const
01316     {
01317     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01318         typedef ::IceProxy::Ice::Object _Base;
01319         return dynamic_cast<SonarMessage*>(_Base::ice_context(__context).get());
01320     #else
01321         return dynamic_cast<SonarMessage*>(::IceProxy::Ice::Object::ice_context(__context).get());
01322     #endif
01323     }
01324 
01325     ::IceInternal::ProxyHandle<SonarMessage> ice_adapterId(const std::string& __id) const
01326     {
01327     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01328         typedef ::IceProxy::Ice::Object _Base;
01329         return dynamic_cast<SonarMessage*>(_Base::ice_adapterId(__id).get());
01330     #else
01331         return dynamic_cast<SonarMessage*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
01332     #endif
01333     }
01334 
01335     ::IceInternal::ProxyHandle<SonarMessage> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
01336     {
01337     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01338         typedef ::IceProxy::Ice::Object _Base;
01339         return dynamic_cast<SonarMessage*>(_Base::ice_endpoints(__endpoints).get());
01340     #else
01341         return dynamic_cast<SonarMessage*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
01342     #endif
01343     }
01344 
01345     ::IceInternal::ProxyHandle<SonarMessage> ice_locatorCacheTimeout(int __timeout) const
01346     {
01347     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01348         typedef ::IceProxy::Ice::Object _Base;
01349         return dynamic_cast<SonarMessage*>(_Base::ice_locatorCacheTimeout(__timeout).get());
01350     #else
01351         return dynamic_cast<SonarMessage*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
01352     #endif
01353     }
01354 
01355     ::IceInternal::ProxyHandle<SonarMessage> ice_connectionCached(bool __cached) const
01356     {
01357     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01358         typedef ::IceProxy::Ice::Object _Base;
01359         return dynamic_cast<SonarMessage*>(_Base::ice_connectionCached(__cached).get());
01360     #else
01361         return dynamic_cast<SonarMessage*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
01362     #endif
01363     }
01364 
01365     ::IceInternal::ProxyHandle<SonarMessage> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
01366     {
01367     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01368         typedef ::IceProxy::Ice::Object _Base;
01369         return dynamic_cast<SonarMessage*>(_Base::ice_endpointSelection(__est).get());
01370     #else
01371         return dynamic_cast<SonarMessage*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
01372     #endif
01373     }
01374 
01375     ::IceInternal::ProxyHandle<SonarMessage> ice_secure(bool __secure) const
01376     {
01377     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01378         typedef ::IceProxy::Ice::Object _Base;
01379         return dynamic_cast<SonarMessage*>(_Base::ice_secure(__secure).get());
01380     #else
01381         return dynamic_cast<SonarMessage*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
01382     #endif
01383     }
01384 
01385     ::IceInternal::ProxyHandle<SonarMessage> ice_preferSecure(bool __preferSecure) const
01386     {
01387     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01388         typedef ::IceProxy::Ice::Object _Base;
01389         return dynamic_cast<SonarMessage*>(_Base::ice_preferSecure(__preferSecure).get());
01390     #else
01391         return dynamic_cast<SonarMessage*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
01392     #endif
01393     }
01394 
01395     ::IceInternal::ProxyHandle<SonarMessage> ice_router(const ::Ice::RouterPrx& __router) const
01396     {
01397     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01398         typedef ::IceProxy::Ice::Object _Base;
01399         return dynamic_cast<SonarMessage*>(_Base::ice_router(__router).get());
01400     #else
01401         return dynamic_cast<SonarMessage*>(::IceProxy::Ice::Object::ice_router(__router).get());
01402     #endif
01403     }
01404 
01405     ::IceInternal::ProxyHandle<SonarMessage> ice_locator(const ::Ice::LocatorPrx& __locator) const
01406     {
01407     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01408         typedef ::IceProxy::Ice::Object _Base;
01409         return dynamic_cast<SonarMessage*>(_Base::ice_locator(__locator).get());
01410     #else
01411         return dynamic_cast<SonarMessage*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
01412     #endif
01413     }
01414 
01415     ::IceInternal::ProxyHandle<SonarMessage> ice_collocationOptimized(bool __co) const
01416     {
01417     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01418         typedef ::IceProxy::Ice::Object _Base;
01419         return dynamic_cast<SonarMessage*>(_Base::ice_collocationOptimized(__co).get());
01420     #else
01421         return dynamic_cast<SonarMessage*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
01422     #endif
01423     }
01424 
01425     ::IceInternal::ProxyHandle<SonarMessage> ice_twoway() const
01426     {
01427     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01428         typedef ::IceProxy::Ice::Object _Base;
01429         return dynamic_cast<SonarMessage*>(_Base::ice_twoway().get());
01430     #else
01431         return dynamic_cast<SonarMessage*>(::IceProxy::Ice::Object::ice_twoway().get());
01432     #endif
01433     }
01434 
01435     ::IceInternal::ProxyHandle<SonarMessage> ice_oneway() const
01436     {
01437     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01438         typedef ::IceProxy::Ice::Object _Base;
01439         return dynamic_cast<SonarMessage*>(_Base::ice_oneway().get());
01440     #else
01441         return dynamic_cast<SonarMessage*>(::IceProxy::Ice::Object::ice_oneway().get());
01442     #endif
01443     }
01444 
01445     ::IceInternal::ProxyHandle<SonarMessage> ice_batchOneway() const
01446     {
01447     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01448         typedef ::IceProxy::Ice::Object _Base;
01449         return dynamic_cast<SonarMessage*>(_Base::ice_batchOneway().get());
01450     #else
01451         return dynamic_cast<SonarMessage*>(::IceProxy::Ice::Object::ice_batchOneway().get());
01452     #endif
01453     }
01454 
01455     ::IceInternal::ProxyHandle<SonarMessage> ice_datagram() const
01456     {
01457     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01458         typedef ::IceProxy::Ice::Object _Base;
01459         return dynamic_cast<SonarMessage*>(_Base::ice_datagram().get());
01460     #else
01461         return dynamic_cast<SonarMessage*>(::IceProxy::Ice::Object::ice_datagram().get());
01462     #endif
01463     }
01464 
01465     ::IceInternal::ProxyHandle<SonarMessage> ice_batchDatagram() const
01466     {
01467     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01468         typedef ::IceProxy::Ice::Object _Base;
01469         return dynamic_cast<SonarMessage*>(_Base::ice_batchDatagram().get());
01470     #else
01471         return dynamic_cast<SonarMessage*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
01472     #endif
01473     }
01474 
01475     ::IceInternal::ProxyHandle<SonarMessage> ice_compress(bool __compress) const
01476     {
01477     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01478         typedef ::IceProxy::Ice::Object _Base;
01479         return dynamic_cast<SonarMessage*>(_Base::ice_compress(__compress).get());
01480     #else
01481         return dynamic_cast<SonarMessage*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
01482     #endif
01483     }
01484 
01485     ::IceInternal::ProxyHandle<SonarMessage> ice_timeout(int __timeout) const
01486     {
01487     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01488         typedef ::IceProxy::Ice::Object _Base;
01489         return dynamic_cast<SonarMessage*>(_Base::ice_timeout(__timeout).get());
01490     #else
01491         return dynamic_cast<SonarMessage*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
01492     #endif
01493     }
01494 
01495     ::IceInternal::ProxyHandle<SonarMessage> ice_connectionId(const std::string& __id) const
01496     {
01497     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01498         typedef ::IceProxy::Ice::Object _Base;
01499         return dynamic_cast<SonarMessage*>(_Base::ice_connectionId(__id).get());
01500     #else
01501         return dynamic_cast<SonarMessage*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
01502     #endif
01503     }
01504 
01505     static const ::std::string& ice_staticId();
01506 
01507 private:
01508 
01509     virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
01510     virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
01511     virtual ::IceProxy::Ice::Object* __newInstance() const;
01512 };
01513 
01514 class GPSMessage : virtual public ::IceProxy::RobotSimEvents::EventMessage
01515 {
01516 public:
01517 
01518     ::IceInternal::ProxyHandle<GPSMessage> ice_context(const ::Ice::Context& __context) const
01519     {
01520     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01521         typedef ::IceProxy::Ice::Object _Base;
01522         return dynamic_cast<GPSMessage*>(_Base::ice_context(__context).get());
01523     #else
01524         return dynamic_cast<GPSMessage*>(::IceProxy::Ice::Object::ice_context(__context).get());
01525     #endif
01526     }
01527 
01528     ::IceInternal::ProxyHandle<GPSMessage> ice_adapterId(const std::string& __id) const
01529     {
01530     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01531         typedef ::IceProxy::Ice::Object _Base;
01532         return dynamic_cast<GPSMessage*>(_Base::ice_adapterId(__id).get());
01533     #else
01534         return dynamic_cast<GPSMessage*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
01535     #endif
01536     }
01537 
01538     ::IceInternal::ProxyHandle<GPSMessage> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
01539     {
01540     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01541         typedef ::IceProxy::Ice::Object _Base;
01542         return dynamic_cast<GPSMessage*>(_Base::ice_endpoints(__endpoints).get());
01543     #else
01544         return dynamic_cast<GPSMessage*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
01545     #endif
01546     }
01547 
01548     ::IceInternal::ProxyHandle<GPSMessage> ice_locatorCacheTimeout(int __timeout) const
01549     {
01550     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01551         typedef ::IceProxy::Ice::Object _Base;
01552         return dynamic_cast<GPSMessage*>(_Base::ice_locatorCacheTimeout(__timeout).get());
01553     #else
01554         return dynamic_cast<GPSMessage*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
01555     #endif
01556     }
01557 
01558     ::IceInternal::ProxyHandle<GPSMessage> ice_connectionCached(bool __cached) const
01559     {
01560     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01561         typedef ::IceProxy::Ice::Object _Base;
01562         return dynamic_cast<GPSMessage*>(_Base::ice_connectionCached(__cached).get());
01563     #else
01564         return dynamic_cast<GPSMessage*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
01565     #endif
01566     }
01567 
01568     ::IceInternal::ProxyHandle<GPSMessage> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
01569     {
01570     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01571         typedef ::IceProxy::Ice::Object _Base;
01572         return dynamic_cast<GPSMessage*>(_Base::ice_endpointSelection(__est).get());
01573     #else
01574         return dynamic_cast<GPSMessage*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
01575     #endif
01576     }
01577 
01578     ::IceInternal::ProxyHandle<GPSMessage> ice_secure(bool __secure) const
01579     {
01580     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01581         typedef ::IceProxy::Ice::Object _Base;
01582         return dynamic_cast<GPSMessage*>(_Base::ice_secure(__secure).get());
01583     #else
01584         return dynamic_cast<GPSMessage*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
01585     #endif
01586     }
01587 
01588     ::IceInternal::ProxyHandle<GPSMessage> ice_preferSecure(bool __preferSecure) const
01589     {
01590     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01591         typedef ::IceProxy::Ice::Object _Base;
01592         return dynamic_cast<GPSMessage*>(_Base::ice_preferSecure(__preferSecure).get());
01593     #else
01594         return dynamic_cast<GPSMessage*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
01595     #endif
01596     }
01597 
01598     ::IceInternal::ProxyHandle<GPSMessage> ice_router(const ::Ice::RouterPrx& __router) const
01599     {
01600     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01601         typedef ::IceProxy::Ice::Object _Base;
01602         return dynamic_cast<GPSMessage*>(_Base::ice_router(__router).get());
01603     #else
01604         return dynamic_cast<GPSMessage*>(::IceProxy::Ice::Object::ice_router(__router).get());
01605     #endif
01606     }
01607 
01608     ::IceInternal::ProxyHandle<GPSMessage> ice_locator(const ::Ice::LocatorPrx& __locator) const
01609     {
01610     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01611         typedef ::IceProxy::Ice::Object _Base;
01612         return dynamic_cast<GPSMessage*>(_Base::ice_locator(__locator).get());
01613     #else
01614         return dynamic_cast<GPSMessage*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
01615     #endif
01616     }
01617 
01618     ::IceInternal::ProxyHandle<GPSMessage> ice_collocationOptimized(bool __co) const
01619     {
01620     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01621         typedef ::IceProxy::Ice::Object _Base;
01622         return dynamic_cast<GPSMessage*>(_Base::ice_collocationOptimized(__co).get());
01623     #else
01624         return dynamic_cast<GPSMessage*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
01625     #endif
01626     }
01627 
01628     ::IceInternal::ProxyHandle<GPSMessage> ice_twoway() const
01629     {
01630     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01631         typedef ::IceProxy::Ice::Object _Base;
01632         return dynamic_cast<GPSMessage*>(_Base::ice_twoway().get());
01633     #else
01634         return dynamic_cast<GPSMessage*>(::IceProxy::Ice::Object::ice_twoway().get());
01635     #endif
01636     }
01637 
01638     ::IceInternal::ProxyHandle<GPSMessage> ice_oneway() const
01639     {
01640     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01641         typedef ::IceProxy::Ice::Object _Base;
01642         return dynamic_cast<GPSMessage*>(_Base::ice_oneway().get());
01643     #else
01644         return dynamic_cast<GPSMessage*>(::IceProxy::Ice::Object::ice_oneway().get());
01645     #endif
01646     }
01647 
01648     ::IceInternal::ProxyHandle<GPSMessage> ice_batchOneway() const
01649     {
01650     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01651         typedef ::IceProxy::Ice::Object _Base;
01652         return dynamic_cast<GPSMessage*>(_Base::ice_batchOneway().get());
01653     #else
01654         return dynamic_cast<GPSMessage*>(::IceProxy::Ice::Object::ice_batchOneway().get());
01655     #endif
01656     }
01657 
01658     ::IceInternal::ProxyHandle<GPSMessage> ice_datagram() const
01659     {
01660     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01661         typedef ::IceProxy::Ice::Object _Base;
01662         return dynamic_cast<GPSMessage*>(_Base::ice_datagram().get());
01663     #else
01664         return dynamic_cast<GPSMessage*>(::IceProxy::Ice::Object::ice_datagram().get());
01665     #endif
01666     }
01667 
01668     ::IceInternal::ProxyHandle<GPSMessage> ice_batchDatagram() const
01669     {
01670     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01671         typedef ::IceProxy::Ice::Object _Base;
01672         return dynamic_cast<GPSMessage*>(_Base::ice_batchDatagram().get());
01673     #else
01674         return dynamic_cast<GPSMessage*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
01675     #endif
01676     }
01677 
01678     ::IceInternal::ProxyHandle<GPSMessage> ice_compress(bool __compress) const
01679     {
01680     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01681         typedef ::IceProxy::Ice::Object _Base;
01682         return dynamic_cast<GPSMessage*>(_Base::ice_compress(__compress).get());
01683     #else
01684         return dynamic_cast<GPSMessage*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
01685     #endif
01686     }
01687 
01688     ::IceInternal::ProxyHandle<GPSMessage> ice_timeout(int __timeout) const
01689     {
01690     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01691         typedef ::IceProxy::Ice::Object _Base;
01692         return dynamic_cast<GPSMessage*>(_Base::ice_timeout(__timeout).get());
01693     #else
01694         return dynamic_cast<GPSMessage*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
01695     #endif
01696     }
01697 
01698     ::IceInternal::ProxyHandle<GPSMessage> ice_connectionId(const std::string& __id) const
01699     {
01700     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01701         typedef ::IceProxy::Ice::Object _Base;
01702         return dynamic_cast<GPSMessage*>(_Base::ice_connectionId(__id).get());
01703     #else
01704         return dynamic_cast<GPSMessage*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
01705     #endif
01706     }
01707 
01708     static const ::std::string& ice_staticId();
01709 
01710 private:
01711 
01712     virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
01713     virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
01714     virtual ::IceProxy::Ice::Object* __newInstance() const;
01715 };
01716 
01717 class LRFMessage : virtual public ::IceProxy::RobotSimEvents::EventMessage
01718 {
01719 public:
01720 
01721     ::IceInternal::ProxyHandle<LRFMessage> ice_context(const ::Ice::Context& __context) const
01722     {
01723     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01724         typedef ::IceProxy::Ice::Object _Base;
01725         return dynamic_cast<LRFMessage*>(_Base::ice_context(__context).get());
01726     #else
01727         return dynamic_cast<LRFMessage*>(::IceProxy::Ice::Object::ice_context(__context).get());
01728     #endif
01729     }
01730 
01731     ::IceInternal::ProxyHandle<LRFMessage> ice_adapterId(const std::string& __id) const
01732     {
01733     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01734         typedef ::IceProxy::Ice::Object _Base;
01735         return dynamic_cast<LRFMessage*>(_Base::ice_adapterId(__id).get());
01736     #else
01737         return dynamic_cast<LRFMessage*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
01738     #endif
01739     }
01740 
01741     ::IceInternal::ProxyHandle<LRFMessage> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
01742     {
01743     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01744         typedef ::IceProxy::Ice::Object _Base;
01745         return dynamic_cast<LRFMessage*>(_Base::ice_endpoints(__endpoints).get());
01746     #else
01747         return dynamic_cast<LRFMessage*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
01748     #endif
01749     }
01750 
01751     ::IceInternal::ProxyHandle<LRFMessage> ice_locatorCacheTimeout(int __timeout) const
01752     {
01753     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01754         typedef ::IceProxy::Ice::Object _Base;
01755         return dynamic_cast<LRFMessage*>(_Base::ice_locatorCacheTimeout(__timeout).get());
01756     #else
01757         return dynamic_cast<LRFMessage*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
01758     #endif
01759     }
01760 
01761     ::IceInternal::ProxyHandle<LRFMessage> ice_connectionCached(bool __cached) const
01762     {
01763     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01764         typedef ::IceProxy::Ice::Object _Base;
01765         return dynamic_cast<LRFMessage*>(_Base::ice_connectionCached(__cached).get());
01766     #else
01767         return dynamic_cast<LRFMessage*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
01768     #endif
01769     }
01770 
01771     ::IceInternal::ProxyHandle<LRFMessage> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
01772     {
01773     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01774         typedef ::IceProxy::Ice::Object _Base;
01775         return dynamic_cast<LRFMessage*>(_Base::ice_endpointSelection(__est).get());
01776     #else
01777         return dynamic_cast<LRFMessage*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
01778     #endif
01779     }
01780 
01781     ::IceInternal::ProxyHandle<LRFMessage> ice_secure(bool __secure) const
01782     {
01783     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01784         typedef ::IceProxy::Ice::Object _Base;
01785         return dynamic_cast<LRFMessage*>(_Base::ice_secure(__secure).get());
01786     #else
01787         return dynamic_cast<LRFMessage*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
01788     #endif
01789     }
01790 
01791     ::IceInternal::ProxyHandle<LRFMessage> ice_preferSecure(bool __preferSecure) const
01792     {
01793     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01794         typedef ::IceProxy::Ice::Object _Base;
01795         return dynamic_cast<LRFMessage*>(_Base::ice_preferSecure(__preferSecure).get());
01796     #else
01797         return dynamic_cast<LRFMessage*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
01798     #endif
01799     }
01800 
01801     ::IceInternal::ProxyHandle<LRFMessage> ice_router(const ::Ice::RouterPrx& __router) const
01802     {
01803     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01804         typedef ::IceProxy::Ice::Object _Base;
01805         return dynamic_cast<LRFMessage*>(_Base::ice_router(__router).get());
01806     #else
01807         return dynamic_cast<LRFMessage*>(::IceProxy::Ice::Object::ice_router(__router).get());
01808     #endif
01809     }
01810 
01811     ::IceInternal::ProxyHandle<LRFMessage> ice_locator(const ::Ice::LocatorPrx& __locator) const
01812     {
01813     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01814         typedef ::IceProxy::Ice::Object _Base;
01815         return dynamic_cast<LRFMessage*>(_Base::ice_locator(__locator).get());
01816     #else
01817         return dynamic_cast<LRFMessage*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
01818     #endif
01819     }
01820 
01821     ::IceInternal::ProxyHandle<LRFMessage> ice_collocationOptimized(bool __co) const
01822     {
01823     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01824         typedef ::IceProxy::Ice::Object _Base;
01825         return dynamic_cast<LRFMessage*>(_Base::ice_collocationOptimized(__co).get());
01826     #else
01827         return dynamic_cast<LRFMessage*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
01828     #endif
01829     }
01830 
01831     ::IceInternal::ProxyHandle<LRFMessage> ice_twoway() const
01832     {
01833     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01834         typedef ::IceProxy::Ice::Object _Base;
01835         return dynamic_cast<LRFMessage*>(_Base::ice_twoway().get());
01836     #else
01837         return dynamic_cast<LRFMessage*>(::IceProxy::Ice::Object::ice_twoway().get());
01838     #endif
01839     }
01840 
01841     ::IceInternal::ProxyHandle<LRFMessage> ice_oneway() const
01842     {
01843     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01844         typedef ::IceProxy::Ice::Object _Base;
01845         return dynamic_cast<LRFMessage*>(_Base::ice_oneway().get());
01846     #else
01847         return dynamic_cast<LRFMessage*>(::IceProxy::Ice::Object::ice_oneway().get());
01848     #endif
01849     }
01850 
01851     ::IceInternal::ProxyHandle<LRFMessage> ice_batchOneway() const
01852     {
01853     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01854         typedef ::IceProxy::Ice::Object _Base;
01855         return dynamic_cast<LRFMessage*>(_Base::ice_batchOneway().get());
01856     #else
01857         return dynamic_cast<LRFMessage*>(::IceProxy::Ice::Object::ice_batchOneway().get());
01858     #endif
01859     }
01860 
01861     ::IceInternal::ProxyHandle<LRFMessage> ice_datagram() const
01862     {
01863     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01864         typedef ::IceProxy::Ice::Object _Base;
01865         return dynamic_cast<LRFMessage*>(_Base::ice_datagram().get());
01866     #else
01867         return dynamic_cast<LRFMessage*>(::IceProxy::Ice::Object::ice_datagram().get());
01868     #endif
01869     }
01870 
01871     ::IceInternal::ProxyHandle<LRFMessage> ice_batchDatagram() const
01872     {
01873     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01874         typedef ::IceProxy::Ice::Object _Base;
01875         return dynamic_cast<LRFMessage*>(_Base::ice_batchDatagram().get());
01876     #else
01877         return dynamic_cast<LRFMessage*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
01878     #endif
01879     }
01880 
01881     ::IceInternal::ProxyHandle<LRFMessage> ice_compress(bool __compress) const
01882     {
01883     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01884         typedef ::IceProxy::Ice::Object _Base;
01885         return dynamic_cast<LRFMessage*>(_Base::ice_compress(__compress).get());
01886     #else
01887         return dynamic_cast<LRFMessage*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
01888     #endif
01889     }
01890 
01891     ::IceInternal::ProxyHandle<LRFMessage> ice_timeout(int __timeout) const
01892     {
01893     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01894         typedef ::IceProxy::Ice::Object _Base;
01895         return dynamic_cast<LRFMessage*>(_Base::ice_timeout(__timeout).get());
01896     #else
01897         return dynamic_cast<LRFMessage*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
01898     #endif
01899     }
01900 
01901     ::IceInternal::ProxyHandle<LRFMessage> ice_connectionId(const std::string& __id) const
01902     {
01903     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01904         typedef ::IceProxy::Ice::Object _Base;
01905         return dynamic_cast<LRFMessage*>(_Base::ice_connectionId(__id).get());
01906     #else
01907         return dynamic_cast<LRFMessage*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
01908     #endif
01909     }
01910 
01911     static const ::std::string& ice_staticId();
01912 
01913 private:
01914 
01915     virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
01916     virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
01917     virtual ::IceProxy::Ice::Object* __newInstance() const;
01918 };
01919 
01920 class SLAMMessage : virtual public ::IceProxy::RobotSimEvents::EventMessage
01921 {
01922 public:
01923 
01924     ::IceInternal::ProxyHandle<SLAMMessage> ice_context(const ::Ice::Context& __context) const
01925     {
01926     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01927         typedef ::IceProxy::Ice::Object _Base;
01928         return dynamic_cast<SLAMMessage*>(_Base::ice_context(__context).get());
01929     #else
01930         return dynamic_cast<SLAMMessage*>(::IceProxy::Ice::Object::ice_context(__context).get());
01931     #endif
01932     }
01933 
01934     ::IceInternal::ProxyHandle<SLAMMessage> ice_adapterId(const std::string& __id) const
01935     {
01936     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01937         typedef ::IceProxy::Ice::Object _Base;
01938         return dynamic_cast<SLAMMessage*>(_Base::ice_adapterId(__id).get());
01939     #else
01940         return dynamic_cast<SLAMMessage*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
01941     #endif
01942     }
01943 
01944     ::IceInternal::ProxyHandle<SLAMMessage> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
01945     {
01946     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01947         typedef ::IceProxy::Ice::Object _Base;
01948         return dynamic_cast<SLAMMessage*>(_Base::ice_endpoints(__endpoints).get());
01949     #else
01950         return dynamic_cast<SLAMMessage*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
01951     #endif
01952     }
01953 
01954     ::IceInternal::ProxyHandle<SLAMMessage> ice_locatorCacheTimeout(int __timeout) const
01955     {
01956     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01957         typedef ::IceProxy::Ice::Object _Base;
01958         return dynamic_cast<SLAMMessage*>(_Base::ice_locatorCacheTimeout(__timeout).get());
01959     #else
01960         return dynamic_cast<SLAMMessage*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
01961     #endif
01962     }
01963 
01964     ::IceInternal::ProxyHandle<SLAMMessage> ice_connectionCached(bool __cached) const
01965     {
01966     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01967         typedef ::IceProxy::Ice::Object _Base;
01968         return dynamic_cast<SLAMMessage*>(_Base::ice_connectionCached(__cached).get());
01969     #else
01970         return dynamic_cast<SLAMMessage*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
01971     #endif
01972     }
01973 
01974     ::IceInternal::ProxyHandle<SLAMMessage> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
01975     {
01976     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01977         typedef ::IceProxy::Ice::Object _Base;
01978         return dynamic_cast<SLAMMessage*>(_Base::ice_endpointSelection(__est).get());
01979     #else
01980         return dynamic_cast<SLAMMessage*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
01981     #endif
01982     }
01983 
01984     ::IceInternal::ProxyHandle<SLAMMessage> ice_secure(bool __secure) const
01985     {
01986     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01987         typedef ::IceProxy::Ice::Object _Base;
01988         return dynamic_cast<SLAMMessage*>(_Base::ice_secure(__secure).get());
01989     #else
01990         return dynamic_cast<SLAMMessage*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
01991     #endif
01992     }
01993 
01994     ::IceInternal::ProxyHandle<SLAMMessage> ice_preferSecure(bool __preferSecure) const
01995     {
01996     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01997         typedef ::IceProxy::Ice::Object _Base;
01998         return dynamic_cast<SLAMMessage*>(_Base::ice_preferSecure(__preferSecure).get());
01999     #else
02000         return dynamic_cast<SLAMMessage*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
02001     #endif
02002     }
02003 
02004     ::IceInternal::ProxyHandle<SLAMMessage> ice_router(const ::Ice::RouterPrx& __router) const
02005     {
02006     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02007         typedef ::IceProxy::Ice::Object _Base;
02008         return dynamic_cast<SLAMMessage*>(_Base::ice_router(__router).get());
02009     #else
02010         return dynamic_cast<SLAMMessage*>(::IceProxy::Ice::Object::ice_router(__router).get());
02011     #endif
02012     }
02013 
02014     ::IceInternal::ProxyHandle<SLAMMessage> ice_locator(const ::Ice::LocatorPrx& __locator) const
02015     {
02016     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02017         typedef ::IceProxy::Ice::Object _Base;
02018         return dynamic_cast<SLAMMessage*>(_Base::ice_locator(__locator).get());
02019     #else
02020         return dynamic_cast<SLAMMessage*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
02021     #endif
02022     }
02023 
02024     ::IceInternal::ProxyHandle<SLAMMessage> ice_collocationOptimized(bool __co) const
02025     {
02026     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02027         typedef ::IceProxy::Ice::Object _Base;
02028         return dynamic_cast<SLAMMessage*>(_Base::ice_collocationOptimized(__co).get());
02029     #else
02030         return dynamic_cast<SLAMMessage*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
02031     #endif
02032     }
02033 
02034     ::IceInternal::ProxyHandle<SLAMMessage> ice_twoway() const
02035     {
02036     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02037         typedef ::IceProxy::Ice::Object _Base;
02038         return dynamic_cast<SLAMMessage*>(_Base::ice_twoway().get());
02039     #else
02040         return dynamic_cast<SLAMMessage*>(::IceProxy::Ice::Object::ice_twoway().get());
02041     #endif
02042     }
02043 
02044     ::IceInternal::ProxyHandle<SLAMMessage> ice_oneway() const
02045     {
02046     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02047         typedef ::IceProxy::Ice::Object _Base;
02048         return dynamic_cast<SLAMMessage*>(_Base::ice_oneway().get());
02049     #else
02050         return dynamic_cast<SLAMMessage*>(::IceProxy::Ice::Object::ice_oneway().get());
02051     #endif
02052     }
02053 
02054     ::IceInternal::ProxyHandle<SLAMMessage> ice_batchOneway() const
02055     {
02056     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02057         typedef ::IceProxy::Ice::Object _Base;
02058         return dynamic_cast<SLAMMessage*>(_Base::ice_batchOneway().get());
02059     #else
02060         return dynamic_cast<SLAMMessage*>(::IceProxy::Ice::Object::ice_batchOneway().get());
02061     #endif
02062     }
02063 
02064     ::IceInternal::ProxyHandle<SLAMMessage> ice_datagram() const
02065     {
02066     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02067         typedef ::IceProxy::Ice::Object _Base;
02068         return dynamic_cast<SLAMMessage*>(_Base::ice_datagram().get());
02069     #else
02070         return dynamic_cast<SLAMMessage*>(::IceProxy::Ice::Object::ice_datagram().get());
02071     #endif
02072     }
02073 
02074     ::IceInternal::ProxyHandle<SLAMMessage> ice_batchDatagram() const
02075     {
02076     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02077         typedef ::IceProxy::Ice::Object _Base;
02078         return dynamic_cast<SLAMMessage*>(_Base::ice_batchDatagram().get());
02079     #else
02080         return dynamic_cast<SLAMMessage*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
02081     #endif
02082     }
02083 
02084     ::IceInternal::ProxyHandle<SLAMMessage> ice_compress(bool __compress) const
02085     {
02086     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02087         typedef ::IceProxy::Ice::Object _Base;
02088         return dynamic_cast<SLAMMessage*>(_Base::ice_compress(__compress).get());
02089     #else
02090         return dynamic_cast<SLAMMessage*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
02091     #endif
02092     }
02093 
02094     ::IceInternal::ProxyHandle<SLAMMessage> ice_timeout(int __timeout) const
02095     {
02096     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02097         typedef ::IceProxy::Ice::Object _Base;
02098         return dynamic_cast<SLAMMessage*>(_Base::ice_timeout(__timeout).get());
02099     #else
02100         return dynamic_cast<SLAMMessage*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
02101     #endif
02102     }
02103 
02104     ::IceInternal::ProxyHandle<SLAMMessage> ice_connectionId(const std::string& __id) const
02105     {
02106     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02107         typedef ::IceProxy::Ice::Object _Base;
02108         return dynamic_cast<SLAMMessage*>(_Base::ice_connectionId(__id).get());
02109     #else
02110         return dynamic_cast<SLAMMessage*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
02111     #endif
02112     }
02113 
02114     static const ::std::string& ice_staticId();
02115 
02116 private:
02117 
02118     virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
02119     virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
02120     virtual ::IceProxy::Ice::Object* __newInstance() const;
02121 };
02122 
02123 class IMUMessage : virtual public ::IceProxy::RobotSimEvents::EventMessage
02124 {
02125 public:
02126 
02127     ::IceInternal::ProxyHandle<IMUMessage> ice_context(const ::Ice::Context& __context) const
02128     {
02129     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02130         typedef ::IceProxy::Ice::Object _Base;
02131         return dynamic_cast<IMUMessage*>(_Base::ice_context(__context).get());
02132     #else
02133         return dynamic_cast<IMUMessage*>(::IceProxy::Ice::Object::ice_context(__context).get());
02134     #endif
02135     }
02136 
02137     ::IceInternal::ProxyHandle<IMUMessage> ice_adapterId(const std::string& __id) const
02138     {
02139     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02140         typedef ::IceProxy::Ice::Object _Base;
02141         return dynamic_cast<IMUMessage*>(_Base::ice_adapterId(__id).get());
02142     #else
02143         return dynamic_cast<IMUMessage*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
02144     #endif
02145     }
02146 
02147     ::IceInternal::ProxyHandle<IMUMessage> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
02148     {
02149     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02150         typedef ::IceProxy::Ice::Object _Base;
02151         return dynamic_cast<IMUMessage*>(_Base::ice_endpoints(__endpoints).get());
02152     #else
02153         return dynamic_cast<IMUMessage*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
02154     #endif
02155     }
02156 
02157     ::IceInternal::ProxyHandle<IMUMessage> ice_locatorCacheTimeout(int __timeout) const
02158     {
02159     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02160         typedef ::IceProxy::Ice::Object _Base;
02161         return dynamic_cast<IMUMessage*>(_Base::ice_locatorCacheTimeout(__timeout).get());
02162     #else
02163         return dynamic_cast<IMUMessage*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
02164     #endif
02165     }
02166 
02167     ::IceInternal::ProxyHandle<IMUMessage> ice_connectionCached(bool __cached) const
02168     {
02169     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02170         typedef ::IceProxy::Ice::Object _Base;
02171         return dynamic_cast<IMUMessage*>(_Base::ice_connectionCached(__cached).get());
02172     #else
02173         return dynamic_cast<IMUMessage*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
02174     #endif
02175     }
02176 
02177     ::IceInternal::ProxyHandle<IMUMessage> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
02178     {
02179     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02180         typedef ::IceProxy::Ice::Object _Base;
02181         return dynamic_cast<IMUMessage*>(_Base::ice_endpointSelection(__est).get());
02182     #else
02183         return dynamic_cast<IMUMessage*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
02184     #endif
02185     }
02186 
02187     ::IceInternal::ProxyHandle<IMUMessage> ice_secure(bool __secure) const
02188     {
02189     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02190         typedef ::IceProxy::Ice::Object _Base;
02191         return dynamic_cast<IMUMessage*>(_Base::ice_secure(__secure).get());
02192     #else
02193         return dynamic_cast<IMUMessage*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
02194     #endif
02195     }
02196 
02197     ::IceInternal::ProxyHandle<IMUMessage> ice_preferSecure(bool __preferSecure) const
02198     {
02199     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02200         typedef ::IceProxy::Ice::Object _Base;
02201         return dynamic_cast<IMUMessage*>(_Base::ice_preferSecure(__preferSecure).get());
02202     #else
02203         return dynamic_cast<IMUMessage*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
02204     #endif
02205     }
02206 
02207     ::IceInternal::ProxyHandle<IMUMessage> ice_router(const ::Ice::RouterPrx& __router) const
02208     {
02209     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02210         typedef ::IceProxy::Ice::Object _Base;
02211         return dynamic_cast<IMUMessage*>(_Base::ice_router(__router).get());
02212     #else
02213         return dynamic_cast<IMUMessage*>(::IceProxy::Ice::Object::ice_router(__router).get());
02214     #endif
02215     }
02216 
02217     ::IceInternal::ProxyHandle<IMUMessage> ice_locator(const ::Ice::LocatorPrx& __locator) const
02218     {
02219     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02220         typedef ::IceProxy::Ice::Object _Base;
02221         return dynamic_cast<IMUMessage*>(_Base::ice_locator(__locator).get());
02222     #else
02223         return dynamic_cast<IMUMessage*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
02224     #endif
02225     }
02226 
02227     ::IceInternal::ProxyHandle<IMUMessage> ice_collocationOptimized(bool __co) const
02228     {
02229     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02230         typedef ::IceProxy::Ice::Object _Base;
02231         return dynamic_cast<IMUMessage*>(_Base::ice_collocationOptimized(__co).get());
02232     #else
02233         return dynamic_cast<IMUMessage*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
02234     #endif
02235     }
02236 
02237     ::IceInternal::ProxyHandle<IMUMessage> ice_twoway() const
02238     {
02239     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02240         typedef ::IceProxy::Ice::Object _Base;
02241         return dynamic_cast<IMUMessage*>(_Base::ice_twoway().get());
02242     #else
02243         return dynamic_cast<IMUMessage*>(::IceProxy::Ice::Object::ice_twoway().get());
02244     #endif
02245     }
02246 
02247     ::IceInternal::ProxyHandle<IMUMessage> ice_oneway() const
02248     {
02249     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02250         typedef ::IceProxy::Ice::Object _Base;
02251         return dynamic_cast<IMUMessage*>(_Base::ice_oneway().get());
02252     #else
02253         return dynamic_cast<IMUMessage*>(::IceProxy::Ice::Object::ice_oneway().get());
02254     #endif
02255     }
02256 
02257     ::IceInternal::ProxyHandle<IMUMessage> ice_batchOneway() const
02258     {
02259     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02260         typedef ::IceProxy::Ice::Object _Base;
02261         return dynamic_cast<IMUMessage*>(_Base::ice_batchOneway().get());
02262     #else
02263         return dynamic_cast<IMUMessage*>(::IceProxy::Ice::Object::ice_batchOneway().get());
02264     #endif
02265     }
02266 
02267     ::IceInternal::ProxyHandle<IMUMessage> ice_datagram() const
02268     {
02269     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02270         typedef ::IceProxy::Ice::Object _Base;
02271         return dynamic_cast<IMUMessage*>(_Base::ice_datagram().get());
02272     #else
02273         return dynamic_cast<IMUMessage*>(::IceProxy::Ice::Object::ice_datagram().get());
02274     #endif
02275     }
02276 
02277     ::IceInternal::ProxyHandle<IMUMessage> ice_batchDatagram() const
02278     {
02279     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02280         typedef ::IceProxy::Ice::Object _Base;
02281         return dynamic_cast<IMUMessage*>(_Base::ice_batchDatagram().get());
02282     #else
02283         return dynamic_cast<IMUMessage*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
02284     #endif
02285     }
02286 
02287     ::IceInternal::ProxyHandle<IMUMessage> ice_compress(bool __compress) const
02288     {
02289     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02290         typedef ::IceProxy::Ice::Object _Base;
02291         return dynamic_cast<IMUMessage*>(_Base::ice_compress(__compress).get());
02292     #else
02293         return dynamic_cast<IMUMessage*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
02294     #endif
02295     }
02296 
02297     ::IceInternal::ProxyHandle<IMUMessage> ice_timeout(int __timeout) const
02298     {
02299     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02300         typedef ::IceProxy::Ice::Object _Base;
02301         return dynamic_cast<IMUMessage*>(_Base::ice_timeout(__timeout).get());
02302     #else
02303         return dynamic_cast<IMUMessage*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
02304     #endif
02305     }
02306 
02307     ::IceInternal::ProxyHandle<IMUMessage> ice_connectionId(const std::string& __id) const
02308     {
02309     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02310         typedef ::IceProxy::Ice::Object _Base;
02311         return dynamic_cast<IMUMessage*>(_Base::ice_connectionId(__id).get());
02312     #else
02313         return dynamic_cast<IMUMessage*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
02314     #endif
02315     }
02316 
02317     static const ::std::string& ice_staticId();
02318 
02319 private:
02320 
02321     virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
02322     virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
02323     virtual ::IceProxy::Ice::Object* __newInstance() const;
02324 };
02325 
02326 class CameraMessage : virtual public ::IceProxy::RobotSimEvents::EventMessage
02327 {
02328 public:
02329 
02330     ::IceInternal::ProxyHandle<CameraMessage> ice_context(const ::Ice::Context& __context) const
02331     {
02332     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02333         typedef ::IceProxy::Ice::Object _Base;
02334         return dynamic_cast<CameraMessage*>(_Base::ice_context(__context).get());
02335     #else
02336         return dynamic_cast<CameraMessage*>(::IceProxy::Ice::Object::ice_context(__context).get());
02337     #endif
02338     }
02339 
02340     ::IceInternal::ProxyHandle<CameraMessage> ice_adapterId(const std::string& __id) const
02341     {
02342     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02343         typedef ::IceProxy::Ice::Object _Base;
02344         return dynamic_cast<CameraMessage*>(_Base::ice_adapterId(__id).get());
02345     #else
02346         return dynamic_cast<CameraMessage*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
02347     #endif
02348     }
02349 
02350     ::IceInternal::ProxyHandle<CameraMessage> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
02351     {
02352     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02353         typedef ::IceProxy::Ice::Object _Base;
02354         return dynamic_cast<CameraMessage*>(_Base::ice_endpoints(__endpoints).get());
02355     #else
02356         return dynamic_cast<CameraMessage*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
02357     #endif
02358     }
02359 
02360     ::IceInternal::ProxyHandle<CameraMessage> ice_locatorCacheTimeout(int __timeout) const
02361     {
02362     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02363         typedef ::IceProxy::Ice::Object _Base;
02364         return dynamic_cast<CameraMessage*>(_Base::ice_locatorCacheTimeout(__timeout).get());
02365     #else
02366         return dynamic_cast<CameraMessage*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
02367     #endif
02368     }
02369 
02370     ::IceInternal::ProxyHandle<CameraMessage> ice_connectionCached(bool __cached) const
02371     {
02372     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02373         typedef ::IceProxy::Ice::Object _Base;
02374         return dynamic_cast<CameraMessage*>(_Base::ice_connectionCached(__cached).get());
02375     #else
02376         return dynamic_cast<CameraMessage*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
02377     #endif
02378     }
02379 
02380     ::IceInternal::ProxyHandle<CameraMessage> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
02381     {
02382     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02383         typedef ::IceProxy::Ice::Object _Base;
02384         return dynamic_cast<CameraMessage*>(_Base::ice_endpointSelection(__est).get());
02385     #else
02386         return dynamic_cast<CameraMessage*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
02387     #endif
02388     }
02389 
02390     ::IceInternal::ProxyHandle<CameraMessage> ice_secure(bool __secure) const
02391     {
02392     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02393         typedef ::IceProxy::Ice::Object _Base;
02394         return dynamic_cast<CameraMessage*>(_Base::ice_secure(__secure).get());
02395     #else
02396         return dynamic_cast<CameraMessage*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
02397     #endif
02398     }
02399 
02400     ::IceInternal::ProxyHandle<CameraMessage> ice_preferSecure(bool __preferSecure) const
02401     {
02402     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02403         typedef ::IceProxy::Ice::Object _Base;
02404         return dynamic_cast<CameraMessage*>(_Base::ice_preferSecure(__preferSecure).get());
02405     #else
02406         return dynamic_cast<CameraMessage*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
02407     #endif
02408     }
02409 
02410     ::IceInternal::ProxyHandle<CameraMessage> ice_router(const ::Ice::RouterPrx& __router) const
02411     {
02412     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02413         typedef ::IceProxy::Ice::Object _Base;
02414         return dynamic_cast<CameraMessage*>(_Base::ice_router(__router).get());
02415     #else
02416         return dynamic_cast<CameraMessage*>(::IceProxy::Ice::Object::ice_router(__router).get());
02417     #endif
02418     }
02419 
02420     ::IceInternal::ProxyHandle<CameraMessage> ice_locator(const ::Ice::LocatorPrx& __locator) const
02421     {
02422     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02423         typedef ::IceProxy::Ice::Object _Base;
02424         return dynamic_cast<CameraMessage*>(_Base::ice_locator(__locator).get());
02425     #else
02426         return dynamic_cast<CameraMessage*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
02427     #endif
02428     }
02429 
02430     ::IceInternal::ProxyHandle<CameraMessage> ice_collocationOptimized(bool __co) const
02431     {
02432     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02433         typedef ::IceProxy::Ice::Object _Base;
02434         return dynamic_cast<CameraMessage*>(_Base::ice_collocationOptimized(__co).get());
02435     #else
02436         return dynamic_cast<CameraMessage*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
02437     #endif
02438     }
02439 
02440     ::IceInternal::ProxyHandle<CameraMessage> ice_twoway() const
02441     {
02442     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02443         typedef ::IceProxy::Ice::Object _Base;
02444         return dynamic_cast<CameraMessage*>(_Base::ice_twoway().get());
02445     #else
02446         return dynamic_cast<CameraMessage*>(::IceProxy::Ice::Object::ice_twoway().get());
02447     #endif
02448     }
02449 
02450     ::IceInternal::ProxyHandle<CameraMessage> ice_oneway() const
02451     {
02452     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02453         typedef ::IceProxy::Ice::Object _Base;
02454         return dynamic_cast<CameraMessage*>(_Base::ice_oneway().get());
02455     #else
02456         return dynamic_cast<CameraMessage*>(::IceProxy::Ice::Object::ice_oneway().get());
02457     #endif
02458     }
02459 
02460     ::IceInternal::ProxyHandle<CameraMessage> ice_batchOneway() const
02461     {
02462     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02463         typedef ::IceProxy::Ice::Object _Base;
02464         return dynamic_cast<CameraMessage*>(_Base::ice_batchOneway().get());
02465     #else
02466         return dynamic_cast<CameraMessage*>(::IceProxy::Ice::Object::ice_batchOneway().get());
02467     #endif
02468     }
02469 
02470     ::IceInternal::ProxyHandle<CameraMessage> ice_datagram() const
02471     {
02472     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02473         typedef ::IceProxy::Ice::Object _Base;
02474         return dynamic_cast<CameraMessage*>(_Base::ice_datagram().get());
02475     #else
02476         return dynamic_cast<CameraMessage*>(::IceProxy::Ice::Object::ice_datagram().get());
02477     #endif
02478     }
02479 
02480     ::IceInternal::ProxyHandle<CameraMessage> ice_batchDatagram() const
02481     {
02482     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02483         typedef ::IceProxy::Ice::Object _Base;
02484         return dynamic_cast<CameraMessage*>(_Base::ice_batchDatagram().get());
02485     #else
02486         return dynamic_cast<CameraMessage*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
02487     #endif
02488     }
02489 
02490     ::IceInternal::ProxyHandle<CameraMessage> ice_compress(bool __compress) const
02491     {
02492     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02493         typedef ::IceProxy::Ice::Object _Base;
02494         return dynamic_cast<CameraMessage*>(_Base::ice_compress(__compress).get());
02495     #else
02496         return dynamic_cast<CameraMessage*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
02497     #endif
02498     }
02499 
02500     ::IceInternal::ProxyHandle<CameraMessage> ice_timeout(int __timeout) const
02501     {
02502     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02503         typedef ::IceProxy::Ice::Object _Base;
02504         return dynamic_cast<CameraMessage*>(_Base::ice_timeout(__timeout).get());
02505     #else
02506         return dynamic_cast<CameraMessage*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
02507     #endif
02508     }
02509 
02510     ::IceInternal::ProxyHandle<CameraMessage> ice_connectionId(const std::string& __id) const
02511     {
02512     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02513         typedef ::IceProxy::Ice::Object _Base;
02514         return dynamic_cast<CameraMessage*>(_Base::ice_connectionId(__id).get());
02515     #else
02516         return dynamic_cast<CameraMessage*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
02517     #endif
02518     }
02519 
02520     static const ::std::string& ice_staticId();
02521 
02522 private:
02523 
02524     virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
02525     virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
02526     virtual ::IceProxy::Ice::Object* __newInstance() const;
02527 };
02528 
02529 class GistSalMessage : virtual public ::IceProxy::RobotSimEvents::EventMessage
02530 {
02531 public:
02532 
02533     ::IceInternal::ProxyHandle<GistSalMessage> ice_context(const ::Ice::Context& __context) const
02534     {
02535     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02536         typedef ::IceProxy::Ice::Object _Base;
02537         return dynamic_cast<GistSalMessage*>(_Base::ice_context(__context).get());
02538     #else
02539         return dynamic_cast<GistSalMessage*>(::IceProxy::Ice::Object::ice_context(__context).get());
02540     #endif
02541     }
02542 
02543     ::IceInternal::ProxyHandle<GistSalMessage> ice_adapterId(const std::string& __id) const
02544     {
02545     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02546         typedef ::IceProxy::Ice::Object _Base;
02547         return dynamic_cast<GistSalMessage*>(_Base::ice_adapterId(__id).get());
02548     #else
02549         return dynamic_cast<GistSalMessage*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
02550     #endif
02551     }
02552 
02553     ::IceInternal::ProxyHandle<GistSalMessage> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
02554     {
02555     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02556         typedef ::IceProxy::Ice::Object _Base;
02557         return dynamic_cast<GistSalMessage*>(_Base::ice_endpoints(__endpoints).get());
02558     #else
02559         return dynamic_cast<GistSalMessage*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
02560     #endif
02561     }
02562 
02563     ::IceInternal::ProxyHandle<GistSalMessage> ice_locatorCacheTimeout(int __timeout) const
02564     {
02565     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02566         typedef ::IceProxy::Ice::Object _Base;
02567         return dynamic_cast<GistSalMessage*>(_Base::ice_locatorCacheTimeout(__timeout).get());
02568     #else
02569         return dynamic_cast<GistSalMessage*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
02570     #endif
02571     }
02572 
02573     ::IceInternal::ProxyHandle<GistSalMessage> ice_connectionCached(bool __cached) const
02574     {
02575     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02576         typedef ::IceProxy::Ice::Object _Base;
02577         return dynamic_cast<GistSalMessage*>(_Base::ice_connectionCached(__cached).get());
02578     #else
02579         return dynamic_cast<GistSalMessage*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
02580     #endif
02581     }
02582 
02583     ::IceInternal::ProxyHandle<GistSalMessage> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
02584     {
02585     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02586         typedef ::IceProxy::Ice::Object _Base;
02587         return dynamic_cast<GistSalMessage*>(_Base::ice_endpointSelection(__est).get());
02588     #else
02589         return dynamic_cast<GistSalMessage*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
02590     #endif
02591     }
02592 
02593     ::IceInternal::ProxyHandle<GistSalMessage> ice_secure(bool __secure) const
02594     {
02595     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02596         typedef ::IceProxy::Ice::Object _Base;
02597         return dynamic_cast<GistSalMessage*>(_Base::ice_secure(__secure).get());
02598     #else
02599         return dynamic_cast<GistSalMessage*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
02600     #endif
02601     }
02602 
02603     ::IceInternal::ProxyHandle<GistSalMessage> ice_preferSecure(bool __preferSecure) const
02604     {
02605     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02606         typedef ::IceProxy::Ice::Object _Base;
02607         return dynamic_cast<GistSalMessage*>(_Base::ice_preferSecure(__preferSecure).get());
02608     #else
02609         return dynamic_cast<GistSalMessage*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
02610     #endif
02611     }
02612 
02613     ::IceInternal::ProxyHandle<GistSalMessage> ice_router(const ::Ice::RouterPrx& __router) const
02614     {
02615     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02616         typedef ::IceProxy::Ice::Object _Base;
02617         return dynamic_cast<GistSalMessage*>(_Base::ice_router(__router).get());
02618     #else
02619         return dynamic_cast<GistSalMessage*>(::IceProxy::Ice::Object::ice_router(__router).get());
02620     #endif
02621     }
02622 
02623     ::IceInternal::ProxyHandle<GistSalMessage> ice_locator(const ::Ice::LocatorPrx& __locator) const
02624     {
02625     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02626         typedef ::IceProxy::Ice::Object _Base;
02627         return dynamic_cast<GistSalMessage*>(_Base::ice_locator(__locator).get());
02628     #else
02629         return dynamic_cast<GistSalMessage*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
02630     #endif
02631     }
02632 
02633     ::IceInternal::ProxyHandle<GistSalMessage> ice_collocationOptimized(bool __co) const
02634     {
02635     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02636         typedef ::IceProxy::Ice::Object _Base;
02637         return dynamic_cast<GistSalMessage*>(_Base::ice_collocationOptimized(__co).get());
02638     #else
02639         return dynamic_cast<GistSalMessage*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
02640     #endif
02641     }
02642 
02643     ::IceInternal::ProxyHandle<GistSalMessage> ice_twoway() const
02644     {
02645     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02646         typedef ::IceProxy::Ice::Object _Base;
02647         return dynamic_cast<GistSalMessage*>(_Base::ice_twoway().get());
02648     #else
02649         return dynamic_cast<GistSalMessage*>(::IceProxy::Ice::Object::ice_twoway().get());
02650     #endif
02651     }
02652 
02653     ::IceInternal::ProxyHandle<GistSalMessage> ice_oneway() const
02654     {
02655     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02656         typedef ::IceProxy::Ice::Object _Base;
02657         return dynamic_cast<GistSalMessage*>(_Base::ice_oneway().get());
02658     #else
02659         return dynamic_cast<GistSalMessage*>(::IceProxy::Ice::Object::ice_oneway().get());
02660     #endif
02661     }
02662 
02663     ::IceInternal::ProxyHandle<GistSalMessage> ice_batchOneway() const
02664     {
02665     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02666         typedef ::IceProxy::Ice::Object _Base;
02667         return dynamic_cast<GistSalMessage*>(_Base::ice_batchOneway().get());
02668     #else
02669         return dynamic_cast<GistSalMessage*>(::IceProxy::Ice::Object::ice_batchOneway().get());
02670     #endif
02671     }
02672 
02673     ::IceInternal::ProxyHandle<GistSalMessage> ice_datagram() const
02674     {
02675     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02676         typedef ::IceProxy::Ice::Object _Base;
02677         return dynamic_cast<GistSalMessage*>(_Base::ice_datagram().get());
02678     #else
02679         return dynamic_cast<GistSalMessage*>(::IceProxy::Ice::Object::ice_datagram().get());
02680     #endif
02681     }
02682 
02683     ::IceInternal::ProxyHandle<GistSalMessage> ice_batchDatagram() const
02684     {
02685     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02686         typedef ::IceProxy::Ice::Object _Base;
02687         return dynamic_cast<GistSalMessage*>(_Base::ice_batchDatagram().get());
02688     #else
02689         return dynamic_cast<GistSalMessage*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
02690     #endif
02691     }
02692 
02693     ::IceInternal::ProxyHandle<GistSalMessage> ice_compress(bool __compress) const
02694     {
02695     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02696         typedef ::IceProxy::Ice::Object _Base;
02697         return dynamic_cast<GistSalMessage*>(_Base::ice_compress(__compress).get());
02698     #else
02699         return dynamic_cast<GistSalMessage*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
02700     #endif
02701     }
02702 
02703     ::IceInternal::ProxyHandle<GistSalMessage> ice_timeout(int __timeout) const
02704     {
02705     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02706         typedef ::IceProxy::Ice::Object _Base;
02707         return dynamic_cast<GistSalMessage*>(_Base::ice_timeout(__timeout).get());
02708     #else
02709         return dynamic_cast<GistSalMessage*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
02710     #endif
02711     }
02712 
02713     ::IceInternal::ProxyHandle<GistSalMessage> ice_connectionId(const std::string& __id) const
02714     {
02715     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02716         typedef ::IceProxy::Ice::Object _Base;
02717         return dynamic_cast<GistSalMessage*>(_Base::ice_connectionId(__id).get());
02718     #else
02719         return dynamic_cast<GistSalMessage*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
02720     #endif
02721     }
02722 
02723     static const ::std::string& ice_staticId();
02724 
02725 private:
02726 
02727     virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
02728     virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
02729     virtual ::IceProxy::Ice::Object* __newInstance() const;
02730 };
02731 
02732 class LandmarkSearchQueueMessage : virtual public ::IceProxy::RobotSimEvents::EventMessage
02733 {
02734 public:
02735 
02736     ::IceInternal::ProxyHandle<LandmarkSearchQueueMessage> ice_context(const ::Ice::Context& __context) const
02737     {
02738     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02739         typedef ::IceProxy::Ice::Object _Base;
02740         return dynamic_cast<LandmarkSearchQueueMessage*>(_Base::ice_context(__context).get());
02741     #else
02742         return dynamic_cast<LandmarkSearchQueueMessage*>(::IceProxy::Ice::Object::ice_context(__context).get());
02743     #endif
02744     }
02745 
02746     ::IceInternal::ProxyHandle<LandmarkSearchQueueMessage> ice_adapterId(const std::string& __id) const
02747     {
02748     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02749         typedef ::IceProxy::Ice::Object _Base;
02750         return dynamic_cast<LandmarkSearchQueueMessage*>(_Base::ice_adapterId(__id).get());
02751     #else
02752         return dynamic_cast<LandmarkSearchQueueMessage*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
02753     #endif
02754     }
02755 
02756     ::IceInternal::ProxyHandle<LandmarkSearchQueueMessage> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
02757     {
02758     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02759         typedef ::IceProxy::Ice::Object _Base;
02760         return dynamic_cast<LandmarkSearchQueueMessage*>(_Base::ice_endpoints(__endpoints).get());
02761     #else
02762         return dynamic_cast<LandmarkSearchQueueMessage*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
02763     #endif
02764     }
02765 
02766     ::IceInternal::ProxyHandle<LandmarkSearchQueueMessage> ice_locatorCacheTimeout(int __timeout) const
02767     {
02768     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02769         typedef ::IceProxy::Ice::Object _Base;
02770         return dynamic_cast<LandmarkSearchQueueMessage*>(_Base::ice_locatorCacheTimeout(__timeout).get());
02771     #else
02772         return dynamic_cast<LandmarkSearchQueueMessage*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
02773     #endif
02774     }
02775 
02776     ::IceInternal::ProxyHandle<LandmarkSearchQueueMessage> ice_connectionCached(bool __cached) const
02777     {
02778     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02779         typedef ::IceProxy::Ice::Object _Base;
02780         return dynamic_cast<LandmarkSearchQueueMessage*>(_Base::ice_connectionCached(__cached).get());
02781     #else
02782         return dynamic_cast<LandmarkSearchQueueMessage*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
02783     #endif
02784     }
02785 
02786     ::IceInternal::ProxyHandle<LandmarkSearchQueueMessage> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
02787     {
02788     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02789         typedef ::IceProxy::Ice::Object _Base;
02790         return dynamic_cast<LandmarkSearchQueueMessage*>(_Base::ice_endpointSelection(__est).get());
02791     #else
02792         return dynamic_cast<LandmarkSearchQueueMessage*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
02793     #endif
02794     }
02795 
02796     ::IceInternal::ProxyHandle<LandmarkSearchQueueMessage> ice_secure(bool __secure) const
02797     {
02798     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02799         typedef ::IceProxy::Ice::Object _Base;
02800         return dynamic_cast<LandmarkSearchQueueMessage*>(_Base::ice_secure(__secure).get());
02801     #else
02802         return dynamic_cast<LandmarkSearchQueueMessage*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
02803     #endif
02804     }
02805 
02806     ::IceInternal::ProxyHandle<LandmarkSearchQueueMessage> ice_preferSecure(bool __preferSecure) const
02807     {
02808     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02809         typedef ::IceProxy::Ice::Object _Base;
02810         return dynamic_cast<LandmarkSearchQueueMessage*>(_Base::ice_preferSecure(__preferSecure).get());
02811     #else
02812         return dynamic_cast<LandmarkSearchQueueMessage*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
02813     #endif
02814     }
02815 
02816     ::IceInternal::ProxyHandle<LandmarkSearchQueueMessage> ice_router(const ::Ice::RouterPrx& __router) const
02817     {
02818     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02819         typedef ::IceProxy::Ice::Object _Base;
02820         return dynamic_cast<LandmarkSearchQueueMessage*>(_Base::ice_router(__router).get());
02821     #else
02822         return dynamic_cast<LandmarkSearchQueueMessage*>(::IceProxy::Ice::Object::ice_router(__router).get());
02823     #endif
02824     }
02825 
02826     ::IceInternal::ProxyHandle<LandmarkSearchQueueMessage> ice_locator(const ::Ice::LocatorPrx& __locator) const
02827     {
02828     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02829         typedef ::IceProxy::Ice::Object _Base;
02830         return dynamic_cast<LandmarkSearchQueueMessage*>(_Base::ice_locator(__locator).get());
02831     #else
02832         return dynamic_cast<LandmarkSearchQueueMessage*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
02833     #endif
02834     }
02835 
02836     ::IceInternal::ProxyHandle<LandmarkSearchQueueMessage> ice_collocationOptimized(bool __co) const
02837     {
02838     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02839         typedef ::IceProxy::Ice::Object _Base;
02840         return dynamic_cast<LandmarkSearchQueueMessage*>(_Base::ice_collocationOptimized(__co).get());
02841     #else
02842         return dynamic_cast<LandmarkSearchQueueMessage*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
02843     #endif
02844     }
02845 
02846     ::IceInternal::ProxyHandle<LandmarkSearchQueueMessage> ice_twoway() const
02847     {
02848     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02849         typedef ::IceProxy::Ice::Object _Base;
02850         return dynamic_cast<LandmarkSearchQueueMessage*>(_Base::ice_twoway().get());
02851     #else
02852         return dynamic_cast<LandmarkSearchQueueMessage*>(::IceProxy::Ice::Object::ice_twoway().get());
02853     #endif
02854     }
02855 
02856     ::IceInternal::ProxyHandle<LandmarkSearchQueueMessage> ice_oneway() const
02857     {
02858     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02859         typedef ::IceProxy::Ice::Object _Base;
02860         return dynamic_cast<LandmarkSearchQueueMessage*>(_Base::ice_oneway().get());
02861     #else
02862         return dynamic_cast<LandmarkSearchQueueMessage*>(::IceProxy::Ice::Object::ice_oneway().get());
02863     #endif
02864     }
02865 
02866     ::IceInternal::ProxyHandle<LandmarkSearchQueueMessage> ice_batchOneway() const
02867     {
02868     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02869         typedef ::IceProxy::Ice::Object _Base;
02870         return dynamic_cast<LandmarkSearchQueueMessage*>(_Base::ice_batchOneway().get());
02871     #else
02872         return dynamic_cast<LandmarkSearchQueueMessage*>(::IceProxy::Ice::Object::ice_batchOneway().get());
02873     #endif
02874     }
02875 
02876     ::IceInternal::ProxyHandle<LandmarkSearchQueueMessage> ice_datagram() const
02877     {
02878     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02879         typedef ::IceProxy::Ice::Object _Base;
02880         return dynamic_cast<LandmarkSearchQueueMessage*>(_Base::ice_datagram().get());
02881     #else
02882         return dynamic_cast<LandmarkSearchQueueMessage*>(::IceProxy::Ice::Object::ice_datagram().get());
02883     #endif
02884     }
02885 
02886     ::IceInternal::ProxyHandle<LandmarkSearchQueueMessage> ice_batchDatagram() const
02887     {
02888     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02889         typedef ::IceProxy::Ice::Object _Base;
02890         return dynamic_cast<LandmarkSearchQueueMessage*>(_Base::ice_batchDatagram().get());
02891     #else
02892         return dynamic_cast<LandmarkSearchQueueMessage*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
02893     #endif
02894     }
02895 
02896     ::IceInternal::ProxyHandle<LandmarkSearchQueueMessage> ice_compress(bool __compress) const
02897     {
02898     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02899         typedef ::IceProxy::Ice::Object _Base;
02900         return dynamic_cast<LandmarkSearchQueueMessage*>(_Base::ice_compress(__compress).get());
02901     #else
02902         return dynamic_cast<LandmarkSearchQueueMessage*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
02903     #endif
02904     }
02905 
02906     ::IceInternal::ProxyHandle<LandmarkSearchQueueMessage> ice_timeout(int __timeout) const
02907     {
02908     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02909         typedef ::IceProxy::Ice::Object _Base;
02910         return dynamic_cast<LandmarkSearchQueueMessage*>(_Base::ice_timeout(__timeout).get());
02911     #else
02912         return dynamic_cast<LandmarkSearchQueueMessage*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
02913     #endif
02914     }
02915 
02916     ::IceInternal::ProxyHandle<LandmarkSearchQueueMessage> ice_connectionId(const std::string& __id) const
02917     {
02918     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02919         typedef ::IceProxy::Ice::Object _Base;
02920         return dynamic_cast<LandmarkSearchQueueMessage*>(_Base::ice_connectionId(__id).get());
02921     #else
02922         return dynamic_cast<LandmarkSearchQueueMessage*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
02923     #endif
02924     }
02925 
02926     static const ::std::string& ice_staticId();
02927 
02928 private:
02929 
02930     virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
02931     virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
02932     virtual ::IceProxy::Ice::Object* __newInstance() const;
02933 };
02934 
02935 class LandmarkTrackMessage : virtual public ::IceProxy::RobotSimEvents::EventMessage
02936 {
02937 public:
02938 
02939     ::IceInternal::ProxyHandle<LandmarkTrackMessage> ice_context(const ::Ice::Context& __context) const
02940     {
02941     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02942         typedef ::IceProxy::Ice::Object _Base;
02943         return dynamic_cast<LandmarkTrackMessage*>(_Base::ice_context(__context).get());
02944     #else
02945         return dynamic_cast<LandmarkTrackMessage*>(::IceProxy::Ice::Object::ice_context(__context).get());
02946     #endif
02947     }
02948 
02949     ::IceInternal::ProxyHandle<LandmarkTrackMessage> ice_adapterId(const std::string& __id) const
02950     {
02951     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02952         typedef ::IceProxy::Ice::Object _Base;
02953         return dynamic_cast<LandmarkTrackMessage*>(_Base::ice_adapterId(__id).get());
02954     #else
02955         return dynamic_cast<LandmarkTrackMessage*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
02956     #endif
02957     }
02958 
02959     ::IceInternal::ProxyHandle<LandmarkTrackMessage> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
02960     {
02961     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02962         typedef ::IceProxy::Ice::Object _Base;
02963         return dynamic_cast<LandmarkTrackMessage*>(_Base::ice_endpoints(__endpoints).get());
02964     #else
02965         return dynamic_cast<LandmarkTrackMessage*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
02966     #endif
02967     }
02968 
02969     ::IceInternal::ProxyHandle<LandmarkTrackMessage> ice_locatorCacheTimeout(int __timeout) const
02970     {
02971     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02972         typedef ::IceProxy::Ice::Object _Base;
02973         return dynamic_cast<LandmarkTrackMessage*>(_Base::ice_locatorCacheTimeout(__timeout).get());
02974     #else
02975         return dynamic_cast<LandmarkTrackMessage*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
02976     #endif
02977     }
02978 
02979     ::IceInternal::ProxyHandle<LandmarkTrackMessage> ice_connectionCached(bool __cached) const
02980     {
02981     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02982         typedef ::IceProxy::Ice::Object _Base;
02983         return dynamic_cast<LandmarkTrackMessage*>(_Base::ice_connectionCached(__cached).get());
02984     #else
02985         return dynamic_cast<LandmarkTrackMessage*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
02986     #endif
02987     }
02988 
02989     ::IceInternal::ProxyHandle<LandmarkTrackMessage> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
02990     {
02991     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02992         typedef ::IceProxy::Ice::Object _Base;
02993         return dynamic_cast<LandmarkTrackMessage*>(_Base::ice_endpointSelection(__est).get());
02994     #else
02995         return dynamic_cast<LandmarkTrackMessage*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
02996     #endif
02997     }
02998 
02999     ::IceInternal::ProxyHandle<LandmarkTrackMessage> ice_secure(bool __secure) const
03000     {
03001     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03002         typedef ::IceProxy::Ice::Object _Base;
03003         return dynamic_cast<LandmarkTrackMessage*>(_Base::ice_secure(__secure).get());
03004     #else
03005         return dynamic_cast<LandmarkTrackMessage*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
03006     #endif
03007     }
03008 
03009     ::IceInternal::ProxyHandle<LandmarkTrackMessage> ice_preferSecure(bool __preferSecure) const
03010     {
03011     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03012         typedef ::IceProxy::Ice::Object _Base;
03013         return dynamic_cast<LandmarkTrackMessage*>(_Base::ice_preferSecure(__preferSecure).get());
03014     #else
03015         return dynamic_cast<LandmarkTrackMessage*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
03016     #endif
03017     }
03018 
03019     ::IceInternal::ProxyHandle<LandmarkTrackMessage> ice_router(const ::Ice::RouterPrx& __router) const
03020     {
03021     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03022         typedef ::IceProxy::Ice::Object _Base;
03023         return dynamic_cast<LandmarkTrackMessage*>(_Base::ice_router(__router).get());
03024     #else
03025         return dynamic_cast<LandmarkTrackMessage*>(::IceProxy::Ice::Object::ice_router(__router).get());
03026     #endif
03027     }
03028 
03029     ::IceInternal::ProxyHandle<LandmarkTrackMessage> ice_locator(const ::Ice::LocatorPrx& __locator) const
03030     {
03031     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03032         typedef ::IceProxy::Ice::Object _Base;
03033         return dynamic_cast<LandmarkTrackMessage*>(_Base::ice_locator(__locator).get());
03034     #else
03035         return dynamic_cast<LandmarkTrackMessage*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
03036     #endif
03037     }
03038 
03039     ::IceInternal::ProxyHandle<LandmarkTrackMessage> ice_collocationOptimized(bool __co) const
03040     {
03041     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03042         typedef ::IceProxy::Ice::Object _Base;
03043         return dynamic_cast<LandmarkTrackMessage*>(_Base::ice_collocationOptimized(__co).get());
03044     #else
03045         return dynamic_cast<LandmarkTrackMessage*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
03046     #endif
03047     }
03048 
03049     ::IceInternal::ProxyHandle<LandmarkTrackMessage> ice_twoway() const
03050     {
03051     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03052         typedef ::IceProxy::Ice::Object _Base;
03053         return dynamic_cast<LandmarkTrackMessage*>(_Base::ice_twoway().get());
03054     #else
03055         return dynamic_cast<LandmarkTrackMessage*>(::IceProxy::Ice::Object::ice_twoway().get());
03056     #endif
03057     }
03058 
03059     ::IceInternal::ProxyHandle<LandmarkTrackMessage> ice_oneway() const
03060     {
03061     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03062         typedef ::IceProxy::Ice::Object _Base;
03063         return dynamic_cast<LandmarkTrackMessage*>(_Base::ice_oneway().get());
03064     #else
03065         return dynamic_cast<LandmarkTrackMessage*>(::IceProxy::Ice::Object::ice_oneway().get());
03066     #endif
03067     }
03068 
03069     ::IceInternal::ProxyHandle<LandmarkTrackMessage> ice_batchOneway() const
03070     {
03071     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03072         typedef ::IceProxy::Ice::Object _Base;
03073         return dynamic_cast<LandmarkTrackMessage*>(_Base::ice_batchOneway().get());
03074     #else
03075         return dynamic_cast<LandmarkTrackMessage*>(::IceProxy::Ice::Object::ice_batchOneway().get());
03076     #endif
03077     }
03078 
03079     ::IceInternal::ProxyHandle<LandmarkTrackMessage> ice_datagram() const
03080     {
03081     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03082         typedef ::IceProxy::Ice::Object _Base;
03083         return dynamic_cast<LandmarkTrackMessage*>(_Base::ice_datagram().get());
03084     #else
03085         return dynamic_cast<LandmarkTrackMessage*>(::IceProxy::Ice::Object::ice_datagram().get());
03086     #endif
03087     }
03088 
03089     ::IceInternal::ProxyHandle<LandmarkTrackMessage> ice_batchDatagram() const
03090     {
03091     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03092         typedef ::IceProxy::Ice::Object _Base;
03093         return dynamic_cast<LandmarkTrackMessage*>(_Base::ice_batchDatagram().get());
03094     #else
03095         return dynamic_cast<LandmarkTrackMessage*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
03096     #endif
03097     }
03098 
03099     ::IceInternal::ProxyHandle<LandmarkTrackMessage> ice_compress(bool __compress) const
03100     {
03101     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03102         typedef ::IceProxy::Ice::Object _Base;
03103         return dynamic_cast<LandmarkTrackMessage*>(_Base::ice_compress(__compress).get());
03104     #else
03105         return dynamic_cast<LandmarkTrackMessage*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
03106     #endif
03107     }
03108 
03109     ::IceInternal::ProxyHandle<LandmarkTrackMessage> ice_timeout(int __timeout) const
03110     {
03111     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03112         typedef ::IceProxy::Ice::Object _Base;
03113         return dynamic_cast<LandmarkTrackMessage*>(_Base::ice_timeout(__timeout).get());
03114     #else
03115         return dynamic_cast<LandmarkTrackMessage*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
03116     #endif
03117     }
03118 
03119     ::IceInternal::ProxyHandle<LandmarkTrackMessage> ice_connectionId(const std::string& __id) const
03120     {
03121     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03122         typedef ::IceProxy::Ice::Object _Base;
03123         return dynamic_cast<LandmarkTrackMessage*>(_Base::ice_connectionId(__id).get());
03124     #else
03125         return dynamic_cast<LandmarkTrackMessage*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
03126     #endif
03127     }
03128 
03129     static const ::std::string& ice_staticId();
03130 
03131 private:
03132 
03133     virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
03134     virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
03135     virtual ::IceProxy::Ice::Object* __newInstance() const;
03136 };
03137 
03138 class LandmarkSearchStatMessage : virtual public ::IceProxy::RobotSimEvents::EventMessage
03139 {
03140 public:
03141 
03142     ::IceInternal::ProxyHandle<LandmarkSearchStatMessage> ice_context(const ::Ice::Context& __context) const
03143     {
03144     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03145         typedef ::IceProxy::Ice::Object _Base;
03146         return dynamic_cast<LandmarkSearchStatMessage*>(_Base::ice_context(__context).get());
03147     #else
03148         return dynamic_cast<LandmarkSearchStatMessage*>(::IceProxy::Ice::Object::ice_context(__context).get());
03149     #endif
03150     }
03151 
03152     ::IceInternal::ProxyHandle<LandmarkSearchStatMessage> ice_adapterId(const std::string& __id) const
03153     {
03154     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03155         typedef ::IceProxy::Ice::Object _Base;
03156         return dynamic_cast<LandmarkSearchStatMessage*>(_Base::ice_adapterId(__id).get());
03157     #else
03158         return dynamic_cast<LandmarkSearchStatMessage*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
03159     #endif
03160     }
03161 
03162     ::IceInternal::ProxyHandle<LandmarkSearchStatMessage> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
03163     {
03164     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03165         typedef ::IceProxy::Ice::Object _Base;
03166         return dynamic_cast<LandmarkSearchStatMessage*>(_Base::ice_endpoints(__endpoints).get());
03167     #else
03168         return dynamic_cast<LandmarkSearchStatMessage*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
03169     #endif
03170     }
03171 
03172     ::IceInternal::ProxyHandle<LandmarkSearchStatMessage> ice_locatorCacheTimeout(int __timeout) const
03173     {
03174     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03175         typedef ::IceProxy::Ice::Object _Base;
03176         return dynamic_cast<LandmarkSearchStatMessage*>(_Base::ice_locatorCacheTimeout(__timeout).get());
03177     #else
03178         return dynamic_cast<LandmarkSearchStatMessage*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
03179     #endif
03180     }
03181 
03182     ::IceInternal::ProxyHandle<LandmarkSearchStatMessage> ice_connectionCached(bool __cached) const
03183     {
03184     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03185         typedef ::IceProxy::Ice::Object _Base;
03186         return dynamic_cast<LandmarkSearchStatMessage*>(_Base::ice_connectionCached(__cached).get());
03187     #else
03188         return dynamic_cast<LandmarkSearchStatMessage*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
03189     #endif
03190     }
03191 
03192     ::IceInternal::ProxyHandle<LandmarkSearchStatMessage> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
03193     {
03194     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03195         typedef ::IceProxy::Ice::Object _Base;
03196         return dynamic_cast<LandmarkSearchStatMessage*>(_Base::ice_endpointSelection(__est).get());
03197     #else
03198         return dynamic_cast<LandmarkSearchStatMessage*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
03199     #endif
03200     }
03201 
03202     ::IceInternal::ProxyHandle<LandmarkSearchStatMessage> ice_secure(bool __secure) const
03203     {
03204     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03205         typedef ::IceProxy::Ice::Object _Base;
03206         return dynamic_cast<LandmarkSearchStatMessage*>(_Base::ice_secure(__secure).get());
03207     #else
03208         return dynamic_cast<LandmarkSearchStatMessage*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
03209     #endif
03210     }
03211 
03212     ::IceInternal::ProxyHandle<LandmarkSearchStatMessage> ice_preferSecure(bool __preferSecure) const
03213     {
03214     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03215         typedef ::IceProxy::Ice::Object _Base;
03216         return dynamic_cast<LandmarkSearchStatMessage*>(_Base::ice_preferSecure(__preferSecure).get());
03217     #else
03218         return dynamic_cast<LandmarkSearchStatMessage*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
03219     #endif
03220     }
03221 
03222     ::IceInternal::ProxyHandle<LandmarkSearchStatMessage> ice_router(const ::Ice::RouterPrx& __router) const
03223     {
03224     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03225         typedef ::IceProxy::Ice::Object _Base;
03226         return dynamic_cast<LandmarkSearchStatMessage*>(_Base::ice_router(__router).get());
03227     #else
03228         return dynamic_cast<LandmarkSearchStatMessage*>(::IceProxy::Ice::Object::ice_router(__router).get());
03229     #endif
03230     }
03231 
03232     ::IceInternal::ProxyHandle<LandmarkSearchStatMessage> ice_locator(const ::Ice::LocatorPrx& __locator) const
03233     {
03234     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03235         typedef ::IceProxy::Ice::Object _Base;
03236         return dynamic_cast<LandmarkSearchStatMessage*>(_Base::ice_locator(__locator).get());
03237     #else
03238         return dynamic_cast<LandmarkSearchStatMessage*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
03239     #endif
03240     }
03241 
03242     ::IceInternal::ProxyHandle<LandmarkSearchStatMessage> ice_collocationOptimized(bool __co) const
03243     {
03244     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03245         typedef ::IceProxy::Ice::Object _Base;
03246         return dynamic_cast<LandmarkSearchStatMessage*>(_Base::ice_collocationOptimized(__co).get());
03247     #else
03248         return dynamic_cast<LandmarkSearchStatMessage*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
03249     #endif
03250     }
03251 
03252     ::IceInternal::ProxyHandle<LandmarkSearchStatMessage> ice_twoway() const
03253     {
03254     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03255         typedef ::IceProxy::Ice::Object _Base;
03256         return dynamic_cast<LandmarkSearchStatMessage*>(_Base::ice_twoway().get());
03257     #else
03258         return dynamic_cast<LandmarkSearchStatMessage*>(::IceProxy::Ice::Object::ice_twoway().get());
03259     #endif
03260     }
03261 
03262     ::IceInternal::ProxyHandle<LandmarkSearchStatMessage> ice_oneway() const
03263     {
03264     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03265         typedef ::IceProxy::Ice::Object _Base;
03266         return dynamic_cast<LandmarkSearchStatMessage*>(_Base::ice_oneway().get());
03267     #else
03268         return dynamic_cast<LandmarkSearchStatMessage*>(::IceProxy::Ice::Object::ice_oneway().get());
03269     #endif
03270     }
03271 
03272     ::IceInternal::ProxyHandle<LandmarkSearchStatMessage> ice_batchOneway() const
03273     {
03274     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03275         typedef ::IceProxy::Ice::Object _Base;
03276         return dynamic_cast<LandmarkSearchStatMessage*>(_Base::ice_batchOneway().get());
03277     #else
03278         return dynamic_cast<LandmarkSearchStatMessage*>(::IceProxy::Ice::Object::ice_batchOneway().get());
03279     #endif
03280     }
03281 
03282     ::IceInternal::ProxyHandle<LandmarkSearchStatMessage> ice_datagram() const
03283     {
03284     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03285         typedef ::IceProxy::Ice::Object _Base;
03286         return dynamic_cast<LandmarkSearchStatMessage*>(_Base::ice_datagram().get());
03287     #else
03288         return dynamic_cast<LandmarkSearchStatMessage*>(::IceProxy::Ice::Object::ice_datagram().get());
03289     #endif
03290     }
03291 
03292     ::IceInternal::ProxyHandle<LandmarkSearchStatMessage> ice_batchDatagram() const
03293     {
03294     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03295         typedef ::IceProxy::Ice::Object _Base;
03296         return dynamic_cast<LandmarkSearchStatMessage*>(_Base::ice_batchDatagram().get());
03297     #else
03298         return dynamic_cast<LandmarkSearchStatMessage*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
03299     #endif
03300     }
03301 
03302     ::IceInternal::ProxyHandle<LandmarkSearchStatMessage> ice_compress(bool __compress) const
03303     {
03304     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03305         typedef ::IceProxy::Ice::Object _Base;
03306         return dynamic_cast<LandmarkSearchStatMessage*>(_Base::ice_compress(__compress).get());
03307     #else
03308         return dynamic_cast<LandmarkSearchStatMessage*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
03309     #endif
03310     }
03311 
03312     ::IceInternal::ProxyHandle<LandmarkSearchStatMessage> ice_timeout(int __timeout) const
03313     {
03314     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03315         typedef ::IceProxy::Ice::Object _Base;
03316         return dynamic_cast<LandmarkSearchStatMessage*>(_Base::ice_timeout(__timeout).get());
03317     #else
03318         return dynamic_cast<LandmarkSearchStatMessage*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
03319     #endif
03320     }
03321 
03322     ::IceInternal::ProxyHandle<LandmarkSearchStatMessage> ice_connectionId(const std::string& __id) const
03323     {
03324     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03325         typedef ::IceProxy::Ice::Object _Base;
03326         return dynamic_cast<LandmarkSearchStatMessage*>(_Base::ice_connectionId(__id).get());
03327     #else
03328         return dynamic_cast<LandmarkSearchStatMessage*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
03329     #endif
03330     }
03331 
03332     static const ::std::string& ice_staticId();
03333 
03334 private:
03335 
03336     virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
03337     virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
03338     virtual ::IceProxy::Ice::Object* __newInstance() const;
03339 };
03340 
03341 class LandmarkMatchResultMessage : virtual public ::IceProxy::RobotSimEvents::EventMessage
03342 {
03343 public:
03344 
03345     ::IceInternal::ProxyHandle<LandmarkMatchResultMessage> ice_context(const ::Ice::Context& __context) const
03346     {
03347     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03348         typedef ::IceProxy::Ice::Object _Base;
03349         return dynamic_cast<LandmarkMatchResultMessage*>(_Base::ice_context(__context).get());
03350     #else
03351         return dynamic_cast<LandmarkMatchResultMessage*>(::IceProxy::Ice::Object::ice_context(__context).get());
03352     #endif
03353     }
03354 
03355     ::IceInternal::ProxyHandle<LandmarkMatchResultMessage> ice_adapterId(const std::string& __id) const
03356     {
03357     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03358         typedef ::IceProxy::Ice::Object _Base;
03359         return dynamic_cast<LandmarkMatchResultMessage*>(_Base::ice_adapterId(__id).get());
03360     #else
03361         return dynamic_cast<LandmarkMatchResultMessage*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
03362     #endif
03363     }
03364 
03365     ::IceInternal::ProxyHandle<LandmarkMatchResultMessage> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
03366     {
03367     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03368         typedef ::IceProxy::Ice::Object _Base;
03369         return dynamic_cast<LandmarkMatchResultMessage*>(_Base::ice_endpoints(__endpoints).get());
03370     #else
03371         return dynamic_cast<LandmarkMatchResultMessage*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
03372     #endif
03373     }
03374 
03375     ::IceInternal::ProxyHandle<LandmarkMatchResultMessage> ice_locatorCacheTimeout(int __timeout) const
03376     {
03377     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03378         typedef ::IceProxy::Ice::Object _Base;
03379         return dynamic_cast<LandmarkMatchResultMessage*>(_Base::ice_locatorCacheTimeout(__timeout).get());
03380     #else
03381         return dynamic_cast<LandmarkMatchResultMessage*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
03382     #endif
03383     }
03384 
03385     ::IceInternal::ProxyHandle<LandmarkMatchResultMessage> ice_connectionCached(bool __cached) const
03386     {
03387     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03388         typedef ::IceProxy::Ice::Object _Base;
03389         return dynamic_cast<LandmarkMatchResultMessage*>(_Base::ice_connectionCached(__cached).get());
03390     #else
03391         return dynamic_cast<LandmarkMatchResultMessage*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
03392     #endif
03393     }
03394 
03395     ::IceInternal::ProxyHandle<LandmarkMatchResultMessage> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
03396     {
03397     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03398         typedef ::IceProxy::Ice::Object _Base;
03399         return dynamic_cast<LandmarkMatchResultMessage*>(_Base::ice_endpointSelection(__est).get());
03400     #else
03401         return dynamic_cast<LandmarkMatchResultMessage*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
03402     #endif
03403     }
03404 
03405     ::IceInternal::ProxyHandle<LandmarkMatchResultMessage> ice_secure(bool __secure) const
03406     {
03407     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03408         typedef ::IceProxy::Ice::Object _Base;
03409         return dynamic_cast<LandmarkMatchResultMessage*>(_Base::ice_secure(__secure).get());
03410     #else
03411         return dynamic_cast<LandmarkMatchResultMessage*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
03412     #endif
03413     }
03414 
03415     ::IceInternal::ProxyHandle<LandmarkMatchResultMessage> ice_preferSecure(bool __preferSecure) const
03416     {
03417     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03418         typedef ::IceProxy::Ice::Object _Base;
03419         return dynamic_cast<LandmarkMatchResultMessage*>(_Base::ice_preferSecure(__preferSecure).get());
03420     #else
03421         return dynamic_cast<LandmarkMatchResultMessage*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
03422     #endif
03423     }
03424 
03425     ::IceInternal::ProxyHandle<LandmarkMatchResultMessage> ice_router(const ::Ice::RouterPrx& __router) const
03426     {
03427     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03428         typedef ::IceProxy::Ice::Object _Base;
03429         return dynamic_cast<LandmarkMatchResultMessage*>(_Base::ice_router(__router).get());
03430     #else
03431         return dynamic_cast<LandmarkMatchResultMessage*>(::IceProxy::Ice::Object::ice_router(__router).get());
03432     #endif
03433     }
03434 
03435     ::IceInternal::ProxyHandle<LandmarkMatchResultMessage> ice_locator(const ::Ice::LocatorPrx& __locator) const
03436     {
03437     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03438         typedef ::IceProxy::Ice::Object _Base;
03439         return dynamic_cast<LandmarkMatchResultMessage*>(_Base::ice_locator(__locator).get());
03440     #else
03441         return dynamic_cast<LandmarkMatchResultMessage*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
03442     #endif
03443     }
03444 
03445     ::IceInternal::ProxyHandle<LandmarkMatchResultMessage> ice_collocationOptimized(bool __co) const
03446     {
03447     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03448         typedef ::IceProxy::Ice::Object _Base;
03449         return dynamic_cast<LandmarkMatchResultMessage*>(_Base::ice_collocationOptimized(__co).get());
03450     #else
03451         return dynamic_cast<LandmarkMatchResultMessage*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
03452     #endif
03453     }
03454 
03455     ::IceInternal::ProxyHandle<LandmarkMatchResultMessage> ice_twoway() const
03456     {
03457     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03458         typedef ::IceProxy::Ice::Object _Base;
03459         return dynamic_cast<LandmarkMatchResultMessage*>(_Base::ice_twoway().get());
03460     #else
03461         return dynamic_cast<LandmarkMatchResultMessage*>(::IceProxy::Ice::Object::ice_twoway().get());
03462     #endif
03463     }
03464 
03465     ::IceInternal::ProxyHandle<LandmarkMatchResultMessage> ice_oneway() const
03466     {
03467     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03468         typedef ::IceProxy::Ice::Object _Base;
03469         return dynamic_cast<LandmarkMatchResultMessage*>(_Base::ice_oneway().get());
03470     #else
03471         return dynamic_cast<LandmarkMatchResultMessage*>(::IceProxy::Ice::Object::ice_oneway().get());
03472     #endif
03473     }
03474 
03475     ::IceInternal::ProxyHandle<LandmarkMatchResultMessage> ice_batchOneway() const
03476     {
03477     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03478         typedef ::IceProxy::Ice::Object _Base;
03479         return dynamic_cast<LandmarkMatchResultMessage*>(_Base::ice_batchOneway().get());
03480     #else
03481         return dynamic_cast<LandmarkMatchResultMessage*>(::IceProxy::Ice::Object::ice_batchOneway().get());
03482     #endif
03483     }
03484 
03485     ::IceInternal::ProxyHandle<LandmarkMatchResultMessage> ice_datagram() const
03486     {
03487     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03488         typedef ::IceProxy::Ice::Object _Base;
03489         return dynamic_cast<LandmarkMatchResultMessage*>(_Base::ice_datagram().get());
03490     #else
03491         return dynamic_cast<LandmarkMatchResultMessage*>(::IceProxy::Ice::Object::ice_datagram().get());
03492     #endif
03493     }
03494 
03495     ::IceInternal::ProxyHandle<LandmarkMatchResultMessage> ice_batchDatagram() const
03496     {
03497     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03498         typedef ::IceProxy::Ice::Object _Base;
03499         return dynamic_cast<LandmarkMatchResultMessage*>(_Base::ice_batchDatagram().get());
03500     #else
03501         return dynamic_cast<LandmarkMatchResultMessage*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
03502     #endif
03503     }
03504 
03505     ::IceInternal::ProxyHandle<LandmarkMatchResultMessage> ice_compress(bool __compress) const
03506     {
03507     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03508         typedef ::IceProxy::Ice::Object _Base;
03509         return dynamic_cast<LandmarkMatchResultMessage*>(_Base::ice_compress(__compress).get());
03510     #else
03511         return dynamic_cast<LandmarkMatchResultMessage*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
03512     #endif
03513     }
03514 
03515     ::IceInternal::ProxyHandle<LandmarkMatchResultMessage> ice_timeout(int __timeout) const
03516     {
03517     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03518         typedef ::IceProxy::Ice::Object _Base;
03519         return dynamic_cast<LandmarkMatchResultMessage*>(_Base::ice_timeout(__timeout).get());
03520     #else
03521         return dynamic_cast<LandmarkMatchResultMessage*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
03522     #endif
03523     }
03524 
03525     ::IceInternal::ProxyHandle<LandmarkMatchResultMessage> ice_connectionId(const std::string& __id) const
03526     {
03527     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03528         typedef ::IceProxy::Ice::Object _Base;
03529         return dynamic_cast<LandmarkMatchResultMessage*>(_Base::ice_connectionId(__id).get());
03530     #else
03531         return dynamic_cast<LandmarkMatchResultMessage*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
03532     #endif
03533     }
03534 
03535     static const ::std::string& ice_staticId();
03536 
03537 private:
03538 
03539     virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
03540     virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
03541     virtual ::IceProxy::Ice::Object* __newInstance() const;
03542 };
03543 
03544 class LandmarkDBSearchResultMessage : virtual public ::IceProxy::RobotSimEvents::EventMessage
03545 {
03546 public:
03547 
03548     ::IceInternal::ProxyHandle<LandmarkDBSearchResultMessage> ice_context(const ::Ice::Context& __context) const
03549     {
03550     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03551         typedef ::IceProxy::Ice::Object _Base;
03552         return dynamic_cast<LandmarkDBSearchResultMessage*>(_Base::ice_context(__context).get());
03553     #else
03554         return dynamic_cast<LandmarkDBSearchResultMessage*>(::IceProxy::Ice::Object::ice_context(__context).get());
03555     #endif
03556     }
03557 
03558     ::IceInternal::ProxyHandle<LandmarkDBSearchResultMessage> ice_adapterId(const std::string& __id) const
03559     {
03560     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03561         typedef ::IceProxy::Ice::Object _Base;
03562         return dynamic_cast<LandmarkDBSearchResultMessage*>(_Base::ice_adapterId(__id).get());
03563     #else
03564         return dynamic_cast<LandmarkDBSearchResultMessage*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
03565     #endif
03566     }
03567 
03568     ::IceInternal::ProxyHandle<LandmarkDBSearchResultMessage> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
03569     {
03570     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03571         typedef ::IceProxy::Ice::Object _Base;
03572         return dynamic_cast<LandmarkDBSearchResultMessage*>(_Base::ice_endpoints(__endpoints).get());
03573     #else
03574         return dynamic_cast<LandmarkDBSearchResultMessage*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
03575     #endif
03576     }
03577 
03578     ::IceInternal::ProxyHandle<LandmarkDBSearchResultMessage> ice_locatorCacheTimeout(int __timeout) const
03579     {
03580     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03581         typedef ::IceProxy::Ice::Object _Base;
03582         return dynamic_cast<LandmarkDBSearchResultMessage*>(_Base::ice_locatorCacheTimeout(__timeout).get());
03583     #else
03584         return dynamic_cast<LandmarkDBSearchResultMessage*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
03585     #endif
03586     }
03587 
03588     ::IceInternal::ProxyHandle<LandmarkDBSearchResultMessage> ice_connectionCached(bool __cached) const
03589     {
03590     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03591         typedef ::IceProxy::Ice::Object _Base;
03592         return dynamic_cast<LandmarkDBSearchResultMessage*>(_Base::ice_connectionCached(__cached).get());
03593     #else
03594         return dynamic_cast<LandmarkDBSearchResultMessage*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
03595     #endif
03596     }
03597 
03598     ::IceInternal::ProxyHandle<LandmarkDBSearchResultMessage> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
03599     {
03600     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03601         typedef ::IceProxy::Ice::Object _Base;
03602         return dynamic_cast<LandmarkDBSearchResultMessage*>(_Base::ice_endpointSelection(__est).get());
03603     #else
03604         return dynamic_cast<LandmarkDBSearchResultMessage*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
03605     #endif
03606     }
03607 
03608     ::IceInternal::ProxyHandle<LandmarkDBSearchResultMessage> ice_secure(bool __secure) const
03609     {
03610     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03611         typedef ::IceProxy::Ice::Object _Base;
03612         return dynamic_cast<LandmarkDBSearchResultMessage*>(_Base::ice_secure(__secure).get());
03613     #else
03614         return dynamic_cast<LandmarkDBSearchResultMessage*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
03615     #endif
03616     }
03617 
03618     ::IceInternal::ProxyHandle<LandmarkDBSearchResultMessage> ice_preferSecure(bool __preferSecure) const
03619     {
03620     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03621         typedef ::IceProxy::Ice::Object _Base;
03622         return dynamic_cast<LandmarkDBSearchResultMessage*>(_Base::ice_preferSecure(__preferSecure).get());
03623     #else
03624         return dynamic_cast<LandmarkDBSearchResultMessage*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
03625     #endif
03626     }
03627 
03628     ::IceInternal::ProxyHandle<LandmarkDBSearchResultMessage> ice_router(const ::Ice::RouterPrx& __router) const
03629     {
03630     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03631         typedef ::IceProxy::Ice::Object _Base;
03632         return dynamic_cast<LandmarkDBSearchResultMessage*>(_Base::ice_router(__router).get());
03633     #else
03634         return dynamic_cast<LandmarkDBSearchResultMessage*>(::IceProxy::Ice::Object::ice_router(__router).get());
03635     #endif
03636     }
03637 
03638     ::IceInternal::ProxyHandle<LandmarkDBSearchResultMessage> ice_locator(const ::Ice::LocatorPrx& __locator) const
03639     {
03640     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03641         typedef ::IceProxy::Ice::Object _Base;
03642         return dynamic_cast<LandmarkDBSearchResultMessage*>(_Base::ice_locator(__locator).get());
03643     #else
03644         return dynamic_cast<LandmarkDBSearchResultMessage*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
03645     #endif
03646     }
03647 
03648     ::IceInternal::ProxyHandle<LandmarkDBSearchResultMessage> ice_collocationOptimized(bool __co) const
03649     {
03650     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03651         typedef ::IceProxy::Ice::Object _Base;
03652         return dynamic_cast<LandmarkDBSearchResultMessage*>(_Base::ice_collocationOptimized(__co).get());
03653     #else
03654         return dynamic_cast<LandmarkDBSearchResultMessage*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
03655     #endif
03656     }
03657 
03658     ::IceInternal::ProxyHandle<LandmarkDBSearchResultMessage> ice_twoway() const
03659     {
03660     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03661         typedef ::IceProxy::Ice::Object _Base;
03662         return dynamic_cast<LandmarkDBSearchResultMessage*>(_Base::ice_twoway().get());
03663     #else
03664         return dynamic_cast<LandmarkDBSearchResultMessage*>(::IceProxy::Ice::Object::ice_twoway().get());
03665     #endif
03666     }
03667 
03668     ::IceInternal::ProxyHandle<LandmarkDBSearchResultMessage> ice_oneway() const
03669     {
03670     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03671         typedef ::IceProxy::Ice::Object _Base;
03672         return dynamic_cast<LandmarkDBSearchResultMessage*>(_Base::ice_oneway().get());
03673     #else
03674         return dynamic_cast<LandmarkDBSearchResultMessage*>(::IceProxy::Ice::Object::ice_oneway().get());
03675     #endif
03676     }
03677 
03678     ::IceInternal::ProxyHandle<LandmarkDBSearchResultMessage> ice_batchOneway() const
03679     {
03680     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03681         typedef ::IceProxy::Ice::Object _Base;
03682         return dynamic_cast<LandmarkDBSearchResultMessage*>(_Base::ice_batchOneway().get());
03683     #else
03684         return dynamic_cast<LandmarkDBSearchResultMessage*>(::IceProxy::Ice::Object::ice_batchOneway().get());
03685     #endif
03686     }
03687 
03688     ::IceInternal::ProxyHandle<LandmarkDBSearchResultMessage> ice_datagram() const
03689     {
03690     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03691         typedef ::IceProxy::Ice::Object _Base;
03692         return dynamic_cast<LandmarkDBSearchResultMessage*>(_Base::ice_datagram().get());
03693     #else
03694         return dynamic_cast<LandmarkDBSearchResultMessage*>(::IceProxy::Ice::Object::ice_datagram().get());
03695     #endif
03696     }
03697 
03698     ::IceInternal::ProxyHandle<LandmarkDBSearchResultMessage> ice_batchDatagram() const
03699     {
03700     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03701         typedef ::IceProxy::Ice::Object _Base;
03702         return dynamic_cast<LandmarkDBSearchResultMessage*>(_Base::ice_batchDatagram().get());
03703     #else
03704         return dynamic_cast<LandmarkDBSearchResultMessage*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
03705     #endif
03706     }
03707 
03708     ::IceInternal::ProxyHandle<LandmarkDBSearchResultMessage> ice_compress(bool __compress) const
03709     {
03710     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03711         typedef ::IceProxy::Ice::Object _Base;
03712         return dynamic_cast<LandmarkDBSearchResultMessage*>(_Base::ice_compress(__compress).get());
03713     #else
03714         return dynamic_cast<LandmarkDBSearchResultMessage*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
03715     #endif
03716     }
03717 
03718     ::IceInternal::ProxyHandle<LandmarkDBSearchResultMessage> ice_timeout(int __timeout) const
03719     {
03720     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03721         typedef ::IceProxy::Ice::Object _Base;
03722         return dynamic_cast<LandmarkDBSearchResultMessage*>(_Base::ice_timeout(__timeout).get());
03723     #else
03724         return dynamic_cast<LandmarkDBSearchResultMessage*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
03725     #endif
03726     }
03727 
03728     ::IceInternal::ProxyHandle<LandmarkDBSearchResultMessage> ice_connectionId(const std::string& __id) const
03729     {
03730     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03731         typedef ::IceProxy::Ice::Object _Base;
03732         return dynamic_cast<LandmarkDBSearchResultMessage*>(_Base::ice_connectionId(__id).get());
03733     #else
03734         return dynamic_cast<LandmarkDBSearchResultMessage*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
03735     #endif
03736     }
03737 
03738     static const ::std::string& ice_staticId();
03739 
03740 private:
03741 
03742     virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
03743     virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
03744     virtual ::IceProxy::Ice::Object* __newInstance() const;
03745 };
03746 
03747 class CurrentLocationMessage : virtual public ::IceProxy::RobotSimEvents::EventMessage
03748 {
03749 public:
03750 
03751     ::IceInternal::ProxyHandle<CurrentLocationMessage> ice_context(const ::Ice::Context& __context) const
03752     {
03753     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03754         typedef ::IceProxy::Ice::Object _Base;
03755         return dynamic_cast<CurrentLocationMessage*>(_Base::ice_context(__context).get());
03756     #else
03757         return dynamic_cast<CurrentLocationMessage*>(::IceProxy::Ice::Object::ice_context(__context).get());
03758     #endif
03759     }
03760 
03761     ::IceInternal::ProxyHandle<CurrentLocationMessage> ice_adapterId(const std::string& __id) const
03762     {
03763     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03764         typedef ::IceProxy::Ice::Object _Base;
03765         return dynamic_cast<CurrentLocationMessage*>(_Base::ice_adapterId(__id).get());
03766     #else
03767         return dynamic_cast<CurrentLocationMessage*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
03768     #endif
03769     }
03770 
03771     ::IceInternal::ProxyHandle<CurrentLocationMessage> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
03772     {
03773     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03774         typedef ::IceProxy::Ice::Object _Base;
03775         return dynamic_cast<CurrentLocationMessage*>(_Base::ice_endpoints(__endpoints).get());
03776     #else
03777         return dynamic_cast<CurrentLocationMessage*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
03778     #endif
03779     }
03780 
03781     ::IceInternal::ProxyHandle<CurrentLocationMessage> ice_locatorCacheTimeout(int __timeout) const
03782     {
03783     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03784         typedef ::IceProxy::Ice::Object _Base;
03785         return dynamic_cast<CurrentLocationMessage*>(_Base::ice_locatorCacheTimeout(__timeout).get());
03786     #else
03787         return dynamic_cast<CurrentLocationMessage*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
03788     #endif
03789     }
03790 
03791     ::IceInternal::ProxyHandle<CurrentLocationMessage> ice_connectionCached(bool __cached) const
03792     {
03793     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03794         typedef ::IceProxy::Ice::Object _Base;
03795         return dynamic_cast<CurrentLocationMessage*>(_Base::ice_connectionCached(__cached).get());
03796     #else
03797         return dynamic_cast<CurrentLocationMessage*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
03798     #endif
03799     }
03800 
03801     ::IceInternal::ProxyHandle<CurrentLocationMessage> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
03802     {
03803     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03804         typedef ::IceProxy::Ice::Object _Base;
03805         return dynamic_cast<CurrentLocationMessage*>(_Base::ice_endpointSelection(__est).get());
03806     #else
03807         return dynamic_cast<CurrentLocationMessage*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
03808     #endif
03809     }
03810 
03811     ::IceInternal::ProxyHandle<CurrentLocationMessage> ice_secure(bool __secure) const
03812     {
03813     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03814         typedef ::IceProxy::Ice::Object _Base;
03815         return dynamic_cast<CurrentLocationMessage*>(_Base::ice_secure(__secure).get());
03816     #else
03817         return dynamic_cast<CurrentLocationMessage*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
03818     #endif
03819     }
03820 
03821     ::IceInternal::ProxyHandle<CurrentLocationMessage> ice_preferSecure(bool __preferSecure) const
03822     {
03823     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03824         typedef ::IceProxy::Ice::Object _Base;
03825         return dynamic_cast<CurrentLocationMessage*>(_Base::ice_preferSecure(__preferSecure).get());
03826     #else
03827         return dynamic_cast<CurrentLocationMessage*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
03828     #endif
03829     }
03830 
03831     ::IceInternal::ProxyHandle<CurrentLocationMessage> ice_router(const ::Ice::RouterPrx& __router) const
03832     {
03833     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03834         typedef ::IceProxy::Ice::Object _Base;
03835         return dynamic_cast<CurrentLocationMessage*>(_Base::ice_router(__router).get());
03836     #else
03837         return dynamic_cast<CurrentLocationMessage*>(::IceProxy::Ice::Object::ice_router(__router).get());
03838     #endif
03839     }
03840 
03841     ::IceInternal::ProxyHandle<CurrentLocationMessage> ice_locator(const ::Ice::LocatorPrx& __locator) const
03842     {
03843     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03844         typedef ::IceProxy::Ice::Object _Base;
03845         return dynamic_cast<CurrentLocationMessage*>(_Base::ice_locator(__locator).get());
03846     #else
03847         return dynamic_cast<CurrentLocationMessage*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
03848     #endif
03849     }
03850 
03851     ::IceInternal::ProxyHandle<CurrentLocationMessage> ice_collocationOptimized(bool __co) const
03852     {
03853     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03854         typedef ::IceProxy::Ice::Object _Base;
03855         return dynamic_cast<CurrentLocationMessage*>(_Base::ice_collocationOptimized(__co).get());
03856     #else
03857         return dynamic_cast<CurrentLocationMessage*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
03858     #endif
03859     }
03860 
03861     ::IceInternal::ProxyHandle<CurrentLocationMessage> ice_twoway() const
03862     {
03863     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03864         typedef ::IceProxy::Ice::Object _Base;
03865         return dynamic_cast<CurrentLocationMessage*>(_Base::ice_twoway().get());
03866     #else
03867         return dynamic_cast<CurrentLocationMessage*>(::IceProxy::Ice::Object::ice_twoway().get());
03868     #endif
03869     }
03870 
03871     ::IceInternal::ProxyHandle<CurrentLocationMessage> ice_oneway() const
03872     {
03873     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03874         typedef ::IceProxy::Ice::Object _Base;
03875         return dynamic_cast<CurrentLocationMessage*>(_Base::ice_oneway().get());
03876     #else
03877         return dynamic_cast<CurrentLocationMessage*>(::IceProxy::Ice::Object::ice_oneway().get());
03878     #endif
03879     }
03880 
03881     ::IceInternal::ProxyHandle<CurrentLocationMessage> ice_batchOneway() const
03882     {
03883     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03884         typedef ::IceProxy::Ice::Object _Base;
03885         return dynamic_cast<CurrentLocationMessage*>(_Base::ice_batchOneway().get());
03886     #else
03887         return dynamic_cast<CurrentLocationMessage*>(::IceProxy::Ice::Object::ice_batchOneway().get());
03888     #endif
03889     }
03890 
03891     ::IceInternal::ProxyHandle<CurrentLocationMessage> ice_datagram() const
03892     {
03893     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03894         typedef ::IceProxy::Ice::Object _Base;
03895         return dynamic_cast<CurrentLocationMessage*>(_Base::ice_datagram().get());
03896     #else
03897         return dynamic_cast<CurrentLocationMessage*>(::IceProxy::Ice::Object::ice_datagram().get());
03898     #endif
03899     }
03900 
03901     ::IceInternal::ProxyHandle<CurrentLocationMessage> ice_batchDatagram() const
03902     {
03903     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03904         typedef ::IceProxy::Ice::Object _Base;
03905         return dynamic_cast<CurrentLocationMessage*>(_Base::ice_batchDatagram().get());
03906     #else
03907         return dynamic_cast<CurrentLocationMessage*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
03908     #endif
03909     }
03910 
03911     ::IceInternal::ProxyHandle<CurrentLocationMessage> ice_compress(bool __compress) const
03912     {
03913     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03914         typedef ::IceProxy::Ice::Object _Base;
03915         return dynamic_cast<CurrentLocationMessage*>(_Base::ice_compress(__compress).get());
03916     #else
03917         return dynamic_cast<CurrentLocationMessage*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
03918     #endif
03919     }
03920 
03921     ::IceInternal::ProxyHandle<CurrentLocationMessage> ice_timeout(int __timeout) const
03922     {
03923     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03924         typedef ::IceProxy::Ice::Object _Base;
03925         return dynamic_cast<CurrentLocationMessage*>(_Base::ice_timeout(__timeout).get());
03926     #else
03927         return dynamic_cast<CurrentLocationMessage*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
03928     #endif
03929     }
03930 
03931     ::IceInternal::ProxyHandle<CurrentLocationMessage> ice_connectionId(const std::string& __id) const
03932     {
03933     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03934         typedef ::IceProxy::Ice::Object _Base;
03935         return dynamic_cast<CurrentLocationMessage*>(_Base::ice_connectionId(__id).get());
03936     #else
03937         return dynamic_cast<CurrentLocationMessage*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
03938     #endif
03939     }
03940 
03941     static const ::std::string& ice_staticId();
03942 
03943 private:
03944 
03945     virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
03946     virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
03947     virtual ::IceProxy::Ice::Object* __newInstance() const;
03948 };
03949 
03950 class CancelSearchMessage : virtual public ::IceProxy::RobotSimEvents::EventMessage
03951 {
03952 public:
03953 
03954     ::IceInternal::ProxyHandle<CancelSearchMessage> ice_context(const ::Ice::Context& __context) const
03955     {
03956     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03957         typedef ::IceProxy::Ice::Object _Base;
03958         return dynamic_cast<CancelSearchMessage*>(_Base::ice_context(__context).get());
03959     #else
03960         return dynamic_cast<CancelSearchMessage*>(::IceProxy::Ice::Object::ice_context(__context).get());
03961     #endif
03962     }
03963 
03964     ::IceInternal::ProxyHandle<CancelSearchMessage> ice_adapterId(const std::string& __id) const
03965     {
03966     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03967         typedef ::IceProxy::Ice::Object _Base;
03968         return dynamic_cast<CancelSearchMessage*>(_Base::ice_adapterId(__id).get());
03969     #else
03970         return dynamic_cast<CancelSearchMessage*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
03971     #endif
03972     }
03973 
03974     ::IceInternal::ProxyHandle<CancelSearchMessage> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
03975     {
03976     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03977         typedef ::IceProxy::Ice::Object _Base;
03978         return dynamic_cast<CancelSearchMessage*>(_Base::ice_endpoints(__endpoints).get());
03979     #else
03980         return dynamic_cast<CancelSearchMessage*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
03981     #endif
03982     }
03983 
03984     ::IceInternal::ProxyHandle<CancelSearchMessage> ice_locatorCacheTimeout(int __timeout) const
03985     {
03986     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03987         typedef ::IceProxy::Ice::Object _Base;
03988         return dynamic_cast<CancelSearchMessage*>(_Base::ice_locatorCacheTimeout(__timeout).get());
03989     #else
03990         return dynamic_cast<CancelSearchMessage*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
03991     #endif
03992     }
03993 
03994     ::IceInternal::ProxyHandle<CancelSearchMessage> ice_connectionCached(bool __cached) const
03995     {
03996     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03997         typedef ::IceProxy::Ice::Object _Base;
03998         return dynamic_cast<CancelSearchMessage*>(_Base::ice_connectionCached(__cached).get());
03999     #else
04000         return dynamic_cast<CancelSearchMessage*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
04001     #endif
04002     }
04003 
04004     ::IceInternal::ProxyHandle<CancelSearchMessage> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
04005     {
04006     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04007         typedef ::IceProxy::Ice::Object _Base;
04008         return dynamic_cast<CancelSearchMessage*>(_Base::ice_endpointSelection(__est).get());
04009     #else
04010         return dynamic_cast<CancelSearchMessage*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
04011     #endif
04012     }
04013 
04014     ::IceInternal::ProxyHandle<CancelSearchMessage> ice_secure(bool __secure) const
04015     {
04016     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04017         typedef ::IceProxy::Ice::Object _Base;
04018         return dynamic_cast<CancelSearchMessage*>(_Base::ice_secure(__secure).get());
04019     #else
04020         return dynamic_cast<CancelSearchMessage*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
04021     #endif
04022     }
04023 
04024     ::IceInternal::ProxyHandle<CancelSearchMessage> ice_preferSecure(bool __preferSecure) const
04025     {
04026     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04027         typedef ::IceProxy::Ice::Object _Base;
04028         return dynamic_cast<CancelSearchMessage*>(_Base::ice_preferSecure(__preferSecure).get());
04029     #else
04030         return dynamic_cast<CancelSearchMessage*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
04031     #endif
04032     }
04033 
04034     ::IceInternal::ProxyHandle<CancelSearchMessage> ice_router(const ::Ice::RouterPrx& __router) const
04035     {
04036     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04037         typedef ::IceProxy::Ice::Object _Base;
04038         return dynamic_cast<CancelSearchMessage*>(_Base::ice_router(__router).get());
04039     #else
04040         return dynamic_cast<CancelSearchMessage*>(::IceProxy::Ice::Object::ice_router(__router).get());
04041     #endif
04042     }
04043 
04044     ::IceInternal::ProxyHandle<CancelSearchMessage> ice_locator(const ::Ice::LocatorPrx& __locator) const
04045     {
04046     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04047         typedef ::IceProxy::Ice::Object _Base;
04048         return dynamic_cast<CancelSearchMessage*>(_Base::ice_locator(__locator).get());
04049     #else
04050         return dynamic_cast<CancelSearchMessage*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
04051     #endif
04052     }
04053 
04054     ::IceInternal::ProxyHandle<CancelSearchMessage> ice_collocationOptimized(bool __co) const
04055     {
04056     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04057         typedef ::IceProxy::Ice::Object _Base;
04058         return dynamic_cast<CancelSearchMessage*>(_Base::ice_collocationOptimized(__co).get());
04059     #else
04060         return dynamic_cast<CancelSearchMessage*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
04061     #endif
04062     }
04063 
04064     ::IceInternal::ProxyHandle<CancelSearchMessage> ice_twoway() const
04065     {
04066     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04067         typedef ::IceProxy::Ice::Object _Base;
04068         return dynamic_cast<CancelSearchMessage*>(_Base::ice_twoway().get());
04069     #else
04070         return dynamic_cast<CancelSearchMessage*>(::IceProxy::Ice::Object::ice_twoway().get());
04071     #endif
04072     }
04073 
04074     ::IceInternal::ProxyHandle<CancelSearchMessage> ice_oneway() const
04075     {
04076     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04077         typedef ::IceProxy::Ice::Object _Base;
04078         return dynamic_cast<CancelSearchMessage*>(_Base::ice_oneway().get());
04079     #else
04080         return dynamic_cast<CancelSearchMessage*>(::IceProxy::Ice::Object::ice_oneway().get());
04081     #endif
04082     }
04083 
04084     ::IceInternal::ProxyHandle<CancelSearchMessage> ice_batchOneway() const
04085     {
04086     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04087         typedef ::IceProxy::Ice::Object _Base;
04088         return dynamic_cast<CancelSearchMessage*>(_Base::ice_batchOneway().get());
04089     #else
04090         return dynamic_cast<CancelSearchMessage*>(::IceProxy::Ice::Object::ice_batchOneway().get());
04091     #endif
04092     }
04093 
04094     ::IceInternal::ProxyHandle<CancelSearchMessage> ice_datagram() const
04095     {
04096     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04097         typedef ::IceProxy::Ice::Object _Base;
04098         return dynamic_cast<CancelSearchMessage*>(_Base::ice_datagram().get());
04099     #else
04100         return dynamic_cast<CancelSearchMessage*>(::IceProxy::Ice::Object::ice_datagram().get());
04101     #endif
04102     }
04103 
04104     ::IceInternal::ProxyHandle<CancelSearchMessage> ice_batchDatagram() const
04105     {
04106     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04107         typedef ::IceProxy::Ice::Object _Base;
04108         return dynamic_cast<CancelSearchMessage*>(_Base::ice_batchDatagram().get());
04109     #else
04110         return dynamic_cast<CancelSearchMessage*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
04111     #endif
04112     }
04113 
04114     ::IceInternal::ProxyHandle<CancelSearchMessage> ice_compress(bool __compress) const
04115     {
04116     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04117         typedef ::IceProxy::Ice::Object _Base;
04118         return dynamic_cast<CancelSearchMessage*>(_Base::ice_compress(__compress).get());
04119     #else
04120         return dynamic_cast<CancelSearchMessage*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
04121     #endif
04122     }
04123 
04124     ::IceInternal::ProxyHandle<CancelSearchMessage> ice_timeout(int __timeout) const
04125     {
04126     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04127         typedef ::IceProxy::Ice::Object _Base;
04128         return dynamic_cast<CancelSearchMessage*>(_Base::ice_timeout(__timeout).get());
04129     #else
04130         return dynamic_cast<CancelSearchMessage*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
04131     #endif
04132     }
04133 
04134     ::IceInternal::ProxyHandle<CancelSearchMessage> ice_connectionId(const std::string& __id) const
04135     {
04136     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04137         typedef ::IceProxy::Ice::Object _Base;
04138         return dynamic_cast<CancelSearchMessage*>(_Base::ice_connectionId(__id).get());
04139     #else
04140         return dynamic_cast<CancelSearchMessage*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
04141     #endif
04142     }
04143 
04144     static const ::std::string& ice_staticId();
04145 
04146 private:
04147 
04148     virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
04149     virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
04150     virtual ::IceProxy::Ice::Object* __newInstance() const;
04151 };
04152 
04153 class SearchDoneMessage : virtual public ::IceProxy::RobotSimEvents::EventMessage
04154 {
04155 public:
04156 
04157     ::IceInternal::ProxyHandle<SearchDoneMessage> ice_context(const ::Ice::Context& __context) const
04158     {
04159     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04160         typedef ::IceProxy::Ice::Object _Base;
04161         return dynamic_cast<SearchDoneMessage*>(_Base::ice_context(__context).get());
04162     #else
04163         return dynamic_cast<SearchDoneMessage*>(::IceProxy::Ice::Object::ice_context(__context).get());
04164     #endif
04165     }
04166 
04167     ::IceInternal::ProxyHandle<SearchDoneMessage> ice_adapterId(const std::string& __id) const
04168     {
04169     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04170         typedef ::IceProxy::Ice::Object _Base;
04171         return dynamic_cast<SearchDoneMessage*>(_Base::ice_adapterId(__id).get());
04172     #else
04173         return dynamic_cast<SearchDoneMessage*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
04174     #endif
04175     }
04176 
04177     ::IceInternal::ProxyHandle<SearchDoneMessage> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
04178     {
04179     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04180         typedef ::IceProxy::Ice::Object _Base;
04181         return dynamic_cast<SearchDoneMessage*>(_Base::ice_endpoints(__endpoints).get());
04182     #else
04183         return dynamic_cast<SearchDoneMessage*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
04184     #endif
04185     }
04186 
04187     ::IceInternal::ProxyHandle<SearchDoneMessage> ice_locatorCacheTimeout(int __timeout) const
04188     {
04189     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04190         typedef ::IceProxy::Ice::Object _Base;
04191         return dynamic_cast<SearchDoneMessage*>(_Base::ice_locatorCacheTimeout(__timeout).get());
04192     #else
04193         return dynamic_cast<SearchDoneMessage*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
04194     #endif
04195     }
04196 
04197     ::IceInternal::ProxyHandle<SearchDoneMessage> ice_connectionCached(bool __cached) const
04198     {
04199     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04200         typedef ::IceProxy::Ice::Object _Base;
04201         return dynamic_cast<SearchDoneMessage*>(_Base::ice_connectionCached(__cached).get());
04202     #else
04203         return dynamic_cast<SearchDoneMessage*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
04204     #endif
04205     }
04206 
04207     ::IceInternal::ProxyHandle<SearchDoneMessage> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
04208     {
04209     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04210         typedef ::IceProxy::Ice::Object _Base;
04211         return dynamic_cast<SearchDoneMessage*>(_Base::ice_endpointSelection(__est).get());
04212     #else
04213         return dynamic_cast<SearchDoneMessage*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
04214     #endif
04215     }
04216 
04217     ::IceInternal::ProxyHandle<SearchDoneMessage> ice_secure(bool __secure) const
04218     {
04219     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04220         typedef ::IceProxy::Ice::Object _Base;
04221         return dynamic_cast<SearchDoneMessage*>(_Base::ice_secure(__secure).get());
04222     #else
04223         return dynamic_cast<SearchDoneMessage*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
04224     #endif
04225     }
04226 
04227     ::IceInternal::ProxyHandle<SearchDoneMessage> ice_preferSecure(bool __preferSecure) const
04228     {
04229     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04230         typedef ::IceProxy::Ice::Object _Base;
04231         return dynamic_cast<SearchDoneMessage*>(_Base::ice_preferSecure(__preferSecure).get());
04232     #else
04233         return dynamic_cast<SearchDoneMessage*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
04234     #endif
04235     }
04236 
04237     ::IceInternal::ProxyHandle<SearchDoneMessage> ice_router(const ::Ice::RouterPrx& __router) const
04238     {
04239     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04240         typedef ::IceProxy::Ice::Object _Base;
04241         return dynamic_cast<SearchDoneMessage*>(_Base::ice_router(__router).get());
04242     #else
04243         return dynamic_cast<SearchDoneMessage*>(::IceProxy::Ice::Object::ice_router(__router).get());
04244     #endif
04245     }
04246 
04247     ::IceInternal::ProxyHandle<SearchDoneMessage> ice_locator(const ::Ice::LocatorPrx& __locator) const
04248     {
04249     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04250         typedef ::IceProxy::Ice::Object _Base;
04251         return dynamic_cast<SearchDoneMessage*>(_Base::ice_locator(__locator).get());
04252     #else
04253         return dynamic_cast<SearchDoneMessage*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
04254     #endif
04255     }
04256 
04257     ::IceInternal::ProxyHandle<SearchDoneMessage> ice_collocationOptimized(bool __co) const
04258     {
04259     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04260         typedef ::IceProxy::Ice::Object _Base;
04261         return dynamic_cast<SearchDoneMessage*>(_Base::ice_collocationOptimized(__co).get());
04262     #else
04263         return dynamic_cast<SearchDoneMessage*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
04264     #endif
04265     }
04266 
04267     ::IceInternal::ProxyHandle<SearchDoneMessage> ice_twoway() const
04268     {
04269     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04270         typedef ::IceProxy::Ice::Object _Base;
04271         return dynamic_cast<SearchDoneMessage*>(_Base::ice_twoway().get());
04272     #else
04273         return dynamic_cast<SearchDoneMessage*>(::IceProxy::Ice::Object::ice_twoway().get());
04274     #endif
04275     }
04276 
04277     ::IceInternal::ProxyHandle<SearchDoneMessage> ice_oneway() const
04278     {
04279     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04280         typedef ::IceProxy::Ice::Object _Base;
04281         return dynamic_cast<SearchDoneMessage*>(_Base::ice_oneway().get());
04282     #else
04283         return dynamic_cast<SearchDoneMessage*>(::IceProxy::Ice::Object::ice_oneway().get());
04284     #endif
04285     }
04286 
04287     ::IceInternal::ProxyHandle<SearchDoneMessage> ice_batchOneway() const
04288     {
04289     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04290         typedef ::IceProxy::Ice::Object _Base;
04291         return dynamic_cast<SearchDoneMessage*>(_Base::ice_batchOneway().get());
04292     #else
04293         return dynamic_cast<SearchDoneMessage*>(::IceProxy::Ice::Object::ice_batchOneway().get());
04294     #endif
04295     }
04296 
04297     ::IceInternal::ProxyHandle<SearchDoneMessage> ice_datagram() const
04298     {
04299     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04300         typedef ::IceProxy::Ice::Object _Base;
04301         return dynamic_cast<SearchDoneMessage*>(_Base::ice_datagram().get());
04302     #else
04303         return dynamic_cast<SearchDoneMessage*>(::IceProxy::Ice::Object::ice_datagram().get());
04304     #endif
04305     }
04306 
04307     ::IceInternal::ProxyHandle<SearchDoneMessage> ice_batchDatagram() const
04308     {
04309     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04310         typedef ::IceProxy::Ice::Object _Base;
04311         return dynamic_cast<SearchDoneMessage*>(_Base::ice_batchDatagram().get());
04312     #else
04313         return dynamic_cast<SearchDoneMessage*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
04314     #endif
04315     }
04316 
04317     ::IceInternal::ProxyHandle<SearchDoneMessage> ice_compress(bool __compress) const
04318     {
04319     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04320         typedef ::IceProxy::Ice::Object _Base;
04321         return dynamic_cast<SearchDoneMessage*>(_Base::ice_compress(__compress).get());
04322     #else
04323         return dynamic_cast<SearchDoneMessage*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
04324     #endif
04325     }
04326 
04327     ::IceInternal::ProxyHandle<SearchDoneMessage> ice_timeout(int __timeout) const
04328     {
04329     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04330         typedef ::IceProxy::Ice::Object _Base;
04331         return dynamic_cast<SearchDoneMessage*>(_Base::ice_timeout(__timeout).get());
04332     #else
04333         return dynamic_cast<SearchDoneMessage*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
04334     #endif
04335     }
04336 
04337     ::IceInternal::ProxyHandle<SearchDoneMessage> ice_connectionId(const std::string& __id) const
04338     {
04339     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04340         typedef ::IceProxy::Ice::Object _Base;
04341         return dynamic_cast<SearchDoneMessage*>(_Base::ice_connectionId(__id).get());
04342     #else
04343         return dynamic_cast<SearchDoneMessage*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
04344     #endif
04345     }
04346 
04347     static const ::std::string& ice_staticId();
04348 
04349 private:
04350 
04351     virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
04352     virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
04353     virtual ::IceProxy::Ice::Object* __newInstance() const;
04354 };
04355 
04356 class NextFrameMessage : virtual public ::IceProxy::RobotSimEvents::EventMessage
04357 {
04358 public:
04359 
04360     ::IceInternal::ProxyHandle<NextFrameMessage> ice_context(const ::Ice::Context& __context) const
04361     {
04362     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04363         typedef ::IceProxy::Ice::Object _Base;
04364         return dynamic_cast<NextFrameMessage*>(_Base::ice_context(__context).get());
04365     #else
04366         return dynamic_cast<NextFrameMessage*>(::IceProxy::Ice::Object::ice_context(__context).get());
04367     #endif
04368     }
04369 
04370     ::IceInternal::ProxyHandle<NextFrameMessage> ice_adapterId(const std::string& __id) const
04371     {
04372     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04373         typedef ::IceProxy::Ice::Object _Base;
04374         return dynamic_cast<NextFrameMessage*>(_Base::ice_adapterId(__id).get());
04375     #else
04376         return dynamic_cast<NextFrameMessage*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
04377     #endif
04378     }
04379 
04380     ::IceInternal::ProxyHandle<NextFrameMessage> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
04381     {
04382     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04383         typedef ::IceProxy::Ice::Object _Base;
04384         return dynamic_cast<NextFrameMessage*>(_Base::ice_endpoints(__endpoints).get());
04385     #else
04386         return dynamic_cast<NextFrameMessage*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
04387     #endif
04388     }
04389 
04390     ::IceInternal::ProxyHandle<NextFrameMessage> ice_locatorCacheTimeout(int __timeout) const
04391     {
04392     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04393         typedef ::IceProxy::Ice::Object _Base;
04394         return dynamic_cast<NextFrameMessage*>(_Base::ice_locatorCacheTimeout(__timeout).get());
04395     #else
04396         return dynamic_cast<NextFrameMessage*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
04397     #endif
04398     }
04399 
04400     ::IceInternal::ProxyHandle<NextFrameMessage> ice_connectionCached(bool __cached) const
04401     {
04402     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04403         typedef ::IceProxy::Ice::Object _Base;
04404         return dynamic_cast<NextFrameMessage*>(_Base::ice_connectionCached(__cached).get());
04405     #else
04406         return dynamic_cast<NextFrameMessage*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
04407     #endif
04408     }
04409 
04410     ::IceInternal::ProxyHandle<NextFrameMessage> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
04411     {
04412     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04413         typedef ::IceProxy::Ice::Object _Base;
04414         return dynamic_cast<NextFrameMessage*>(_Base::ice_endpointSelection(__est).get());
04415     #else
04416         return dynamic_cast<NextFrameMessage*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
04417     #endif
04418     }
04419 
04420     ::IceInternal::ProxyHandle<NextFrameMessage> ice_secure(bool __secure) const
04421     {
04422     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04423         typedef ::IceProxy::Ice::Object _Base;
04424         return dynamic_cast<NextFrameMessage*>(_Base::ice_secure(__secure).get());
04425     #else
04426         return dynamic_cast<NextFrameMessage*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
04427     #endif
04428     }
04429 
04430     ::IceInternal::ProxyHandle<NextFrameMessage> ice_preferSecure(bool __preferSecure) const
04431     {
04432     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04433         typedef ::IceProxy::Ice::Object _Base;
04434         return dynamic_cast<NextFrameMessage*>(_Base::ice_preferSecure(__preferSecure).get());
04435     #else
04436         return dynamic_cast<NextFrameMessage*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
04437     #endif
04438     }
04439 
04440     ::IceInternal::ProxyHandle<NextFrameMessage> ice_router(const ::Ice::RouterPrx& __router) const
04441     {
04442     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04443         typedef ::IceProxy::Ice::Object _Base;
04444         return dynamic_cast<NextFrameMessage*>(_Base::ice_router(__router).get());
04445     #else
04446         return dynamic_cast<NextFrameMessage*>(::IceProxy::Ice::Object::ice_router(__router).get());
04447     #endif
04448     }
04449 
04450     ::IceInternal::ProxyHandle<NextFrameMessage> ice_locator(const ::Ice::LocatorPrx& __locator) const
04451     {
04452     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04453         typedef ::IceProxy::Ice::Object _Base;
04454         return dynamic_cast<NextFrameMessage*>(_Base::ice_locator(__locator).get());
04455     #else
04456         return dynamic_cast<NextFrameMessage*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
04457     #endif
04458     }
04459 
04460     ::IceInternal::ProxyHandle<NextFrameMessage> ice_collocationOptimized(bool __co) const
04461     {
04462     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04463         typedef ::IceProxy::Ice::Object _Base;
04464         return dynamic_cast<NextFrameMessage*>(_Base::ice_collocationOptimized(__co).get());
04465     #else
04466         return dynamic_cast<NextFrameMessage*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
04467     #endif
04468     }
04469 
04470     ::IceInternal::ProxyHandle<NextFrameMessage> ice_twoway() const
04471     {
04472     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04473         typedef ::IceProxy::Ice::Object _Base;
04474         return dynamic_cast<NextFrameMessage*>(_Base::ice_twoway().get());
04475     #else
04476         return dynamic_cast<NextFrameMessage*>(::IceProxy::Ice::Object::ice_twoway().get());
04477     #endif
04478     }
04479 
04480     ::IceInternal::ProxyHandle<NextFrameMessage> ice_oneway() const
04481     {
04482     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04483         typedef ::IceProxy::Ice::Object _Base;
04484         return dynamic_cast<NextFrameMessage*>(_Base::ice_oneway().get());
04485     #else
04486         return dynamic_cast<NextFrameMessage*>(::IceProxy::Ice::Object::ice_oneway().get());
04487     #endif
04488     }
04489 
04490     ::IceInternal::ProxyHandle<NextFrameMessage> ice_batchOneway() const
04491     {
04492     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04493         typedef ::IceProxy::Ice::Object _Base;
04494         return dynamic_cast<NextFrameMessage*>(_Base::ice_batchOneway().get());
04495     #else
04496         return dynamic_cast<NextFrameMessage*>(::IceProxy::Ice::Object::ice_batchOneway().get());
04497     #endif
04498     }
04499 
04500     ::IceInternal::ProxyHandle<NextFrameMessage> ice_datagram() const
04501     {
04502     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04503         typedef ::IceProxy::Ice::Object _Base;
04504         return dynamic_cast<NextFrameMessage*>(_Base::ice_datagram().get());
04505     #else
04506         return dynamic_cast<NextFrameMessage*>(::IceProxy::Ice::Object::ice_datagram().get());
04507     #endif
04508     }
04509 
04510     ::IceInternal::ProxyHandle<NextFrameMessage> ice_batchDatagram() const
04511     {
04512     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04513         typedef ::IceProxy::Ice::Object _Base;
04514         return dynamic_cast<NextFrameMessage*>(_Base::ice_batchDatagram().get());
04515     #else
04516         return dynamic_cast<NextFrameMessage*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
04517     #endif
04518     }
04519 
04520     ::IceInternal::ProxyHandle<NextFrameMessage> ice_compress(bool __compress) const
04521     {
04522     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04523         typedef ::IceProxy::Ice::Object _Base;
04524         return dynamic_cast<NextFrameMessage*>(_Base::ice_compress(__compress).get());
04525     #else
04526         return dynamic_cast<NextFrameMessage*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
04527     #endif
04528     }
04529 
04530     ::IceInternal::ProxyHandle<NextFrameMessage> ice_timeout(int __timeout) const
04531     {
04532     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04533         typedef ::IceProxy::Ice::Object _Base;
04534         return dynamic_cast<NextFrameMessage*>(_Base::ice_timeout(__timeout).get());
04535     #else
04536         return dynamic_cast<NextFrameMessage*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
04537     #endif
04538     }
04539 
04540     ::IceInternal::ProxyHandle<NextFrameMessage> ice_connectionId(const std::string& __id) const
04541     {
04542     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04543         typedef ::IceProxy::Ice::Object _Base;
04544         return dynamic_cast<NextFrameMessage*>(_Base::ice_connectionId(__id).get());
04545     #else
04546         return dynamic_cast<NextFrameMessage*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
04547     #endif
04548     }
04549 
04550     static const ::std::string& ice_staticId();
04551 
04552 private:
04553 
04554     virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
04555     virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
04556     virtual ::IceProxy::Ice::Object* __newInstance() const;
04557 };
04558 
04559 class AbortMessage : virtual public ::IceProxy::RobotSimEvents::EventMessage
04560 {
04561 public:
04562 
04563     ::IceInternal::ProxyHandle<AbortMessage> ice_context(const ::Ice::Context& __context) const
04564     {
04565     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04566         typedef ::IceProxy::Ice::Object _Base;
04567         return dynamic_cast<AbortMessage*>(_Base::ice_context(__context).get());
04568     #else
04569         return dynamic_cast<AbortMessage*>(::IceProxy::Ice::Object::ice_context(__context).get());
04570     #endif
04571     }
04572 
04573     ::IceInternal::ProxyHandle<AbortMessage> ice_adapterId(const std::string& __id) const
04574     {
04575     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04576         typedef ::IceProxy::Ice::Object _Base;
04577         return dynamic_cast<AbortMessage*>(_Base::ice_adapterId(__id).get());
04578     #else
04579         return dynamic_cast<AbortMessage*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
04580     #endif
04581     }
04582 
04583     ::IceInternal::ProxyHandle<AbortMessage> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
04584     {
04585     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04586         typedef ::IceProxy::Ice::Object _Base;
04587         return dynamic_cast<AbortMessage*>(_Base::ice_endpoints(__endpoints).get());
04588     #else
04589         return dynamic_cast<AbortMessage*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
04590     #endif
04591     }
04592 
04593     ::IceInternal::ProxyHandle<AbortMessage> ice_locatorCacheTimeout(int __timeout) const
04594     {
04595     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04596         typedef ::IceProxy::Ice::Object _Base;
04597         return dynamic_cast<AbortMessage*>(_Base::ice_locatorCacheTimeout(__timeout).get());
04598     #else
04599         return dynamic_cast<AbortMessage*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
04600     #endif
04601     }
04602 
04603     ::IceInternal::ProxyHandle<AbortMessage> ice_connectionCached(bool __cached) const
04604     {
04605     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04606         typedef ::IceProxy::Ice::Object _Base;
04607         return dynamic_cast<AbortMessage*>(_Base::ice_connectionCached(__cached).get());
04608     #else
04609         return dynamic_cast<AbortMessage*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
04610     #endif
04611     }
04612 
04613     ::IceInternal::ProxyHandle<AbortMessage> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
04614     {
04615     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04616         typedef ::IceProxy::Ice::Object _Base;
04617         return dynamic_cast<AbortMessage*>(_Base::ice_endpointSelection(__est).get());
04618     #else
04619         return dynamic_cast<AbortMessage*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
04620     #endif
04621     }
04622 
04623     ::IceInternal::ProxyHandle<AbortMessage> ice_secure(bool __secure) const
04624     {
04625     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04626         typedef ::IceProxy::Ice::Object _Base;
04627         return dynamic_cast<AbortMessage*>(_Base::ice_secure(__secure).get());
04628     #else
04629         return dynamic_cast<AbortMessage*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
04630     #endif
04631     }
04632 
04633     ::IceInternal::ProxyHandle<AbortMessage> ice_preferSecure(bool __preferSecure) const
04634     {
04635     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04636         typedef ::IceProxy::Ice::Object _Base;
04637         return dynamic_cast<AbortMessage*>(_Base::ice_preferSecure(__preferSecure).get());
04638     #else
04639         return dynamic_cast<AbortMessage*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
04640     #endif
04641     }
04642 
04643     ::IceInternal::ProxyHandle<AbortMessage> ice_router(const ::Ice::RouterPrx& __router) const
04644     {
04645     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04646         typedef ::IceProxy::Ice::Object _Base;
04647         return dynamic_cast<AbortMessage*>(_Base::ice_router(__router).get());
04648     #else
04649         return dynamic_cast<AbortMessage*>(::IceProxy::Ice::Object::ice_router(__router).get());
04650     #endif
04651     }
04652 
04653     ::IceInternal::ProxyHandle<AbortMessage> ice_locator(const ::Ice::LocatorPrx& __locator) const
04654     {
04655     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04656         typedef ::IceProxy::Ice::Object _Base;
04657         return dynamic_cast<AbortMessage*>(_Base::ice_locator(__locator).get());
04658     #else
04659         return dynamic_cast<AbortMessage*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
04660     #endif
04661     }
04662 
04663     ::IceInternal::ProxyHandle<AbortMessage> ice_collocationOptimized(bool __co) const
04664     {
04665     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04666         typedef ::IceProxy::Ice::Object _Base;
04667         return dynamic_cast<AbortMessage*>(_Base::ice_collocationOptimized(__co).get());
04668     #else
04669         return dynamic_cast<AbortMessage*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
04670     #endif
04671     }
04672 
04673     ::IceInternal::ProxyHandle<AbortMessage> ice_twoway() const
04674     {
04675     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04676         typedef ::IceProxy::Ice::Object _Base;
04677         return dynamic_cast<AbortMessage*>(_Base::ice_twoway().get());
04678     #else
04679         return dynamic_cast<AbortMessage*>(::IceProxy::Ice::Object::ice_twoway().get());
04680     #endif
04681     }
04682 
04683     ::IceInternal::ProxyHandle<AbortMessage> ice_oneway() const
04684     {
04685     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04686         typedef ::IceProxy::Ice::Object _Base;
04687         return dynamic_cast<AbortMessage*>(_Base::ice_oneway().get());
04688     #else
04689         return dynamic_cast<AbortMessage*>(::IceProxy::Ice::Object::ice_oneway().get());
04690     #endif
04691     }
04692 
04693     ::IceInternal::ProxyHandle<AbortMessage> ice_batchOneway() const
04694     {
04695     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04696         typedef ::IceProxy::Ice::Object _Base;
04697         return dynamic_cast<AbortMessage*>(_Base::ice_batchOneway().get());
04698     #else
04699         return dynamic_cast<AbortMessage*>(::IceProxy::Ice::Object::ice_batchOneway().get());
04700     #endif
04701     }
04702 
04703     ::IceInternal::ProxyHandle<AbortMessage> ice_datagram() const
04704     {
04705     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04706         typedef ::IceProxy::Ice::Object _Base;
04707         return dynamic_cast<AbortMessage*>(_Base::ice_datagram().get());
04708     #else
04709         return dynamic_cast<AbortMessage*>(::IceProxy::Ice::Object::ice_datagram().get());
04710     #endif
04711     }
04712 
04713     ::IceInternal::ProxyHandle<AbortMessage> ice_batchDatagram() const
04714     {
04715     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04716         typedef ::IceProxy::Ice::Object _Base;
04717         return dynamic_cast<AbortMessage*>(_Base::ice_batchDatagram().get());
04718     #else
04719         return dynamic_cast<AbortMessage*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
04720     #endif
04721     }
04722 
04723     ::IceInternal::ProxyHandle<AbortMessage> ice_compress(bool __compress) const
04724     {
04725     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04726         typedef ::IceProxy::Ice::Object _Base;
04727         return dynamic_cast<AbortMessage*>(_Base::ice_compress(__compress).get());
04728     #else
04729         return dynamic_cast<AbortMessage*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
04730     #endif
04731     }
04732 
04733     ::IceInternal::ProxyHandle<AbortMessage> ice_timeout(int __timeout) const
04734     {
04735     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04736         typedef ::IceProxy::Ice::Object _Base;
04737         return dynamic_cast<AbortMessage*>(_Base::ice_timeout(__timeout).get());
04738     #else
04739         return dynamic_cast<AbortMessage*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
04740     #endif
04741     }
04742 
04743     ::IceInternal::ProxyHandle<AbortMessage> ice_connectionId(const std::string& __id) const
04744     {
04745     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04746         typedef ::IceProxy::Ice::Object _Base;
04747         return dynamic_cast<AbortMessage*>(_Base::ice_connectionId(__id).get());
04748     #else
04749         return dynamic_cast<AbortMessage*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
04750     #endif
04751     }
04752 
04753     static const ::std::string& ice_staticId();
04754 
04755 private:
04756 
04757     virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
04758     virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
04759     virtual ::IceProxy::Ice::Object* __newInstance() const;
04760 };
04761 
04762 class FacesMessage : virtual public ::IceProxy::RobotSimEvents::EventMessage
04763 {
04764 public:
04765 
04766     ::IceInternal::ProxyHandle<FacesMessage> ice_context(const ::Ice::Context& __context) const
04767     {
04768     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04769         typedef ::IceProxy::Ice::Object _Base;
04770         return dynamic_cast<FacesMessage*>(_Base::ice_context(__context).get());
04771     #else
04772         return dynamic_cast<FacesMessage*>(::IceProxy::Ice::Object::ice_context(__context).get());
04773     #endif
04774     }
04775 
04776     ::IceInternal::ProxyHandle<FacesMessage> ice_adapterId(const std::string& __id) const
04777     {
04778     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04779         typedef ::IceProxy::Ice::Object _Base;
04780         return dynamic_cast<FacesMessage*>(_Base::ice_adapterId(__id).get());
04781     #else
04782         return dynamic_cast<FacesMessage*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
04783     #endif
04784     }
04785 
04786     ::IceInternal::ProxyHandle<FacesMessage> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
04787     {
04788     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04789         typedef ::IceProxy::Ice::Object _Base;
04790         return dynamic_cast<FacesMessage*>(_Base::ice_endpoints(__endpoints).get());
04791     #else
04792         return dynamic_cast<FacesMessage*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
04793     #endif
04794     }
04795 
04796     ::IceInternal::ProxyHandle<FacesMessage> ice_locatorCacheTimeout(int __timeout) const
04797     {
04798     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04799         typedef ::IceProxy::Ice::Object _Base;
04800         return dynamic_cast<FacesMessage*>(_Base::ice_locatorCacheTimeout(__timeout).get());
04801     #else
04802         return dynamic_cast<FacesMessage*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
04803     #endif
04804     }
04805 
04806     ::IceInternal::ProxyHandle<FacesMessage> ice_connectionCached(bool __cached) const
04807     {
04808     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04809         typedef ::IceProxy::Ice::Object _Base;
04810         return dynamic_cast<FacesMessage*>(_Base::ice_connectionCached(__cached).get());
04811     #else
04812         return dynamic_cast<FacesMessage*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
04813     #endif
04814     }
04815 
04816     ::IceInternal::ProxyHandle<FacesMessage> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
04817     {
04818     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04819         typedef ::IceProxy::Ice::Object _Base;
04820         return dynamic_cast<FacesMessage*>(_Base::ice_endpointSelection(__est).get());
04821     #else
04822         return dynamic_cast<FacesMessage*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
04823     #endif
04824     }
04825 
04826     ::IceInternal::ProxyHandle<FacesMessage> ice_secure(bool __secure) const
04827     {
04828     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04829         typedef ::IceProxy::Ice::Object _Base;
04830         return dynamic_cast<FacesMessage*>(_Base::ice_secure(__secure).get());
04831     #else
04832         return dynamic_cast<FacesMessage*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
04833     #endif
04834     }
04835 
04836     ::IceInternal::ProxyHandle<FacesMessage> ice_preferSecure(bool __preferSecure) const
04837     {
04838     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04839         typedef ::IceProxy::Ice::Object _Base;
04840         return dynamic_cast<FacesMessage*>(_Base::ice_preferSecure(__preferSecure).get());
04841     #else
04842         return dynamic_cast<FacesMessage*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
04843     #endif
04844     }
04845 
04846     ::IceInternal::ProxyHandle<FacesMessage> ice_router(const ::Ice::RouterPrx& __router) const
04847     {
04848     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04849         typedef ::IceProxy::Ice::Object _Base;
04850         return dynamic_cast<FacesMessage*>(_Base::ice_router(__router).get());
04851     #else
04852         return dynamic_cast<FacesMessage*>(::IceProxy::Ice::Object::ice_router(__router).get());
04853     #endif
04854     }
04855 
04856     ::IceInternal::ProxyHandle<FacesMessage> ice_locator(const ::Ice::LocatorPrx& __locator) const
04857     {
04858     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04859         typedef ::IceProxy::Ice::Object _Base;
04860         return dynamic_cast<FacesMessage*>(_Base::ice_locator(__locator).get());
04861     #else
04862         return dynamic_cast<FacesMessage*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
04863     #endif
04864     }
04865 
04866     ::IceInternal::ProxyHandle<FacesMessage> ice_collocationOptimized(bool __co) const
04867     {
04868     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04869         typedef ::IceProxy::Ice::Object _Base;
04870         return dynamic_cast<FacesMessage*>(_Base::ice_collocationOptimized(__co).get());
04871     #else
04872         return dynamic_cast<FacesMessage*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
04873     #endif
04874     }
04875 
04876     ::IceInternal::ProxyHandle<FacesMessage> ice_twoway() const
04877     {
04878     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04879         typedef ::IceProxy::Ice::Object _Base;
04880         return dynamic_cast<FacesMessage*>(_Base::ice_twoway().get());
04881     #else
04882         return dynamic_cast<FacesMessage*>(::IceProxy::Ice::Object::ice_twoway().get());
04883     #endif
04884     }
04885 
04886     ::IceInternal::ProxyHandle<FacesMessage> ice_oneway() const
04887     {
04888     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04889         typedef ::IceProxy::Ice::Object _Base;
04890         return dynamic_cast<FacesMessage*>(_Base::ice_oneway().get());
04891     #else
04892         return dynamic_cast<FacesMessage*>(::IceProxy::Ice::Object::ice_oneway().get());
04893     #endif
04894     }
04895 
04896     ::IceInternal::ProxyHandle<FacesMessage> ice_batchOneway() const
04897     {
04898     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04899         typedef ::IceProxy::Ice::Object _Base;
04900         return dynamic_cast<FacesMessage*>(_Base::ice_batchOneway().get());
04901     #else
04902         return dynamic_cast<FacesMessage*>(::IceProxy::Ice::Object::ice_batchOneway().get());
04903     #endif
04904     }
04905 
04906     ::IceInternal::ProxyHandle<FacesMessage> ice_datagram() const
04907     {
04908     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04909         typedef ::IceProxy::Ice::Object _Base;
04910         return dynamic_cast<FacesMessage*>(_Base::ice_datagram().get());
04911     #else
04912         return dynamic_cast<FacesMessage*>(::IceProxy::Ice::Object::ice_datagram().get());
04913     #endif
04914     }
04915 
04916     ::IceInternal::ProxyHandle<FacesMessage> ice_batchDatagram() const
04917     {
04918     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04919         typedef ::IceProxy::Ice::Object _Base;
04920         return dynamic_cast<FacesMessage*>(_Base::ice_batchDatagram().get());
04921     #else
04922         return dynamic_cast<FacesMessage*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
04923     #endif
04924     }
04925 
04926     ::IceInternal::ProxyHandle<FacesMessage> ice_compress(bool __compress) const
04927     {
04928     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04929         typedef ::IceProxy::Ice::Object _Base;
04930         return dynamic_cast<FacesMessage*>(_Base::ice_compress(__compress).get());
04931     #else
04932         return dynamic_cast<FacesMessage*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
04933     #endif
04934     }
04935 
04936     ::IceInternal::ProxyHandle<FacesMessage> ice_timeout(int __timeout) const
04937     {
04938     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04939         typedef ::IceProxy::Ice::Object _Base;
04940         return dynamic_cast<FacesMessage*>(_Base::ice_timeout(__timeout).get());
04941     #else
04942         return dynamic_cast<FacesMessage*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
04943     #endif
04944     }
04945 
04946     ::IceInternal::ProxyHandle<FacesMessage> ice_connectionId(const std::string& __id) const
04947     {
04948     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04949         typedef ::IceProxy::Ice::Object _Base;
04950         return dynamic_cast<FacesMessage*>(_Base::ice_connectionId(__id).get());
04951     #else
04952         return dynamic_cast<FacesMessage*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
04953     #endif
04954     }
04955 
04956     static const ::std::string& ice_staticId();
04957 
04958 private:
04959 
04960     virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
04961     virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
04962     virtual ::IceProxy::Ice::Object* __newInstance() const;
04963 };
04964 
04965 class GUISpeechMessage : virtual public ::IceProxy::RobotSimEvents::EventMessage
04966 {
04967 public:
04968 
04969     ::IceInternal::ProxyHandle<GUISpeechMessage> ice_context(const ::Ice::Context& __context) const
04970     {
04971     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04972         typedef ::IceProxy::Ice::Object _Base;
04973         return dynamic_cast<GUISpeechMessage*>(_Base::ice_context(__context).get());
04974     #else
04975         return dynamic_cast<GUISpeechMessage*>(::IceProxy::Ice::Object::ice_context(__context).get());
04976     #endif
04977     }
04978 
04979     ::IceInternal::ProxyHandle<GUISpeechMessage> ice_adapterId(const std::string& __id) const
04980     {
04981     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04982         typedef ::IceProxy::Ice::Object _Base;
04983         return dynamic_cast<GUISpeechMessage*>(_Base::ice_adapterId(__id).get());
04984     #else
04985         return dynamic_cast<GUISpeechMessage*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
04986     #endif
04987     }
04988 
04989     ::IceInternal::ProxyHandle<GUISpeechMessage> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
04990     {
04991     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04992         typedef ::IceProxy::Ice::Object _Base;
04993         return dynamic_cast<GUISpeechMessage*>(_Base::ice_endpoints(__endpoints).get());
04994     #else
04995         return dynamic_cast<GUISpeechMessage*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
04996     #endif
04997     }
04998 
04999     ::IceInternal::ProxyHandle<GUISpeechMessage> ice_locatorCacheTimeout(int __timeout) const
05000     {
05001     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05002         typedef ::IceProxy::Ice::Object _Base;
05003         return dynamic_cast<GUISpeechMessage*>(_Base::ice_locatorCacheTimeout(__timeout).get());
05004     #else
05005         return dynamic_cast<GUISpeechMessage*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
05006     #endif
05007     }
05008 
05009     ::IceInternal::ProxyHandle<GUISpeechMessage> ice_connectionCached(bool __cached) const
05010     {
05011     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05012         typedef ::IceProxy::Ice::Object _Base;
05013         return dynamic_cast<GUISpeechMessage*>(_Base::ice_connectionCached(__cached).get());
05014     #else
05015         return dynamic_cast<GUISpeechMessage*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
05016     #endif
05017     }
05018 
05019     ::IceInternal::ProxyHandle<GUISpeechMessage> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
05020     {
05021     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05022         typedef ::IceProxy::Ice::Object _Base;
05023         return dynamic_cast<GUISpeechMessage*>(_Base::ice_endpointSelection(__est).get());
05024     #else
05025         return dynamic_cast<GUISpeechMessage*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
05026     #endif
05027     }
05028 
05029     ::IceInternal::ProxyHandle<GUISpeechMessage> ice_secure(bool __secure) const
05030     {
05031     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05032         typedef ::IceProxy::Ice::Object _Base;
05033         return dynamic_cast<GUISpeechMessage*>(_Base::ice_secure(__secure).get());
05034     #else
05035         return dynamic_cast<GUISpeechMessage*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
05036     #endif
05037     }
05038 
05039     ::IceInternal::ProxyHandle<GUISpeechMessage> ice_preferSecure(bool __preferSecure) const
05040     {
05041     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05042         typedef ::IceProxy::Ice::Object _Base;
05043         return dynamic_cast<GUISpeechMessage*>(_Base::ice_preferSecure(__preferSecure).get());
05044     #else
05045         return dynamic_cast<GUISpeechMessage*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
05046     #endif
05047     }
05048 
05049     ::IceInternal::ProxyHandle<GUISpeechMessage> ice_router(const ::Ice::RouterPrx& __router) const
05050     {
05051     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05052         typedef ::IceProxy::Ice::Object _Base;
05053         return dynamic_cast<GUISpeechMessage*>(_Base::ice_router(__router).get());
05054     #else
05055         return dynamic_cast<GUISpeechMessage*>(::IceProxy::Ice::Object::ice_router(__router).get());
05056     #endif
05057     }
05058 
05059     ::IceInternal::ProxyHandle<GUISpeechMessage> ice_locator(const ::Ice::LocatorPrx& __locator) const
05060     {
05061     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05062         typedef ::IceProxy::Ice::Object _Base;
05063         return dynamic_cast<GUISpeechMessage*>(_Base::ice_locator(__locator).get());
05064     #else
05065         return dynamic_cast<GUISpeechMessage*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
05066     #endif
05067     }
05068 
05069     ::IceInternal::ProxyHandle<GUISpeechMessage> ice_collocationOptimized(bool __co) const
05070     {
05071     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05072         typedef ::IceProxy::Ice::Object _Base;
05073         return dynamic_cast<GUISpeechMessage*>(_Base::ice_collocationOptimized(__co).get());
05074     #else
05075         return dynamic_cast<GUISpeechMessage*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
05076     #endif
05077     }
05078 
05079     ::IceInternal::ProxyHandle<GUISpeechMessage> ice_twoway() const
05080     {
05081     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05082         typedef ::IceProxy::Ice::Object _Base;
05083         return dynamic_cast<GUISpeechMessage*>(_Base::ice_twoway().get());
05084     #else
05085         return dynamic_cast<GUISpeechMessage*>(::IceProxy::Ice::Object::ice_twoway().get());
05086     #endif
05087     }
05088 
05089     ::IceInternal::ProxyHandle<GUISpeechMessage> ice_oneway() const
05090     {
05091     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05092         typedef ::IceProxy::Ice::Object _Base;
05093         return dynamic_cast<GUISpeechMessage*>(_Base::ice_oneway().get());
05094     #else
05095         return dynamic_cast<GUISpeechMessage*>(::IceProxy::Ice::Object::ice_oneway().get());
05096     #endif
05097     }
05098 
05099     ::IceInternal::ProxyHandle<GUISpeechMessage> ice_batchOneway() const
05100     {
05101     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05102         typedef ::IceProxy::Ice::Object _Base;
05103         return dynamic_cast<GUISpeechMessage*>(_Base::ice_batchOneway().get());
05104     #else
05105         return dynamic_cast<GUISpeechMessage*>(::IceProxy::Ice::Object::ice_batchOneway().get());
05106     #endif
05107     }
05108 
05109     ::IceInternal::ProxyHandle<GUISpeechMessage> ice_datagram() const
05110     {
05111     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05112         typedef ::IceProxy::Ice::Object _Base;
05113         return dynamic_cast<GUISpeechMessage*>(_Base::ice_datagram().get());
05114     #else
05115         return dynamic_cast<GUISpeechMessage*>(::IceProxy::Ice::Object::ice_datagram().get());
05116     #endif
05117     }
05118 
05119     ::IceInternal::ProxyHandle<GUISpeechMessage> ice_batchDatagram() const
05120     {
05121     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05122         typedef ::IceProxy::Ice::Object _Base;
05123         return dynamic_cast<GUISpeechMessage*>(_Base::ice_batchDatagram().get());
05124     #else
05125         return dynamic_cast<GUISpeechMessage*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
05126     #endif
05127     }
05128 
05129     ::IceInternal::ProxyHandle<GUISpeechMessage> ice_compress(bool __compress) const
05130     {
05131     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05132         typedef ::IceProxy::Ice::Object _Base;
05133         return dynamic_cast<GUISpeechMessage*>(_Base::ice_compress(__compress).get());
05134     #else
05135         return dynamic_cast<GUISpeechMessage*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
05136     #endif
05137     }
05138 
05139     ::IceInternal::ProxyHandle<GUISpeechMessage> ice_timeout(int __timeout) const
05140     {
05141     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05142         typedef ::IceProxy::Ice::Object _Base;
05143         return dynamic_cast<GUISpeechMessage*>(_Base::ice_timeout(__timeout).get());
05144     #else
05145         return dynamic_cast<GUISpeechMessage*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
05146     #endif
05147     }
05148 
05149     ::IceInternal::ProxyHandle<GUISpeechMessage> ice_connectionId(const std::string& __id) const
05150     {
05151     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05152         typedef ::IceProxy::Ice::Object _Base;
05153         return dynamic_cast<GUISpeechMessage*>(_Base::ice_connectionId(__id).get());
05154     #else
05155         return dynamic_cast<GUISpeechMessage*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
05156     #endif
05157     }
05158 
05159     static const ::std::string& ice_staticId();
05160 
05161 private:
05162 
05163     virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
05164     virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
05165     virtual ::IceProxy::Ice::Object* __newInstance() const;
05166 };
05167 
05168 }
05169 
05170 }
05171 
05172 namespace IceDelegate
05173 {
05174 
05175 namespace BeobotEvents
05176 {
05177 
05178 class MotorMessage : virtual public ::IceDelegate::RobotSimEvents::EventMessage
05179 {
05180 public:
05181 };
05182 
05183 class MotorRequest : virtual public ::IceDelegate::RobotSimEvents::EventMessage
05184 {
05185 public:
05186 };
05187 
05188 class CornerMotorRequest : virtual public ::IceDelegate::RobotSimEvents::EventMessage
05189 {
05190 public:
05191 };
05192 
05193 class CornerLocationMessage : virtual public ::IceDelegate::RobotSimEvents::EventMessage
05194 {
05195 public:
05196 };
05197 
05198 class SonarMessage : virtual public ::IceDelegate::RobotSimEvents::EventMessage
05199 {
05200 public:
05201 };
05202 
05203 class GPSMessage : virtual public ::IceDelegate::RobotSimEvents::EventMessage
05204 {
05205 public:
05206 };
05207 
05208 class LRFMessage : virtual public ::IceDelegate::RobotSimEvents::EventMessage
05209 {
05210 public:
05211 };
05212 
05213 class SLAMMessage : virtual public ::IceDelegate::RobotSimEvents::EventMessage
05214 {
05215 public:
05216 };
05217 
05218 class IMUMessage : virtual public ::IceDelegate::RobotSimEvents::EventMessage
05219 {
05220 public:
05221 };
05222 
05223 class CameraMessage : virtual public ::IceDelegate::RobotSimEvents::EventMessage
05224 {
05225 public:
05226 };
05227 
05228 class GistSalMessage : virtual public ::IceDelegate::RobotSimEvents::EventMessage
05229 {
05230 public:
05231 };
05232 
05233 class LandmarkSearchQueueMessage : virtual public ::IceDelegate::RobotSimEvents::EventMessage
05234 {
05235 public:
05236 };
05237 
05238 class LandmarkTrackMessage : virtual public ::IceDelegate::RobotSimEvents::EventMessage
05239 {
05240 public:
05241 };
05242 
05243 class LandmarkSearchStatMessage : virtual public ::IceDelegate::RobotSimEvents::EventMessage
05244 {
05245 public:
05246 };
05247 
05248 class LandmarkMatchResultMessage : virtual public ::IceDelegate::RobotSimEvents::EventMessage
05249 {
05250 public:
05251 };
05252 
05253 class LandmarkDBSearchResultMessage : virtual public ::IceDelegate::RobotSimEvents::EventMessage
05254 {
05255 public:
05256 };
05257 
05258 class CurrentLocationMessage : virtual public ::IceDelegate::RobotSimEvents::EventMessage
05259 {
05260 public:
05261 };
05262 
05263 class CancelSearchMessage : virtual public ::IceDelegate::RobotSimEvents::EventMessage
05264 {
05265 public:
05266 };
05267 
05268 class SearchDoneMessage : virtual public ::IceDelegate::RobotSimEvents::EventMessage
05269 {
05270 public:
05271 };
05272 
05273 class NextFrameMessage : virtual public ::IceDelegate::RobotSimEvents::EventMessage
05274 {
05275 public:
05276 };
05277 
05278 class AbortMessage : virtual public ::IceDelegate::RobotSimEvents::EventMessage
05279 {
05280 public:
05281 };
05282 
05283 class FacesMessage : virtual public ::IceDelegate::RobotSimEvents::EventMessage
05284 {
05285 public:
05286 };
05287 
05288 class GUISpeechMessage : virtual public ::IceDelegate::RobotSimEvents::EventMessage
05289 {
05290 public:
05291 };
05292 
05293 }
05294 
05295 }
05296 
05297 namespace IceDelegateM
05298 {
05299 
05300 namespace BeobotEvents
05301 {
05302 
05303 class MotorMessage : virtual public ::IceDelegate::BeobotEvents::MotorMessage,
05304                      virtual public ::IceDelegateM::RobotSimEvents::EventMessage
05305 {
05306 public:
05307 };
05308 
05309 class MotorRequest : virtual public ::IceDelegate::BeobotEvents::MotorRequest,
05310                      virtual public ::IceDelegateM::RobotSimEvents::EventMessage
05311 {
05312 public:
05313 };
05314 
05315 class CornerMotorRequest : virtual public ::IceDelegate::BeobotEvents::CornerMotorRequest,
05316                            virtual public ::IceDelegateM::RobotSimEvents::EventMessage
05317 {
05318 public:
05319 };
05320 
05321 class CornerLocationMessage : virtual public ::IceDelegate::BeobotEvents::CornerLocationMessage,
05322                               virtual public ::IceDelegateM::RobotSimEvents::EventMessage
05323 {
05324 public:
05325 };
05326 
05327 class SonarMessage : virtual public ::IceDelegate::BeobotEvents::SonarMessage,
05328                      virtual public ::IceDelegateM::RobotSimEvents::EventMessage
05329 {
05330 public:
05331 };
05332 
05333 class GPSMessage : virtual public ::IceDelegate::BeobotEvents::GPSMessage,
05334                    virtual public ::IceDelegateM::RobotSimEvents::EventMessage
05335 {
05336 public:
05337 };
05338 
05339 class LRFMessage : virtual public ::IceDelegate::BeobotEvents::LRFMessage,
05340                    virtual public ::IceDelegateM::RobotSimEvents::EventMessage
05341 {
05342 public:
05343 };
05344 
05345 class SLAMMessage : virtual public ::IceDelegate::BeobotEvents::SLAMMessage,
05346                     virtual public ::IceDelegateM::RobotSimEvents::EventMessage
05347 {
05348 public:
05349 };
05350 
05351 class IMUMessage : virtual public ::IceDelegate::BeobotEvents::IMUMessage,
05352                    virtual public ::IceDelegateM::RobotSimEvents::EventMessage
05353 {
05354 public:
05355 };
05356 
05357 class CameraMessage : virtual public ::IceDelegate::BeobotEvents::CameraMessage,
05358                       virtual public ::IceDelegateM::RobotSimEvents::EventMessage
05359 {
05360 public:
05361 };
05362 
05363 class GistSalMessage : virtual public ::IceDelegate::BeobotEvents::GistSalMessage,
05364                        virtual public ::IceDelegateM::RobotSimEvents::EventMessage
05365 {
05366 public:
05367 };
05368 
05369 class LandmarkSearchQueueMessage : virtual public ::IceDelegate::BeobotEvents::LandmarkSearchQueueMessage,
05370                                    virtual public ::IceDelegateM::RobotSimEvents::EventMessage
05371 {
05372 public:
05373 };
05374 
05375 class LandmarkTrackMessage : virtual public ::IceDelegate::BeobotEvents::LandmarkTrackMessage,
05376                              virtual public ::IceDelegateM::RobotSimEvents::EventMessage
05377 {
05378 public:
05379 };
05380 
05381 class LandmarkSearchStatMessage : virtual public ::IceDelegate::BeobotEvents::LandmarkSearchStatMessage,
05382                                   virtual public ::IceDelegateM::RobotSimEvents::EventMessage
05383 {
05384 public:
05385 };
05386 
05387 class LandmarkMatchResultMessage : virtual public ::IceDelegate::BeobotEvents::LandmarkMatchResultMessage,
05388                                    virtual public ::IceDelegateM::RobotSimEvents::EventMessage
05389 {
05390 public:
05391 };
05392 
05393 class LandmarkDBSearchResultMessage : virtual public ::IceDelegate::BeobotEvents::LandmarkDBSearchResultMessage,
05394                                       virtual public ::IceDelegateM::RobotSimEvents::EventMessage
05395 {
05396 public:
05397 };
05398 
05399 class CurrentLocationMessage : virtual public ::IceDelegate::BeobotEvents::CurrentLocationMessage,
05400                                virtual public ::IceDelegateM::RobotSimEvents::EventMessage
05401 {
05402 public:
05403 };
05404 
05405 class CancelSearchMessage : virtual public ::IceDelegate::BeobotEvents::CancelSearchMessage,
05406                             virtual public ::IceDelegateM::RobotSimEvents::EventMessage
05407 {
05408 public:
05409 };
05410 
05411 class SearchDoneMessage : virtual public ::IceDelegate::BeobotEvents::SearchDoneMessage,
05412                           virtual public ::IceDelegateM::RobotSimEvents::EventMessage
05413 {
05414 public:
05415 };
05416 
05417 class NextFrameMessage : virtual public ::IceDelegate::BeobotEvents::NextFrameMessage,
05418                          virtual public ::IceDelegateM::RobotSimEvents::EventMessage
05419 {
05420 public:
05421 };
05422 
05423 class AbortMessage : virtual public ::IceDelegate::BeobotEvents::AbortMessage,
05424                      virtual public ::IceDelegateM::RobotSimEvents::EventMessage
05425 {
05426 public:
05427 };
05428 
05429 class FacesMessage : virtual public ::IceDelegate::BeobotEvents::FacesMessage,
05430                      virtual public ::IceDelegateM::RobotSimEvents::EventMessage
05431 {
05432 public:
05433 };
05434 
05435 class GUISpeechMessage : virtual public ::IceDelegate::BeobotEvents::GUISpeechMessage,
05436                          virtual public ::IceDelegateM::RobotSimEvents::EventMessage
05437 {
05438 public:
05439 };
05440 
05441 }
05442 
05443 }
05444 
05445 namespace IceDelegateD
05446 {
05447 
05448 namespace BeobotEvents
05449 {
05450 
05451 class MotorMessage : virtual public ::IceDelegate::BeobotEvents::MotorMessage,
05452                      virtual public ::IceDelegateD::RobotSimEvents::EventMessage
05453 {
05454 public:
05455 };
05456 
05457 class MotorRequest : virtual public ::IceDelegate::BeobotEvents::MotorRequest,
05458                      virtual public ::IceDelegateD::RobotSimEvents::EventMessage
05459 {
05460 public:
05461 };
05462 
05463 class CornerMotorRequest : virtual public ::IceDelegate::BeobotEvents::CornerMotorRequest,
05464                            virtual public ::IceDelegateD::RobotSimEvents::EventMessage
05465 {
05466 public:
05467 };
05468 
05469 class CornerLocationMessage : virtual public ::IceDelegate::BeobotEvents::CornerLocationMessage,
05470                               virtual public ::IceDelegateD::RobotSimEvents::EventMessage
05471 {
05472 public:
05473 };
05474 
05475 class SonarMessage : virtual public ::IceDelegate::BeobotEvents::SonarMessage,
05476                      virtual public ::IceDelegateD::RobotSimEvents::EventMessage
05477 {
05478 public:
05479 };
05480 
05481 class GPSMessage : virtual public ::IceDelegate::BeobotEvents::GPSMessage,
05482                    virtual public ::IceDelegateD::RobotSimEvents::EventMessage
05483 {
05484 public:
05485 };
05486 
05487 class LRFMessage : virtual public ::IceDelegate::BeobotEvents::LRFMessage,
05488                    virtual public ::IceDelegateD::RobotSimEvents::EventMessage
05489 {
05490 public:
05491 };
05492 
05493 class SLAMMessage : virtual public ::IceDelegate::BeobotEvents::SLAMMessage,
05494                     virtual public ::IceDelegateD::RobotSimEvents::EventMessage
05495 {
05496 public:
05497 };
05498 
05499 class IMUMessage : virtual public ::IceDelegate::BeobotEvents::IMUMessage,
05500                    virtual public ::IceDelegateD::RobotSimEvents::EventMessage
05501 {
05502 public:
05503 };
05504 
05505 class CameraMessage : virtual public ::IceDelegate::BeobotEvents::CameraMessage,
05506                       virtual public ::IceDelegateD::RobotSimEvents::EventMessage
05507 {
05508 public:
05509 };
05510 
05511 class GistSalMessage : virtual public ::IceDelegate::BeobotEvents::GistSalMessage,
05512                        virtual public ::IceDelegateD::RobotSimEvents::EventMessage
05513 {
05514 public:
05515 };
05516 
05517 class LandmarkSearchQueueMessage : virtual public ::IceDelegate::BeobotEvents::LandmarkSearchQueueMessage,
05518                                    virtual public ::IceDelegateD::RobotSimEvents::EventMessage
05519 {
05520 public:
05521 };
05522 
05523 class LandmarkTrackMessage : virtual public ::IceDelegate::BeobotEvents::LandmarkTrackMessage,
05524                              virtual public ::IceDelegateD::RobotSimEvents::EventMessage
05525 {
05526 public:
05527 };
05528 
05529 class LandmarkSearchStatMessage : virtual public ::IceDelegate::BeobotEvents::LandmarkSearchStatMessage,
05530                                   virtual public ::IceDelegateD::RobotSimEvents::EventMessage
05531 {
05532 public:
05533 };
05534 
05535 class LandmarkMatchResultMessage : virtual public ::IceDelegate::BeobotEvents::LandmarkMatchResultMessage,
05536                                    virtual public ::IceDelegateD::RobotSimEvents::EventMessage
05537 {
05538 public:
05539 };
05540 
05541 class LandmarkDBSearchResultMessage : virtual public ::IceDelegate::BeobotEvents::LandmarkDBSearchResultMessage,
05542                                       virtual public ::IceDelegateD::RobotSimEvents::EventMessage
05543 {
05544 public:
05545 };
05546 
05547 class CurrentLocationMessage : virtual public ::IceDelegate::BeobotEvents::CurrentLocationMessage,
05548                                virtual public ::IceDelegateD::RobotSimEvents::EventMessage
05549 {
05550 public:
05551 };
05552 
05553 class CancelSearchMessage : virtual public ::IceDelegate::BeobotEvents::CancelSearchMessage,
05554                             virtual public ::IceDelegateD::RobotSimEvents::EventMessage
05555 {
05556 public:
05557 };
05558 
05559 class SearchDoneMessage : virtual public ::IceDelegate::BeobotEvents::SearchDoneMessage,
05560                           virtual public ::IceDelegateD::RobotSimEvents::EventMessage
05561 {
05562 public:
05563 };
05564 
05565 class NextFrameMessage : virtual public ::IceDelegate::BeobotEvents::NextFrameMessage,
05566                          virtual public ::IceDelegateD::RobotSimEvents::EventMessage
05567 {
05568 public:
05569 };
05570 
05571 class AbortMessage : virtual public ::IceDelegate::BeobotEvents::AbortMessage,
05572                      virtual public ::IceDelegateD::RobotSimEvents::EventMessage
05573 {
05574 public:
05575 };
05576 
05577 class FacesMessage : virtual public ::IceDelegate::BeobotEvents::FacesMessage,
05578                      virtual public ::IceDelegateD::RobotSimEvents::EventMessage
05579 {
05580 public:
05581 };
05582 
05583 class GUISpeechMessage : virtual public ::IceDelegate::BeobotEvents::GUISpeechMessage,
05584                          virtual public ::IceDelegateD::RobotSimEvents::EventMessage
05585 {
05586 public:
05587 };
05588 
05589 }
05590 
05591 }
05592 
05593 namespace BeobotEvents
05594 {
05595 
05596 class MotorMessage : virtual public ::RobotSimEvents::EventMessage
05597 {
05598 public:
05599 
05600     typedef MotorMessagePrx ProxyType;
05601     typedef MotorMessagePtr PointerType;
05602 
05603     MotorMessage() {}
05604     MotorMessage(::Ice::Int, ::Ice::Int, ::Ice::Int, ::Ice::Double, ::Ice::Double, ::Ice::Double, ::Ice::Double, ::Ice::Double, ::Ice::Double, ::Ice::Double, ::Ice::Int);
05605     virtual ::Ice::ObjectPtr ice_clone() const;
05606 
05607     virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
05608     virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
05609     virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
05610     static const ::std::string& ice_staticId();
05611 
05612 
05613     virtual void __write(::IceInternal::BasicStream*) const;
05614     virtual void __read(::IceInternal::BasicStream*, bool);
05615     virtual void __write(const ::Ice::OutputStreamPtr&) const;
05616     virtual void __read(const ::Ice::InputStreamPtr&, bool);
05617 
05618     static const ::Ice::ObjectFactoryPtr& ice_factory();
05619 
05620 protected:
05621 
05622     virtual ~MotorMessage() {}
05623 
05624     friend class MotorMessage__staticInit;
05625 
05626 public:
05627 
05628     ::Ice::Int rcMode;
05629 
05630     ::Ice::Int motor1;
05631 
05632     ::Ice::Int motor2;
05633 
05634     ::Ice::Double transVel;
05635 
05636     ::Ice::Double rotVel;
05637 
05638     ::Ice::Double encoderX;
05639 
05640     ::Ice::Double encoderY;
05641 
05642     ::Ice::Double encoderOri;
05643 
05644     ::Ice::Double rcTransVel;
05645 
05646     ::Ice::Double rcRotVel;
05647 
05648     ::Ice::Int RequestID;
05649 };
05650 
05651 class MotorMessage__staticInit
05652 {
05653 public:
05654 
05655     ::BeobotEvents::MotorMessage _init;
05656 };
05657 
05658 static MotorMessage__staticInit _MotorMessage_init;
05659 
05660 class MotorRequest : virtual public ::RobotSimEvents::EventMessage
05661 {
05662 public:
05663 
05664     typedef MotorRequestPrx ProxyType;
05665     typedef MotorRequestPtr PointerType;
05666 
05667     MotorRequest() {}
05668     MotorRequest(::Ice::Double, ::Ice::Double);
05669     virtual ::Ice::ObjectPtr ice_clone() const;
05670 
05671     virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
05672     virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
05673     virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
05674     static const ::std::string& ice_staticId();
05675 
05676 
05677     virtual void __write(::IceInternal::BasicStream*) const;
05678     virtual void __read(::IceInternal::BasicStream*, bool);
05679     virtual void __write(const ::Ice::OutputStreamPtr&) const;
05680     virtual void __read(const ::Ice::InputStreamPtr&, bool);
05681 
05682     static const ::Ice::ObjectFactoryPtr& ice_factory();
05683 
05684 protected:
05685 
05686     virtual ~MotorRequest() {}
05687 
05688 public:
05689 
05690     ::Ice::Double transVel;
05691 
05692     ::Ice::Double rotVel;
05693 };
05694 
05695 class CornerMotorRequest : virtual public ::RobotSimEvents::EventMessage
05696 {
05697 public:
05698 
05699     typedef CornerMotorRequestPrx ProxyType;
05700     typedef CornerMotorRequestPtr PointerType;
05701 
05702     CornerMotorRequest() {}
05703     CornerMotorRequest(::Ice::Double, ::Ice::Double, ::Ice::Int);
05704     virtual ::Ice::ObjectPtr ice_clone() const;
05705 
05706     virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
05707     virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
05708     virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
05709     static const ::std::string& ice_staticId();
05710 
05711 
05712     virtual void __write(::IceInternal::BasicStream*) const;
05713     virtual void __read(::IceInternal::BasicStream*, bool);
05714     virtual void __write(const ::Ice::OutputStreamPtr&) const;
05715     virtual void __read(const ::Ice::InputStreamPtr&, bool);
05716 
05717     static const ::Ice::ObjectFactoryPtr& ice_factory();
05718 
05719 protected:
05720 
05721     virtual ~CornerMotorRequest() {}
05722 
05723 public:
05724 
05725     ::Ice::Double transVel;
05726 
05727     ::Ice::Double rotVel;
05728 
05729     ::Ice::Int status;
05730 };
05731 
05732 class CornerLocationMessage : virtual public ::RobotSimEvents::EventMessage
05733 {
05734 public:
05735 
05736     typedef CornerLocationMessagePrx ProxyType;
05737     typedef CornerLocationMessagePtr PointerType;
05738 
05739     CornerLocationMessage() {}
05740     explicit CornerLocationMessage(::Ice::Int);
05741     virtual ::Ice::ObjectPtr ice_clone() const;
05742 
05743     virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
05744     virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
05745     virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
05746     static const ::std::string& ice_staticId();
05747 
05748 
05749     virtual void __write(::IceInternal::BasicStream*) const;
05750     virtual void __read(::IceInternal::BasicStream*, bool);
05751     virtual void __write(const ::Ice::OutputStreamPtr&) const;
05752     virtual void __read(const ::Ice::InputStreamPtr&, bool);
05753 
05754     static const ::Ice::ObjectFactoryPtr& ice_factory();
05755 
05756 protected:
05757 
05758     virtual ~CornerLocationMessage() {}
05759 
05760 public:
05761 
05762     ::Ice::Int cornerLocation;
05763 };
05764 
05765 class SonarMessage : virtual public ::RobotSimEvents::EventMessage
05766 {
05767 public:
05768 
05769     typedef SonarMessagePrx ProxyType;
05770     typedef SonarMessagePtr PointerType;
05771 
05772     SonarMessage() {}
05773     SonarMessage(const ::BeobotEvents::DoubleSeq&, const ::BeobotEvents::DoubleSeq&);
05774     virtual ::Ice::ObjectPtr ice_clone() const;
05775 
05776     virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
05777     virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
05778     virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
05779     static const ::std::string& ice_staticId();
05780 
05781 
05782     virtual void __write(::IceInternal::BasicStream*) const;
05783     virtual void __read(::IceInternal::BasicStream*, bool);
05784     virtual void __write(const ::Ice::OutputStreamPtr&) const;
05785     virtual void __read(const ::Ice::InputStreamPtr&, bool);
05786 
05787     static const ::Ice::ObjectFactoryPtr& ice_factory();
05788 
05789 protected:
05790 
05791     virtual ~SonarMessage() {}
05792 
05793 public:
05794 
05795     ::BeobotEvents::DoubleSeq distances;
05796 
05797     ::BeobotEvents::DoubleSeq angles;
05798 };
05799 
05800 class GPSMessage : virtual public ::RobotSimEvents::EventMessage
05801 {
05802 public:
05803 
05804     typedef GPSMessagePrx ProxyType;
05805     typedef GPSMessagePtr PointerType;
05806 
05807     GPSMessage() {}
05808     GPSMessage(::Ice::Double, ::Ice::Double, ::Ice::Int, ::Ice::Int, ::Ice::Int);
05809     virtual ::Ice::ObjectPtr ice_clone() const;
05810 
05811     virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
05812     virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
05813     virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
05814     static const ::std::string& ice_staticId();
05815 
05816 
05817     virtual void __write(::IceInternal::BasicStream*) const;
05818     virtual void __read(::IceInternal::BasicStream*, bool);
05819     virtual void __write(const ::Ice::OutputStreamPtr&) const;
05820     virtual void __read(const ::Ice::InputStreamPtr&, bool);
05821 
05822     static const ::Ice::ObjectFactoryPtr& ice_factory();
05823 
05824 protected:
05825 
05826     virtual ~GPSMessage() {}
05827 
05828 public:
05829 
05830     ::Ice::Double latitude;
05831 
05832     ::Ice::Double longitude;
05833 
05834     ::Ice::Int precision;
05835 
05836     ::Ice::Int satNum;
05837 
05838     ::Ice::Int RequestID;
05839 };
05840 
05841 class LRFMessage : virtual public ::RobotSimEvents::EventMessage
05842 {
05843 public:
05844 
05845     typedef LRFMessagePrx ProxyType;
05846     typedef LRFMessagePtr PointerType;
05847 
05848     LRFMessage() {}
05849     LRFMessage(const ::BeobotEvents::DoubleSeq&, const ::BeobotEvents::DoubleSeq&, ::Ice::Int);
05850     virtual ::Ice::ObjectPtr ice_clone() const;
05851 
05852     virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
05853     virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
05854     virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
05855     static const ::std::string& ice_staticId();
05856 
05857 
05858     virtual void __write(::IceInternal::BasicStream*) const;
05859     virtual void __read(::IceInternal::BasicStream*, bool);
05860     virtual void __write(const ::Ice::OutputStreamPtr&) const;
05861     virtual void __read(const ::Ice::InputStreamPtr&, bool);
05862 
05863     static const ::Ice::ObjectFactoryPtr& ice_factory();
05864 
05865 protected:
05866 
05867     virtual ~LRFMessage() {}
05868 
05869 public:
05870 
05871     ::BeobotEvents::DoubleSeq distances;
05872 
05873     ::BeobotEvents::DoubleSeq angles;
05874 
05875     ::Ice::Int RequestID;
05876 };
05877 
05878 class SLAMMessage : virtual public ::RobotSimEvents::EventMessage
05879 {
05880 public:
05881 
05882     typedef SLAMMessagePrx ProxyType;
05883     typedef SLAMMessagePtr PointerType;
05884 
05885     SLAMMessage() {}
05886     SLAMMessage(::Ice::Double, ::Ice::Double, ::Ice::Double, ::Ice::Double, ::Ice::Int);
05887     virtual ::Ice::ObjectPtr ice_clone() const;
05888 
05889     virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
05890     virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
05891     virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
05892     static const ::std::string& ice_staticId();
05893 
05894 
05895     virtual void __write(::IceInternal::BasicStream*) const;
05896     virtual void __read(::IceInternal::BasicStream*, bool);
05897     virtual void __write(const ::Ice::OutputStreamPtr&) const;
05898     virtual void __read(const ::Ice::InputStreamPtr&, bool);
05899 
05900     static const ::Ice::ObjectFactoryPtr& ice_factory();
05901 
05902 protected:
05903 
05904     virtual ~SLAMMessage() {}
05905 
05906 public:
05907 
05908     ::Ice::Double mapResolution;
05909 
05910     ::Ice::Double robotX;
05911 
05912     ::Ice::Double robotY;
05913 
05914     ::Ice::Double robotOri;
05915 
05916     ::Ice::Int RequestID;
05917 };
05918 
05919 class IMUMessage : virtual public ::RobotSimEvents::EventMessage
05920 {
05921 public:
05922 
05923     typedef IMUMessagePrx ProxyType;
05924     typedef IMUMessagePtr PointerType;
05925 
05926     IMUMessage() {}
05927     IMUMessage(bool, ::Ice::Float, ::Ice::Float, ::Ice::Float, ::Ice::Float, ::Ice::Float, ::Ice::Float, bool, ::Ice::Float, ::Ice::Float, ::Ice::Float, bool, ::Ice::Float, ::Ice::Float, ::Ice::Float, ::Ice::Int);
05928     virtual ::Ice::ObjectPtr ice_clone() const;
05929 
05930     virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
05931     virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
05932     virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
05933     static const ::std::string& ice_staticId();
05934 
05935 
05936     virtual void __write(::IceInternal::BasicStream*) const;
05937     virtual void __read(::IceInternal::BasicStream*, bool);
05938     virtual void __write(const ::Ice::OutputStreamPtr&) const;
05939     virtual void __read(const ::Ice::InputStreamPtr&, bool);
05940 
05941     static const ::Ice::ObjectFactoryPtr& ice_factory();
05942 
05943 protected:
05944 
05945     virtual ~IMUMessage() {}
05946 
05947 public:
05948 
05949     bool validAccAndAng;
05950 
05951     ::Ice::Float accelX;
05952 
05953     ::Ice::Float accelY;
05954 
05955     ::Ice::Float accelZ;
05956 
05957     ::Ice::Float angRateX;
05958 
05959     ::Ice::Float angRateY;
05960 
05961     ::Ice::Float angRateZ;
05962 
05963     bool validRollPitchYaw;
05964 
05965     ::Ice::Float roll;
05966 
05967     ::Ice::Float pitch;
05968 
05969     ::Ice::Float yaw;
05970 
05971     bool validMagnetometer;
05972 
05973     ::Ice::Float magX;
05974 
05975     ::Ice::Float magY;
05976 
05977     ::Ice::Float magZ;
05978 
05979     ::Ice::Int RequestID;
05980 };
05981 
05982 class CameraMessage : virtual public ::RobotSimEvents::EventMessage
05983 {
05984 public:
05985 
05986     typedef CameraMessagePrx ProxyType;
05987     typedef CameraMessagePtr PointerType;
05988 
05989     CameraMessage() {}
05990     CameraMessage(const ::ImageIceMod::ImageIce&, ::Ice::Int);
05991     virtual ::Ice::ObjectPtr ice_clone() const;
05992 
05993     virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
05994     virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
05995     virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
05996     static const ::std::string& ice_staticId();
05997 
05998 
05999     virtual void __write(::IceInternal::BasicStream*) const;
06000     virtual void __read(::IceInternal::BasicStream*, bool);
06001     virtual void __write(const ::Ice::OutputStreamPtr&) const;
06002     virtual void __read(const ::Ice::InputStreamPtr&, bool);
06003 
06004     static const ::Ice::ObjectFactoryPtr& ice_factory();
06005 
06006 protected:
06007 
06008     virtual ~CameraMessage() {}
06009 
06010 public:
06011 
06012     ::ImageIceMod::ImageIce image;
06013 
06014     ::Ice::Int RequestID;
06015 };
06016 
06017 class GistSalMessage : virtual public ::RobotSimEvents::EventMessage
06018 {
06019 public:
06020 
06021     typedef GistSalMessagePrx ProxyType;
06022     typedef GistSalMessagePtr PointerType;
06023 
06024     GistSalMessage() {}
06025     GistSalMessage(const ::ImageIceMod::ImageIce&, const ::BeobotEvents::DoubleSeq&, const ::BeobotEvents::SalientRegionSeq&, const ::ImageIceMod::ImageIceSeq&, ::Ice::Int);
06026     virtual ::Ice::ObjectPtr ice_clone() const;
06027 
06028     virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
06029     virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
06030     virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
06031     static const ::std::string& ice_staticId();
06032 
06033 
06034     virtual void __write(::IceInternal::BasicStream*) const;
06035     virtual void __read(::IceInternal::BasicStream*, bool);
06036     virtual void __write(const ::Ice::OutputStreamPtr&) const;
06037     virtual void __read(const ::Ice::InputStreamPtr&, bool);
06038 
06039     static const ::Ice::ObjectFactoryPtr& ice_factory();
06040 
06041 protected:
06042 
06043     virtual ~GistSalMessage() {}
06044 
06045 public:
06046 
06047     ::ImageIceMod::ImageIce currIma;
06048 
06049     ::BeobotEvents::DoubleSeq gistFeatures;
06050 
06051     ::BeobotEvents::SalientRegionSeq salientRegions;
06052 
06053     ::ImageIceMod::ImageIceSeq conspicuityMaps;
06054 
06055     ::Ice::Int RequestID;
06056 };
06057 
06058 class LandmarkSearchQueueMessage : virtual public ::RobotSimEvents::EventMessage
06059 {
06060 public:
06061 
06062     typedef LandmarkSearchQueueMessagePrx ProxyType;
06063     typedef LandmarkSearchQueueMessagePtr PointerType;
06064 
06065     LandmarkSearchQueueMessage() {}
06066     LandmarkSearchQueueMessage(const ::ImageIceMod::ImageIce&, const ::BeobotEvents::SalientRegionSeq&, const ::BeobotEvents::LandmarkSearchJobSeq&, ::Ice::Int);
06067     virtual ::Ice::ObjectPtr ice_clone() const;
06068 
06069     virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
06070     virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
06071     virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
06072     static const ::std::string& ice_staticId();
06073 
06074 
06075     virtual void __write(::IceInternal::BasicStream*) const;
06076     virtual void __read(::IceInternal::BasicStream*, bool);
06077     virtual void __write(const ::Ice::OutputStreamPtr&) const;
06078     virtual void __read(const ::Ice::InputStreamPtr&, bool);
06079 
06080     static const ::Ice::ObjectFactoryPtr& ice_factory();
06081 
06082 protected:
06083 
06084     virtual ~LandmarkSearchQueueMessage() {}
06085 
06086 public:
06087 
06088     ::ImageIceMod::ImageIce currIma;
06089 
06090     ::BeobotEvents::SalientRegionSeq salientRegions;
06091 
06092     ::BeobotEvents::LandmarkSearchJobSeq jobs;
06093 
06094     ::Ice::Int RequestID;
06095 };
06096 
06097 class LandmarkTrackMessage : virtual public ::RobotSimEvents::EventMessage
06098 {
06099 public:
06100 
06101     typedef LandmarkTrackMessagePrx ProxyType;
06102     typedef LandmarkTrackMessagePtr PointerType;
06103 
06104     LandmarkTrackMessage() {}
06105     LandmarkTrackMessage(const ::ImageIceMod::ImageIce&, const ::BeobotEvents::DoubleSeq&, const ::BeobotEvents::SalientRegionSeq&, const ::ImageIceMod::ImageIceSeq&, bool, ::Ice::Int);
06106     virtual ::Ice::ObjectPtr ice_clone() const;
06107 
06108     virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
06109     virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
06110     virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
06111     static const ::std::string& ice_staticId();
06112 
06113 
06114     virtual void __write(::IceInternal::BasicStream*) const;
06115     virtual void __read(::IceInternal::BasicStream*, bool);
06116     virtual void __write(const ::Ice::OutputStreamPtr&) const;
06117     virtual void __read(const ::Ice::InputStreamPtr&, bool);
06118 
06119     static const ::Ice::ObjectFactoryPtr& ice_factory();
06120 
06121 protected:
06122 
06123     virtual ~LandmarkTrackMessage() {}
06124 
06125 public:
06126 
06127     ::ImageIceMod::ImageIce currIma;
06128 
06129     ::BeobotEvents::DoubleSeq gistFeatures;
06130 
06131     ::BeobotEvents::SalientRegionSeq salientRegions;
06132 
06133     ::ImageIceMod::ImageIceSeq conspicuityMaps;
06134 
06135     bool resetTracker;
06136 
06137     ::Ice::Int RequestID;
06138 };
06139 
06140 class LandmarkSearchStatMessage : virtual public ::RobotSimEvents::EventMessage
06141 {
06142 public:
06143 
06144     typedef LandmarkSearchStatMessagePrx ProxyType;
06145     typedef LandmarkSearchStatMessagePtr PointerType;
06146 
06147     LandmarkSearchStatMessage() {}
06148     LandmarkSearchStatMessage(::Ice::Int, ::Ice::Int, bool, ::Ice::Int);
06149     virtual ::Ice::ObjectPtr ice_clone() const;
06150 
06151     virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
06152     virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
06153     virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
06154     static const ::std::string& ice_staticId();
06155 
06156 
06157     virtual void __write(::IceInternal::BasicStream*) const;
06158     virtual void __read(::IceInternal::BasicStream*, bool);
06159     virtual void __write(const ::Ice::OutputStreamPtr&) const;
06160     virtual void __read(const ::Ice::InputStreamPtr&, bool);
06161 
06162     static const ::Ice::ObjectFactoryPtr& ice_factory();
06163 
06164 protected:
06165 
06166     virtual ~LandmarkSearchStatMessage() {}
06167 
06168 public:
06169 
06170     ::Ice::Int inputSalRegID;
06171 
06172     ::Ice::Int numObjSearch;
06173 
06174     bool found;
06175 
06176     ::Ice::Int RequestID;
06177 };
06178 
06179 class LandmarkMatchResultMessage : virtual public ::RobotSimEvents::EventMessage
06180 {
06181 public:
06182 
06183     typedef LandmarkMatchResultMessagePrx ProxyType;
06184     typedef LandmarkMatchResultMessagePtr PointerType;
06185 
06186     LandmarkMatchResultMessage() {}
06187     LandmarkMatchResultMessage(::Ice::Int, const ::ImageIceMod::ImageIce&, const ::BeobotEvents::LandmarkSearchJob&, ::Ice::Int, ::Ice::Float, ::Ice::Float);
06188     virtual ::Ice::ObjectPtr ice_clone() const;
06189 
06190     virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
06191     virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
06192     virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
06193     static const ::std::string& ice_staticId();
06194 
06195 
06196     virtual void __write(::IceInternal::BasicStream*) const;
06197     virtual void __read(::IceInternal::BasicStream*, bool);
06198     virtual void __write(const ::Ice::OutputStreamPtr&) const;
06199     virtual void __read(const ::Ice::InputStreamPtr&, bool);
06200 
06201     static const ::Ice::ObjectFactoryPtr& ice_factory();
06202 
06203 protected:
06204 
06205     virtual ~LandmarkMatchResultMessage() {}
06206 
06207 public:
06208 
06209     ::Ice::Int RequestID;
06210 
06211     ::ImageIceMod::ImageIce voMatchImage;
06212 
06213     ::BeobotEvents::LandmarkSearchJob matchInfo;
06214 
06215     ::Ice::Int segNumMatch;
06216 
06217     ::Ice::Float lenTravMatch;
06218 
06219     ::Ice::Float MatchScore;
06220 };
06221 
06222 class LandmarkDBSearchResultMessage : virtual public ::RobotSimEvents::EventMessage
06223 {
06224 public:
06225 
06226     typedef LandmarkDBSearchResultMessagePrx ProxyType;
06227     typedef LandmarkDBSearchResultMessagePtr PointerType;
06228 
06229     LandmarkDBSearchResultMessage() {}
06230     LandmarkDBSearchResultMessage(::Ice::Int, const ::BeobotEvents::LandmarkSearchJobSeq&);
06231     virtual ::Ice::ObjectPtr ice_clone() const;
06232 
06233     virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
06234     virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
06235     virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
06236     static const ::std::string& ice_staticId();
06237 
06238 
06239     virtual void __write(::IceInternal::BasicStream*) const;
06240     virtual void __read(::IceInternal::BasicStream*, bool);
06241     virtual void __write(const ::Ice::OutputStreamPtr&) const;
06242     virtual void __read(const ::Ice::InputStreamPtr&, bool);
06243 
06244     static const ::Ice::ObjectFactoryPtr& ice_factory();
06245 
06246 protected:
06247 
06248     virtual ~LandmarkDBSearchResultMessage() {}
06249 
06250 public:
06251 
06252     ::Ice::Int RequestID;
06253 
06254     ::BeobotEvents::LandmarkSearchJobSeq matches;
06255 };
06256 
06257 class CurrentLocationMessage : virtual public ::RobotSimEvents::EventMessage
06258 {
06259 public:
06260 
06261     typedef CurrentLocationMessagePrx ProxyType;
06262     typedef CurrentLocationMessagePtr PointerType;
06263 
06264     CurrentLocationMessage() {}
06265     CurrentLocationMessage(::Ice::Int, ::Ice::Int, ::Ice::Float);
06266     virtual ::Ice::ObjectPtr ice_clone() const;
06267 
06268     virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
06269     virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
06270     virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
06271     static const ::std::string& ice_staticId();
06272 
06273 
06274     virtual void __write(::IceInternal::BasicStream*) const;
06275     virtual void __read(::IceInternal::BasicStream*, bool);
06276     virtual void __write(const ::Ice::OutputStreamPtr&) const;
06277     virtual void __read(const ::Ice::InputStreamPtr&, bool);
06278 
06279     static const ::Ice::ObjectFactoryPtr& ice_factory();
06280 
06281 protected:
06282 
06283     virtual ~CurrentLocationMessage() {}
06284 
06285 public:
06286 
06287     ::Ice::Int RequestID;
06288 
06289     ::Ice::Int segNum;
06290 
06291     ::Ice::Float lenTrav;
06292 };
06293 
06294 class CancelSearchMessage : virtual public ::RobotSimEvents::EventMessage
06295 {
06296 public:
06297 
06298     typedef CancelSearchMessagePrx ProxyType;
06299     typedef CancelSearchMessagePtr PointerType;
06300 
06301     CancelSearchMessage() {}
06302     CancelSearchMessage(::Ice::Int, bool);
06303     virtual ::Ice::ObjectPtr ice_clone() const;
06304 
06305     virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
06306     virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
06307     virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
06308     static const ::std::string& ice_staticId();
06309 
06310 
06311     virtual void __write(::IceInternal::BasicStream*) const;
06312     virtual void __read(::IceInternal::BasicStream*, bool);
06313     virtual void __write(const ::Ice::OutputStreamPtr&) const;
06314     virtual void __read(const ::Ice::InputStreamPtr&, bool);
06315 
06316     static const ::Ice::ObjectFactoryPtr& ice_factory();
06317 
06318 protected:
06319 
06320     virtual ~CancelSearchMessage() {}
06321 
06322 public:
06323 
06324     ::Ice::Int RequestID;
06325 
06326     bool abort;
06327 };
06328 
06329 class SearchDoneMessage : virtual public ::RobotSimEvents::EventMessage
06330 {
06331 public:
06332 
06333     typedef SearchDoneMessagePrx ProxyType;
06334     typedef SearchDoneMessagePtr PointerType;
06335 
06336     SearchDoneMessage() {}
06337     explicit SearchDoneMessage(::Ice::Int);
06338     virtual ::Ice::ObjectPtr ice_clone() const;
06339 
06340     virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
06341     virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
06342     virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
06343     static const ::std::string& ice_staticId();
06344 
06345 
06346     virtual void __write(::IceInternal::BasicStream*) const;
06347     virtual void __read(::IceInternal::BasicStream*, bool);
06348     virtual void __write(const ::Ice::OutputStreamPtr&) const;
06349     virtual void __read(const ::Ice::InputStreamPtr&, bool);
06350 
06351     static const ::Ice::ObjectFactoryPtr& ice_factory();
06352 
06353 protected:
06354 
06355     virtual ~SearchDoneMessage() {}
06356 
06357 public:
06358 
06359     ::Ice::Int RequestID;
06360 };
06361 
06362 class NextFrameMessage : virtual public ::RobotSimEvents::EventMessage
06363 {
06364 public:
06365 
06366     typedef NextFrameMessagePrx ProxyType;
06367     typedef NextFrameMessagePtr PointerType;
06368 
06369     NextFrameMessage() {}
06370     explicit NextFrameMessage(::Ice::Int);
06371     virtual ::Ice::ObjectPtr ice_clone() const;
06372 
06373     virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
06374     virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
06375     virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
06376     static const ::std::string& ice_staticId();
06377 
06378 
06379     virtual void __write(::IceInternal::BasicStream*) const;
06380     virtual void __read(::IceInternal::BasicStream*, bool);
06381     virtual void __write(const ::Ice::OutputStreamPtr&) const;
06382     virtual void __read(const ::Ice::InputStreamPtr&, bool);
06383 
06384     static const ::Ice::ObjectFactoryPtr& ice_factory();
06385 
06386 protected:
06387 
06388     virtual ~NextFrameMessage() {}
06389 
06390 public:
06391 
06392     ::Ice::Int RequestID;
06393 };
06394 
06395 class AbortMessage : virtual public ::RobotSimEvents::EventMessage
06396 {
06397 public:
06398 
06399     typedef AbortMessagePrx ProxyType;
06400     typedef AbortMessagePtr PointerType;
06401 
06402     AbortMessage() {}
06403     explicit AbortMessage(::Ice::Int);
06404     virtual ::Ice::ObjectPtr ice_clone() const;
06405 
06406     virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
06407     virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
06408     virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
06409     static const ::std::string& ice_staticId();
06410 
06411 
06412     virtual void __write(::IceInternal::BasicStream*) const;
06413     virtual void __read(::IceInternal::BasicStream*, bool);
06414     virtual void __write(const ::Ice::OutputStreamPtr&) const;
06415     virtual void __read(const ::Ice::InputStreamPtr&, bool);
06416 
06417     static const ::Ice::ObjectFactoryPtr& ice_factory();
06418 
06419 protected:
06420 
06421     virtual ~AbortMessage() {}
06422 
06423 public:
06424 
06425     ::Ice::Int RequestID;
06426 };
06427 
06428 class FacesMessage : virtual public ::RobotSimEvents::EventMessage
06429 {
06430 public:
06431 
06432     typedef FacesMessagePrx ProxyType;
06433     typedef FacesMessagePtr PointerType;
06434 
06435     FacesMessage() {}
06436     FacesMessage(const ::BeobotEvents::RectangleIceSeq&, ::Ice::Int);
06437     virtual ::Ice::ObjectPtr ice_clone() const;
06438 
06439     virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
06440     virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
06441     virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
06442     static const ::std::string& ice_staticId();
06443 
06444 
06445     virtual void __write(::IceInternal::BasicStream*) const;
06446     virtual void __read(::IceInternal::BasicStream*, bool);
06447     virtual void __write(const ::Ice::OutputStreamPtr&) const;
06448     virtual void __read(const ::Ice::InputStreamPtr&, bool);
06449 
06450     static const ::Ice::ObjectFactoryPtr& ice_factory();
06451 
06452 protected:
06453 
06454     virtual ~FacesMessage() {}
06455 
06456 public:
06457 
06458     ::BeobotEvents::RectangleIceSeq faces;
06459 
06460     ::Ice::Int RequestID;
06461 };
06462 
06463 class GUISpeechMessage : virtual public ::RobotSimEvents::EventMessage
06464 {
06465 public:
06466 
06467     typedef GUISpeechMessagePrx ProxyType;
06468     typedef GUISpeechMessagePtr PointerType;
06469 
06470     GUISpeechMessage() {}
06471     GUISpeechMessage(::Ice::Int, const ::std::string&, ::Ice::Int);
06472     virtual ::Ice::ObjectPtr ice_clone() const;
06473 
06474     virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
06475     virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
06476     virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
06477     static const ::std::string& ice_staticId();
06478 
06479 
06480     virtual void __write(::IceInternal::BasicStream*) const;
06481     virtual void __read(::IceInternal::BasicStream*, bool);
06482     virtual void __write(const ::Ice::OutputStreamPtr&) const;
06483     virtual void __read(const ::Ice::InputStreamPtr&, bool);
06484 
06485     static const ::Ice::ObjectFactoryPtr& ice_factory();
06486 
06487 protected:
06488 
06489     virtual ~GUISpeechMessage() {}
06490 
06491 public:
06492 
06493     ::Ice::Int RequestID;
06494 
06495     ::std::string itsMessage;
06496 
06497     ::Ice::Int itsCommand;
06498 };
06499 
06500 }
06501 
06502 #endif
Generated on Sun May 8 08:40:43 2011 for iLab Neuromorphic Vision Toolkit by  doxygen 1.6.3