00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013 #ifndef __src_Ice__RobotSimEvents_ice_H__
00014 #define __src_Ice__RobotSimEvents_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/UndefSysMacros.h>
00030
00031 #ifndef ICE_IGNORE_VERSION
00032 # if ICE_INT_VERSION / 100 != 303
00033 # error Ice version mismatch!
00034 # endif
00035 # if ICE_INT_VERSION % 100 > 50
00036 # error Beta header file detected
00037 # endif
00038 # if ICE_INT_VERSION % 100 < 1
00039 # error Ice patch level mismatch!
00040 # endif
00041 #endif
00042
00043 namespace IceProxy
00044 {
00045
00046 namespace RobotSimEvents
00047 {
00048
00049 class EventMessage;
00050
00051 class Events;
00052
00053 class ActionMessage;
00054
00055 class GPSMessage;
00056
00057 class MotionMessage;
00058
00059 class RetinaMessage;
00060
00061 class MovementControllerMessage;
00062
00063 class JoyStickControlMessage;
00064
00065 class BeeStemConfigMessage;
00066
00067 class IMUDataServerMessage;
00068
00069 class BeeStemMotorControllerMessage;
00070
00071 class LocalizationMessage;
00072
00073 class BeeStemMessage;
00074
00075 class ChatMessage;
00076
00077 class RemoteControlMessage;
00078
00079 class StateMessage;
00080
00081 class GoalStateMessage;
00082
00083 class GoalProgressMessage;
00084
00085 class AttendedRegionMessage;
00086
00087 class ObjectMessage;
00088
00089 class SeaBeePositionMessage;
00090
00091 class SeaBeeStateConditionMessage;
00092
00093 class VisionRectangleMessage;
00094
00095 class StraightEdgeMessage;
00096
00097 class VisionObjectMessage;
00098
00099 class LandmarksMessage;
00100
00101 class CameraConfigMessage;
00102
00103 class SalientPointMessage;
00104
00105 class BuoyColorSegmentMessage;
00106
00107 class PipeColorSegmentMessage;
00108
00109 class BuoyColorSegmentConfigMessage;
00110
00111 class PipeColorSegmentConfigMessage;
00112
00113 }
00114
00115 }
00116
00117 namespace RobotSimEvents
00118 {
00119
00120 class EventMessage;
00121 bool operator==(const EventMessage&, const EventMessage&);
00122 bool operator<(const EventMessage&, const EventMessage&);
00123
00124 class Events;
00125 bool operator==(const Events&, const Events&);
00126 bool operator<(const Events&, const Events&);
00127
00128 class ActionMessage;
00129 bool operator==(const ActionMessage&, const ActionMessage&);
00130 bool operator<(const ActionMessage&, const ActionMessage&);
00131
00132 class GPSMessage;
00133 bool operator==(const GPSMessage&, const GPSMessage&);
00134 bool operator<(const GPSMessage&, const GPSMessage&);
00135
00136 class MotionMessage;
00137 bool operator==(const MotionMessage&, const MotionMessage&);
00138 bool operator<(const MotionMessage&, const MotionMessage&);
00139
00140 class RetinaMessage;
00141 bool operator==(const RetinaMessage&, const RetinaMessage&);
00142 bool operator<(const RetinaMessage&, const RetinaMessage&);
00143
00144 class MovementControllerMessage;
00145 bool operator==(const MovementControllerMessage&, const MovementControllerMessage&);
00146 bool operator<(const MovementControllerMessage&, const MovementControllerMessage&);
00147
00148 class JoyStickControlMessage;
00149 bool operator==(const JoyStickControlMessage&, const JoyStickControlMessage&);
00150 bool operator<(const JoyStickControlMessage&, const JoyStickControlMessage&);
00151
00152 class BeeStemConfigMessage;
00153 bool operator==(const BeeStemConfigMessage&, const BeeStemConfigMessage&);
00154 bool operator<(const BeeStemConfigMessage&, const BeeStemConfigMessage&);
00155
00156 class IMUDataServerMessage;
00157 bool operator==(const IMUDataServerMessage&, const IMUDataServerMessage&);
00158 bool operator<(const IMUDataServerMessage&, const IMUDataServerMessage&);
00159
00160 class BeeStemMotorControllerMessage;
00161 bool operator==(const BeeStemMotorControllerMessage&, const BeeStemMotorControllerMessage&);
00162 bool operator<(const BeeStemMotorControllerMessage&, const BeeStemMotorControllerMessage&);
00163
00164 class LocalizationMessage;
00165 bool operator==(const LocalizationMessage&, const LocalizationMessage&);
00166 bool operator<(const LocalizationMessage&, const LocalizationMessage&);
00167
00168 class BeeStemMessage;
00169 bool operator==(const BeeStemMessage&, const BeeStemMessage&);
00170 bool operator<(const BeeStemMessage&, const BeeStemMessage&);
00171
00172 class ChatMessage;
00173 bool operator==(const ChatMessage&, const ChatMessage&);
00174 bool operator<(const ChatMessage&, const ChatMessage&);
00175
00176 class RemoteControlMessage;
00177 bool operator==(const RemoteControlMessage&, const RemoteControlMessage&);
00178 bool operator<(const RemoteControlMessage&, const RemoteControlMessage&);
00179
00180 class StateMessage;
00181 bool operator==(const StateMessage&, const StateMessage&);
00182 bool operator<(const StateMessage&, const StateMessage&);
00183
00184 class GoalStateMessage;
00185 bool operator==(const GoalStateMessage&, const GoalStateMessage&);
00186 bool operator<(const GoalStateMessage&, const GoalStateMessage&);
00187
00188 class GoalProgressMessage;
00189 bool operator==(const GoalProgressMessage&, const GoalProgressMessage&);
00190 bool operator<(const GoalProgressMessage&, const GoalProgressMessage&);
00191
00192 class AttendedRegionMessage;
00193 bool operator==(const AttendedRegionMessage&, const AttendedRegionMessage&);
00194 bool operator<(const AttendedRegionMessage&, const AttendedRegionMessage&);
00195
00196 class ObjectMessage;
00197 bool operator==(const ObjectMessage&, const ObjectMessage&);
00198 bool operator<(const ObjectMessage&, const ObjectMessage&);
00199
00200 class SeaBeePositionMessage;
00201 bool operator==(const SeaBeePositionMessage&, const SeaBeePositionMessage&);
00202 bool operator<(const SeaBeePositionMessage&, const SeaBeePositionMessage&);
00203
00204 class SeaBeeStateConditionMessage;
00205 bool operator==(const SeaBeeStateConditionMessage&, const SeaBeeStateConditionMessage&);
00206 bool operator<(const SeaBeeStateConditionMessage&, const SeaBeeStateConditionMessage&);
00207
00208 class VisionRectangleMessage;
00209 bool operator==(const VisionRectangleMessage&, const VisionRectangleMessage&);
00210 bool operator<(const VisionRectangleMessage&, const VisionRectangleMessage&);
00211
00212 class StraightEdgeMessage;
00213 bool operator==(const StraightEdgeMessage&, const StraightEdgeMessage&);
00214 bool operator<(const StraightEdgeMessage&, const StraightEdgeMessage&);
00215
00216 class VisionObjectMessage;
00217 bool operator==(const VisionObjectMessage&, const VisionObjectMessage&);
00218 bool operator<(const VisionObjectMessage&, const VisionObjectMessage&);
00219
00220 class LandmarksMessage;
00221 bool operator==(const LandmarksMessage&, const LandmarksMessage&);
00222 bool operator<(const LandmarksMessage&, const LandmarksMessage&);
00223
00224 class CameraConfigMessage;
00225 bool operator==(const CameraConfigMessage&, const CameraConfigMessage&);
00226 bool operator<(const CameraConfigMessage&, const CameraConfigMessage&);
00227
00228 class SalientPointMessage;
00229 bool operator==(const SalientPointMessage&, const SalientPointMessage&);
00230 bool operator<(const SalientPointMessage&, const SalientPointMessage&);
00231
00232 class BuoyColorSegmentMessage;
00233 bool operator==(const BuoyColorSegmentMessage&, const BuoyColorSegmentMessage&);
00234 bool operator<(const BuoyColorSegmentMessage&, const BuoyColorSegmentMessage&);
00235
00236 class PipeColorSegmentMessage;
00237 bool operator==(const PipeColorSegmentMessage&, const PipeColorSegmentMessage&);
00238 bool operator<(const PipeColorSegmentMessage&, const PipeColorSegmentMessage&);
00239
00240 class BuoyColorSegmentConfigMessage;
00241 bool operator==(const BuoyColorSegmentConfigMessage&, const BuoyColorSegmentConfigMessage&);
00242 bool operator<(const BuoyColorSegmentConfigMessage&, const BuoyColorSegmentConfigMessage&);
00243
00244 class PipeColorSegmentConfigMessage;
00245 bool operator==(const PipeColorSegmentConfigMessage&, const PipeColorSegmentConfigMessage&);
00246 bool operator<(const PipeColorSegmentConfigMessage&, const PipeColorSegmentConfigMessage&);
00247
00248 }
00249
00250 namespace IceInternal
00251 {
00252
00253 ::Ice::Object* upCast(::RobotSimEvents::EventMessage*);
00254 ::IceProxy::Ice::Object* upCast(::IceProxy::RobotSimEvents::EventMessage*);
00255
00256 ::Ice::Object* upCast(::RobotSimEvents::Events*);
00257 ::IceProxy::Ice::Object* upCast(::IceProxy::RobotSimEvents::Events*);
00258
00259 ::Ice::Object* upCast(::RobotSimEvents::ActionMessage*);
00260 ::IceProxy::Ice::Object* upCast(::IceProxy::RobotSimEvents::ActionMessage*);
00261
00262 ::Ice::Object* upCast(::RobotSimEvents::GPSMessage*);
00263 ::IceProxy::Ice::Object* upCast(::IceProxy::RobotSimEvents::GPSMessage*);
00264
00265 ::Ice::Object* upCast(::RobotSimEvents::MotionMessage*);
00266 ::IceProxy::Ice::Object* upCast(::IceProxy::RobotSimEvents::MotionMessage*);
00267
00268 ::Ice::Object* upCast(::RobotSimEvents::RetinaMessage*);
00269 ::IceProxy::Ice::Object* upCast(::IceProxy::RobotSimEvents::RetinaMessage*);
00270
00271 ::Ice::Object* upCast(::RobotSimEvents::MovementControllerMessage*);
00272 ::IceProxy::Ice::Object* upCast(::IceProxy::RobotSimEvents::MovementControllerMessage*);
00273
00274 ::Ice::Object* upCast(::RobotSimEvents::JoyStickControlMessage*);
00275 ::IceProxy::Ice::Object* upCast(::IceProxy::RobotSimEvents::JoyStickControlMessage*);
00276
00277 ::Ice::Object* upCast(::RobotSimEvents::BeeStemConfigMessage*);
00278 ::IceProxy::Ice::Object* upCast(::IceProxy::RobotSimEvents::BeeStemConfigMessage*);
00279
00280 ::Ice::Object* upCast(::RobotSimEvents::IMUDataServerMessage*);
00281 ::IceProxy::Ice::Object* upCast(::IceProxy::RobotSimEvents::IMUDataServerMessage*);
00282
00283 ::Ice::Object* upCast(::RobotSimEvents::BeeStemMotorControllerMessage*);
00284 ::IceProxy::Ice::Object* upCast(::IceProxy::RobotSimEvents::BeeStemMotorControllerMessage*);
00285
00286 ::Ice::Object* upCast(::RobotSimEvents::LocalizationMessage*);
00287 ::IceProxy::Ice::Object* upCast(::IceProxy::RobotSimEvents::LocalizationMessage*);
00288
00289 ::Ice::Object* upCast(::RobotSimEvents::BeeStemMessage*);
00290 ::IceProxy::Ice::Object* upCast(::IceProxy::RobotSimEvents::BeeStemMessage*);
00291
00292 ::Ice::Object* upCast(::RobotSimEvents::ChatMessage*);
00293 ::IceProxy::Ice::Object* upCast(::IceProxy::RobotSimEvents::ChatMessage*);
00294
00295 ::Ice::Object* upCast(::RobotSimEvents::RemoteControlMessage*);
00296 ::IceProxy::Ice::Object* upCast(::IceProxy::RobotSimEvents::RemoteControlMessage*);
00297
00298 ::Ice::Object* upCast(::RobotSimEvents::StateMessage*);
00299 ::IceProxy::Ice::Object* upCast(::IceProxy::RobotSimEvents::StateMessage*);
00300
00301 ::Ice::Object* upCast(::RobotSimEvents::GoalStateMessage*);
00302 ::IceProxy::Ice::Object* upCast(::IceProxy::RobotSimEvents::GoalStateMessage*);
00303
00304 ::Ice::Object* upCast(::RobotSimEvents::GoalProgressMessage*);
00305 ::IceProxy::Ice::Object* upCast(::IceProxy::RobotSimEvents::GoalProgressMessage*);
00306
00307 ::Ice::Object* upCast(::RobotSimEvents::AttendedRegionMessage*);
00308 ::IceProxy::Ice::Object* upCast(::IceProxy::RobotSimEvents::AttendedRegionMessage*);
00309
00310 ::Ice::Object* upCast(::RobotSimEvents::ObjectMessage*);
00311 ::IceProxy::Ice::Object* upCast(::IceProxy::RobotSimEvents::ObjectMessage*);
00312
00313 ::Ice::Object* upCast(::RobotSimEvents::SeaBeePositionMessage*);
00314 ::IceProxy::Ice::Object* upCast(::IceProxy::RobotSimEvents::SeaBeePositionMessage*);
00315
00316 ::Ice::Object* upCast(::RobotSimEvents::SeaBeeStateConditionMessage*);
00317 ::IceProxy::Ice::Object* upCast(::IceProxy::RobotSimEvents::SeaBeeStateConditionMessage*);
00318
00319 ::Ice::Object* upCast(::RobotSimEvents::VisionRectangleMessage*);
00320 ::IceProxy::Ice::Object* upCast(::IceProxy::RobotSimEvents::VisionRectangleMessage*);
00321
00322 ::Ice::Object* upCast(::RobotSimEvents::StraightEdgeMessage*);
00323 ::IceProxy::Ice::Object* upCast(::IceProxy::RobotSimEvents::StraightEdgeMessage*);
00324
00325 ::Ice::Object* upCast(::RobotSimEvents::VisionObjectMessage*);
00326 ::IceProxy::Ice::Object* upCast(::IceProxy::RobotSimEvents::VisionObjectMessage*);
00327
00328 ::Ice::Object* upCast(::RobotSimEvents::LandmarksMessage*);
00329 ::IceProxy::Ice::Object* upCast(::IceProxy::RobotSimEvents::LandmarksMessage*);
00330
00331 ::Ice::Object* upCast(::RobotSimEvents::CameraConfigMessage*);
00332 ::IceProxy::Ice::Object* upCast(::IceProxy::RobotSimEvents::CameraConfigMessage*);
00333
00334 ::Ice::Object* upCast(::RobotSimEvents::SalientPointMessage*);
00335 ::IceProxy::Ice::Object* upCast(::IceProxy::RobotSimEvents::SalientPointMessage*);
00336
00337 ::Ice::Object* upCast(::RobotSimEvents::BuoyColorSegmentMessage*);
00338 ::IceProxy::Ice::Object* upCast(::IceProxy::RobotSimEvents::BuoyColorSegmentMessage*);
00339
00340 ::Ice::Object* upCast(::RobotSimEvents::PipeColorSegmentMessage*);
00341 ::IceProxy::Ice::Object* upCast(::IceProxy::RobotSimEvents::PipeColorSegmentMessage*);
00342
00343 ::Ice::Object* upCast(::RobotSimEvents::BuoyColorSegmentConfigMessage*);
00344 ::IceProxy::Ice::Object* upCast(::IceProxy::RobotSimEvents::BuoyColorSegmentConfigMessage*);
00345
00346 ::Ice::Object* upCast(::RobotSimEvents::PipeColorSegmentConfigMessage*);
00347 ::IceProxy::Ice::Object* upCast(::IceProxy::RobotSimEvents::PipeColorSegmentConfigMessage*);
00348
00349 }
00350
00351 namespace RobotSimEvents
00352 {
00353
00354 typedef ::IceInternal::Handle< ::RobotSimEvents::EventMessage> EventMessagePtr;
00355 typedef ::IceInternal::ProxyHandle< ::IceProxy::RobotSimEvents::EventMessage> EventMessagePrx;
00356
00357 void __read(::IceInternal::BasicStream*, EventMessagePrx&);
00358 void __patch__EventMessagePtr(void*, ::Ice::ObjectPtr&);
00359
00360 typedef ::IceInternal::Handle< ::RobotSimEvents::Events> EventsPtr;
00361 typedef ::IceInternal::ProxyHandle< ::IceProxy::RobotSimEvents::Events> EventsPrx;
00362
00363 void __read(::IceInternal::BasicStream*, EventsPrx&);
00364 void __patch__EventsPtr(void*, ::Ice::ObjectPtr&);
00365
00366 typedef ::IceInternal::Handle< ::RobotSimEvents::ActionMessage> ActionMessagePtr;
00367 typedef ::IceInternal::ProxyHandle< ::IceProxy::RobotSimEvents::ActionMessage> ActionMessagePrx;
00368
00369 void __read(::IceInternal::BasicStream*, ActionMessagePrx&);
00370 void __patch__ActionMessagePtr(void*, ::Ice::ObjectPtr&);
00371
00372 typedef ::IceInternal::Handle< ::RobotSimEvents::GPSMessage> GPSMessagePtr;
00373 typedef ::IceInternal::ProxyHandle< ::IceProxy::RobotSimEvents::GPSMessage> GPSMessagePrx;
00374
00375 void __read(::IceInternal::BasicStream*, GPSMessagePrx&);
00376 void __patch__GPSMessagePtr(void*, ::Ice::ObjectPtr&);
00377
00378 typedef ::IceInternal::Handle< ::RobotSimEvents::MotionMessage> MotionMessagePtr;
00379 typedef ::IceInternal::ProxyHandle< ::IceProxy::RobotSimEvents::MotionMessage> MotionMessagePrx;
00380
00381 void __read(::IceInternal::BasicStream*, MotionMessagePrx&);
00382 void __patch__MotionMessagePtr(void*, ::Ice::ObjectPtr&);
00383
00384 typedef ::IceInternal::Handle< ::RobotSimEvents::RetinaMessage> RetinaMessagePtr;
00385 typedef ::IceInternal::ProxyHandle< ::IceProxy::RobotSimEvents::RetinaMessage> RetinaMessagePrx;
00386
00387 void __read(::IceInternal::BasicStream*, RetinaMessagePrx&);
00388 void __patch__RetinaMessagePtr(void*, ::Ice::ObjectPtr&);
00389
00390 typedef ::IceInternal::Handle< ::RobotSimEvents::MovementControllerMessage> MovementControllerMessagePtr;
00391 typedef ::IceInternal::ProxyHandle< ::IceProxy::RobotSimEvents::MovementControllerMessage> MovementControllerMessagePrx;
00392
00393 void __read(::IceInternal::BasicStream*, MovementControllerMessagePrx&);
00394 void __patch__MovementControllerMessagePtr(void*, ::Ice::ObjectPtr&);
00395
00396 typedef ::IceInternal::Handle< ::RobotSimEvents::JoyStickControlMessage> JoyStickControlMessagePtr;
00397 typedef ::IceInternal::ProxyHandle< ::IceProxy::RobotSimEvents::JoyStickControlMessage> JoyStickControlMessagePrx;
00398
00399 void __read(::IceInternal::BasicStream*, JoyStickControlMessagePrx&);
00400 void __patch__JoyStickControlMessagePtr(void*, ::Ice::ObjectPtr&);
00401
00402 typedef ::IceInternal::Handle< ::RobotSimEvents::BeeStemConfigMessage> BeeStemConfigMessagePtr;
00403 typedef ::IceInternal::ProxyHandle< ::IceProxy::RobotSimEvents::BeeStemConfigMessage> BeeStemConfigMessagePrx;
00404
00405 void __read(::IceInternal::BasicStream*, BeeStemConfigMessagePrx&);
00406 void __patch__BeeStemConfigMessagePtr(void*, ::Ice::ObjectPtr&);
00407
00408 typedef ::IceInternal::Handle< ::RobotSimEvents::IMUDataServerMessage> IMUDataServerMessagePtr;
00409 typedef ::IceInternal::ProxyHandle< ::IceProxy::RobotSimEvents::IMUDataServerMessage> IMUDataServerMessagePrx;
00410
00411 void __read(::IceInternal::BasicStream*, IMUDataServerMessagePrx&);
00412 void __patch__IMUDataServerMessagePtr(void*, ::Ice::ObjectPtr&);
00413
00414 typedef ::IceInternal::Handle< ::RobotSimEvents::BeeStemMotorControllerMessage> BeeStemMotorControllerMessagePtr;
00415 typedef ::IceInternal::ProxyHandle< ::IceProxy::RobotSimEvents::BeeStemMotorControllerMessage> BeeStemMotorControllerMessagePrx;
00416
00417 void __read(::IceInternal::BasicStream*, BeeStemMotorControllerMessagePrx&);
00418 void __patch__BeeStemMotorControllerMessagePtr(void*, ::Ice::ObjectPtr&);
00419
00420 typedef ::IceInternal::Handle< ::RobotSimEvents::LocalizationMessage> LocalizationMessagePtr;
00421 typedef ::IceInternal::ProxyHandle< ::IceProxy::RobotSimEvents::LocalizationMessage> LocalizationMessagePrx;
00422
00423 void __read(::IceInternal::BasicStream*, LocalizationMessagePrx&);
00424 void __patch__LocalizationMessagePtr(void*, ::Ice::ObjectPtr&);
00425
00426 typedef ::IceInternal::Handle< ::RobotSimEvents::BeeStemMessage> BeeStemMessagePtr;
00427 typedef ::IceInternal::ProxyHandle< ::IceProxy::RobotSimEvents::BeeStemMessage> BeeStemMessagePrx;
00428
00429 void __read(::IceInternal::BasicStream*, BeeStemMessagePrx&);
00430 void __patch__BeeStemMessagePtr(void*, ::Ice::ObjectPtr&);
00431
00432 typedef ::IceInternal::Handle< ::RobotSimEvents::ChatMessage> ChatMessagePtr;
00433 typedef ::IceInternal::ProxyHandle< ::IceProxy::RobotSimEvents::ChatMessage> ChatMessagePrx;
00434
00435 void __read(::IceInternal::BasicStream*, ChatMessagePrx&);
00436 void __patch__ChatMessagePtr(void*, ::Ice::ObjectPtr&);
00437
00438 typedef ::IceInternal::Handle< ::RobotSimEvents::RemoteControlMessage> RemoteControlMessagePtr;
00439 typedef ::IceInternal::ProxyHandle< ::IceProxy::RobotSimEvents::RemoteControlMessage> RemoteControlMessagePrx;
00440
00441 void __read(::IceInternal::BasicStream*, RemoteControlMessagePrx&);
00442 void __patch__RemoteControlMessagePtr(void*, ::Ice::ObjectPtr&);
00443
00444 typedef ::IceInternal::Handle< ::RobotSimEvents::StateMessage> StateMessagePtr;
00445 typedef ::IceInternal::ProxyHandle< ::IceProxy::RobotSimEvents::StateMessage> StateMessagePrx;
00446
00447 void __read(::IceInternal::BasicStream*, StateMessagePrx&);
00448 void __patch__StateMessagePtr(void*, ::Ice::ObjectPtr&);
00449
00450 typedef ::IceInternal::Handle< ::RobotSimEvents::GoalStateMessage> GoalStateMessagePtr;
00451 typedef ::IceInternal::ProxyHandle< ::IceProxy::RobotSimEvents::GoalStateMessage> GoalStateMessagePrx;
00452
00453 void __read(::IceInternal::BasicStream*, GoalStateMessagePrx&);
00454 void __patch__GoalStateMessagePtr(void*, ::Ice::ObjectPtr&);
00455
00456 typedef ::IceInternal::Handle< ::RobotSimEvents::GoalProgressMessage> GoalProgressMessagePtr;
00457 typedef ::IceInternal::ProxyHandle< ::IceProxy::RobotSimEvents::GoalProgressMessage> GoalProgressMessagePrx;
00458
00459 void __read(::IceInternal::BasicStream*, GoalProgressMessagePrx&);
00460 void __patch__GoalProgressMessagePtr(void*, ::Ice::ObjectPtr&);
00461
00462 typedef ::IceInternal::Handle< ::RobotSimEvents::AttendedRegionMessage> AttendedRegionMessagePtr;
00463 typedef ::IceInternal::ProxyHandle< ::IceProxy::RobotSimEvents::AttendedRegionMessage> AttendedRegionMessagePrx;
00464
00465 void __read(::IceInternal::BasicStream*, AttendedRegionMessagePrx&);
00466 void __patch__AttendedRegionMessagePtr(void*, ::Ice::ObjectPtr&);
00467
00468 typedef ::IceInternal::Handle< ::RobotSimEvents::ObjectMessage> ObjectMessagePtr;
00469 typedef ::IceInternal::ProxyHandle< ::IceProxy::RobotSimEvents::ObjectMessage> ObjectMessagePrx;
00470
00471 void __read(::IceInternal::BasicStream*, ObjectMessagePrx&);
00472 void __patch__ObjectMessagePtr(void*, ::Ice::ObjectPtr&);
00473
00474 typedef ::IceInternal::Handle< ::RobotSimEvents::SeaBeePositionMessage> SeaBeePositionMessagePtr;
00475 typedef ::IceInternal::ProxyHandle< ::IceProxy::RobotSimEvents::SeaBeePositionMessage> SeaBeePositionMessagePrx;
00476
00477 void __read(::IceInternal::BasicStream*, SeaBeePositionMessagePrx&);
00478 void __patch__SeaBeePositionMessagePtr(void*, ::Ice::ObjectPtr&);
00479
00480 typedef ::IceInternal::Handle< ::RobotSimEvents::SeaBeeStateConditionMessage> SeaBeeStateConditionMessagePtr;
00481 typedef ::IceInternal::ProxyHandle< ::IceProxy::RobotSimEvents::SeaBeeStateConditionMessage> SeaBeeStateConditionMessagePrx;
00482
00483 void __read(::IceInternal::BasicStream*, SeaBeeStateConditionMessagePrx&);
00484 void __patch__SeaBeeStateConditionMessagePtr(void*, ::Ice::ObjectPtr&);
00485
00486 typedef ::IceInternal::Handle< ::RobotSimEvents::VisionRectangleMessage> VisionRectangleMessagePtr;
00487 typedef ::IceInternal::ProxyHandle< ::IceProxy::RobotSimEvents::VisionRectangleMessage> VisionRectangleMessagePrx;
00488
00489 void __read(::IceInternal::BasicStream*, VisionRectangleMessagePrx&);
00490 void __patch__VisionRectangleMessagePtr(void*, ::Ice::ObjectPtr&);
00491
00492 typedef ::IceInternal::Handle< ::RobotSimEvents::StraightEdgeMessage> StraightEdgeMessagePtr;
00493 typedef ::IceInternal::ProxyHandle< ::IceProxy::RobotSimEvents::StraightEdgeMessage> StraightEdgeMessagePrx;
00494
00495 void __read(::IceInternal::BasicStream*, StraightEdgeMessagePrx&);
00496 void __patch__StraightEdgeMessagePtr(void*, ::Ice::ObjectPtr&);
00497
00498 typedef ::IceInternal::Handle< ::RobotSimEvents::VisionObjectMessage> VisionObjectMessagePtr;
00499 typedef ::IceInternal::ProxyHandle< ::IceProxy::RobotSimEvents::VisionObjectMessage> VisionObjectMessagePrx;
00500
00501 void __read(::IceInternal::BasicStream*, VisionObjectMessagePrx&);
00502 void __patch__VisionObjectMessagePtr(void*, ::Ice::ObjectPtr&);
00503
00504 typedef ::IceInternal::Handle< ::RobotSimEvents::LandmarksMessage> LandmarksMessagePtr;
00505 typedef ::IceInternal::ProxyHandle< ::IceProxy::RobotSimEvents::LandmarksMessage> LandmarksMessagePrx;
00506
00507 void __read(::IceInternal::BasicStream*, LandmarksMessagePrx&);
00508 void __patch__LandmarksMessagePtr(void*, ::Ice::ObjectPtr&);
00509
00510 typedef ::IceInternal::Handle< ::RobotSimEvents::CameraConfigMessage> CameraConfigMessagePtr;
00511 typedef ::IceInternal::ProxyHandle< ::IceProxy::RobotSimEvents::CameraConfigMessage> CameraConfigMessagePrx;
00512
00513 void __read(::IceInternal::BasicStream*, CameraConfigMessagePrx&);
00514 void __patch__CameraConfigMessagePtr(void*, ::Ice::ObjectPtr&);
00515
00516 typedef ::IceInternal::Handle< ::RobotSimEvents::SalientPointMessage> SalientPointMessagePtr;
00517 typedef ::IceInternal::ProxyHandle< ::IceProxy::RobotSimEvents::SalientPointMessage> SalientPointMessagePrx;
00518
00519 void __read(::IceInternal::BasicStream*, SalientPointMessagePrx&);
00520 void __patch__SalientPointMessagePtr(void*, ::Ice::ObjectPtr&);
00521
00522 typedef ::IceInternal::Handle< ::RobotSimEvents::BuoyColorSegmentMessage> BuoyColorSegmentMessagePtr;
00523 typedef ::IceInternal::ProxyHandle< ::IceProxy::RobotSimEvents::BuoyColorSegmentMessage> BuoyColorSegmentMessagePrx;
00524
00525 void __read(::IceInternal::BasicStream*, BuoyColorSegmentMessagePrx&);
00526 void __patch__BuoyColorSegmentMessagePtr(void*, ::Ice::ObjectPtr&);
00527
00528 typedef ::IceInternal::Handle< ::RobotSimEvents::PipeColorSegmentMessage> PipeColorSegmentMessagePtr;
00529 typedef ::IceInternal::ProxyHandle< ::IceProxy::RobotSimEvents::PipeColorSegmentMessage> PipeColorSegmentMessagePrx;
00530
00531 void __read(::IceInternal::BasicStream*, PipeColorSegmentMessagePrx&);
00532 void __patch__PipeColorSegmentMessagePtr(void*, ::Ice::ObjectPtr&);
00533
00534 typedef ::IceInternal::Handle< ::RobotSimEvents::BuoyColorSegmentConfigMessage> BuoyColorSegmentConfigMessagePtr;
00535 typedef ::IceInternal::ProxyHandle< ::IceProxy::RobotSimEvents::BuoyColorSegmentConfigMessage> BuoyColorSegmentConfigMessagePrx;
00536
00537 void __read(::IceInternal::BasicStream*, BuoyColorSegmentConfigMessagePrx&);
00538 void __patch__BuoyColorSegmentConfigMessagePtr(void*, ::Ice::ObjectPtr&);
00539
00540 typedef ::IceInternal::Handle< ::RobotSimEvents::PipeColorSegmentConfigMessage> PipeColorSegmentConfigMessagePtr;
00541 typedef ::IceInternal::ProxyHandle< ::IceProxy::RobotSimEvents::PipeColorSegmentConfigMessage> PipeColorSegmentConfigMessagePrx;
00542
00543 void __read(::IceInternal::BasicStream*, PipeColorSegmentConfigMessagePrx&);
00544 void __patch__PipeColorSegmentConfigMessagePtr(void*, ::Ice::ObjectPtr&);
00545
00546 }
00547
00548 namespace RobotSimEvents
00549 {
00550
00551 typedef ::std::vector< ::ImageIceMod::SensorVote> SensorVoteVector;
00552 void __writeSensorVoteVector(::IceInternal::BasicStream*, const ::ImageIceMod::SensorVote*, const ::ImageIceMod::SensorVote*);
00553 void __readSensorVoteVector(::IceInternal::BasicStream*, SensorVoteVector&);
00554
00555 typedef ::std::vector< ::Ice::Float> FloatVector;
00556
00557 typedef ::std::vector< ::Ice::Int> IntVector;
00558
00559 typedef ::std::vector< ::ImageIceMod::QuadrilateralIce> QuadrilateralIceVector;
00560 void __writeQuadrilateralIceVector(::IceInternal::BasicStream*, const ::ImageIceMod::QuadrilateralIce*, const ::ImageIceMod::QuadrilateralIce*);
00561 void __readQuadrilateralIceVector(::IceInternal::BasicStream*, QuadrilateralIceVector&);
00562
00563 enum SeaBeeObjectType
00564 {
00565 PLATFORM,
00566 GATE,
00567 PIPE,
00568 FLARE,
00569 BIN,
00570 BARBWIRE,
00571 MACHINEGUN,
00572 OCTAGON
00573 };
00574
00575 void __write(::IceInternal::BasicStream*, SeaBeeObjectType);
00576 void __read(::IceInternal::BasicStream*, SeaBeeObjectType&);
00577
00578 typedef ::std::vector< ::Ice::Byte> FeatureVector;
00579
00580 struct LandmarkInfo
00581 {
00582 ::Ice::Int id;
00583 ::std::string name;
00584 ::RobotSimEvents::FeatureVector fv;
00585 ::Ice::Float range;
00586 ::Ice::Float bearing;
00587 ::Ice::Float prob;
00588
00589 bool operator==(const LandmarkInfo&) const;
00590 bool operator<(const LandmarkInfo&) const;
00591 bool operator!=(const LandmarkInfo& __rhs) const
00592 {
00593 return !operator==(__rhs);
00594 }
00595 bool operator<=(const LandmarkInfo& __rhs) const
00596 {
00597 return operator<(__rhs) || operator==(__rhs);
00598 }
00599 bool operator>(const LandmarkInfo& __rhs) const
00600 {
00601 return !operator<(__rhs) && !operator==(__rhs);
00602 }
00603 bool operator>=(const LandmarkInfo& __rhs) const
00604 {
00605 return !operator<(__rhs);
00606 }
00607
00608 void __write(::IceInternal::BasicStream*) const;
00609 void __read(::IceInternal::BasicStream*);
00610 };
00611
00612 typedef ::std::vector< ::RobotSimEvents::LandmarkInfo> LandmarksInfo;
00613 void __writeLandmarksInfo(::IceInternal::BasicStream*, const ::RobotSimEvents::LandmarkInfo*, const ::RobotSimEvents::LandmarkInfo*);
00614 void __readLandmarksInfo(::IceInternal::BasicStream*, LandmarksInfo&);
00615
00616 }
00617
00618 namespace IceProxy
00619 {
00620
00621 namespace RobotSimEvents
00622 {
00623
00624 class EventMessage : virtual public ::IceProxy::Ice::Object
00625 {
00626 public:
00627
00628 ::IceInternal::ProxyHandle<EventMessage> ice_context(const ::Ice::Context& __context) const
00629 {
00630 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00631 typedef ::IceProxy::Ice::Object _Base;
00632 return dynamic_cast<EventMessage*>(_Base::ice_context(__context).get());
00633 #else
00634 return dynamic_cast<EventMessage*>(::IceProxy::Ice::Object::ice_context(__context).get());
00635 #endif
00636 }
00637
00638 ::IceInternal::ProxyHandle<EventMessage> ice_adapterId(const std::string& __id) const
00639 {
00640 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00641 typedef ::IceProxy::Ice::Object _Base;
00642 return dynamic_cast<EventMessage*>(_Base::ice_adapterId(__id).get());
00643 #else
00644 return dynamic_cast<EventMessage*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
00645 #endif
00646 }
00647
00648 ::IceInternal::ProxyHandle<EventMessage> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
00649 {
00650 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00651 typedef ::IceProxy::Ice::Object _Base;
00652 return dynamic_cast<EventMessage*>(_Base::ice_endpoints(__endpoints).get());
00653 #else
00654 return dynamic_cast<EventMessage*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
00655 #endif
00656 }
00657
00658 ::IceInternal::ProxyHandle<EventMessage> ice_locatorCacheTimeout(int __timeout) const
00659 {
00660 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00661 typedef ::IceProxy::Ice::Object _Base;
00662 return dynamic_cast<EventMessage*>(_Base::ice_locatorCacheTimeout(__timeout).get());
00663 #else
00664 return dynamic_cast<EventMessage*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
00665 #endif
00666 }
00667
00668 ::IceInternal::ProxyHandle<EventMessage> ice_connectionCached(bool __cached) const
00669 {
00670 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00671 typedef ::IceProxy::Ice::Object _Base;
00672 return dynamic_cast<EventMessage*>(_Base::ice_connectionCached(__cached).get());
00673 #else
00674 return dynamic_cast<EventMessage*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
00675 #endif
00676 }
00677
00678 ::IceInternal::ProxyHandle<EventMessage> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
00679 {
00680 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00681 typedef ::IceProxy::Ice::Object _Base;
00682 return dynamic_cast<EventMessage*>(_Base::ice_endpointSelection(__est).get());
00683 #else
00684 return dynamic_cast<EventMessage*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
00685 #endif
00686 }
00687
00688 ::IceInternal::ProxyHandle<EventMessage> ice_secure(bool __secure) const
00689 {
00690 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00691 typedef ::IceProxy::Ice::Object _Base;
00692 return dynamic_cast<EventMessage*>(_Base::ice_secure(__secure).get());
00693 #else
00694 return dynamic_cast<EventMessage*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
00695 #endif
00696 }
00697
00698 ::IceInternal::ProxyHandle<EventMessage> ice_preferSecure(bool __preferSecure) const
00699 {
00700 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00701 typedef ::IceProxy::Ice::Object _Base;
00702 return dynamic_cast<EventMessage*>(_Base::ice_preferSecure(__preferSecure).get());
00703 #else
00704 return dynamic_cast<EventMessage*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
00705 #endif
00706 }
00707
00708 ::IceInternal::ProxyHandle<EventMessage> ice_router(const ::Ice::RouterPrx& __router) const
00709 {
00710 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00711 typedef ::IceProxy::Ice::Object _Base;
00712 return dynamic_cast<EventMessage*>(_Base::ice_router(__router).get());
00713 #else
00714 return dynamic_cast<EventMessage*>(::IceProxy::Ice::Object::ice_router(__router).get());
00715 #endif
00716 }
00717
00718 ::IceInternal::ProxyHandle<EventMessage> ice_locator(const ::Ice::LocatorPrx& __locator) const
00719 {
00720 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00721 typedef ::IceProxy::Ice::Object _Base;
00722 return dynamic_cast<EventMessage*>(_Base::ice_locator(__locator).get());
00723 #else
00724 return dynamic_cast<EventMessage*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
00725 #endif
00726 }
00727
00728 ::IceInternal::ProxyHandle<EventMessage> ice_collocationOptimized(bool __co) const
00729 {
00730 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00731 typedef ::IceProxy::Ice::Object _Base;
00732 return dynamic_cast<EventMessage*>(_Base::ice_collocationOptimized(__co).get());
00733 #else
00734 return dynamic_cast<EventMessage*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
00735 #endif
00736 }
00737
00738 ::IceInternal::ProxyHandle<EventMessage> ice_twoway() const
00739 {
00740 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00741 typedef ::IceProxy::Ice::Object _Base;
00742 return dynamic_cast<EventMessage*>(_Base::ice_twoway().get());
00743 #else
00744 return dynamic_cast<EventMessage*>(::IceProxy::Ice::Object::ice_twoway().get());
00745 #endif
00746 }
00747
00748 ::IceInternal::ProxyHandle<EventMessage> ice_oneway() const
00749 {
00750 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00751 typedef ::IceProxy::Ice::Object _Base;
00752 return dynamic_cast<EventMessage*>(_Base::ice_oneway().get());
00753 #else
00754 return dynamic_cast<EventMessage*>(::IceProxy::Ice::Object::ice_oneway().get());
00755 #endif
00756 }
00757
00758 ::IceInternal::ProxyHandle<EventMessage> ice_batchOneway() const
00759 {
00760 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00761 typedef ::IceProxy::Ice::Object _Base;
00762 return dynamic_cast<EventMessage*>(_Base::ice_batchOneway().get());
00763 #else
00764 return dynamic_cast<EventMessage*>(::IceProxy::Ice::Object::ice_batchOneway().get());
00765 #endif
00766 }
00767
00768 ::IceInternal::ProxyHandle<EventMessage> ice_datagram() const
00769 {
00770 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00771 typedef ::IceProxy::Ice::Object _Base;
00772 return dynamic_cast<EventMessage*>(_Base::ice_datagram().get());
00773 #else
00774 return dynamic_cast<EventMessage*>(::IceProxy::Ice::Object::ice_datagram().get());
00775 #endif
00776 }
00777
00778 ::IceInternal::ProxyHandle<EventMessage> ice_batchDatagram() const
00779 {
00780 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00781 typedef ::IceProxy::Ice::Object _Base;
00782 return dynamic_cast<EventMessage*>(_Base::ice_batchDatagram().get());
00783 #else
00784 return dynamic_cast<EventMessage*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
00785 #endif
00786 }
00787
00788 ::IceInternal::ProxyHandle<EventMessage> ice_compress(bool __compress) const
00789 {
00790 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00791 typedef ::IceProxy::Ice::Object _Base;
00792 return dynamic_cast<EventMessage*>(_Base::ice_compress(__compress).get());
00793 #else
00794 return dynamic_cast<EventMessage*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
00795 #endif
00796 }
00797
00798 ::IceInternal::ProxyHandle<EventMessage> ice_timeout(int __timeout) const
00799 {
00800 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00801 typedef ::IceProxy::Ice::Object _Base;
00802 return dynamic_cast<EventMessage*>(_Base::ice_timeout(__timeout).get());
00803 #else
00804 return dynamic_cast<EventMessage*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
00805 #endif
00806 }
00807
00808 ::IceInternal::ProxyHandle<EventMessage> ice_connectionId(const std::string& __id) const
00809 {
00810 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00811 typedef ::IceProxy::Ice::Object _Base;
00812 return dynamic_cast<EventMessage*>(_Base::ice_connectionId(__id).get());
00813 #else
00814 return dynamic_cast<EventMessage*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
00815 #endif
00816 }
00817
00818 static const ::std::string& ice_staticId();
00819
00820 private:
00821
00822 virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
00823 virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
00824 virtual ::IceProxy::Ice::Object* __newInstance() const;
00825 };
00826
00827 class Events : virtual public ::IceProxy::Ice::Object
00828 {
00829 public:
00830
00831 void updateMessage(const ::RobotSimEvents::EventMessagePtr& eMsg)
00832 {
00833 updateMessage(eMsg, 0);
00834 }
00835 void updateMessage(const ::RobotSimEvents::EventMessagePtr& eMsg, const ::Ice::Context& __ctx)
00836 {
00837 updateMessage(eMsg, &__ctx);
00838 }
00839
00840 private:
00841
00842 void updateMessage(const ::RobotSimEvents::EventMessagePtr&, const ::Ice::Context*);
00843
00844 public:
00845
00846 ::IceInternal::ProxyHandle<Events> ice_context(const ::Ice::Context& __context) const
00847 {
00848 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00849 typedef ::IceProxy::Ice::Object _Base;
00850 return dynamic_cast<Events*>(_Base::ice_context(__context).get());
00851 #else
00852 return dynamic_cast<Events*>(::IceProxy::Ice::Object::ice_context(__context).get());
00853 #endif
00854 }
00855
00856 ::IceInternal::ProxyHandle<Events> ice_adapterId(const std::string& __id) const
00857 {
00858 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00859 typedef ::IceProxy::Ice::Object _Base;
00860 return dynamic_cast<Events*>(_Base::ice_adapterId(__id).get());
00861 #else
00862 return dynamic_cast<Events*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
00863 #endif
00864 }
00865
00866 ::IceInternal::ProxyHandle<Events> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
00867 {
00868 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00869 typedef ::IceProxy::Ice::Object _Base;
00870 return dynamic_cast<Events*>(_Base::ice_endpoints(__endpoints).get());
00871 #else
00872 return dynamic_cast<Events*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
00873 #endif
00874 }
00875
00876 ::IceInternal::ProxyHandle<Events> ice_locatorCacheTimeout(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<Events*>(_Base::ice_locatorCacheTimeout(__timeout).get());
00881 #else
00882 return dynamic_cast<Events*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
00883 #endif
00884 }
00885
00886 ::IceInternal::ProxyHandle<Events> ice_connectionCached(bool __cached) const
00887 {
00888 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00889 typedef ::IceProxy::Ice::Object _Base;
00890 return dynamic_cast<Events*>(_Base::ice_connectionCached(__cached).get());
00891 #else
00892 return dynamic_cast<Events*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
00893 #endif
00894 }
00895
00896 ::IceInternal::ProxyHandle<Events> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
00897 {
00898 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00899 typedef ::IceProxy::Ice::Object _Base;
00900 return dynamic_cast<Events*>(_Base::ice_endpointSelection(__est).get());
00901 #else
00902 return dynamic_cast<Events*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
00903 #endif
00904 }
00905
00906 ::IceInternal::ProxyHandle<Events> ice_secure(bool __secure) const
00907 {
00908 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00909 typedef ::IceProxy::Ice::Object _Base;
00910 return dynamic_cast<Events*>(_Base::ice_secure(__secure).get());
00911 #else
00912 return dynamic_cast<Events*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
00913 #endif
00914 }
00915
00916 ::IceInternal::ProxyHandle<Events> ice_preferSecure(bool __preferSecure) const
00917 {
00918 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00919 typedef ::IceProxy::Ice::Object _Base;
00920 return dynamic_cast<Events*>(_Base::ice_preferSecure(__preferSecure).get());
00921 #else
00922 return dynamic_cast<Events*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
00923 #endif
00924 }
00925
00926 ::IceInternal::ProxyHandle<Events> ice_router(const ::Ice::RouterPrx& __router) const
00927 {
00928 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00929 typedef ::IceProxy::Ice::Object _Base;
00930 return dynamic_cast<Events*>(_Base::ice_router(__router).get());
00931 #else
00932 return dynamic_cast<Events*>(::IceProxy::Ice::Object::ice_router(__router).get());
00933 #endif
00934 }
00935
00936 ::IceInternal::ProxyHandle<Events> ice_locator(const ::Ice::LocatorPrx& __locator) const
00937 {
00938 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00939 typedef ::IceProxy::Ice::Object _Base;
00940 return dynamic_cast<Events*>(_Base::ice_locator(__locator).get());
00941 #else
00942 return dynamic_cast<Events*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
00943 #endif
00944 }
00945
00946 ::IceInternal::ProxyHandle<Events> ice_collocationOptimized(bool __co) const
00947 {
00948 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00949 typedef ::IceProxy::Ice::Object _Base;
00950 return dynamic_cast<Events*>(_Base::ice_collocationOptimized(__co).get());
00951 #else
00952 return dynamic_cast<Events*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
00953 #endif
00954 }
00955
00956 ::IceInternal::ProxyHandle<Events> ice_twoway() const
00957 {
00958 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00959 typedef ::IceProxy::Ice::Object _Base;
00960 return dynamic_cast<Events*>(_Base::ice_twoway().get());
00961 #else
00962 return dynamic_cast<Events*>(::IceProxy::Ice::Object::ice_twoway().get());
00963 #endif
00964 }
00965
00966 ::IceInternal::ProxyHandle<Events> ice_oneway() const
00967 {
00968 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00969 typedef ::IceProxy::Ice::Object _Base;
00970 return dynamic_cast<Events*>(_Base::ice_oneway().get());
00971 #else
00972 return dynamic_cast<Events*>(::IceProxy::Ice::Object::ice_oneway().get());
00973 #endif
00974 }
00975
00976 ::IceInternal::ProxyHandle<Events> ice_batchOneway() const
00977 {
00978 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00979 typedef ::IceProxy::Ice::Object _Base;
00980 return dynamic_cast<Events*>(_Base::ice_batchOneway().get());
00981 #else
00982 return dynamic_cast<Events*>(::IceProxy::Ice::Object::ice_batchOneway().get());
00983 #endif
00984 }
00985
00986 ::IceInternal::ProxyHandle<Events> ice_datagram() const
00987 {
00988 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00989 typedef ::IceProxy::Ice::Object _Base;
00990 return dynamic_cast<Events*>(_Base::ice_datagram().get());
00991 #else
00992 return dynamic_cast<Events*>(::IceProxy::Ice::Object::ice_datagram().get());
00993 #endif
00994 }
00995
00996 ::IceInternal::ProxyHandle<Events> ice_batchDatagram() const
00997 {
00998 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00999 typedef ::IceProxy::Ice::Object _Base;
01000 return dynamic_cast<Events*>(_Base::ice_batchDatagram().get());
01001 #else
01002 return dynamic_cast<Events*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
01003 #endif
01004 }
01005
01006 ::IceInternal::ProxyHandle<Events> ice_compress(bool __compress) const
01007 {
01008 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01009 typedef ::IceProxy::Ice::Object _Base;
01010 return dynamic_cast<Events*>(_Base::ice_compress(__compress).get());
01011 #else
01012 return dynamic_cast<Events*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
01013 #endif
01014 }
01015
01016 ::IceInternal::ProxyHandle<Events> ice_timeout(int __timeout) const
01017 {
01018 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01019 typedef ::IceProxy::Ice::Object _Base;
01020 return dynamic_cast<Events*>(_Base::ice_timeout(__timeout).get());
01021 #else
01022 return dynamic_cast<Events*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
01023 #endif
01024 }
01025
01026 ::IceInternal::ProxyHandle<Events> ice_connectionId(const std::string& __id) const
01027 {
01028 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01029 typedef ::IceProxy::Ice::Object _Base;
01030 return dynamic_cast<Events*>(_Base::ice_connectionId(__id).get());
01031 #else
01032 return dynamic_cast<Events*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
01033 #endif
01034 }
01035
01036 static const ::std::string& ice_staticId();
01037
01038 private:
01039
01040 virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
01041 virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
01042 virtual ::IceProxy::Ice::Object* __newInstance() const;
01043 };
01044
01045 class ActionMessage : virtual public ::IceProxy::RobotSimEvents::EventMessage
01046 {
01047 public:
01048
01049 ::IceInternal::ProxyHandle<ActionMessage> ice_context(const ::Ice::Context& __context) const
01050 {
01051 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01052 typedef ::IceProxy::Ice::Object _Base;
01053 return dynamic_cast<ActionMessage*>(_Base::ice_context(__context).get());
01054 #else
01055 return dynamic_cast<ActionMessage*>(::IceProxy::Ice::Object::ice_context(__context).get());
01056 #endif
01057 }
01058
01059 ::IceInternal::ProxyHandle<ActionMessage> ice_adapterId(const std::string& __id) const
01060 {
01061 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01062 typedef ::IceProxy::Ice::Object _Base;
01063 return dynamic_cast<ActionMessage*>(_Base::ice_adapterId(__id).get());
01064 #else
01065 return dynamic_cast<ActionMessage*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
01066 #endif
01067 }
01068
01069 ::IceInternal::ProxyHandle<ActionMessage> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
01070 {
01071 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01072 typedef ::IceProxy::Ice::Object _Base;
01073 return dynamic_cast<ActionMessage*>(_Base::ice_endpoints(__endpoints).get());
01074 #else
01075 return dynamic_cast<ActionMessage*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
01076 #endif
01077 }
01078
01079 ::IceInternal::ProxyHandle<ActionMessage> ice_locatorCacheTimeout(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<ActionMessage*>(_Base::ice_locatorCacheTimeout(__timeout).get());
01084 #else
01085 return dynamic_cast<ActionMessage*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
01086 #endif
01087 }
01088
01089 ::IceInternal::ProxyHandle<ActionMessage> ice_connectionCached(bool __cached) const
01090 {
01091 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01092 typedef ::IceProxy::Ice::Object _Base;
01093 return dynamic_cast<ActionMessage*>(_Base::ice_connectionCached(__cached).get());
01094 #else
01095 return dynamic_cast<ActionMessage*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
01096 #endif
01097 }
01098
01099 ::IceInternal::ProxyHandle<ActionMessage> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
01100 {
01101 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01102 typedef ::IceProxy::Ice::Object _Base;
01103 return dynamic_cast<ActionMessage*>(_Base::ice_endpointSelection(__est).get());
01104 #else
01105 return dynamic_cast<ActionMessage*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
01106 #endif
01107 }
01108
01109 ::IceInternal::ProxyHandle<ActionMessage> ice_secure(bool __secure) const
01110 {
01111 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01112 typedef ::IceProxy::Ice::Object _Base;
01113 return dynamic_cast<ActionMessage*>(_Base::ice_secure(__secure).get());
01114 #else
01115 return dynamic_cast<ActionMessage*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
01116 #endif
01117 }
01118
01119 ::IceInternal::ProxyHandle<ActionMessage> ice_preferSecure(bool __preferSecure) const
01120 {
01121 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01122 typedef ::IceProxy::Ice::Object _Base;
01123 return dynamic_cast<ActionMessage*>(_Base::ice_preferSecure(__preferSecure).get());
01124 #else
01125 return dynamic_cast<ActionMessage*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
01126 #endif
01127 }
01128
01129 ::IceInternal::ProxyHandle<ActionMessage> ice_router(const ::Ice::RouterPrx& __router) const
01130 {
01131 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01132 typedef ::IceProxy::Ice::Object _Base;
01133 return dynamic_cast<ActionMessage*>(_Base::ice_router(__router).get());
01134 #else
01135 return dynamic_cast<ActionMessage*>(::IceProxy::Ice::Object::ice_router(__router).get());
01136 #endif
01137 }
01138
01139 ::IceInternal::ProxyHandle<ActionMessage> ice_locator(const ::Ice::LocatorPrx& __locator) const
01140 {
01141 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01142 typedef ::IceProxy::Ice::Object _Base;
01143 return dynamic_cast<ActionMessage*>(_Base::ice_locator(__locator).get());
01144 #else
01145 return dynamic_cast<ActionMessage*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
01146 #endif
01147 }
01148
01149 ::IceInternal::ProxyHandle<ActionMessage> ice_collocationOptimized(bool __co) const
01150 {
01151 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01152 typedef ::IceProxy::Ice::Object _Base;
01153 return dynamic_cast<ActionMessage*>(_Base::ice_collocationOptimized(__co).get());
01154 #else
01155 return dynamic_cast<ActionMessage*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
01156 #endif
01157 }
01158
01159 ::IceInternal::ProxyHandle<ActionMessage> ice_twoway() const
01160 {
01161 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01162 typedef ::IceProxy::Ice::Object _Base;
01163 return dynamic_cast<ActionMessage*>(_Base::ice_twoway().get());
01164 #else
01165 return dynamic_cast<ActionMessage*>(::IceProxy::Ice::Object::ice_twoway().get());
01166 #endif
01167 }
01168
01169 ::IceInternal::ProxyHandle<ActionMessage> ice_oneway() const
01170 {
01171 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01172 typedef ::IceProxy::Ice::Object _Base;
01173 return dynamic_cast<ActionMessage*>(_Base::ice_oneway().get());
01174 #else
01175 return dynamic_cast<ActionMessage*>(::IceProxy::Ice::Object::ice_oneway().get());
01176 #endif
01177 }
01178
01179 ::IceInternal::ProxyHandle<ActionMessage> ice_batchOneway() const
01180 {
01181 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01182 typedef ::IceProxy::Ice::Object _Base;
01183 return dynamic_cast<ActionMessage*>(_Base::ice_batchOneway().get());
01184 #else
01185 return dynamic_cast<ActionMessage*>(::IceProxy::Ice::Object::ice_batchOneway().get());
01186 #endif
01187 }
01188
01189 ::IceInternal::ProxyHandle<ActionMessage> ice_datagram() const
01190 {
01191 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01192 typedef ::IceProxy::Ice::Object _Base;
01193 return dynamic_cast<ActionMessage*>(_Base::ice_datagram().get());
01194 #else
01195 return dynamic_cast<ActionMessage*>(::IceProxy::Ice::Object::ice_datagram().get());
01196 #endif
01197 }
01198
01199 ::IceInternal::ProxyHandle<ActionMessage> ice_batchDatagram() const
01200 {
01201 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01202 typedef ::IceProxy::Ice::Object _Base;
01203 return dynamic_cast<ActionMessage*>(_Base::ice_batchDatagram().get());
01204 #else
01205 return dynamic_cast<ActionMessage*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
01206 #endif
01207 }
01208
01209 ::IceInternal::ProxyHandle<ActionMessage> ice_compress(bool __compress) const
01210 {
01211 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01212 typedef ::IceProxy::Ice::Object _Base;
01213 return dynamic_cast<ActionMessage*>(_Base::ice_compress(__compress).get());
01214 #else
01215 return dynamic_cast<ActionMessage*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
01216 #endif
01217 }
01218
01219 ::IceInternal::ProxyHandle<ActionMessage> ice_timeout(int __timeout) const
01220 {
01221 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01222 typedef ::IceProxy::Ice::Object _Base;
01223 return dynamic_cast<ActionMessage*>(_Base::ice_timeout(__timeout).get());
01224 #else
01225 return dynamic_cast<ActionMessage*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
01226 #endif
01227 }
01228
01229 ::IceInternal::ProxyHandle<ActionMessage> ice_connectionId(const std::string& __id) const
01230 {
01231 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01232 typedef ::IceProxy::Ice::Object _Base;
01233 return dynamic_cast<ActionMessage*>(_Base::ice_connectionId(__id).get());
01234 #else
01235 return dynamic_cast<ActionMessage*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
01236 #endif
01237 }
01238
01239 static const ::std::string& ice_staticId();
01240
01241 private:
01242
01243 virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
01244 virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
01245 virtual ::IceProxy::Ice::Object* __newInstance() const;
01246 };
01247
01248 class GPSMessage : virtual public ::IceProxy::RobotSimEvents::EventMessage
01249 {
01250 public:
01251
01252 ::IceInternal::ProxyHandle<GPSMessage> ice_context(const ::Ice::Context& __context) const
01253 {
01254 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01255 typedef ::IceProxy::Ice::Object _Base;
01256 return dynamic_cast<GPSMessage*>(_Base::ice_context(__context).get());
01257 #else
01258 return dynamic_cast<GPSMessage*>(::IceProxy::Ice::Object::ice_context(__context).get());
01259 #endif
01260 }
01261
01262 ::IceInternal::ProxyHandle<GPSMessage> ice_adapterId(const std::string& __id) const
01263 {
01264 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01265 typedef ::IceProxy::Ice::Object _Base;
01266 return dynamic_cast<GPSMessage*>(_Base::ice_adapterId(__id).get());
01267 #else
01268 return dynamic_cast<GPSMessage*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
01269 #endif
01270 }
01271
01272 ::IceInternal::ProxyHandle<GPSMessage> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
01273 {
01274 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01275 typedef ::IceProxy::Ice::Object _Base;
01276 return dynamic_cast<GPSMessage*>(_Base::ice_endpoints(__endpoints).get());
01277 #else
01278 return dynamic_cast<GPSMessage*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
01279 #endif
01280 }
01281
01282 ::IceInternal::ProxyHandle<GPSMessage> ice_locatorCacheTimeout(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<GPSMessage*>(_Base::ice_locatorCacheTimeout(__timeout).get());
01287 #else
01288 return dynamic_cast<GPSMessage*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
01289 #endif
01290 }
01291
01292 ::IceInternal::ProxyHandle<GPSMessage> ice_connectionCached(bool __cached) const
01293 {
01294 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01295 typedef ::IceProxy::Ice::Object _Base;
01296 return dynamic_cast<GPSMessage*>(_Base::ice_connectionCached(__cached).get());
01297 #else
01298 return dynamic_cast<GPSMessage*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
01299 #endif
01300 }
01301
01302 ::IceInternal::ProxyHandle<GPSMessage> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
01303 {
01304 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01305 typedef ::IceProxy::Ice::Object _Base;
01306 return dynamic_cast<GPSMessage*>(_Base::ice_endpointSelection(__est).get());
01307 #else
01308 return dynamic_cast<GPSMessage*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
01309 #endif
01310 }
01311
01312 ::IceInternal::ProxyHandle<GPSMessage> ice_secure(bool __secure) const
01313 {
01314 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01315 typedef ::IceProxy::Ice::Object _Base;
01316 return dynamic_cast<GPSMessage*>(_Base::ice_secure(__secure).get());
01317 #else
01318 return dynamic_cast<GPSMessage*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
01319 #endif
01320 }
01321
01322 ::IceInternal::ProxyHandle<GPSMessage> ice_preferSecure(bool __preferSecure) const
01323 {
01324 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01325 typedef ::IceProxy::Ice::Object _Base;
01326 return dynamic_cast<GPSMessage*>(_Base::ice_preferSecure(__preferSecure).get());
01327 #else
01328 return dynamic_cast<GPSMessage*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
01329 #endif
01330 }
01331
01332 ::IceInternal::ProxyHandle<GPSMessage> ice_router(const ::Ice::RouterPrx& __router) const
01333 {
01334 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01335 typedef ::IceProxy::Ice::Object _Base;
01336 return dynamic_cast<GPSMessage*>(_Base::ice_router(__router).get());
01337 #else
01338 return dynamic_cast<GPSMessage*>(::IceProxy::Ice::Object::ice_router(__router).get());
01339 #endif
01340 }
01341
01342 ::IceInternal::ProxyHandle<GPSMessage> ice_locator(const ::Ice::LocatorPrx& __locator) const
01343 {
01344 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01345 typedef ::IceProxy::Ice::Object _Base;
01346 return dynamic_cast<GPSMessage*>(_Base::ice_locator(__locator).get());
01347 #else
01348 return dynamic_cast<GPSMessage*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
01349 #endif
01350 }
01351
01352 ::IceInternal::ProxyHandle<GPSMessage> ice_collocationOptimized(bool __co) const
01353 {
01354 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01355 typedef ::IceProxy::Ice::Object _Base;
01356 return dynamic_cast<GPSMessage*>(_Base::ice_collocationOptimized(__co).get());
01357 #else
01358 return dynamic_cast<GPSMessage*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
01359 #endif
01360 }
01361
01362 ::IceInternal::ProxyHandle<GPSMessage> ice_twoway() const
01363 {
01364 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01365 typedef ::IceProxy::Ice::Object _Base;
01366 return dynamic_cast<GPSMessage*>(_Base::ice_twoway().get());
01367 #else
01368 return dynamic_cast<GPSMessage*>(::IceProxy::Ice::Object::ice_twoway().get());
01369 #endif
01370 }
01371
01372 ::IceInternal::ProxyHandle<GPSMessage> ice_oneway() const
01373 {
01374 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01375 typedef ::IceProxy::Ice::Object _Base;
01376 return dynamic_cast<GPSMessage*>(_Base::ice_oneway().get());
01377 #else
01378 return dynamic_cast<GPSMessage*>(::IceProxy::Ice::Object::ice_oneway().get());
01379 #endif
01380 }
01381
01382 ::IceInternal::ProxyHandle<GPSMessage> ice_batchOneway() const
01383 {
01384 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01385 typedef ::IceProxy::Ice::Object _Base;
01386 return dynamic_cast<GPSMessage*>(_Base::ice_batchOneway().get());
01387 #else
01388 return dynamic_cast<GPSMessage*>(::IceProxy::Ice::Object::ice_batchOneway().get());
01389 #endif
01390 }
01391
01392 ::IceInternal::ProxyHandle<GPSMessage> ice_datagram() const
01393 {
01394 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01395 typedef ::IceProxy::Ice::Object _Base;
01396 return dynamic_cast<GPSMessage*>(_Base::ice_datagram().get());
01397 #else
01398 return dynamic_cast<GPSMessage*>(::IceProxy::Ice::Object::ice_datagram().get());
01399 #endif
01400 }
01401
01402 ::IceInternal::ProxyHandle<GPSMessage> ice_batchDatagram() const
01403 {
01404 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01405 typedef ::IceProxy::Ice::Object _Base;
01406 return dynamic_cast<GPSMessage*>(_Base::ice_batchDatagram().get());
01407 #else
01408 return dynamic_cast<GPSMessage*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
01409 #endif
01410 }
01411
01412 ::IceInternal::ProxyHandle<GPSMessage> ice_compress(bool __compress) const
01413 {
01414 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01415 typedef ::IceProxy::Ice::Object _Base;
01416 return dynamic_cast<GPSMessage*>(_Base::ice_compress(__compress).get());
01417 #else
01418 return dynamic_cast<GPSMessage*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
01419 #endif
01420 }
01421
01422 ::IceInternal::ProxyHandle<GPSMessage> ice_timeout(int __timeout) const
01423 {
01424 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01425 typedef ::IceProxy::Ice::Object _Base;
01426 return dynamic_cast<GPSMessage*>(_Base::ice_timeout(__timeout).get());
01427 #else
01428 return dynamic_cast<GPSMessage*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
01429 #endif
01430 }
01431
01432 ::IceInternal::ProxyHandle<GPSMessage> ice_connectionId(const std::string& __id) const
01433 {
01434 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01435 typedef ::IceProxy::Ice::Object _Base;
01436 return dynamic_cast<GPSMessage*>(_Base::ice_connectionId(__id).get());
01437 #else
01438 return dynamic_cast<GPSMessage*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
01439 #endif
01440 }
01441
01442 static const ::std::string& ice_staticId();
01443
01444 private:
01445
01446 virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
01447 virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
01448 virtual ::IceProxy::Ice::Object* __newInstance() const;
01449 };
01450
01451 class MotionMessage : virtual public ::IceProxy::RobotSimEvents::EventMessage
01452 {
01453 public:
01454
01455 ::IceInternal::ProxyHandle<MotionMessage> ice_context(const ::Ice::Context& __context) const
01456 {
01457 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01458 typedef ::IceProxy::Ice::Object _Base;
01459 return dynamic_cast<MotionMessage*>(_Base::ice_context(__context).get());
01460 #else
01461 return dynamic_cast<MotionMessage*>(::IceProxy::Ice::Object::ice_context(__context).get());
01462 #endif
01463 }
01464
01465 ::IceInternal::ProxyHandle<MotionMessage> ice_adapterId(const std::string& __id) const
01466 {
01467 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01468 typedef ::IceProxy::Ice::Object _Base;
01469 return dynamic_cast<MotionMessage*>(_Base::ice_adapterId(__id).get());
01470 #else
01471 return dynamic_cast<MotionMessage*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
01472 #endif
01473 }
01474
01475 ::IceInternal::ProxyHandle<MotionMessage> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
01476 {
01477 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01478 typedef ::IceProxy::Ice::Object _Base;
01479 return dynamic_cast<MotionMessage*>(_Base::ice_endpoints(__endpoints).get());
01480 #else
01481 return dynamic_cast<MotionMessage*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
01482 #endif
01483 }
01484
01485 ::IceInternal::ProxyHandle<MotionMessage> ice_locatorCacheTimeout(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<MotionMessage*>(_Base::ice_locatorCacheTimeout(__timeout).get());
01490 #else
01491 return dynamic_cast<MotionMessage*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
01492 #endif
01493 }
01494
01495 ::IceInternal::ProxyHandle<MotionMessage> ice_connectionCached(bool __cached) const
01496 {
01497 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01498 typedef ::IceProxy::Ice::Object _Base;
01499 return dynamic_cast<MotionMessage*>(_Base::ice_connectionCached(__cached).get());
01500 #else
01501 return dynamic_cast<MotionMessage*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
01502 #endif
01503 }
01504
01505 ::IceInternal::ProxyHandle<MotionMessage> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
01506 {
01507 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01508 typedef ::IceProxy::Ice::Object _Base;
01509 return dynamic_cast<MotionMessage*>(_Base::ice_endpointSelection(__est).get());
01510 #else
01511 return dynamic_cast<MotionMessage*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
01512 #endif
01513 }
01514
01515 ::IceInternal::ProxyHandle<MotionMessage> ice_secure(bool __secure) const
01516 {
01517 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01518 typedef ::IceProxy::Ice::Object _Base;
01519 return dynamic_cast<MotionMessage*>(_Base::ice_secure(__secure).get());
01520 #else
01521 return dynamic_cast<MotionMessage*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
01522 #endif
01523 }
01524
01525 ::IceInternal::ProxyHandle<MotionMessage> ice_preferSecure(bool __preferSecure) const
01526 {
01527 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01528 typedef ::IceProxy::Ice::Object _Base;
01529 return dynamic_cast<MotionMessage*>(_Base::ice_preferSecure(__preferSecure).get());
01530 #else
01531 return dynamic_cast<MotionMessage*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
01532 #endif
01533 }
01534
01535 ::IceInternal::ProxyHandle<MotionMessage> ice_router(const ::Ice::RouterPrx& __router) const
01536 {
01537 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01538 typedef ::IceProxy::Ice::Object _Base;
01539 return dynamic_cast<MotionMessage*>(_Base::ice_router(__router).get());
01540 #else
01541 return dynamic_cast<MotionMessage*>(::IceProxy::Ice::Object::ice_router(__router).get());
01542 #endif
01543 }
01544
01545 ::IceInternal::ProxyHandle<MotionMessage> ice_locator(const ::Ice::LocatorPrx& __locator) const
01546 {
01547 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01548 typedef ::IceProxy::Ice::Object _Base;
01549 return dynamic_cast<MotionMessage*>(_Base::ice_locator(__locator).get());
01550 #else
01551 return dynamic_cast<MotionMessage*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
01552 #endif
01553 }
01554
01555 ::IceInternal::ProxyHandle<MotionMessage> ice_collocationOptimized(bool __co) const
01556 {
01557 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01558 typedef ::IceProxy::Ice::Object _Base;
01559 return dynamic_cast<MotionMessage*>(_Base::ice_collocationOptimized(__co).get());
01560 #else
01561 return dynamic_cast<MotionMessage*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
01562 #endif
01563 }
01564
01565 ::IceInternal::ProxyHandle<MotionMessage> ice_twoway() const
01566 {
01567 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01568 typedef ::IceProxy::Ice::Object _Base;
01569 return dynamic_cast<MotionMessage*>(_Base::ice_twoway().get());
01570 #else
01571 return dynamic_cast<MotionMessage*>(::IceProxy::Ice::Object::ice_twoway().get());
01572 #endif
01573 }
01574
01575 ::IceInternal::ProxyHandle<MotionMessage> ice_oneway() const
01576 {
01577 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01578 typedef ::IceProxy::Ice::Object _Base;
01579 return dynamic_cast<MotionMessage*>(_Base::ice_oneway().get());
01580 #else
01581 return dynamic_cast<MotionMessage*>(::IceProxy::Ice::Object::ice_oneway().get());
01582 #endif
01583 }
01584
01585 ::IceInternal::ProxyHandle<MotionMessage> ice_batchOneway() const
01586 {
01587 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01588 typedef ::IceProxy::Ice::Object _Base;
01589 return dynamic_cast<MotionMessage*>(_Base::ice_batchOneway().get());
01590 #else
01591 return dynamic_cast<MotionMessage*>(::IceProxy::Ice::Object::ice_batchOneway().get());
01592 #endif
01593 }
01594
01595 ::IceInternal::ProxyHandle<MotionMessage> ice_datagram() const
01596 {
01597 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01598 typedef ::IceProxy::Ice::Object _Base;
01599 return dynamic_cast<MotionMessage*>(_Base::ice_datagram().get());
01600 #else
01601 return dynamic_cast<MotionMessage*>(::IceProxy::Ice::Object::ice_datagram().get());
01602 #endif
01603 }
01604
01605 ::IceInternal::ProxyHandle<MotionMessage> ice_batchDatagram() const
01606 {
01607 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01608 typedef ::IceProxy::Ice::Object _Base;
01609 return dynamic_cast<MotionMessage*>(_Base::ice_batchDatagram().get());
01610 #else
01611 return dynamic_cast<MotionMessage*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
01612 #endif
01613 }
01614
01615 ::IceInternal::ProxyHandle<MotionMessage> ice_compress(bool __compress) const
01616 {
01617 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01618 typedef ::IceProxy::Ice::Object _Base;
01619 return dynamic_cast<MotionMessage*>(_Base::ice_compress(__compress).get());
01620 #else
01621 return dynamic_cast<MotionMessage*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
01622 #endif
01623 }
01624
01625 ::IceInternal::ProxyHandle<MotionMessage> ice_timeout(int __timeout) const
01626 {
01627 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01628 typedef ::IceProxy::Ice::Object _Base;
01629 return dynamic_cast<MotionMessage*>(_Base::ice_timeout(__timeout).get());
01630 #else
01631 return dynamic_cast<MotionMessage*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
01632 #endif
01633 }
01634
01635 ::IceInternal::ProxyHandle<MotionMessage> ice_connectionId(const std::string& __id) const
01636 {
01637 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01638 typedef ::IceProxy::Ice::Object _Base;
01639 return dynamic_cast<MotionMessage*>(_Base::ice_connectionId(__id).get());
01640 #else
01641 return dynamic_cast<MotionMessage*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
01642 #endif
01643 }
01644
01645 static const ::std::string& ice_staticId();
01646
01647 private:
01648
01649 virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
01650 virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
01651 virtual ::IceProxy::Ice::Object* __newInstance() const;
01652 };
01653
01654 class RetinaMessage : virtual public ::IceProxy::RobotSimEvents::EventMessage
01655 {
01656 public:
01657
01658 ::IceInternal::ProxyHandle<RetinaMessage> ice_context(const ::Ice::Context& __context) const
01659 {
01660 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01661 typedef ::IceProxy::Ice::Object _Base;
01662 return dynamic_cast<RetinaMessage*>(_Base::ice_context(__context).get());
01663 #else
01664 return dynamic_cast<RetinaMessage*>(::IceProxy::Ice::Object::ice_context(__context).get());
01665 #endif
01666 }
01667
01668 ::IceInternal::ProxyHandle<RetinaMessage> ice_adapterId(const std::string& __id) const
01669 {
01670 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01671 typedef ::IceProxy::Ice::Object _Base;
01672 return dynamic_cast<RetinaMessage*>(_Base::ice_adapterId(__id).get());
01673 #else
01674 return dynamic_cast<RetinaMessage*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
01675 #endif
01676 }
01677
01678 ::IceInternal::ProxyHandle<RetinaMessage> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
01679 {
01680 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01681 typedef ::IceProxy::Ice::Object _Base;
01682 return dynamic_cast<RetinaMessage*>(_Base::ice_endpoints(__endpoints).get());
01683 #else
01684 return dynamic_cast<RetinaMessage*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
01685 #endif
01686 }
01687
01688 ::IceInternal::ProxyHandle<RetinaMessage> ice_locatorCacheTimeout(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<RetinaMessage*>(_Base::ice_locatorCacheTimeout(__timeout).get());
01693 #else
01694 return dynamic_cast<RetinaMessage*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
01695 #endif
01696 }
01697
01698 ::IceInternal::ProxyHandle<RetinaMessage> ice_connectionCached(bool __cached) const
01699 {
01700 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01701 typedef ::IceProxy::Ice::Object _Base;
01702 return dynamic_cast<RetinaMessage*>(_Base::ice_connectionCached(__cached).get());
01703 #else
01704 return dynamic_cast<RetinaMessage*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
01705 #endif
01706 }
01707
01708 ::IceInternal::ProxyHandle<RetinaMessage> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
01709 {
01710 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01711 typedef ::IceProxy::Ice::Object _Base;
01712 return dynamic_cast<RetinaMessage*>(_Base::ice_endpointSelection(__est).get());
01713 #else
01714 return dynamic_cast<RetinaMessage*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
01715 #endif
01716 }
01717
01718 ::IceInternal::ProxyHandle<RetinaMessage> ice_secure(bool __secure) const
01719 {
01720 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01721 typedef ::IceProxy::Ice::Object _Base;
01722 return dynamic_cast<RetinaMessage*>(_Base::ice_secure(__secure).get());
01723 #else
01724 return dynamic_cast<RetinaMessage*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
01725 #endif
01726 }
01727
01728 ::IceInternal::ProxyHandle<RetinaMessage> ice_preferSecure(bool __preferSecure) const
01729 {
01730 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01731 typedef ::IceProxy::Ice::Object _Base;
01732 return dynamic_cast<RetinaMessage*>(_Base::ice_preferSecure(__preferSecure).get());
01733 #else
01734 return dynamic_cast<RetinaMessage*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
01735 #endif
01736 }
01737
01738 ::IceInternal::ProxyHandle<RetinaMessage> ice_router(const ::Ice::RouterPrx& __router) const
01739 {
01740 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01741 typedef ::IceProxy::Ice::Object _Base;
01742 return dynamic_cast<RetinaMessage*>(_Base::ice_router(__router).get());
01743 #else
01744 return dynamic_cast<RetinaMessage*>(::IceProxy::Ice::Object::ice_router(__router).get());
01745 #endif
01746 }
01747
01748 ::IceInternal::ProxyHandle<RetinaMessage> ice_locator(const ::Ice::LocatorPrx& __locator) const
01749 {
01750 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01751 typedef ::IceProxy::Ice::Object _Base;
01752 return dynamic_cast<RetinaMessage*>(_Base::ice_locator(__locator).get());
01753 #else
01754 return dynamic_cast<RetinaMessage*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
01755 #endif
01756 }
01757
01758 ::IceInternal::ProxyHandle<RetinaMessage> ice_collocationOptimized(bool __co) const
01759 {
01760 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01761 typedef ::IceProxy::Ice::Object _Base;
01762 return dynamic_cast<RetinaMessage*>(_Base::ice_collocationOptimized(__co).get());
01763 #else
01764 return dynamic_cast<RetinaMessage*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
01765 #endif
01766 }
01767
01768 ::IceInternal::ProxyHandle<RetinaMessage> ice_twoway() const
01769 {
01770 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01771 typedef ::IceProxy::Ice::Object _Base;
01772 return dynamic_cast<RetinaMessage*>(_Base::ice_twoway().get());
01773 #else
01774 return dynamic_cast<RetinaMessage*>(::IceProxy::Ice::Object::ice_twoway().get());
01775 #endif
01776 }
01777
01778 ::IceInternal::ProxyHandle<RetinaMessage> ice_oneway() const
01779 {
01780 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01781 typedef ::IceProxy::Ice::Object _Base;
01782 return dynamic_cast<RetinaMessage*>(_Base::ice_oneway().get());
01783 #else
01784 return dynamic_cast<RetinaMessage*>(::IceProxy::Ice::Object::ice_oneway().get());
01785 #endif
01786 }
01787
01788 ::IceInternal::ProxyHandle<RetinaMessage> ice_batchOneway() const
01789 {
01790 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01791 typedef ::IceProxy::Ice::Object _Base;
01792 return dynamic_cast<RetinaMessage*>(_Base::ice_batchOneway().get());
01793 #else
01794 return dynamic_cast<RetinaMessage*>(::IceProxy::Ice::Object::ice_batchOneway().get());
01795 #endif
01796 }
01797
01798 ::IceInternal::ProxyHandle<RetinaMessage> ice_datagram() const
01799 {
01800 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01801 typedef ::IceProxy::Ice::Object _Base;
01802 return dynamic_cast<RetinaMessage*>(_Base::ice_datagram().get());
01803 #else
01804 return dynamic_cast<RetinaMessage*>(::IceProxy::Ice::Object::ice_datagram().get());
01805 #endif
01806 }
01807
01808 ::IceInternal::ProxyHandle<RetinaMessage> ice_batchDatagram() const
01809 {
01810 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01811 typedef ::IceProxy::Ice::Object _Base;
01812 return dynamic_cast<RetinaMessage*>(_Base::ice_batchDatagram().get());
01813 #else
01814 return dynamic_cast<RetinaMessage*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
01815 #endif
01816 }
01817
01818 ::IceInternal::ProxyHandle<RetinaMessage> ice_compress(bool __compress) const
01819 {
01820 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01821 typedef ::IceProxy::Ice::Object _Base;
01822 return dynamic_cast<RetinaMessage*>(_Base::ice_compress(__compress).get());
01823 #else
01824 return dynamic_cast<RetinaMessage*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
01825 #endif
01826 }
01827
01828 ::IceInternal::ProxyHandle<RetinaMessage> ice_timeout(int __timeout) const
01829 {
01830 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01831 typedef ::IceProxy::Ice::Object _Base;
01832 return dynamic_cast<RetinaMessage*>(_Base::ice_timeout(__timeout).get());
01833 #else
01834 return dynamic_cast<RetinaMessage*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
01835 #endif
01836 }
01837
01838 ::IceInternal::ProxyHandle<RetinaMessage> ice_connectionId(const std::string& __id) const
01839 {
01840 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01841 typedef ::IceProxy::Ice::Object _Base;
01842 return dynamic_cast<RetinaMessage*>(_Base::ice_connectionId(__id).get());
01843 #else
01844 return dynamic_cast<RetinaMessage*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
01845 #endif
01846 }
01847
01848 static const ::std::string& ice_staticId();
01849
01850 private:
01851
01852 virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
01853 virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
01854 virtual ::IceProxy::Ice::Object* __newInstance() const;
01855 };
01856
01857 class MovementControllerMessage : virtual public ::IceProxy::RobotSimEvents::EventMessage
01858 {
01859 public:
01860
01861 ::IceInternal::ProxyHandle<MovementControllerMessage> ice_context(const ::Ice::Context& __context) const
01862 {
01863 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01864 typedef ::IceProxy::Ice::Object _Base;
01865 return dynamic_cast<MovementControllerMessage*>(_Base::ice_context(__context).get());
01866 #else
01867 return dynamic_cast<MovementControllerMessage*>(::IceProxy::Ice::Object::ice_context(__context).get());
01868 #endif
01869 }
01870
01871 ::IceInternal::ProxyHandle<MovementControllerMessage> ice_adapterId(const std::string& __id) const
01872 {
01873 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01874 typedef ::IceProxy::Ice::Object _Base;
01875 return dynamic_cast<MovementControllerMessage*>(_Base::ice_adapterId(__id).get());
01876 #else
01877 return dynamic_cast<MovementControllerMessage*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
01878 #endif
01879 }
01880
01881 ::IceInternal::ProxyHandle<MovementControllerMessage> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
01882 {
01883 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01884 typedef ::IceProxy::Ice::Object _Base;
01885 return dynamic_cast<MovementControllerMessage*>(_Base::ice_endpoints(__endpoints).get());
01886 #else
01887 return dynamic_cast<MovementControllerMessage*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
01888 #endif
01889 }
01890
01891 ::IceInternal::ProxyHandle<MovementControllerMessage> ice_locatorCacheTimeout(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<MovementControllerMessage*>(_Base::ice_locatorCacheTimeout(__timeout).get());
01896 #else
01897 return dynamic_cast<MovementControllerMessage*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
01898 #endif
01899 }
01900
01901 ::IceInternal::ProxyHandle<MovementControllerMessage> ice_connectionCached(bool __cached) const
01902 {
01903 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01904 typedef ::IceProxy::Ice::Object _Base;
01905 return dynamic_cast<MovementControllerMessage*>(_Base::ice_connectionCached(__cached).get());
01906 #else
01907 return dynamic_cast<MovementControllerMessage*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
01908 #endif
01909 }
01910
01911 ::IceInternal::ProxyHandle<MovementControllerMessage> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
01912 {
01913 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01914 typedef ::IceProxy::Ice::Object _Base;
01915 return dynamic_cast<MovementControllerMessage*>(_Base::ice_endpointSelection(__est).get());
01916 #else
01917 return dynamic_cast<MovementControllerMessage*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
01918 #endif
01919 }
01920
01921 ::IceInternal::ProxyHandle<MovementControllerMessage> ice_secure(bool __secure) const
01922 {
01923 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01924 typedef ::IceProxy::Ice::Object _Base;
01925 return dynamic_cast<MovementControllerMessage*>(_Base::ice_secure(__secure).get());
01926 #else
01927 return dynamic_cast<MovementControllerMessage*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
01928 #endif
01929 }
01930
01931 ::IceInternal::ProxyHandle<MovementControllerMessage> ice_preferSecure(bool __preferSecure) const
01932 {
01933 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01934 typedef ::IceProxy::Ice::Object _Base;
01935 return dynamic_cast<MovementControllerMessage*>(_Base::ice_preferSecure(__preferSecure).get());
01936 #else
01937 return dynamic_cast<MovementControllerMessage*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
01938 #endif
01939 }
01940
01941 ::IceInternal::ProxyHandle<MovementControllerMessage> ice_router(const ::Ice::RouterPrx& __router) const
01942 {
01943 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01944 typedef ::IceProxy::Ice::Object _Base;
01945 return dynamic_cast<MovementControllerMessage*>(_Base::ice_router(__router).get());
01946 #else
01947 return dynamic_cast<MovementControllerMessage*>(::IceProxy::Ice::Object::ice_router(__router).get());
01948 #endif
01949 }
01950
01951 ::IceInternal::ProxyHandle<MovementControllerMessage> ice_locator(const ::Ice::LocatorPrx& __locator) const
01952 {
01953 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01954 typedef ::IceProxy::Ice::Object _Base;
01955 return dynamic_cast<MovementControllerMessage*>(_Base::ice_locator(__locator).get());
01956 #else
01957 return dynamic_cast<MovementControllerMessage*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
01958 #endif
01959 }
01960
01961 ::IceInternal::ProxyHandle<MovementControllerMessage> ice_collocationOptimized(bool __co) const
01962 {
01963 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01964 typedef ::IceProxy::Ice::Object _Base;
01965 return dynamic_cast<MovementControllerMessage*>(_Base::ice_collocationOptimized(__co).get());
01966 #else
01967 return dynamic_cast<MovementControllerMessage*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
01968 #endif
01969 }
01970
01971 ::IceInternal::ProxyHandle<MovementControllerMessage> ice_twoway() const
01972 {
01973 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01974 typedef ::IceProxy::Ice::Object _Base;
01975 return dynamic_cast<MovementControllerMessage*>(_Base::ice_twoway().get());
01976 #else
01977 return dynamic_cast<MovementControllerMessage*>(::IceProxy::Ice::Object::ice_twoway().get());
01978 #endif
01979 }
01980
01981 ::IceInternal::ProxyHandle<MovementControllerMessage> ice_oneway() const
01982 {
01983 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01984 typedef ::IceProxy::Ice::Object _Base;
01985 return dynamic_cast<MovementControllerMessage*>(_Base::ice_oneway().get());
01986 #else
01987 return dynamic_cast<MovementControllerMessage*>(::IceProxy::Ice::Object::ice_oneway().get());
01988 #endif
01989 }
01990
01991 ::IceInternal::ProxyHandle<MovementControllerMessage> ice_batchOneway() const
01992 {
01993 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01994 typedef ::IceProxy::Ice::Object _Base;
01995 return dynamic_cast<MovementControllerMessage*>(_Base::ice_batchOneway().get());
01996 #else
01997 return dynamic_cast<MovementControllerMessage*>(::IceProxy::Ice::Object::ice_batchOneway().get());
01998 #endif
01999 }
02000
02001 ::IceInternal::ProxyHandle<MovementControllerMessage> ice_datagram() const
02002 {
02003 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02004 typedef ::IceProxy::Ice::Object _Base;
02005 return dynamic_cast<MovementControllerMessage*>(_Base::ice_datagram().get());
02006 #else
02007 return dynamic_cast<MovementControllerMessage*>(::IceProxy::Ice::Object::ice_datagram().get());
02008 #endif
02009 }
02010
02011 ::IceInternal::ProxyHandle<MovementControllerMessage> ice_batchDatagram() const
02012 {
02013 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02014 typedef ::IceProxy::Ice::Object _Base;
02015 return dynamic_cast<MovementControllerMessage*>(_Base::ice_batchDatagram().get());
02016 #else
02017 return dynamic_cast<MovementControllerMessage*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
02018 #endif
02019 }
02020
02021 ::IceInternal::ProxyHandle<MovementControllerMessage> ice_compress(bool __compress) const
02022 {
02023 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02024 typedef ::IceProxy::Ice::Object _Base;
02025 return dynamic_cast<MovementControllerMessage*>(_Base::ice_compress(__compress).get());
02026 #else
02027 return dynamic_cast<MovementControllerMessage*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
02028 #endif
02029 }
02030
02031 ::IceInternal::ProxyHandle<MovementControllerMessage> ice_timeout(int __timeout) const
02032 {
02033 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02034 typedef ::IceProxy::Ice::Object _Base;
02035 return dynamic_cast<MovementControllerMessage*>(_Base::ice_timeout(__timeout).get());
02036 #else
02037 return dynamic_cast<MovementControllerMessage*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
02038 #endif
02039 }
02040
02041 ::IceInternal::ProxyHandle<MovementControllerMessage> ice_connectionId(const std::string& __id) const
02042 {
02043 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02044 typedef ::IceProxy::Ice::Object _Base;
02045 return dynamic_cast<MovementControllerMessage*>(_Base::ice_connectionId(__id).get());
02046 #else
02047 return dynamic_cast<MovementControllerMessage*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
02048 #endif
02049 }
02050
02051 static const ::std::string& ice_staticId();
02052
02053 private:
02054
02055 virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
02056 virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
02057 virtual ::IceProxy::Ice::Object* __newInstance() const;
02058 };
02059
02060 class JoyStickControlMessage : virtual public ::IceProxy::RobotSimEvents::EventMessage
02061 {
02062 public:
02063
02064 ::IceInternal::ProxyHandle<JoyStickControlMessage> ice_context(const ::Ice::Context& __context) const
02065 {
02066 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02067 typedef ::IceProxy::Ice::Object _Base;
02068 return dynamic_cast<JoyStickControlMessage*>(_Base::ice_context(__context).get());
02069 #else
02070 return dynamic_cast<JoyStickControlMessage*>(::IceProxy::Ice::Object::ice_context(__context).get());
02071 #endif
02072 }
02073
02074 ::IceInternal::ProxyHandle<JoyStickControlMessage> ice_adapterId(const std::string& __id) const
02075 {
02076 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02077 typedef ::IceProxy::Ice::Object _Base;
02078 return dynamic_cast<JoyStickControlMessage*>(_Base::ice_adapterId(__id).get());
02079 #else
02080 return dynamic_cast<JoyStickControlMessage*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
02081 #endif
02082 }
02083
02084 ::IceInternal::ProxyHandle<JoyStickControlMessage> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
02085 {
02086 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02087 typedef ::IceProxy::Ice::Object _Base;
02088 return dynamic_cast<JoyStickControlMessage*>(_Base::ice_endpoints(__endpoints).get());
02089 #else
02090 return dynamic_cast<JoyStickControlMessage*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
02091 #endif
02092 }
02093
02094 ::IceInternal::ProxyHandle<JoyStickControlMessage> ice_locatorCacheTimeout(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<JoyStickControlMessage*>(_Base::ice_locatorCacheTimeout(__timeout).get());
02099 #else
02100 return dynamic_cast<JoyStickControlMessage*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
02101 #endif
02102 }
02103
02104 ::IceInternal::ProxyHandle<JoyStickControlMessage> ice_connectionCached(bool __cached) const
02105 {
02106 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02107 typedef ::IceProxy::Ice::Object _Base;
02108 return dynamic_cast<JoyStickControlMessage*>(_Base::ice_connectionCached(__cached).get());
02109 #else
02110 return dynamic_cast<JoyStickControlMessage*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
02111 #endif
02112 }
02113
02114 ::IceInternal::ProxyHandle<JoyStickControlMessage> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
02115 {
02116 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02117 typedef ::IceProxy::Ice::Object _Base;
02118 return dynamic_cast<JoyStickControlMessage*>(_Base::ice_endpointSelection(__est).get());
02119 #else
02120 return dynamic_cast<JoyStickControlMessage*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
02121 #endif
02122 }
02123
02124 ::IceInternal::ProxyHandle<JoyStickControlMessage> ice_secure(bool __secure) const
02125 {
02126 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02127 typedef ::IceProxy::Ice::Object _Base;
02128 return dynamic_cast<JoyStickControlMessage*>(_Base::ice_secure(__secure).get());
02129 #else
02130 return dynamic_cast<JoyStickControlMessage*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
02131 #endif
02132 }
02133
02134 ::IceInternal::ProxyHandle<JoyStickControlMessage> ice_preferSecure(bool __preferSecure) const
02135 {
02136 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02137 typedef ::IceProxy::Ice::Object _Base;
02138 return dynamic_cast<JoyStickControlMessage*>(_Base::ice_preferSecure(__preferSecure).get());
02139 #else
02140 return dynamic_cast<JoyStickControlMessage*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
02141 #endif
02142 }
02143
02144 ::IceInternal::ProxyHandle<JoyStickControlMessage> ice_router(const ::Ice::RouterPrx& __router) const
02145 {
02146 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02147 typedef ::IceProxy::Ice::Object _Base;
02148 return dynamic_cast<JoyStickControlMessage*>(_Base::ice_router(__router).get());
02149 #else
02150 return dynamic_cast<JoyStickControlMessage*>(::IceProxy::Ice::Object::ice_router(__router).get());
02151 #endif
02152 }
02153
02154 ::IceInternal::ProxyHandle<JoyStickControlMessage> ice_locator(const ::Ice::LocatorPrx& __locator) const
02155 {
02156 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02157 typedef ::IceProxy::Ice::Object _Base;
02158 return dynamic_cast<JoyStickControlMessage*>(_Base::ice_locator(__locator).get());
02159 #else
02160 return dynamic_cast<JoyStickControlMessage*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
02161 #endif
02162 }
02163
02164 ::IceInternal::ProxyHandle<JoyStickControlMessage> ice_collocationOptimized(bool __co) const
02165 {
02166 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02167 typedef ::IceProxy::Ice::Object _Base;
02168 return dynamic_cast<JoyStickControlMessage*>(_Base::ice_collocationOptimized(__co).get());
02169 #else
02170 return dynamic_cast<JoyStickControlMessage*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
02171 #endif
02172 }
02173
02174 ::IceInternal::ProxyHandle<JoyStickControlMessage> ice_twoway() const
02175 {
02176 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02177 typedef ::IceProxy::Ice::Object _Base;
02178 return dynamic_cast<JoyStickControlMessage*>(_Base::ice_twoway().get());
02179 #else
02180 return dynamic_cast<JoyStickControlMessage*>(::IceProxy::Ice::Object::ice_twoway().get());
02181 #endif
02182 }
02183
02184 ::IceInternal::ProxyHandle<JoyStickControlMessage> ice_oneway() const
02185 {
02186 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02187 typedef ::IceProxy::Ice::Object _Base;
02188 return dynamic_cast<JoyStickControlMessage*>(_Base::ice_oneway().get());
02189 #else
02190 return dynamic_cast<JoyStickControlMessage*>(::IceProxy::Ice::Object::ice_oneway().get());
02191 #endif
02192 }
02193
02194 ::IceInternal::ProxyHandle<JoyStickControlMessage> ice_batchOneway() const
02195 {
02196 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02197 typedef ::IceProxy::Ice::Object _Base;
02198 return dynamic_cast<JoyStickControlMessage*>(_Base::ice_batchOneway().get());
02199 #else
02200 return dynamic_cast<JoyStickControlMessage*>(::IceProxy::Ice::Object::ice_batchOneway().get());
02201 #endif
02202 }
02203
02204 ::IceInternal::ProxyHandle<JoyStickControlMessage> ice_datagram() const
02205 {
02206 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02207 typedef ::IceProxy::Ice::Object _Base;
02208 return dynamic_cast<JoyStickControlMessage*>(_Base::ice_datagram().get());
02209 #else
02210 return dynamic_cast<JoyStickControlMessage*>(::IceProxy::Ice::Object::ice_datagram().get());
02211 #endif
02212 }
02213
02214 ::IceInternal::ProxyHandle<JoyStickControlMessage> ice_batchDatagram() const
02215 {
02216 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02217 typedef ::IceProxy::Ice::Object _Base;
02218 return dynamic_cast<JoyStickControlMessage*>(_Base::ice_batchDatagram().get());
02219 #else
02220 return dynamic_cast<JoyStickControlMessage*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
02221 #endif
02222 }
02223
02224 ::IceInternal::ProxyHandle<JoyStickControlMessage> ice_compress(bool __compress) const
02225 {
02226 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02227 typedef ::IceProxy::Ice::Object _Base;
02228 return dynamic_cast<JoyStickControlMessage*>(_Base::ice_compress(__compress).get());
02229 #else
02230 return dynamic_cast<JoyStickControlMessage*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
02231 #endif
02232 }
02233
02234 ::IceInternal::ProxyHandle<JoyStickControlMessage> ice_timeout(int __timeout) const
02235 {
02236 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02237 typedef ::IceProxy::Ice::Object _Base;
02238 return dynamic_cast<JoyStickControlMessage*>(_Base::ice_timeout(__timeout).get());
02239 #else
02240 return dynamic_cast<JoyStickControlMessage*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
02241 #endif
02242 }
02243
02244 ::IceInternal::ProxyHandle<JoyStickControlMessage> ice_connectionId(const std::string& __id) const
02245 {
02246 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02247 typedef ::IceProxy::Ice::Object _Base;
02248 return dynamic_cast<JoyStickControlMessage*>(_Base::ice_connectionId(__id).get());
02249 #else
02250 return dynamic_cast<JoyStickControlMessage*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
02251 #endif
02252 }
02253
02254 static const ::std::string& ice_staticId();
02255
02256 private:
02257
02258 virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
02259 virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
02260 virtual ::IceProxy::Ice::Object* __newInstance() const;
02261 };
02262
02263 class BeeStemConfigMessage : virtual public ::IceProxy::RobotSimEvents::EventMessage
02264 {
02265 public:
02266
02267 ::IceInternal::ProxyHandle<BeeStemConfigMessage> ice_context(const ::Ice::Context& __context) const
02268 {
02269 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02270 typedef ::IceProxy::Ice::Object _Base;
02271 return dynamic_cast<BeeStemConfigMessage*>(_Base::ice_context(__context).get());
02272 #else
02273 return dynamic_cast<BeeStemConfigMessage*>(::IceProxy::Ice::Object::ice_context(__context).get());
02274 #endif
02275 }
02276
02277 ::IceInternal::ProxyHandle<BeeStemConfigMessage> ice_adapterId(const std::string& __id) const
02278 {
02279 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02280 typedef ::IceProxy::Ice::Object _Base;
02281 return dynamic_cast<BeeStemConfigMessage*>(_Base::ice_adapterId(__id).get());
02282 #else
02283 return dynamic_cast<BeeStemConfigMessage*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
02284 #endif
02285 }
02286
02287 ::IceInternal::ProxyHandle<BeeStemConfigMessage> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
02288 {
02289 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02290 typedef ::IceProxy::Ice::Object _Base;
02291 return dynamic_cast<BeeStemConfigMessage*>(_Base::ice_endpoints(__endpoints).get());
02292 #else
02293 return dynamic_cast<BeeStemConfigMessage*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
02294 #endif
02295 }
02296
02297 ::IceInternal::ProxyHandle<BeeStemConfigMessage> ice_locatorCacheTimeout(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<BeeStemConfigMessage*>(_Base::ice_locatorCacheTimeout(__timeout).get());
02302 #else
02303 return dynamic_cast<BeeStemConfigMessage*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
02304 #endif
02305 }
02306
02307 ::IceInternal::ProxyHandle<BeeStemConfigMessage> ice_connectionCached(bool __cached) const
02308 {
02309 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02310 typedef ::IceProxy::Ice::Object _Base;
02311 return dynamic_cast<BeeStemConfigMessage*>(_Base::ice_connectionCached(__cached).get());
02312 #else
02313 return dynamic_cast<BeeStemConfigMessage*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
02314 #endif
02315 }
02316
02317 ::IceInternal::ProxyHandle<BeeStemConfigMessage> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
02318 {
02319 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02320 typedef ::IceProxy::Ice::Object _Base;
02321 return dynamic_cast<BeeStemConfigMessage*>(_Base::ice_endpointSelection(__est).get());
02322 #else
02323 return dynamic_cast<BeeStemConfigMessage*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
02324 #endif
02325 }
02326
02327 ::IceInternal::ProxyHandle<BeeStemConfigMessage> ice_secure(bool __secure) const
02328 {
02329 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02330 typedef ::IceProxy::Ice::Object _Base;
02331 return dynamic_cast<BeeStemConfigMessage*>(_Base::ice_secure(__secure).get());
02332 #else
02333 return dynamic_cast<BeeStemConfigMessage*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
02334 #endif
02335 }
02336
02337 ::IceInternal::ProxyHandle<BeeStemConfigMessage> ice_preferSecure(bool __preferSecure) const
02338 {
02339 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02340 typedef ::IceProxy::Ice::Object _Base;
02341 return dynamic_cast<BeeStemConfigMessage*>(_Base::ice_preferSecure(__preferSecure).get());
02342 #else
02343 return dynamic_cast<BeeStemConfigMessage*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
02344 #endif
02345 }
02346
02347 ::IceInternal::ProxyHandle<BeeStemConfigMessage> ice_router(const ::Ice::RouterPrx& __router) const
02348 {
02349 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02350 typedef ::IceProxy::Ice::Object _Base;
02351 return dynamic_cast<BeeStemConfigMessage*>(_Base::ice_router(__router).get());
02352 #else
02353 return dynamic_cast<BeeStemConfigMessage*>(::IceProxy::Ice::Object::ice_router(__router).get());
02354 #endif
02355 }
02356
02357 ::IceInternal::ProxyHandle<BeeStemConfigMessage> ice_locator(const ::Ice::LocatorPrx& __locator) const
02358 {
02359 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02360 typedef ::IceProxy::Ice::Object _Base;
02361 return dynamic_cast<BeeStemConfigMessage*>(_Base::ice_locator(__locator).get());
02362 #else
02363 return dynamic_cast<BeeStemConfigMessage*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
02364 #endif
02365 }
02366
02367 ::IceInternal::ProxyHandle<BeeStemConfigMessage> ice_collocationOptimized(bool __co) const
02368 {
02369 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02370 typedef ::IceProxy::Ice::Object _Base;
02371 return dynamic_cast<BeeStemConfigMessage*>(_Base::ice_collocationOptimized(__co).get());
02372 #else
02373 return dynamic_cast<BeeStemConfigMessage*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
02374 #endif
02375 }
02376
02377 ::IceInternal::ProxyHandle<BeeStemConfigMessage> ice_twoway() const
02378 {
02379 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02380 typedef ::IceProxy::Ice::Object _Base;
02381 return dynamic_cast<BeeStemConfigMessage*>(_Base::ice_twoway().get());
02382 #else
02383 return dynamic_cast<BeeStemConfigMessage*>(::IceProxy::Ice::Object::ice_twoway().get());
02384 #endif
02385 }
02386
02387 ::IceInternal::ProxyHandle<BeeStemConfigMessage> ice_oneway() const
02388 {
02389 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02390 typedef ::IceProxy::Ice::Object _Base;
02391 return dynamic_cast<BeeStemConfigMessage*>(_Base::ice_oneway().get());
02392 #else
02393 return dynamic_cast<BeeStemConfigMessage*>(::IceProxy::Ice::Object::ice_oneway().get());
02394 #endif
02395 }
02396
02397 ::IceInternal::ProxyHandle<BeeStemConfigMessage> ice_batchOneway() const
02398 {
02399 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02400 typedef ::IceProxy::Ice::Object _Base;
02401 return dynamic_cast<BeeStemConfigMessage*>(_Base::ice_batchOneway().get());
02402 #else
02403 return dynamic_cast<BeeStemConfigMessage*>(::IceProxy::Ice::Object::ice_batchOneway().get());
02404 #endif
02405 }
02406
02407 ::IceInternal::ProxyHandle<BeeStemConfigMessage> ice_datagram() const
02408 {
02409 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02410 typedef ::IceProxy::Ice::Object _Base;
02411 return dynamic_cast<BeeStemConfigMessage*>(_Base::ice_datagram().get());
02412 #else
02413 return dynamic_cast<BeeStemConfigMessage*>(::IceProxy::Ice::Object::ice_datagram().get());
02414 #endif
02415 }
02416
02417 ::IceInternal::ProxyHandle<BeeStemConfigMessage> ice_batchDatagram() const
02418 {
02419 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02420 typedef ::IceProxy::Ice::Object _Base;
02421 return dynamic_cast<BeeStemConfigMessage*>(_Base::ice_batchDatagram().get());
02422 #else
02423 return dynamic_cast<BeeStemConfigMessage*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
02424 #endif
02425 }
02426
02427 ::IceInternal::ProxyHandle<BeeStemConfigMessage> ice_compress(bool __compress) const
02428 {
02429 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02430 typedef ::IceProxy::Ice::Object _Base;
02431 return dynamic_cast<BeeStemConfigMessage*>(_Base::ice_compress(__compress).get());
02432 #else
02433 return dynamic_cast<BeeStemConfigMessage*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
02434 #endif
02435 }
02436
02437 ::IceInternal::ProxyHandle<BeeStemConfigMessage> ice_timeout(int __timeout) const
02438 {
02439 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02440 typedef ::IceProxy::Ice::Object _Base;
02441 return dynamic_cast<BeeStemConfigMessage*>(_Base::ice_timeout(__timeout).get());
02442 #else
02443 return dynamic_cast<BeeStemConfigMessage*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
02444 #endif
02445 }
02446
02447 ::IceInternal::ProxyHandle<BeeStemConfigMessage> ice_connectionId(const std::string& __id) const
02448 {
02449 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02450 typedef ::IceProxy::Ice::Object _Base;
02451 return dynamic_cast<BeeStemConfigMessage*>(_Base::ice_connectionId(__id).get());
02452 #else
02453 return dynamic_cast<BeeStemConfigMessage*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
02454 #endif
02455 }
02456
02457 static const ::std::string& ice_staticId();
02458
02459 private:
02460
02461 virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
02462 virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
02463 virtual ::IceProxy::Ice::Object* __newInstance() const;
02464 };
02465
02466 class IMUDataServerMessage : virtual public ::IceProxy::RobotSimEvents::EventMessage
02467 {
02468 public:
02469
02470 ::IceInternal::ProxyHandle<IMUDataServerMessage> ice_context(const ::Ice::Context& __context) const
02471 {
02472 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02473 typedef ::IceProxy::Ice::Object _Base;
02474 return dynamic_cast<IMUDataServerMessage*>(_Base::ice_context(__context).get());
02475 #else
02476 return dynamic_cast<IMUDataServerMessage*>(::IceProxy::Ice::Object::ice_context(__context).get());
02477 #endif
02478 }
02479
02480 ::IceInternal::ProxyHandle<IMUDataServerMessage> ice_adapterId(const std::string& __id) const
02481 {
02482 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02483 typedef ::IceProxy::Ice::Object _Base;
02484 return dynamic_cast<IMUDataServerMessage*>(_Base::ice_adapterId(__id).get());
02485 #else
02486 return dynamic_cast<IMUDataServerMessage*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
02487 #endif
02488 }
02489
02490 ::IceInternal::ProxyHandle<IMUDataServerMessage> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
02491 {
02492 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02493 typedef ::IceProxy::Ice::Object _Base;
02494 return dynamic_cast<IMUDataServerMessage*>(_Base::ice_endpoints(__endpoints).get());
02495 #else
02496 return dynamic_cast<IMUDataServerMessage*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
02497 #endif
02498 }
02499
02500 ::IceInternal::ProxyHandle<IMUDataServerMessage> ice_locatorCacheTimeout(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<IMUDataServerMessage*>(_Base::ice_locatorCacheTimeout(__timeout).get());
02505 #else
02506 return dynamic_cast<IMUDataServerMessage*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
02507 #endif
02508 }
02509
02510 ::IceInternal::ProxyHandle<IMUDataServerMessage> ice_connectionCached(bool __cached) const
02511 {
02512 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02513 typedef ::IceProxy::Ice::Object _Base;
02514 return dynamic_cast<IMUDataServerMessage*>(_Base::ice_connectionCached(__cached).get());
02515 #else
02516 return dynamic_cast<IMUDataServerMessage*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
02517 #endif
02518 }
02519
02520 ::IceInternal::ProxyHandle<IMUDataServerMessage> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
02521 {
02522 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02523 typedef ::IceProxy::Ice::Object _Base;
02524 return dynamic_cast<IMUDataServerMessage*>(_Base::ice_endpointSelection(__est).get());
02525 #else
02526 return dynamic_cast<IMUDataServerMessage*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
02527 #endif
02528 }
02529
02530 ::IceInternal::ProxyHandle<IMUDataServerMessage> ice_secure(bool __secure) const
02531 {
02532 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02533 typedef ::IceProxy::Ice::Object _Base;
02534 return dynamic_cast<IMUDataServerMessage*>(_Base::ice_secure(__secure).get());
02535 #else
02536 return dynamic_cast<IMUDataServerMessage*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
02537 #endif
02538 }
02539
02540 ::IceInternal::ProxyHandle<IMUDataServerMessage> ice_preferSecure(bool __preferSecure) const
02541 {
02542 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02543 typedef ::IceProxy::Ice::Object _Base;
02544 return dynamic_cast<IMUDataServerMessage*>(_Base::ice_preferSecure(__preferSecure).get());
02545 #else
02546 return dynamic_cast<IMUDataServerMessage*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
02547 #endif
02548 }
02549
02550 ::IceInternal::ProxyHandle<IMUDataServerMessage> ice_router(const ::Ice::RouterPrx& __router) const
02551 {
02552 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02553 typedef ::IceProxy::Ice::Object _Base;
02554 return dynamic_cast<IMUDataServerMessage*>(_Base::ice_router(__router).get());
02555 #else
02556 return dynamic_cast<IMUDataServerMessage*>(::IceProxy::Ice::Object::ice_router(__router).get());
02557 #endif
02558 }
02559
02560 ::IceInternal::ProxyHandle<IMUDataServerMessage> ice_locator(const ::Ice::LocatorPrx& __locator) const
02561 {
02562 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02563 typedef ::IceProxy::Ice::Object _Base;
02564 return dynamic_cast<IMUDataServerMessage*>(_Base::ice_locator(__locator).get());
02565 #else
02566 return dynamic_cast<IMUDataServerMessage*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
02567 #endif
02568 }
02569
02570 ::IceInternal::ProxyHandle<IMUDataServerMessage> ice_collocationOptimized(bool __co) const
02571 {
02572 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02573 typedef ::IceProxy::Ice::Object _Base;
02574 return dynamic_cast<IMUDataServerMessage*>(_Base::ice_collocationOptimized(__co).get());
02575 #else
02576 return dynamic_cast<IMUDataServerMessage*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
02577 #endif
02578 }
02579
02580 ::IceInternal::ProxyHandle<IMUDataServerMessage> ice_twoway() const
02581 {
02582 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02583 typedef ::IceProxy::Ice::Object _Base;
02584 return dynamic_cast<IMUDataServerMessage*>(_Base::ice_twoway().get());
02585 #else
02586 return dynamic_cast<IMUDataServerMessage*>(::IceProxy::Ice::Object::ice_twoway().get());
02587 #endif
02588 }
02589
02590 ::IceInternal::ProxyHandle<IMUDataServerMessage> ice_oneway() const
02591 {
02592 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02593 typedef ::IceProxy::Ice::Object _Base;
02594 return dynamic_cast<IMUDataServerMessage*>(_Base::ice_oneway().get());
02595 #else
02596 return dynamic_cast<IMUDataServerMessage*>(::IceProxy::Ice::Object::ice_oneway().get());
02597 #endif
02598 }
02599
02600 ::IceInternal::ProxyHandle<IMUDataServerMessage> ice_batchOneway() const
02601 {
02602 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02603 typedef ::IceProxy::Ice::Object _Base;
02604 return dynamic_cast<IMUDataServerMessage*>(_Base::ice_batchOneway().get());
02605 #else
02606 return dynamic_cast<IMUDataServerMessage*>(::IceProxy::Ice::Object::ice_batchOneway().get());
02607 #endif
02608 }
02609
02610 ::IceInternal::ProxyHandle<IMUDataServerMessage> ice_datagram() const
02611 {
02612 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02613 typedef ::IceProxy::Ice::Object _Base;
02614 return dynamic_cast<IMUDataServerMessage*>(_Base::ice_datagram().get());
02615 #else
02616 return dynamic_cast<IMUDataServerMessage*>(::IceProxy::Ice::Object::ice_datagram().get());
02617 #endif
02618 }
02619
02620 ::IceInternal::ProxyHandle<IMUDataServerMessage> ice_batchDatagram() const
02621 {
02622 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02623 typedef ::IceProxy::Ice::Object _Base;
02624 return dynamic_cast<IMUDataServerMessage*>(_Base::ice_batchDatagram().get());
02625 #else
02626 return dynamic_cast<IMUDataServerMessage*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
02627 #endif
02628 }
02629
02630 ::IceInternal::ProxyHandle<IMUDataServerMessage> ice_compress(bool __compress) const
02631 {
02632 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02633 typedef ::IceProxy::Ice::Object _Base;
02634 return dynamic_cast<IMUDataServerMessage*>(_Base::ice_compress(__compress).get());
02635 #else
02636 return dynamic_cast<IMUDataServerMessage*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
02637 #endif
02638 }
02639
02640 ::IceInternal::ProxyHandle<IMUDataServerMessage> ice_timeout(int __timeout) const
02641 {
02642 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02643 typedef ::IceProxy::Ice::Object _Base;
02644 return dynamic_cast<IMUDataServerMessage*>(_Base::ice_timeout(__timeout).get());
02645 #else
02646 return dynamic_cast<IMUDataServerMessage*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
02647 #endif
02648 }
02649
02650 ::IceInternal::ProxyHandle<IMUDataServerMessage> ice_connectionId(const std::string& __id) const
02651 {
02652 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02653 typedef ::IceProxy::Ice::Object _Base;
02654 return dynamic_cast<IMUDataServerMessage*>(_Base::ice_connectionId(__id).get());
02655 #else
02656 return dynamic_cast<IMUDataServerMessage*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
02657 #endif
02658 }
02659
02660 static const ::std::string& ice_staticId();
02661
02662 private:
02663
02664 virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
02665 virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
02666 virtual ::IceProxy::Ice::Object* __newInstance() const;
02667 };
02668
02669 class BeeStemMotorControllerMessage : virtual public ::IceProxy::RobotSimEvents::EventMessage
02670 {
02671 public:
02672
02673 ::IceInternal::ProxyHandle<BeeStemMotorControllerMessage> ice_context(const ::Ice::Context& __context) const
02674 {
02675 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02676 typedef ::IceProxy::Ice::Object _Base;
02677 return dynamic_cast<BeeStemMotorControllerMessage*>(_Base::ice_context(__context).get());
02678 #else
02679 return dynamic_cast<BeeStemMotorControllerMessage*>(::IceProxy::Ice::Object::ice_context(__context).get());
02680 #endif
02681 }
02682
02683 ::IceInternal::ProxyHandle<BeeStemMotorControllerMessage> ice_adapterId(const std::string& __id) const
02684 {
02685 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02686 typedef ::IceProxy::Ice::Object _Base;
02687 return dynamic_cast<BeeStemMotorControllerMessage*>(_Base::ice_adapterId(__id).get());
02688 #else
02689 return dynamic_cast<BeeStemMotorControllerMessage*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
02690 #endif
02691 }
02692
02693 ::IceInternal::ProxyHandle<BeeStemMotorControllerMessage> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
02694 {
02695 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02696 typedef ::IceProxy::Ice::Object _Base;
02697 return dynamic_cast<BeeStemMotorControllerMessage*>(_Base::ice_endpoints(__endpoints).get());
02698 #else
02699 return dynamic_cast<BeeStemMotorControllerMessage*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
02700 #endif
02701 }
02702
02703 ::IceInternal::ProxyHandle<BeeStemMotorControllerMessage> ice_locatorCacheTimeout(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<BeeStemMotorControllerMessage*>(_Base::ice_locatorCacheTimeout(__timeout).get());
02708 #else
02709 return dynamic_cast<BeeStemMotorControllerMessage*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
02710 #endif
02711 }
02712
02713 ::IceInternal::ProxyHandle<BeeStemMotorControllerMessage> ice_connectionCached(bool __cached) const
02714 {
02715 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02716 typedef ::IceProxy::Ice::Object _Base;
02717 return dynamic_cast<BeeStemMotorControllerMessage*>(_Base::ice_connectionCached(__cached).get());
02718 #else
02719 return dynamic_cast<BeeStemMotorControllerMessage*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
02720 #endif
02721 }
02722
02723 ::IceInternal::ProxyHandle<BeeStemMotorControllerMessage> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
02724 {
02725 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02726 typedef ::IceProxy::Ice::Object _Base;
02727 return dynamic_cast<BeeStemMotorControllerMessage*>(_Base::ice_endpointSelection(__est).get());
02728 #else
02729 return dynamic_cast<BeeStemMotorControllerMessage*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
02730 #endif
02731 }
02732
02733 ::IceInternal::ProxyHandle<BeeStemMotorControllerMessage> ice_secure(bool __secure) const
02734 {
02735 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02736 typedef ::IceProxy::Ice::Object _Base;
02737 return dynamic_cast<BeeStemMotorControllerMessage*>(_Base::ice_secure(__secure).get());
02738 #else
02739 return dynamic_cast<BeeStemMotorControllerMessage*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
02740 #endif
02741 }
02742
02743 ::IceInternal::ProxyHandle<BeeStemMotorControllerMessage> ice_preferSecure(bool __preferSecure) const
02744 {
02745 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02746 typedef ::IceProxy::Ice::Object _Base;
02747 return dynamic_cast<BeeStemMotorControllerMessage*>(_Base::ice_preferSecure(__preferSecure).get());
02748 #else
02749 return dynamic_cast<BeeStemMotorControllerMessage*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
02750 #endif
02751 }
02752
02753 ::IceInternal::ProxyHandle<BeeStemMotorControllerMessage> ice_router(const ::Ice::RouterPrx& __router) const
02754 {
02755 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02756 typedef ::IceProxy::Ice::Object _Base;
02757 return dynamic_cast<BeeStemMotorControllerMessage*>(_Base::ice_router(__router).get());
02758 #else
02759 return dynamic_cast<BeeStemMotorControllerMessage*>(::IceProxy::Ice::Object::ice_router(__router).get());
02760 #endif
02761 }
02762
02763 ::IceInternal::ProxyHandle<BeeStemMotorControllerMessage> ice_locator(const ::Ice::LocatorPrx& __locator) const
02764 {
02765 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02766 typedef ::IceProxy::Ice::Object _Base;
02767 return dynamic_cast<BeeStemMotorControllerMessage*>(_Base::ice_locator(__locator).get());
02768 #else
02769 return dynamic_cast<BeeStemMotorControllerMessage*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
02770 #endif
02771 }
02772
02773 ::IceInternal::ProxyHandle<BeeStemMotorControllerMessage> ice_collocationOptimized(bool __co) const
02774 {
02775 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02776 typedef ::IceProxy::Ice::Object _Base;
02777 return dynamic_cast<BeeStemMotorControllerMessage*>(_Base::ice_collocationOptimized(__co).get());
02778 #else
02779 return dynamic_cast<BeeStemMotorControllerMessage*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
02780 #endif
02781 }
02782
02783 ::IceInternal::ProxyHandle<BeeStemMotorControllerMessage> ice_twoway() const
02784 {
02785 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02786 typedef ::IceProxy::Ice::Object _Base;
02787 return dynamic_cast<BeeStemMotorControllerMessage*>(_Base::ice_twoway().get());
02788 #else
02789 return dynamic_cast<BeeStemMotorControllerMessage*>(::IceProxy::Ice::Object::ice_twoway().get());
02790 #endif
02791 }
02792
02793 ::IceInternal::ProxyHandle<BeeStemMotorControllerMessage> ice_oneway() const
02794 {
02795 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02796 typedef ::IceProxy::Ice::Object _Base;
02797 return dynamic_cast<BeeStemMotorControllerMessage*>(_Base::ice_oneway().get());
02798 #else
02799 return dynamic_cast<BeeStemMotorControllerMessage*>(::IceProxy::Ice::Object::ice_oneway().get());
02800 #endif
02801 }
02802
02803 ::IceInternal::ProxyHandle<BeeStemMotorControllerMessage> ice_batchOneway() const
02804 {
02805 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02806 typedef ::IceProxy::Ice::Object _Base;
02807 return dynamic_cast<BeeStemMotorControllerMessage*>(_Base::ice_batchOneway().get());
02808 #else
02809 return dynamic_cast<BeeStemMotorControllerMessage*>(::IceProxy::Ice::Object::ice_batchOneway().get());
02810 #endif
02811 }
02812
02813 ::IceInternal::ProxyHandle<BeeStemMotorControllerMessage> ice_datagram() const
02814 {
02815 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02816 typedef ::IceProxy::Ice::Object _Base;
02817 return dynamic_cast<BeeStemMotorControllerMessage*>(_Base::ice_datagram().get());
02818 #else
02819 return dynamic_cast<BeeStemMotorControllerMessage*>(::IceProxy::Ice::Object::ice_datagram().get());
02820 #endif
02821 }
02822
02823 ::IceInternal::ProxyHandle<BeeStemMotorControllerMessage> ice_batchDatagram() const
02824 {
02825 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02826 typedef ::IceProxy::Ice::Object _Base;
02827 return dynamic_cast<BeeStemMotorControllerMessage*>(_Base::ice_batchDatagram().get());
02828 #else
02829 return dynamic_cast<BeeStemMotorControllerMessage*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
02830 #endif
02831 }
02832
02833 ::IceInternal::ProxyHandle<BeeStemMotorControllerMessage> ice_compress(bool __compress) const
02834 {
02835 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02836 typedef ::IceProxy::Ice::Object _Base;
02837 return dynamic_cast<BeeStemMotorControllerMessage*>(_Base::ice_compress(__compress).get());
02838 #else
02839 return dynamic_cast<BeeStemMotorControllerMessage*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
02840 #endif
02841 }
02842
02843 ::IceInternal::ProxyHandle<BeeStemMotorControllerMessage> ice_timeout(int __timeout) const
02844 {
02845 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02846 typedef ::IceProxy::Ice::Object _Base;
02847 return dynamic_cast<BeeStemMotorControllerMessage*>(_Base::ice_timeout(__timeout).get());
02848 #else
02849 return dynamic_cast<BeeStemMotorControllerMessage*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
02850 #endif
02851 }
02852
02853 ::IceInternal::ProxyHandle<BeeStemMotorControllerMessage> ice_connectionId(const std::string& __id) const
02854 {
02855 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02856 typedef ::IceProxy::Ice::Object _Base;
02857 return dynamic_cast<BeeStemMotorControllerMessage*>(_Base::ice_connectionId(__id).get());
02858 #else
02859 return dynamic_cast<BeeStemMotorControllerMessage*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
02860 #endif
02861 }
02862
02863 static const ::std::string& ice_staticId();
02864
02865 private:
02866
02867 virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
02868 virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
02869 virtual ::IceProxy::Ice::Object* __newInstance() const;
02870 };
02871
02872 class LocalizationMessage : virtual public ::IceProxy::RobotSimEvents::EventMessage
02873 {
02874 public:
02875
02876 ::IceInternal::ProxyHandle<LocalizationMessage> ice_context(const ::Ice::Context& __context) const
02877 {
02878 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02879 typedef ::IceProxy::Ice::Object _Base;
02880 return dynamic_cast<LocalizationMessage*>(_Base::ice_context(__context).get());
02881 #else
02882 return dynamic_cast<LocalizationMessage*>(::IceProxy::Ice::Object::ice_context(__context).get());
02883 #endif
02884 }
02885
02886 ::IceInternal::ProxyHandle<LocalizationMessage> ice_adapterId(const std::string& __id) const
02887 {
02888 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02889 typedef ::IceProxy::Ice::Object _Base;
02890 return dynamic_cast<LocalizationMessage*>(_Base::ice_adapterId(__id).get());
02891 #else
02892 return dynamic_cast<LocalizationMessage*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
02893 #endif
02894 }
02895
02896 ::IceInternal::ProxyHandle<LocalizationMessage> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
02897 {
02898 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02899 typedef ::IceProxy::Ice::Object _Base;
02900 return dynamic_cast<LocalizationMessage*>(_Base::ice_endpoints(__endpoints).get());
02901 #else
02902 return dynamic_cast<LocalizationMessage*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
02903 #endif
02904 }
02905
02906 ::IceInternal::ProxyHandle<LocalizationMessage> ice_locatorCacheTimeout(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<LocalizationMessage*>(_Base::ice_locatorCacheTimeout(__timeout).get());
02911 #else
02912 return dynamic_cast<LocalizationMessage*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
02913 #endif
02914 }
02915
02916 ::IceInternal::ProxyHandle<LocalizationMessage> ice_connectionCached(bool __cached) const
02917 {
02918 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02919 typedef ::IceProxy::Ice::Object _Base;
02920 return dynamic_cast<LocalizationMessage*>(_Base::ice_connectionCached(__cached).get());
02921 #else
02922 return dynamic_cast<LocalizationMessage*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
02923 #endif
02924 }
02925
02926 ::IceInternal::ProxyHandle<LocalizationMessage> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
02927 {
02928 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02929 typedef ::IceProxy::Ice::Object _Base;
02930 return dynamic_cast<LocalizationMessage*>(_Base::ice_endpointSelection(__est).get());
02931 #else
02932 return dynamic_cast<LocalizationMessage*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
02933 #endif
02934 }
02935
02936 ::IceInternal::ProxyHandle<LocalizationMessage> ice_secure(bool __secure) const
02937 {
02938 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02939 typedef ::IceProxy::Ice::Object _Base;
02940 return dynamic_cast<LocalizationMessage*>(_Base::ice_secure(__secure).get());
02941 #else
02942 return dynamic_cast<LocalizationMessage*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
02943 #endif
02944 }
02945
02946 ::IceInternal::ProxyHandle<LocalizationMessage> ice_preferSecure(bool __preferSecure) const
02947 {
02948 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02949 typedef ::IceProxy::Ice::Object _Base;
02950 return dynamic_cast<LocalizationMessage*>(_Base::ice_preferSecure(__preferSecure).get());
02951 #else
02952 return dynamic_cast<LocalizationMessage*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
02953 #endif
02954 }
02955
02956 ::IceInternal::ProxyHandle<LocalizationMessage> ice_router(const ::Ice::RouterPrx& __router) const
02957 {
02958 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02959 typedef ::IceProxy::Ice::Object _Base;
02960 return dynamic_cast<LocalizationMessage*>(_Base::ice_router(__router).get());
02961 #else
02962 return dynamic_cast<LocalizationMessage*>(::IceProxy::Ice::Object::ice_router(__router).get());
02963 #endif
02964 }
02965
02966 ::IceInternal::ProxyHandle<LocalizationMessage> ice_locator(const ::Ice::LocatorPrx& __locator) const
02967 {
02968 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02969 typedef ::IceProxy::Ice::Object _Base;
02970 return dynamic_cast<LocalizationMessage*>(_Base::ice_locator(__locator).get());
02971 #else
02972 return dynamic_cast<LocalizationMessage*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
02973 #endif
02974 }
02975
02976 ::IceInternal::ProxyHandle<LocalizationMessage> ice_collocationOptimized(bool __co) const
02977 {
02978 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02979 typedef ::IceProxy::Ice::Object _Base;
02980 return dynamic_cast<LocalizationMessage*>(_Base::ice_collocationOptimized(__co).get());
02981 #else
02982 return dynamic_cast<LocalizationMessage*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
02983 #endif
02984 }
02985
02986 ::IceInternal::ProxyHandle<LocalizationMessage> ice_twoway() const
02987 {
02988 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02989 typedef ::IceProxy::Ice::Object _Base;
02990 return dynamic_cast<LocalizationMessage*>(_Base::ice_twoway().get());
02991 #else
02992 return dynamic_cast<LocalizationMessage*>(::IceProxy::Ice::Object::ice_twoway().get());
02993 #endif
02994 }
02995
02996 ::IceInternal::ProxyHandle<LocalizationMessage> ice_oneway() const
02997 {
02998 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02999 typedef ::IceProxy::Ice::Object _Base;
03000 return dynamic_cast<LocalizationMessage*>(_Base::ice_oneway().get());
03001 #else
03002 return dynamic_cast<LocalizationMessage*>(::IceProxy::Ice::Object::ice_oneway().get());
03003 #endif
03004 }
03005
03006 ::IceInternal::ProxyHandle<LocalizationMessage> ice_batchOneway() const
03007 {
03008 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03009 typedef ::IceProxy::Ice::Object _Base;
03010 return dynamic_cast<LocalizationMessage*>(_Base::ice_batchOneway().get());
03011 #else
03012 return dynamic_cast<LocalizationMessage*>(::IceProxy::Ice::Object::ice_batchOneway().get());
03013 #endif
03014 }
03015
03016 ::IceInternal::ProxyHandle<LocalizationMessage> ice_datagram() const
03017 {
03018 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03019 typedef ::IceProxy::Ice::Object _Base;
03020 return dynamic_cast<LocalizationMessage*>(_Base::ice_datagram().get());
03021 #else
03022 return dynamic_cast<LocalizationMessage*>(::IceProxy::Ice::Object::ice_datagram().get());
03023 #endif
03024 }
03025
03026 ::IceInternal::ProxyHandle<LocalizationMessage> ice_batchDatagram() const
03027 {
03028 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03029 typedef ::IceProxy::Ice::Object _Base;
03030 return dynamic_cast<LocalizationMessage*>(_Base::ice_batchDatagram().get());
03031 #else
03032 return dynamic_cast<LocalizationMessage*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
03033 #endif
03034 }
03035
03036 ::IceInternal::ProxyHandle<LocalizationMessage> ice_compress(bool __compress) const
03037 {
03038 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03039 typedef ::IceProxy::Ice::Object _Base;
03040 return dynamic_cast<LocalizationMessage*>(_Base::ice_compress(__compress).get());
03041 #else
03042 return dynamic_cast<LocalizationMessage*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
03043 #endif
03044 }
03045
03046 ::IceInternal::ProxyHandle<LocalizationMessage> ice_timeout(int __timeout) const
03047 {
03048 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03049 typedef ::IceProxy::Ice::Object _Base;
03050 return dynamic_cast<LocalizationMessage*>(_Base::ice_timeout(__timeout).get());
03051 #else
03052 return dynamic_cast<LocalizationMessage*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
03053 #endif
03054 }
03055
03056 ::IceInternal::ProxyHandle<LocalizationMessage> ice_connectionId(const std::string& __id) const
03057 {
03058 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03059 typedef ::IceProxy::Ice::Object _Base;
03060 return dynamic_cast<LocalizationMessage*>(_Base::ice_connectionId(__id).get());
03061 #else
03062 return dynamic_cast<LocalizationMessage*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
03063 #endif
03064 }
03065
03066 static const ::std::string& ice_staticId();
03067
03068 private:
03069
03070 virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
03071 virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
03072 virtual ::IceProxy::Ice::Object* __newInstance() const;
03073 };
03074
03075 class BeeStemMessage : virtual public ::IceProxy::RobotSimEvents::EventMessage
03076 {
03077 public:
03078
03079 ::IceInternal::ProxyHandle<BeeStemMessage> ice_context(const ::Ice::Context& __context) const
03080 {
03081 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03082 typedef ::IceProxy::Ice::Object _Base;
03083 return dynamic_cast<BeeStemMessage*>(_Base::ice_context(__context).get());
03084 #else
03085 return dynamic_cast<BeeStemMessage*>(::IceProxy::Ice::Object::ice_context(__context).get());
03086 #endif
03087 }
03088
03089 ::IceInternal::ProxyHandle<BeeStemMessage> ice_adapterId(const std::string& __id) const
03090 {
03091 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03092 typedef ::IceProxy::Ice::Object _Base;
03093 return dynamic_cast<BeeStemMessage*>(_Base::ice_adapterId(__id).get());
03094 #else
03095 return dynamic_cast<BeeStemMessage*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
03096 #endif
03097 }
03098
03099 ::IceInternal::ProxyHandle<BeeStemMessage> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
03100 {
03101 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03102 typedef ::IceProxy::Ice::Object _Base;
03103 return dynamic_cast<BeeStemMessage*>(_Base::ice_endpoints(__endpoints).get());
03104 #else
03105 return dynamic_cast<BeeStemMessage*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
03106 #endif
03107 }
03108
03109 ::IceInternal::ProxyHandle<BeeStemMessage> ice_locatorCacheTimeout(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<BeeStemMessage*>(_Base::ice_locatorCacheTimeout(__timeout).get());
03114 #else
03115 return dynamic_cast<BeeStemMessage*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
03116 #endif
03117 }
03118
03119 ::IceInternal::ProxyHandle<BeeStemMessage> ice_connectionCached(bool __cached) const
03120 {
03121 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03122 typedef ::IceProxy::Ice::Object _Base;
03123 return dynamic_cast<BeeStemMessage*>(_Base::ice_connectionCached(__cached).get());
03124 #else
03125 return dynamic_cast<BeeStemMessage*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
03126 #endif
03127 }
03128
03129 ::IceInternal::ProxyHandle<BeeStemMessage> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
03130 {
03131 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03132 typedef ::IceProxy::Ice::Object _Base;
03133 return dynamic_cast<BeeStemMessage*>(_Base::ice_endpointSelection(__est).get());
03134 #else
03135 return dynamic_cast<BeeStemMessage*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
03136 #endif
03137 }
03138
03139 ::IceInternal::ProxyHandle<BeeStemMessage> ice_secure(bool __secure) const
03140 {
03141 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03142 typedef ::IceProxy::Ice::Object _Base;
03143 return dynamic_cast<BeeStemMessage*>(_Base::ice_secure(__secure).get());
03144 #else
03145 return dynamic_cast<BeeStemMessage*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
03146 #endif
03147 }
03148
03149 ::IceInternal::ProxyHandle<BeeStemMessage> ice_preferSecure(bool __preferSecure) const
03150 {
03151 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03152 typedef ::IceProxy::Ice::Object _Base;
03153 return dynamic_cast<BeeStemMessage*>(_Base::ice_preferSecure(__preferSecure).get());
03154 #else
03155 return dynamic_cast<BeeStemMessage*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
03156 #endif
03157 }
03158
03159 ::IceInternal::ProxyHandle<BeeStemMessage> ice_router(const ::Ice::RouterPrx& __router) const
03160 {
03161 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03162 typedef ::IceProxy::Ice::Object _Base;
03163 return dynamic_cast<BeeStemMessage*>(_Base::ice_router(__router).get());
03164 #else
03165 return dynamic_cast<BeeStemMessage*>(::IceProxy::Ice::Object::ice_router(__router).get());
03166 #endif
03167 }
03168
03169 ::IceInternal::ProxyHandle<BeeStemMessage> ice_locator(const ::Ice::LocatorPrx& __locator) const
03170 {
03171 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03172 typedef ::IceProxy::Ice::Object _Base;
03173 return dynamic_cast<BeeStemMessage*>(_Base::ice_locator(__locator).get());
03174 #else
03175 return dynamic_cast<BeeStemMessage*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
03176 #endif
03177 }
03178
03179 ::IceInternal::ProxyHandle<BeeStemMessage> ice_collocationOptimized(bool __co) const
03180 {
03181 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03182 typedef ::IceProxy::Ice::Object _Base;
03183 return dynamic_cast<BeeStemMessage*>(_Base::ice_collocationOptimized(__co).get());
03184 #else
03185 return dynamic_cast<BeeStemMessage*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
03186 #endif
03187 }
03188
03189 ::IceInternal::ProxyHandle<BeeStemMessage> ice_twoway() const
03190 {
03191 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03192 typedef ::IceProxy::Ice::Object _Base;
03193 return dynamic_cast<BeeStemMessage*>(_Base::ice_twoway().get());
03194 #else
03195 return dynamic_cast<BeeStemMessage*>(::IceProxy::Ice::Object::ice_twoway().get());
03196 #endif
03197 }
03198
03199 ::IceInternal::ProxyHandle<BeeStemMessage> ice_oneway() const
03200 {
03201 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03202 typedef ::IceProxy::Ice::Object _Base;
03203 return dynamic_cast<BeeStemMessage*>(_Base::ice_oneway().get());
03204 #else
03205 return dynamic_cast<BeeStemMessage*>(::IceProxy::Ice::Object::ice_oneway().get());
03206 #endif
03207 }
03208
03209 ::IceInternal::ProxyHandle<BeeStemMessage> ice_batchOneway() const
03210 {
03211 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03212 typedef ::IceProxy::Ice::Object _Base;
03213 return dynamic_cast<BeeStemMessage*>(_Base::ice_batchOneway().get());
03214 #else
03215 return dynamic_cast<BeeStemMessage*>(::IceProxy::Ice::Object::ice_batchOneway().get());
03216 #endif
03217 }
03218
03219 ::IceInternal::ProxyHandle<BeeStemMessage> ice_datagram() const
03220 {
03221 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03222 typedef ::IceProxy::Ice::Object _Base;
03223 return dynamic_cast<BeeStemMessage*>(_Base::ice_datagram().get());
03224 #else
03225 return dynamic_cast<BeeStemMessage*>(::IceProxy::Ice::Object::ice_datagram().get());
03226 #endif
03227 }
03228
03229 ::IceInternal::ProxyHandle<BeeStemMessage> ice_batchDatagram() const
03230 {
03231 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03232 typedef ::IceProxy::Ice::Object _Base;
03233 return dynamic_cast<BeeStemMessage*>(_Base::ice_batchDatagram().get());
03234 #else
03235 return dynamic_cast<BeeStemMessage*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
03236 #endif
03237 }
03238
03239 ::IceInternal::ProxyHandle<BeeStemMessage> ice_compress(bool __compress) const
03240 {
03241 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03242 typedef ::IceProxy::Ice::Object _Base;
03243 return dynamic_cast<BeeStemMessage*>(_Base::ice_compress(__compress).get());
03244 #else
03245 return dynamic_cast<BeeStemMessage*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
03246 #endif
03247 }
03248
03249 ::IceInternal::ProxyHandle<BeeStemMessage> ice_timeout(int __timeout) const
03250 {
03251 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03252 typedef ::IceProxy::Ice::Object _Base;
03253 return dynamic_cast<BeeStemMessage*>(_Base::ice_timeout(__timeout).get());
03254 #else
03255 return dynamic_cast<BeeStemMessage*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
03256 #endif
03257 }
03258
03259 ::IceInternal::ProxyHandle<BeeStemMessage> ice_connectionId(const std::string& __id) const
03260 {
03261 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03262 typedef ::IceProxy::Ice::Object _Base;
03263 return dynamic_cast<BeeStemMessage*>(_Base::ice_connectionId(__id).get());
03264 #else
03265 return dynamic_cast<BeeStemMessage*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
03266 #endif
03267 }
03268
03269 static const ::std::string& ice_staticId();
03270
03271 private:
03272
03273 virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
03274 virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
03275 virtual ::IceProxy::Ice::Object* __newInstance() const;
03276 };
03277
03278 class ChatMessage : virtual public ::IceProxy::RobotSimEvents::EventMessage
03279 {
03280 public:
03281
03282 ::IceInternal::ProxyHandle<ChatMessage> ice_context(const ::Ice::Context& __context) const
03283 {
03284 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03285 typedef ::IceProxy::Ice::Object _Base;
03286 return dynamic_cast<ChatMessage*>(_Base::ice_context(__context).get());
03287 #else
03288 return dynamic_cast<ChatMessage*>(::IceProxy::Ice::Object::ice_context(__context).get());
03289 #endif
03290 }
03291
03292 ::IceInternal::ProxyHandle<ChatMessage> ice_adapterId(const std::string& __id) const
03293 {
03294 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03295 typedef ::IceProxy::Ice::Object _Base;
03296 return dynamic_cast<ChatMessage*>(_Base::ice_adapterId(__id).get());
03297 #else
03298 return dynamic_cast<ChatMessage*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
03299 #endif
03300 }
03301
03302 ::IceInternal::ProxyHandle<ChatMessage> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
03303 {
03304 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03305 typedef ::IceProxy::Ice::Object _Base;
03306 return dynamic_cast<ChatMessage*>(_Base::ice_endpoints(__endpoints).get());
03307 #else
03308 return dynamic_cast<ChatMessage*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
03309 #endif
03310 }
03311
03312 ::IceInternal::ProxyHandle<ChatMessage> ice_locatorCacheTimeout(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<ChatMessage*>(_Base::ice_locatorCacheTimeout(__timeout).get());
03317 #else
03318 return dynamic_cast<ChatMessage*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
03319 #endif
03320 }
03321
03322 ::IceInternal::ProxyHandle<ChatMessage> ice_connectionCached(bool __cached) const
03323 {
03324 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03325 typedef ::IceProxy::Ice::Object _Base;
03326 return dynamic_cast<ChatMessage*>(_Base::ice_connectionCached(__cached).get());
03327 #else
03328 return dynamic_cast<ChatMessage*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
03329 #endif
03330 }
03331
03332 ::IceInternal::ProxyHandle<ChatMessage> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
03333 {
03334 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03335 typedef ::IceProxy::Ice::Object _Base;
03336 return dynamic_cast<ChatMessage*>(_Base::ice_endpointSelection(__est).get());
03337 #else
03338 return dynamic_cast<ChatMessage*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
03339 #endif
03340 }
03341
03342 ::IceInternal::ProxyHandle<ChatMessage> ice_secure(bool __secure) const
03343 {
03344 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03345 typedef ::IceProxy::Ice::Object _Base;
03346 return dynamic_cast<ChatMessage*>(_Base::ice_secure(__secure).get());
03347 #else
03348 return dynamic_cast<ChatMessage*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
03349 #endif
03350 }
03351
03352 ::IceInternal::ProxyHandle<ChatMessage> ice_preferSecure(bool __preferSecure) const
03353 {
03354 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03355 typedef ::IceProxy::Ice::Object _Base;
03356 return dynamic_cast<ChatMessage*>(_Base::ice_preferSecure(__preferSecure).get());
03357 #else
03358 return dynamic_cast<ChatMessage*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
03359 #endif
03360 }
03361
03362 ::IceInternal::ProxyHandle<ChatMessage> ice_router(const ::Ice::RouterPrx& __router) const
03363 {
03364 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03365 typedef ::IceProxy::Ice::Object _Base;
03366 return dynamic_cast<ChatMessage*>(_Base::ice_router(__router).get());
03367 #else
03368 return dynamic_cast<ChatMessage*>(::IceProxy::Ice::Object::ice_router(__router).get());
03369 #endif
03370 }
03371
03372 ::IceInternal::ProxyHandle<ChatMessage> ice_locator(const ::Ice::LocatorPrx& __locator) const
03373 {
03374 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03375 typedef ::IceProxy::Ice::Object _Base;
03376 return dynamic_cast<ChatMessage*>(_Base::ice_locator(__locator).get());
03377 #else
03378 return dynamic_cast<ChatMessage*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
03379 #endif
03380 }
03381
03382 ::IceInternal::ProxyHandle<ChatMessage> ice_collocationOptimized(bool __co) const
03383 {
03384 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03385 typedef ::IceProxy::Ice::Object _Base;
03386 return dynamic_cast<ChatMessage*>(_Base::ice_collocationOptimized(__co).get());
03387 #else
03388 return dynamic_cast<ChatMessage*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
03389 #endif
03390 }
03391
03392 ::IceInternal::ProxyHandle<ChatMessage> ice_twoway() const
03393 {
03394 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03395 typedef ::IceProxy::Ice::Object _Base;
03396 return dynamic_cast<ChatMessage*>(_Base::ice_twoway().get());
03397 #else
03398 return dynamic_cast<ChatMessage*>(::IceProxy::Ice::Object::ice_twoway().get());
03399 #endif
03400 }
03401
03402 ::IceInternal::ProxyHandle<ChatMessage> ice_oneway() const
03403 {
03404 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03405 typedef ::IceProxy::Ice::Object _Base;
03406 return dynamic_cast<ChatMessage*>(_Base::ice_oneway().get());
03407 #else
03408 return dynamic_cast<ChatMessage*>(::IceProxy::Ice::Object::ice_oneway().get());
03409 #endif
03410 }
03411
03412 ::IceInternal::ProxyHandle<ChatMessage> ice_batchOneway() const
03413 {
03414 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03415 typedef ::IceProxy::Ice::Object _Base;
03416 return dynamic_cast<ChatMessage*>(_Base::ice_batchOneway().get());
03417 #else
03418 return dynamic_cast<ChatMessage*>(::IceProxy::Ice::Object::ice_batchOneway().get());
03419 #endif
03420 }
03421
03422 ::IceInternal::ProxyHandle<ChatMessage> ice_datagram() const
03423 {
03424 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03425 typedef ::IceProxy::Ice::Object _Base;
03426 return dynamic_cast<ChatMessage*>(_Base::ice_datagram().get());
03427 #else
03428 return dynamic_cast<ChatMessage*>(::IceProxy::Ice::Object::ice_datagram().get());
03429 #endif
03430 }
03431
03432 ::IceInternal::ProxyHandle<ChatMessage> ice_batchDatagram() const
03433 {
03434 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03435 typedef ::IceProxy::Ice::Object _Base;
03436 return dynamic_cast<ChatMessage*>(_Base::ice_batchDatagram().get());
03437 #else
03438 return dynamic_cast<ChatMessage*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
03439 #endif
03440 }
03441
03442 ::IceInternal::ProxyHandle<ChatMessage> ice_compress(bool __compress) const
03443 {
03444 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03445 typedef ::IceProxy::Ice::Object _Base;
03446 return dynamic_cast<ChatMessage*>(_Base::ice_compress(__compress).get());
03447 #else
03448 return dynamic_cast<ChatMessage*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
03449 #endif
03450 }
03451
03452 ::IceInternal::ProxyHandle<ChatMessage> ice_timeout(int __timeout) const
03453 {
03454 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03455 typedef ::IceProxy::Ice::Object _Base;
03456 return dynamic_cast<ChatMessage*>(_Base::ice_timeout(__timeout).get());
03457 #else
03458 return dynamic_cast<ChatMessage*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
03459 #endif
03460 }
03461
03462 ::IceInternal::ProxyHandle<ChatMessage> ice_connectionId(const std::string& __id) const
03463 {
03464 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03465 typedef ::IceProxy::Ice::Object _Base;
03466 return dynamic_cast<ChatMessage*>(_Base::ice_connectionId(__id).get());
03467 #else
03468 return dynamic_cast<ChatMessage*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
03469 #endif
03470 }
03471
03472 static const ::std::string& ice_staticId();
03473
03474 private:
03475
03476 virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
03477 virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
03478 virtual ::IceProxy::Ice::Object* __newInstance() const;
03479 };
03480
03481 class RemoteControlMessage : virtual public ::IceProxy::RobotSimEvents::EventMessage
03482 {
03483 public:
03484
03485 ::IceInternal::ProxyHandle<RemoteControlMessage> ice_context(const ::Ice::Context& __context) const
03486 {
03487 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03488 typedef ::IceProxy::Ice::Object _Base;
03489 return dynamic_cast<RemoteControlMessage*>(_Base::ice_context(__context).get());
03490 #else
03491 return dynamic_cast<RemoteControlMessage*>(::IceProxy::Ice::Object::ice_context(__context).get());
03492 #endif
03493 }
03494
03495 ::IceInternal::ProxyHandle<RemoteControlMessage> ice_adapterId(const std::string& __id) const
03496 {
03497 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03498 typedef ::IceProxy::Ice::Object _Base;
03499 return dynamic_cast<RemoteControlMessage*>(_Base::ice_adapterId(__id).get());
03500 #else
03501 return dynamic_cast<RemoteControlMessage*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
03502 #endif
03503 }
03504
03505 ::IceInternal::ProxyHandle<RemoteControlMessage> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
03506 {
03507 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03508 typedef ::IceProxy::Ice::Object _Base;
03509 return dynamic_cast<RemoteControlMessage*>(_Base::ice_endpoints(__endpoints).get());
03510 #else
03511 return dynamic_cast<RemoteControlMessage*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
03512 #endif
03513 }
03514
03515 ::IceInternal::ProxyHandle<RemoteControlMessage> ice_locatorCacheTimeout(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<RemoteControlMessage*>(_Base::ice_locatorCacheTimeout(__timeout).get());
03520 #else
03521 return dynamic_cast<RemoteControlMessage*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
03522 #endif
03523 }
03524
03525 ::IceInternal::ProxyHandle<RemoteControlMessage> ice_connectionCached(bool __cached) const
03526 {
03527 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03528 typedef ::IceProxy::Ice::Object _Base;
03529 return dynamic_cast<RemoteControlMessage*>(_Base::ice_connectionCached(__cached).get());
03530 #else
03531 return dynamic_cast<RemoteControlMessage*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
03532 #endif
03533 }
03534
03535 ::IceInternal::ProxyHandle<RemoteControlMessage> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
03536 {
03537 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03538 typedef ::IceProxy::Ice::Object _Base;
03539 return dynamic_cast<RemoteControlMessage*>(_Base::ice_endpointSelection(__est).get());
03540 #else
03541 return dynamic_cast<RemoteControlMessage*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
03542 #endif
03543 }
03544
03545 ::IceInternal::ProxyHandle<RemoteControlMessage> ice_secure(bool __secure) const
03546 {
03547 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03548 typedef ::IceProxy::Ice::Object _Base;
03549 return dynamic_cast<RemoteControlMessage*>(_Base::ice_secure(__secure).get());
03550 #else
03551 return dynamic_cast<RemoteControlMessage*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
03552 #endif
03553 }
03554
03555 ::IceInternal::ProxyHandle<RemoteControlMessage> ice_preferSecure(bool __preferSecure) const
03556 {
03557 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03558 typedef ::IceProxy::Ice::Object _Base;
03559 return dynamic_cast<RemoteControlMessage*>(_Base::ice_preferSecure(__preferSecure).get());
03560 #else
03561 return dynamic_cast<RemoteControlMessage*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
03562 #endif
03563 }
03564
03565 ::IceInternal::ProxyHandle<RemoteControlMessage> ice_router(const ::Ice::RouterPrx& __router) const
03566 {
03567 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03568 typedef ::IceProxy::Ice::Object _Base;
03569 return dynamic_cast<RemoteControlMessage*>(_Base::ice_router(__router).get());
03570 #else
03571 return dynamic_cast<RemoteControlMessage*>(::IceProxy::Ice::Object::ice_router(__router).get());
03572 #endif
03573 }
03574
03575 ::IceInternal::ProxyHandle<RemoteControlMessage> ice_locator(const ::Ice::LocatorPrx& __locator) const
03576 {
03577 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03578 typedef ::IceProxy::Ice::Object _Base;
03579 return dynamic_cast<RemoteControlMessage*>(_Base::ice_locator(__locator).get());
03580 #else
03581 return dynamic_cast<RemoteControlMessage*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
03582 #endif
03583 }
03584
03585 ::IceInternal::ProxyHandle<RemoteControlMessage> ice_collocationOptimized(bool __co) const
03586 {
03587 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03588 typedef ::IceProxy::Ice::Object _Base;
03589 return dynamic_cast<RemoteControlMessage*>(_Base::ice_collocationOptimized(__co).get());
03590 #else
03591 return dynamic_cast<RemoteControlMessage*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
03592 #endif
03593 }
03594
03595 ::IceInternal::ProxyHandle<RemoteControlMessage> ice_twoway() const
03596 {
03597 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03598 typedef ::IceProxy::Ice::Object _Base;
03599 return dynamic_cast<RemoteControlMessage*>(_Base::ice_twoway().get());
03600 #else
03601 return dynamic_cast<RemoteControlMessage*>(::IceProxy::Ice::Object::ice_twoway().get());
03602 #endif
03603 }
03604
03605 ::IceInternal::ProxyHandle<RemoteControlMessage> ice_oneway() const
03606 {
03607 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03608 typedef ::IceProxy::Ice::Object _Base;
03609 return dynamic_cast<RemoteControlMessage*>(_Base::ice_oneway().get());
03610 #else
03611 return dynamic_cast<RemoteControlMessage*>(::IceProxy::Ice::Object::ice_oneway().get());
03612 #endif
03613 }
03614
03615 ::IceInternal::ProxyHandle<RemoteControlMessage> ice_batchOneway() const
03616 {
03617 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03618 typedef ::IceProxy::Ice::Object _Base;
03619 return dynamic_cast<RemoteControlMessage*>(_Base::ice_batchOneway().get());
03620 #else
03621 return dynamic_cast<RemoteControlMessage*>(::IceProxy::Ice::Object::ice_batchOneway().get());
03622 #endif
03623 }
03624
03625 ::IceInternal::ProxyHandle<RemoteControlMessage> ice_datagram() const
03626 {
03627 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03628 typedef ::IceProxy::Ice::Object _Base;
03629 return dynamic_cast<RemoteControlMessage*>(_Base::ice_datagram().get());
03630 #else
03631 return dynamic_cast<RemoteControlMessage*>(::IceProxy::Ice::Object::ice_datagram().get());
03632 #endif
03633 }
03634
03635 ::IceInternal::ProxyHandle<RemoteControlMessage> ice_batchDatagram() const
03636 {
03637 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03638 typedef ::IceProxy::Ice::Object _Base;
03639 return dynamic_cast<RemoteControlMessage*>(_Base::ice_batchDatagram().get());
03640 #else
03641 return dynamic_cast<RemoteControlMessage*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
03642 #endif
03643 }
03644
03645 ::IceInternal::ProxyHandle<RemoteControlMessage> ice_compress(bool __compress) const
03646 {
03647 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03648 typedef ::IceProxy::Ice::Object _Base;
03649 return dynamic_cast<RemoteControlMessage*>(_Base::ice_compress(__compress).get());
03650 #else
03651 return dynamic_cast<RemoteControlMessage*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
03652 #endif
03653 }
03654
03655 ::IceInternal::ProxyHandle<RemoteControlMessage> ice_timeout(int __timeout) const
03656 {
03657 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03658 typedef ::IceProxy::Ice::Object _Base;
03659 return dynamic_cast<RemoteControlMessage*>(_Base::ice_timeout(__timeout).get());
03660 #else
03661 return dynamic_cast<RemoteControlMessage*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
03662 #endif
03663 }
03664
03665 ::IceInternal::ProxyHandle<RemoteControlMessage> ice_connectionId(const std::string& __id) const
03666 {
03667 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03668 typedef ::IceProxy::Ice::Object _Base;
03669 return dynamic_cast<RemoteControlMessage*>(_Base::ice_connectionId(__id).get());
03670 #else
03671 return dynamic_cast<RemoteControlMessage*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
03672 #endif
03673 }
03674
03675 static const ::std::string& ice_staticId();
03676
03677 private:
03678
03679 virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
03680 virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
03681 virtual ::IceProxy::Ice::Object* __newInstance() const;
03682 };
03683
03684 class StateMessage : virtual public ::IceProxy::RobotSimEvents::EventMessage
03685 {
03686 public:
03687
03688 ::IceInternal::ProxyHandle<StateMessage> ice_context(const ::Ice::Context& __context) const
03689 {
03690 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03691 typedef ::IceProxy::Ice::Object _Base;
03692 return dynamic_cast<StateMessage*>(_Base::ice_context(__context).get());
03693 #else
03694 return dynamic_cast<StateMessage*>(::IceProxy::Ice::Object::ice_context(__context).get());
03695 #endif
03696 }
03697
03698 ::IceInternal::ProxyHandle<StateMessage> ice_adapterId(const std::string& __id) const
03699 {
03700 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03701 typedef ::IceProxy::Ice::Object _Base;
03702 return dynamic_cast<StateMessage*>(_Base::ice_adapterId(__id).get());
03703 #else
03704 return dynamic_cast<StateMessage*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
03705 #endif
03706 }
03707
03708 ::IceInternal::ProxyHandle<StateMessage> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
03709 {
03710 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03711 typedef ::IceProxy::Ice::Object _Base;
03712 return dynamic_cast<StateMessage*>(_Base::ice_endpoints(__endpoints).get());
03713 #else
03714 return dynamic_cast<StateMessage*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
03715 #endif
03716 }
03717
03718 ::IceInternal::ProxyHandle<StateMessage> ice_locatorCacheTimeout(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<StateMessage*>(_Base::ice_locatorCacheTimeout(__timeout).get());
03723 #else
03724 return dynamic_cast<StateMessage*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
03725 #endif
03726 }
03727
03728 ::IceInternal::ProxyHandle<StateMessage> ice_connectionCached(bool __cached) const
03729 {
03730 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03731 typedef ::IceProxy::Ice::Object _Base;
03732 return dynamic_cast<StateMessage*>(_Base::ice_connectionCached(__cached).get());
03733 #else
03734 return dynamic_cast<StateMessage*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
03735 #endif
03736 }
03737
03738 ::IceInternal::ProxyHandle<StateMessage> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
03739 {
03740 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03741 typedef ::IceProxy::Ice::Object _Base;
03742 return dynamic_cast<StateMessage*>(_Base::ice_endpointSelection(__est).get());
03743 #else
03744 return dynamic_cast<StateMessage*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
03745 #endif
03746 }
03747
03748 ::IceInternal::ProxyHandle<StateMessage> ice_secure(bool __secure) const
03749 {
03750 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03751 typedef ::IceProxy::Ice::Object _Base;
03752 return dynamic_cast<StateMessage*>(_Base::ice_secure(__secure).get());
03753 #else
03754 return dynamic_cast<StateMessage*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
03755 #endif
03756 }
03757
03758 ::IceInternal::ProxyHandle<StateMessage> ice_preferSecure(bool __preferSecure) const
03759 {
03760 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03761 typedef ::IceProxy::Ice::Object _Base;
03762 return dynamic_cast<StateMessage*>(_Base::ice_preferSecure(__preferSecure).get());
03763 #else
03764 return dynamic_cast<StateMessage*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
03765 #endif
03766 }
03767
03768 ::IceInternal::ProxyHandle<StateMessage> ice_router(const ::Ice::RouterPrx& __router) const
03769 {
03770 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03771 typedef ::IceProxy::Ice::Object _Base;
03772 return dynamic_cast<StateMessage*>(_Base::ice_router(__router).get());
03773 #else
03774 return dynamic_cast<StateMessage*>(::IceProxy::Ice::Object::ice_router(__router).get());
03775 #endif
03776 }
03777
03778 ::IceInternal::ProxyHandle<StateMessage> ice_locator(const ::Ice::LocatorPrx& __locator) const
03779 {
03780 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03781 typedef ::IceProxy::Ice::Object _Base;
03782 return dynamic_cast<StateMessage*>(_Base::ice_locator(__locator).get());
03783 #else
03784 return dynamic_cast<StateMessage*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
03785 #endif
03786 }
03787
03788 ::IceInternal::ProxyHandle<StateMessage> ice_collocationOptimized(bool __co) const
03789 {
03790 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03791 typedef ::IceProxy::Ice::Object _Base;
03792 return dynamic_cast<StateMessage*>(_Base::ice_collocationOptimized(__co).get());
03793 #else
03794 return dynamic_cast<StateMessage*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
03795 #endif
03796 }
03797
03798 ::IceInternal::ProxyHandle<StateMessage> ice_twoway() const
03799 {
03800 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03801 typedef ::IceProxy::Ice::Object _Base;
03802 return dynamic_cast<StateMessage*>(_Base::ice_twoway().get());
03803 #else
03804 return dynamic_cast<StateMessage*>(::IceProxy::Ice::Object::ice_twoway().get());
03805 #endif
03806 }
03807
03808 ::IceInternal::ProxyHandle<StateMessage> ice_oneway() const
03809 {
03810 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03811 typedef ::IceProxy::Ice::Object _Base;
03812 return dynamic_cast<StateMessage*>(_Base::ice_oneway().get());
03813 #else
03814 return dynamic_cast<StateMessage*>(::IceProxy::Ice::Object::ice_oneway().get());
03815 #endif
03816 }
03817
03818 ::IceInternal::ProxyHandle<StateMessage> ice_batchOneway() const
03819 {
03820 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03821 typedef ::IceProxy::Ice::Object _Base;
03822 return dynamic_cast<StateMessage*>(_Base::ice_batchOneway().get());
03823 #else
03824 return dynamic_cast<StateMessage*>(::IceProxy::Ice::Object::ice_batchOneway().get());
03825 #endif
03826 }
03827
03828 ::IceInternal::ProxyHandle<StateMessage> ice_datagram() const
03829 {
03830 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03831 typedef ::IceProxy::Ice::Object _Base;
03832 return dynamic_cast<StateMessage*>(_Base::ice_datagram().get());
03833 #else
03834 return dynamic_cast<StateMessage*>(::IceProxy::Ice::Object::ice_datagram().get());
03835 #endif
03836 }
03837
03838 ::IceInternal::ProxyHandle<StateMessage> ice_batchDatagram() const
03839 {
03840 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03841 typedef ::IceProxy::Ice::Object _Base;
03842 return dynamic_cast<StateMessage*>(_Base::ice_batchDatagram().get());
03843 #else
03844 return dynamic_cast<StateMessage*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
03845 #endif
03846 }
03847
03848 ::IceInternal::ProxyHandle<StateMessage> ice_compress(bool __compress) const
03849 {
03850 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03851 typedef ::IceProxy::Ice::Object _Base;
03852 return dynamic_cast<StateMessage*>(_Base::ice_compress(__compress).get());
03853 #else
03854 return dynamic_cast<StateMessage*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
03855 #endif
03856 }
03857
03858 ::IceInternal::ProxyHandle<StateMessage> ice_timeout(int __timeout) const
03859 {
03860 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03861 typedef ::IceProxy::Ice::Object _Base;
03862 return dynamic_cast<StateMessage*>(_Base::ice_timeout(__timeout).get());
03863 #else
03864 return dynamic_cast<StateMessage*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
03865 #endif
03866 }
03867
03868 ::IceInternal::ProxyHandle<StateMessage> ice_connectionId(const std::string& __id) const
03869 {
03870 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03871 typedef ::IceProxy::Ice::Object _Base;
03872 return dynamic_cast<StateMessage*>(_Base::ice_connectionId(__id).get());
03873 #else
03874 return dynamic_cast<StateMessage*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
03875 #endif
03876 }
03877
03878 static const ::std::string& ice_staticId();
03879
03880 private:
03881
03882 virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
03883 virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
03884 virtual ::IceProxy::Ice::Object* __newInstance() const;
03885 };
03886
03887 class GoalStateMessage : virtual public ::IceProxy::RobotSimEvents::EventMessage
03888 {
03889 public:
03890
03891 ::IceInternal::ProxyHandle<GoalStateMessage> ice_context(const ::Ice::Context& __context) const
03892 {
03893 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03894 typedef ::IceProxy::Ice::Object _Base;
03895 return dynamic_cast<GoalStateMessage*>(_Base::ice_context(__context).get());
03896 #else
03897 return dynamic_cast<GoalStateMessage*>(::IceProxy::Ice::Object::ice_context(__context).get());
03898 #endif
03899 }
03900
03901 ::IceInternal::ProxyHandle<GoalStateMessage> ice_adapterId(const std::string& __id) const
03902 {
03903 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03904 typedef ::IceProxy::Ice::Object _Base;
03905 return dynamic_cast<GoalStateMessage*>(_Base::ice_adapterId(__id).get());
03906 #else
03907 return dynamic_cast<GoalStateMessage*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
03908 #endif
03909 }
03910
03911 ::IceInternal::ProxyHandle<GoalStateMessage> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
03912 {
03913 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03914 typedef ::IceProxy::Ice::Object _Base;
03915 return dynamic_cast<GoalStateMessage*>(_Base::ice_endpoints(__endpoints).get());
03916 #else
03917 return dynamic_cast<GoalStateMessage*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
03918 #endif
03919 }
03920
03921 ::IceInternal::ProxyHandle<GoalStateMessage> ice_locatorCacheTimeout(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<GoalStateMessage*>(_Base::ice_locatorCacheTimeout(__timeout).get());
03926 #else
03927 return dynamic_cast<GoalStateMessage*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
03928 #endif
03929 }
03930
03931 ::IceInternal::ProxyHandle<GoalStateMessage> ice_connectionCached(bool __cached) const
03932 {
03933 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03934 typedef ::IceProxy::Ice::Object _Base;
03935 return dynamic_cast<GoalStateMessage*>(_Base::ice_connectionCached(__cached).get());
03936 #else
03937 return dynamic_cast<GoalStateMessage*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
03938 #endif
03939 }
03940
03941 ::IceInternal::ProxyHandle<GoalStateMessage> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
03942 {
03943 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03944 typedef ::IceProxy::Ice::Object _Base;
03945 return dynamic_cast<GoalStateMessage*>(_Base::ice_endpointSelection(__est).get());
03946 #else
03947 return dynamic_cast<GoalStateMessage*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
03948 #endif
03949 }
03950
03951 ::IceInternal::ProxyHandle<GoalStateMessage> ice_secure(bool __secure) const
03952 {
03953 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03954 typedef ::IceProxy::Ice::Object _Base;
03955 return dynamic_cast<GoalStateMessage*>(_Base::ice_secure(__secure).get());
03956 #else
03957 return dynamic_cast<GoalStateMessage*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
03958 #endif
03959 }
03960
03961 ::IceInternal::ProxyHandle<GoalStateMessage> ice_preferSecure(bool __preferSecure) const
03962 {
03963 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03964 typedef ::IceProxy::Ice::Object _Base;
03965 return dynamic_cast<GoalStateMessage*>(_Base::ice_preferSecure(__preferSecure).get());
03966 #else
03967 return dynamic_cast<GoalStateMessage*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
03968 #endif
03969 }
03970
03971 ::IceInternal::ProxyHandle<GoalStateMessage> ice_router(const ::Ice::RouterPrx& __router) const
03972 {
03973 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03974 typedef ::IceProxy::Ice::Object _Base;
03975 return dynamic_cast<GoalStateMessage*>(_Base::ice_router(__router).get());
03976 #else
03977 return dynamic_cast<GoalStateMessage*>(::IceProxy::Ice::Object::ice_router(__router).get());
03978 #endif
03979 }
03980
03981 ::IceInternal::ProxyHandle<GoalStateMessage> ice_locator(const ::Ice::LocatorPrx& __locator) const
03982 {
03983 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03984 typedef ::IceProxy::Ice::Object _Base;
03985 return dynamic_cast<GoalStateMessage*>(_Base::ice_locator(__locator).get());
03986 #else
03987 return dynamic_cast<GoalStateMessage*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
03988 #endif
03989 }
03990
03991 ::IceInternal::ProxyHandle<GoalStateMessage> ice_collocationOptimized(bool __co) const
03992 {
03993 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03994 typedef ::IceProxy::Ice::Object _Base;
03995 return dynamic_cast<GoalStateMessage*>(_Base::ice_collocationOptimized(__co).get());
03996 #else
03997 return dynamic_cast<GoalStateMessage*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
03998 #endif
03999 }
04000
04001 ::IceInternal::ProxyHandle<GoalStateMessage> ice_twoway() const
04002 {
04003 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04004 typedef ::IceProxy::Ice::Object _Base;
04005 return dynamic_cast<GoalStateMessage*>(_Base::ice_twoway().get());
04006 #else
04007 return dynamic_cast<GoalStateMessage*>(::IceProxy::Ice::Object::ice_twoway().get());
04008 #endif
04009 }
04010
04011 ::IceInternal::ProxyHandle<GoalStateMessage> ice_oneway() const
04012 {
04013 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04014 typedef ::IceProxy::Ice::Object _Base;
04015 return dynamic_cast<GoalStateMessage*>(_Base::ice_oneway().get());
04016 #else
04017 return dynamic_cast<GoalStateMessage*>(::IceProxy::Ice::Object::ice_oneway().get());
04018 #endif
04019 }
04020
04021 ::IceInternal::ProxyHandle<GoalStateMessage> ice_batchOneway() const
04022 {
04023 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04024 typedef ::IceProxy::Ice::Object _Base;
04025 return dynamic_cast<GoalStateMessage*>(_Base::ice_batchOneway().get());
04026 #else
04027 return dynamic_cast<GoalStateMessage*>(::IceProxy::Ice::Object::ice_batchOneway().get());
04028 #endif
04029 }
04030
04031 ::IceInternal::ProxyHandle<GoalStateMessage> ice_datagram() const
04032 {
04033 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04034 typedef ::IceProxy::Ice::Object _Base;
04035 return dynamic_cast<GoalStateMessage*>(_Base::ice_datagram().get());
04036 #else
04037 return dynamic_cast<GoalStateMessage*>(::IceProxy::Ice::Object::ice_datagram().get());
04038 #endif
04039 }
04040
04041 ::IceInternal::ProxyHandle<GoalStateMessage> ice_batchDatagram() const
04042 {
04043 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04044 typedef ::IceProxy::Ice::Object _Base;
04045 return dynamic_cast<GoalStateMessage*>(_Base::ice_batchDatagram().get());
04046 #else
04047 return dynamic_cast<GoalStateMessage*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
04048 #endif
04049 }
04050
04051 ::IceInternal::ProxyHandle<GoalStateMessage> ice_compress(bool __compress) const
04052 {
04053 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04054 typedef ::IceProxy::Ice::Object _Base;
04055 return dynamic_cast<GoalStateMessage*>(_Base::ice_compress(__compress).get());
04056 #else
04057 return dynamic_cast<GoalStateMessage*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
04058 #endif
04059 }
04060
04061 ::IceInternal::ProxyHandle<GoalStateMessage> ice_timeout(int __timeout) const
04062 {
04063 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04064 typedef ::IceProxy::Ice::Object _Base;
04065 return dynamic_cast<GoalStateMessage*>(_Base::ice_timeout(__timeout).get());
04066 #else
04067 return dynamic_cast<GoalStateMessage*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
04068 #endif
04069 }
04070
04071 ::IceInternal::ProxyHandle<GoalStateMessage> ice_connectionId(const std::string& __id) const
04072 {
04073 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04074 typedef ::IceProxy::Ice::Object _Base;
04075 return dynamic_cast<GoalStateMessage*>(_Base::ice_connectionId(__id).get());
04076 #else
04077 return dynamic_cast<GoalStateMessage*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
04078 #endif
04079 }
04080
04081 static const ::std::string& ice_staticId();
04082
04083 private:
04084
04085 virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
04086 virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
04087 virtual ::IceProxy::Ice::Object* __newInstance() const;
04088 };
04089
04090 class GoalProgressMessage : virtual public ::IceProxy::RobotSimEvents::EventMessage
04091 {
04092 public:
04093
04094 ::IceInternal::ProxyHandle<GoalProgressMessage> ice_context(const ::Ice::Context& __context) const
04095 {
04096 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04097 typedef ::IceProxy::Ice::Object _Base;
04098 return dynamic_cast<GoalProgressMessage*>(_Base::ice_context(__context).get());
04099 #else
04100 return dynamic_cast<GoalProgressMessage*>(::IceProxy::Ice::Object::ice_context(__context).get());
04101 #endif
04102 }
04103
04104 ::IceInternal::ProxyHandle<GoalProgressMessage> ice_adapterId(const std::string& __id) const
04105 {
04106 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04107 typedef ::IceProxy::Ice::Object _Base;
04108 return dynamic_cast<GoalProgressMessage*>(_Base::ice_adapterId(__id).get());
04109 #else
04110 return dynamic_cast<GoalProgressMessage*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
04111 #endif
04112 }
04113
04114 ::IceInternal::ProxyHandle<GoalProgressMessage> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
04115 {
04116 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04117 typedef ::IceProxy::Ice::Object _Base;
04118 return dynamic_cast<GoalProgressMessage*>(_Base::ice_endpoints(__endpoints).get());
04119 #else
04120 return dynamic_cast<GoalProgressMessage*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
04121 #endif
04122 }
04123
04124 ::IceInternal::ProxyHandle<GoalProgressMessage> ice_locatorCacheTimeout(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<GoalProgressMessage*>(_Base::ice_locatorCacheTimeout(__timeout).get());
04129 #else
04130 return dynamic_cast<GoalProgressMessage*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
04131 #endif
04132 }
04133
04134 ::IceInternal::ProxyHandle<GoalProgressMessage> ice_connectionCached(bool __cached) const
04135 {
04136 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04137 typedef ::IceProxy::Ice::Object _Base;
04138 return dynamic_cast<GoalProgressMessage*>(_Base::ice_connectionCached(__cached).get());
04139 #else
04140 return dynamic_cast<GoalProgressMessage*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
04141 #endif
04142 }
04143
04144 ::IceInternal::ProxyHandle<GoalProgressMessage> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
04145 {
04146 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04147 typedef ::IceProxy::Ice::Object _Base;
04148 return dynamic_cast<GoalProgressMessage*>(_Base::ice_endpointSelection(__est).get());
04149 #else
04150 return dynamic_cast<GoalProgressMessage*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
04151 #endif
04152 }
04153
04154 ::IceInternal::ProxyHandle<GoalProgressMessage> ice_secure(bool __secure) const
04155 {
04156 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04157 typedef ::IceProxy::Ice::Object _Base;
04158 return dynamic_cast<GoalProgressMessage*>(_Base::ice_secure(__secure).get());
04159 #else
04160 return dynamic_cast<GoalProgressMessage*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
04161 #endif
04162 }
04163
04164 ::IceInternal::ProxyHandle<GoalProgressMessage> ice_preferSecure(bool __preferSecure) const
04165 {
04166 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04167 typedef ::IceProxy::Ice::Object _Base;
04168 return dynamic_cast<GoalProgressMessage*>(_Base::ice_preferSecure(__preferSecure).get());
04169 #else
04170 return dynamic_cast<GoalProgressMessage*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
04171 #endif
04172 }
04173
04174 ::IceInternal::ProxyHandle<GoalProgressMessage> ice_router(const ::Ice::RouterPrx& __router) const
04175 {
04176 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04177 typedef ::IceProxy::Ice::Object _Base;
04178 return dynamic_cast<GoalProgressMessage*>(_Base::ice_router(__router).get());
04179 #else
04180 return dynamic_cast<GoalProgressMessage*>(::IceProxy::Ice::Object::ice_router(__router).get());
04181 #endif
04182 }
04183
04184 ::IceInternal::ProxyHandle<GoalProgressMessage> ice_locator(const ::Ice::LocatorPrx& __locator) const
04185 {
04186 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04187 typedef ::IceProxy::Ice::Object _Base;
04188 return dynamic_cast<GoalProgressMessage*>(_Base::ice_locator(__locator).get());
04189 #else
04190 return dynamic_cast<GoalProgressMessage*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
04191 #endif
04192 }
04193
04194 ::IceInternal::ProxyHandle<GoalProgressMessage> ice_collocationOptimized(bool __co) const
04195 {
04196 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04197 typedef ::IceProxy::Ice::Object _Base;
04198 return dynamic_cast<GoalProgressMessage*>(_Base::ice_collocationOptimized(__co).get());
04199 #else
04200 return dynamic_cast<GoalProgressMessage*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
04201 #endif
04202 }
04203
04204 ::IceInternal::ProxyHandle<GoalProgressMessage> ice_twoway() const
04205 {
04206 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04207 typedef ::IceProxy::Ice::Object _Base;
04208 return dynamic_cast<GoalProgressMessage*>(_Base::ice_twoway().get());
04209 #else
04210 return dynamic_cast<GoalProgressMessage*>(::IceProxy::Ice::Object::ice_twoway().get());
04211 #endif
04212 }
04213
04214 ::IceInternal::ProxyHandle<GoalProgressMessage> ice_oneway() const
04215 {
04216 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04217 typedef ::IceProxy::Ice::Object _Base;
04218 return dynamic_cast<GoalProgressMessage*>(_Base::ice_oneway().get());
04219 #else
04220 return dynamic_cast<GoalProgressMessage*>(::IceProxy::Ice::Object::ice_oneway().get());
04221 #endif
04222 }
04223
04224 ::IceInternal::ProxyHandle<GoalProgressMessage> ice_batchOneway() const
04225 {
04226 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04227 typedef ::IceProxy::Ice::Object _Base;
04228 return dynamic_cast<GoalProgressMessage*>(_Base::ice_batchOneway().get());
04229 #else
04230 return dynamic_cast<GoalProgressMessage*>(::IceProxy::Ice::Object::ice_batchOneway().get());
04231 #endif
04232 }
04233
04234 ::IceInternal::ProxyHandle<GoalProgressMessage> ice_datagram() const
04235 {
04236 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04237 typedef ::IceProxy::Ice::Object _Base;
04238 return dynamic_cast<GoalProgressMessage*>(_Base::ice_datagram().get());
04239 #else
04240 return dynamic_cast<GoalProgressMessage*>(::IceProxy::Ice::Object::ice_datagram().get());
04241 #endif
04242 }
04243
04244 ::IceInternal::ProxyHandle<GoalProgressMessage> ice_batchDatagram() const
04245 {
04246 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04247 typedef ::IceProxy::Ice::Object _Base;
04248 return dynamic_cast<GoalProgressMessage*>(_Base::ice_batchDatagram().get());
04249 #else
04250 return dynamic_cast<GoalProgressMessage*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
04251 #endif
04252 }
04253
04254 ::IceInternal::ProxyHandle<GoalProgressMessage> ice_compress(bool __compress) const
04255 {
04256 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04257 typedef ::IceProxy::Ice::Object _Base;
04258 return dynamic_cast<GoalProgressMessage*>(_Base::ice_compress(__compress).get());
04259 #else
04260 return dynamic_cast<GoalProgressMessage*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
04261 #endif
04262 }
04263
04264 ::IceInternal::ProxyHandle<GoalProgressMessage> ice_timeout(int __timeout) const
04265 {
04266 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04267 typedef ::IceProxy::Ice::Object _Base;
04268 return dynamic_cast<GoalProgressMessage*>(_Base::ice_timeout(__timeout).get());
04269 #else
04270 return dynamic_cast<GoalProgressMessage*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
04271 #endif
04272 }
04273
04274 ::IceInternal::ProxyHandle<GoalProgressMessage> ice_connectionId(const std::string& __id) const
04275 {
04276 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04277 typedef ::IceProxy::Ice::Object _Base;
04278 return dynamic_cast<GoalProgressMessage*>(_Base::ice_connectionId(__id).get());
04279 #else
04280 return dynamic_cast<GoalProgressMessage*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
04281 #endif
04282 }
04283
04284 static const ::std::string& ice_staticId();
04285
04286 private:
04287
04288 virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
04289 virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
04290 virtual ::IceProxy::Ice::Object* __newInstance() const;
04291 };
04292
04293 class AttendedRegionMessage : virtual public ::IceProxy::RobotSimEvents::EventMessage
04294 {
04295 public:
04296
04297 ::IceInternal::ProxyHandle<AttendedRegionMessage> ice_context(const ::Ice::Context& __context) const
04298 {
04299 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04300 typedef ::IceProxy::Ice::Object _Base;
04301 return dynamic_cast<AttendedRegionMessage*>(_Base::ice_context(__context).get());
04302 #else
04303 return dynamic_cast<AttendedRegionMessage*>(::IceProxy::Ice::Object::ice_context(__context).get());
04304 #endif
04305 }
04306
04307 ::IceInternal::ProxyHandle<AttendedRegionMessage> ice_adapterId(const std::string& __id) const
04308 {
04309 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04310 typedef ::IceProxy::Ice::Object _Base;
04311 return dynamic_cast<AttendedRegionMessage*>(_Base::ice_adapterId(__id).get());
04312 #else
04313 return dynamic_cast<AttendedRegionMessage*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
04314 #endif
04315 }
04316
04317 ::IceInternal::ProxyHandle<AttendedRegionMessage> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
04318 {
04319 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04320 typedef ::IceProxy::Ice::Object _Base;
04321 return dynamic_cast<AttendedRegionMessage*>(_Base::ice_endpoints(__endpoints).get());
04322 #else
04323 return dynamic_cast<AttendedRegionMessage*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
04324 #endif
04325 }
04326
04327 ::IceInternal::ProxyHandle<AttendedRegionMessage> ice_locatorCacheTimeout(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<AttendedRegionMessage*>(_Base::ice_locatorCacheTimeout(__timeout).get());
04332 #else
04333 return dynamic_cast<AttendedRegionMessage*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
04334 #endif
04335 }
04336
04337 ::IceInternal::ProxyHandle<AttendedRegionMessage> ice_connectionCached(bool __cached) const
04338 {
04339 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04340 typedef ::IceProxy::Ice::Object _Base;
04341 return dynamic_cast<AttendedRegionMessage*>(_Base::ice_connectionCached(__cached).get());
04342 #else
04343 return dynamic_cast<AttendedRegionMessage*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
04344 #endif
04345 }
04346
04347 ::IceInternal::ProxyHandle<AttendedRegionMessage> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
04348 {
04349 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04350 typedef ::IceProxy::Ice::Object _Base;
04351 return dynamic_cast<AttendedRegionMessage*>(_Base::ice_endpointSelection(__est).get());
04352 #else
04353 return dynamic_cast<AttendedRegionMessage*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
04354 #endif
04355 }
04356
04357 ::IceInternal::ProxyHandle<AttendedRegionMessage> ice_secure(bool __secure) const
04358 {
04359 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04360 typedef ::IceProxy::Ice::Object _Base;
04361 return dynamic_cast<AttendedRegionMessage*>(_Base::ice_secure(__secure).get());
04362 #else
04363 return dynamic_cast<AttendedRegionMessage*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
04364 #endif
04365 }
04366
04367 ::IceInternal::ProxyHandle<AttendedRegionMessage> ice_preferSecure(bool __preferSecure) const
04368 {
04369 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04370 typedef ::IceProxy::Ice::Object _Base;
04371 return dynamic_cast<AttendedRegionMessage*>(_Base::ice_preferSecure(__preferSecure).get());
04372 #else
04373 return dynamic_cast<AttendedRegionMessage*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
04374 #endif
04375 }
04376
04377 ::IceInternal::ProxyHandle<AttendedRegionMessage> ice_router(const ::Ice::RouterPrx& __router) const
04378 {
04379 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04380 typedef ::IceProxy::Ice::Object _Base;
04381 return dynamic_cast<AttendedRegionMessage*>(_Base::ice_router(__router).get());
04382 #else
04383 return dynamic_cast<AttendedRegionMessage*>(::IceProxy::Ice::Object::ice_router(__router).get());
04384 #endif
04385 }
04386
04387 ::IceInternal::ProxyHandle<AttendedRegionMessage> ice_locator(const ::Ice::LocatorPrx& __locator) const
04388 {
04389 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04390 typedef ::IceProxy::Ice::Object _Base;
04391 return dynamic_cast<AttendedRegionMessage*>(_Base::ice_locator(__locator).get());
04392 #else
04393 return dynamic_cast<AttendedRegionMessage*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
04394 #endif
04395 }
04396
04397 ::IceInternal::ProxyHandle<AttendedRegionMessage> ice_collocationOptimized(bool __co) const
04398 {
04399 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04400 typedef ::IceProxy::Ice::Object _Base;
04401 return dynamic_cast<AttendedRegionMessage*>(_Base::ice_collocationOptimized(__co).get());
04402 #else
04403 return dynamic_cast<AttendedRegionMessage*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
04404 #endif
04405 }
04406
04407 ::IceInternal::ProxyHandle<AttendedRegionMessage> ice_twoway() const
04408 {
04409 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04410 typedef ::IceProxy::Ice::Object _Base;
04411 return dynamic_cast<AttendedRegionMessage*>(_Base::ice_twoway().get());
04412 #else
04413 return dynamic_cast<AttendedRegionMessage*>(::IceProxy::Ice::Object::ice_twoway().get());
04414 #endif
04415 }
04416
04417 ::IceInternal::ProxyHandle<AttendedRegionMessage> ice_oneway() const
04418 {
04419 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04420 typedef ::IceProxy::Ice::Object _Base;
04421 return dynamic_cast<AttendedRegionMessage*>(_Base::ice_oneway().get());
04422 #else
04423 return dynamic_cast<AttendedRegionMessage*>(::IceProxy::Ice::Object::ice_oneway().get());
04424 #endif
04425 }
04426
04427 ::IceInternal::ProxyHandle<AttendedRegionMessage> ice_batchOneway() const
04428 {
04429 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04430 typedef ::IceProxy::Ice::Object _Base;
04431 return dynamic_cast<AttendedRegionMessage*>(_Base::ice_batchOneway().get());
04432 #else
04433 return dynamic_cast<AttendedRegionMessage*>(::IceProxy::Ice::Object::ice_batchOneway().get());
04434 #endif
04435 }
04436
04437 ::IceInternal::ProxyHandle<AttendedRegionMessage> ice_datagram() const
04438 {
04439 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04440 typedef ::IceProxy::Ice::Object _Base;
04441 return dynamic_cast<AttendedRegionMessage*>(_Base::ice_datagram().get());
04442 #else
04443 return dynamic_cast<AttendedRegionMessage*>(::IceProxy::Ice::Object::ice_datagram().get());
04444 #endif
04445 }
04446
04447 ::IceInternal::ProxyHandle<AttendedRegionMessage> ice_batchDatagram() const
04448 {
04449 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04450 typedef ::IceProxy::Ice::Object _Base;
04451 return dynamic_cast<AttendedRegionMessage*>(_Base::ice_batchDatagram().get());
04452 #else
04453 return dynamic_cast<AttendedRegionMessage*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
04454 #endif
04455 }
04456
04457 ::IceInternal::ProxyHandle<AttendedRegionMessage> ice_compress(bool __compress) const
04458 {
04459 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04460 typedef ::IceProxy::Ice::Object _Base;
04461 return dynamic_cast<AttendedRegionMessage*>(_Base::ice_compress(__compress).get());
04462 #else
04463 return dynamic_cast<AttendedRegionMessage*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
04464 #endif
04465 }
04466
04467 ::IceInternal::ProxyHandle<AttendedRegionMessage> ice_timeout(int __timeout) const
04468 {
04469 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04470 typedef ::IceProxy::Ice::Object _Base;
04471 return dynamic_cast<AttendedRegionMessage*>(_Base::ice_timeout(__timeout).get());
04472 #else
04473 return dynamic_cast<AttendedRegionMessage*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
04474 #endif
04475 }
04476
04477 ::IceInternal::ProxyHandle<AttendedRegionMessage> ice_connectionId(const std::string& __id) const
04478 {
04479 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04480 typedef ::IceProxy::Ice::Object _Base;
04481 return dynamic_cast<AttendedRegionMessage*>(_Base::ice_connectionId(__id).get());
04482 #else
04483 return dynamic_cast<AttendedRegionMessage*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
04484 #endif
04485 }
04486
04487 static const ::std::string& ice_staticId();
04488
04489 private:
04490
04491 virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
04492 virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
04493 virtual ::IceProxy::Ice::Object* __newInstance() const;
04494 };
04495
04496 class ObjectMessage : virtual public ::IceProxy::RobotSimEvents::EventMessage
04497 {
04498 public:
04499
04500 ::IceInternal::ProxyHandle<ObjectMessage> ice_context(const ::Ice::Context& __context) const
04501 {
04502 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04503 typedef ::IceProxy::Ice::Object _Base;
04504 return dynamic_cast<ObjectMessage*>(_Base::ice_context(__context).get());
04505 #else
04506 return dynamic_cast<ObjectMessage*>(::IceProxy::Ice::Object::ice_context(__context).get());
04507 #endif
04508 }
04509
04510 ::IceInternal::ProxyHandle<ObjectMessage> ice_adapterId(const std::string& __id) const
04511 {
04512 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04513 typedef ::IceProxy::Ice::Object _Base;
04514 return dynamic_cast<ObjectMessage*>(_Base::ice_adapterId(__id).get());
04515 #else
04516 return dynamic_cast<ObjectMessage*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
04517 #endif
04518 }
04519
04520 ::IceInternal::ProxyHandle<ObjectMessage> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
04521 {
04522 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04523 typedef ::IceProxy::Ice::Object _Base;
04524 return dynamic_cast<ObjectMessage*>(_Base::ice_endpoints(__endpoints).get());
04525 #else
04526 return dynamic_cast<ObjectMessage*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
04527 #endif
04528 }
04529
04530 ::IceInternal::ProxyHandle<ObjectMessage> ice_locatorCacheTimeout(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<ObjectMessage*>(_Base::ice_locatorCacheTimeout(__timeout).get());
04535 #else
04536 return dynamic_cast<ObjectMessage*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
04537 #endif
04538 }
04539
04540 ::IceInternal::ProxyHandle<ObjectMessage> ice_connectionCached(bool __cached) const
04541 {
04542 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04543 typedef ::IceProxy::Ice::Object _Base;
04544 return dynamic_cast<ObjectMessage*>(_Base::ice_connectionCached(__cached).get());
04545 #else
04546 return dynamic_cast<ObjectMessage*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
04547 #endif
04548 }
04549
04550 ::IceInternal::ProxyHandle<ObjectMessage> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
04551 {
04552 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04553 typedef ::IceProxy::Ice::Object _Base;
04554 return dynamic_cast<ObjectMessage*>(_Base::ice_endpointSelection(__est).get());
04555 #else
04556 return dynamic_cast<ObjectMessage*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
04557 #endif
04558 }
04559
04560 ::IceInternal::ProxyHandle<ObjectMessage> ice_secure(bool __secure) const
04561 {
04562 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04563 typedef ::IceProxy::Ice::Object _Base;
04564 return dynamic_cast<ObjectMessage*>(_Base::ice_secure(__secure).get());
04565 #else
04566 return dynamic_cast<ObjectMessage*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
04567 #endif
04568 }
04569
04570 ::IceInternal::ProxyHandle<ObjectMessage> ice_preferSecure(bool __preferSecure) const
04571 {
04572 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04573 typedef ::IceProxy::Ice::Object _Base;
04574 return dynamic_cast<ObjectMessage*>(_Base::ice_preferSecure(__preferSecure).get());
04575 #else
04576 return dynamic_cast<ObjectMessage*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
04577 #endif
04578 }
04579
04580 ::IceInternal::ProxyHandle<ObjectMessage> ice_router(const ::Ice::RouterPrx& __router) const
04581 {
04582 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04583 typedef ::IceProxy::Ice::Object _Base;
04584 return dynamic_cast<ObjectMessage*>(_Base::ice_router(__router).get());
04585 #else
04586 return dynamic_cast<ObjectMessage*>(::IceProxy::Ice::Object::ice_router(__router).get());
04587 #endif
04588 }
04589
04590 ::IceInternal::ProxyHandle<ObjectMessage> ice_locator(const ::Ice::LocatorPrx& __locator) const
04591 {
04592 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04593 typedef ::IceProxy::Ice::Object _Base;
04594 return dynamic_cast<ObjectMessage*>(_Base::ice_locator(__locator).get());
04595 #else
04596 return dynamic_cast<ObjectMessage*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
04597 #endif
04598 }
04599
04600 ::IceInternal::ProxyHandle<ObjectMessage> ice_collocationOptimized(bool __co) const
04601 {
04602 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04603 typedef ::IceProxy::Ice::Object _Base;
04604 return dynamic_cast<ObjectMessage*>(_Base::ice_collocationOptimized(__co).get());
04605 #else
04606 return dynamic_cast<ObjectMessage*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
04607 #endif
04608 }
04609
04610 ::IceInternal::ProxyHandle<ObjectMessage> ice_twoway() const
04611 {
04612 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04613 typedef ::IceProxy::Ice::Object _Base;
04614 return dynamic_cast<ObjectMessage*>(_Base::ice_twoway().get());
04615 #else
04616 return dynamic_cast<ObjectMessage*>(::IceProxy::Ice::Object::ice_twoway().get());
04617 #endif
04618 }
04619
04620 ::IceInternal::ProxyHandle<ObjectMessage> ice_oneway() const
04621 {
04622 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04623 typedef ::IceProxy::Ice::Object _Base;
04624 return dynamic_cast<ObjectMessage*>(_Base::ice_oneway().get());
04625 #else
04626 return dynamic_cast<ObjectMessage*>(::IceProxy::Ice::Object::ice_oneway().get());
04627 #endif
04628 }
04629
04630 ::IceInternal::ProxyHandle<ObjectMessage> ice_batchOneway() const
04631 {
04632 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04633 typedef ::IceProxy::Ice::Object _Base;
04634 return dynamic_cast<ObjectMessage*>(_Base::ice_batchOneway().get());
04635 #else
04636 return dynamic_cast<ObjectMessage*>(::IceProxy::Ice::Object::ice_batchOneway().get());
04637 #endif
04638 }
04639
04640 ::IceInternal::ProxyHandle<ObjectMessage> ice_datagram() const
04641 {
04642 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04643 typedef ::IceProxy::Ice::Object _Base;
04644 return dynamic_cast<ObjectMessage*>(_Base::ice_datagram().get());
04645 #else
04646 return dynamic_cast<ObjectMessage*>(::IceProxy::Ice::Object::ice_datagram().get());
04647 #endif
04648 }
04649
04650 ::IceInternal::ProxyHandle<ObjectMessage> ice_batchDatagram() const
04651 {
04652 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04653 typedef ::IceProxy::Ice::Object _Base;
04654 return dynamic_cast<ObjectMessage*>(_Base::ice_batchDatagram().get());
04655 #else
04656 return dynamic_cast<ObjectMessage*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
04657 #endif
04658 }
04659
04660 ::IceInternal::ProxyHandle<ObjectMessage> ice_compress(bool __compress) const
04661 {
04662 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04663 typedef ::IceProxy::Ice::Object _Base;
04664 return dynamic_cast<ObjectMessage*>(_Base::ice_compress(__compress).get());
04665 #else
04666 return dynamic_cast<ObjectMessage*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
04667 #endif
04668 }
04669
04670 ::IceInternal::ProxyHandle<ObjectMessage> ice_timeout(int __timeout) const
04671 {
04672 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04673 typedef ::IceProxy::Ice::Object _Base;
04674 return dynamic_cast<ObjectMessage*>(_Base::ice_timeout(__timeout).get());
04675 #else
04676 return dynamic_cast<ObjectMessage*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
04677 #endif
04678 }
04679
04680 ::IceInternal::ProxyHandle<ObjectMessage> ice_connectionId(const std::string& __id) const
04681 {
04682 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04683 typedef ::IceProxy::Ice::Object _Base;
04684 return dynamic_cast<ObjectMessage*>(_Base::ice_connectionId(__id).get());
04685 #else
04686 return dynamic_cast<ObjectMessage*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
04687 #endif
04688 }
04689
04690 static const ::std::string& ice_staticId();
04691
04692 private:
04693
04694 virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
04695 virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
04696 virtual ::IceProxy::Ice::Object* __newInstance() const;
04697 };
04698
04699 class SeaBeePositionMessage : virtual public ::IceProxy::RobotSimEvents::EventMessage
04700 {
04701 public:
04702
04703 ::IceInternal::ProxyHandle<SeaBeePositionMessage> ice_context(const ::Ice::Context& __context) const
04704 {
04705 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04706 typedef ::IceProxy::Ice::Object _Base;
04707 return dynamic_cast<SeaBeePositionMessage*>(_Base::ice_context(__context).get());
04708 #else
04709 return dynamic_cast<SeaBeePositionMessage*>(::IceProxy::Ice::Object::ice_context(__context).get());
04710 #endif
04711 }
04712
04713 ::IceInternal::ProxyHandle<SeaBeePositionMessage> ice_adapterId(const std::string& __id) const
04714 {
04715 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04716 typedef ::IceProxy::Ice::Object _Base;
04717 return dynamic_cast<SeaBeePositionMessage*>(_Base::ice_adapterId(__id).get());
04718 #else
04719 return dynamic_cast<SeaBeePositionMessage*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
04720 #endif
04721 }
04722
04723 ::IceInternal::ProxyHandle<SeaBeePositionMessage> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
04724 {
04725 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04726 typedef ::IceProxy::Ice::Object _Base;
04727 return dynamic_cast<SeaBeePositionMessage*>(_Base::ice_endpoints(__endpoints).get());
04728 #else
04729 return dynamic_cast<SeaBeePositionMessage*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
04730 #endif
04731 }
04732
04733 ::IceInternal::ProxyHandle<SeaBeePositionMessage> ice_locatorCacheTimeout(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<SeaBeePositionMessage*>(_Base::ice_locatorCacheTimeout(__timeout).get());
04738 #else
04739 return dynamic_cast<SeaBeePositionMessage*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
04740 #endif
04741 }
04742
04743 ::IceInternal::ProxyHandle<SeaBeePositionMessage> ice_connectionCached(bool __cached) const
04744 {
04745 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04746 typedef ::IceProxy::Ice::Object _Base;
04747 return dynamic_cast<SeaBeePositionMessage*>(_Base::ice_connectionCached(__cached).get());
04748 #else
04749 return dynamic_cast<SeaBeePositionMessage*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
04750 #endif
04751 }
04752
04753 ::IceInternal::ProxyHandle<SeaBeePositionMessage> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
04754 {
04755 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04756 typedef ::IceProxy::Ice::Object _Base;
04757 return dynamic_cast<SeaBeePositionMessage*>(_Base::ice_endpointSelection(__est).get());
04758 #else
04759 return dynamic_cast<SeaBeePositionMessage*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
04760 #endif
04761 }
04762
04763 ::IceInternal::ProxyHandle<SeaBeePositionMessage> ice_secure(bool __secure) const
04764 {
04765 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04766 typedef ::IceProxy::Ice::Object _Base;
04767 return dynamic_cast<SeaBeePositionMessage*>(_Base::ice_secure(__secure).get());
04768 #else
04769 return dynamic_cast<SeaBeePositionMessage*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
04770 #endif
04771 }
04772
04773 ::IceInternal::ProxyHandle<SeaBeePositionMessage> ice_preferSecure(bool __preferSecure) const
04774 {
04775 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04776 typedef ::IceProxy::Ice::Object _Base;
04777 return dynamic_cast<SeaBeePositionMessage*>(_Base::ice_preferSecure(__preferSecure).get());
04778 #else
04779 return dynamic_cast<SeaBeePositionMessage*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
04780 #endif
04781 }
04782
04783 ::IceInternal::ProxyHandle<SeaBeePositionMessage> ice_router(const ::Ice::RouterPrx& __router) const
04784 {
04785 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04786 typedef ::IceProxy::Ice::Object _Base;
04787 return dynamic_cast<SeaBeePositionMessage*>(_Base::ice_router(__router).get());
04788 #else
04789 return dynamic_cast<SeaBeePositionMessage*>(::IceProxy::Ice::Object::ice_router(__router).get());
04790 #endif
04791 }
04792
04793 ::IceInternal::ProxyHandle<SeaBeePositionMessage> ice_locator(const ::Ice::LocatorPrx& __locator) const
04794 {
04795 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04796 typedef ::IceProxy::Ice::Object _Base;
04797 return dynamic_cast<SeaBeePositionMessage*>(_Base::ice_locator(__locator).get());
04798 #else
04799 return dynamic_cast<SeaBeePositionMessage*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
04800 #endif
04801 }
04802
04803 ::IceInternal::ProxyHandle<SeaBeePositionMessage> ice_collocationOptimized(bool __co) const
04804 {
04805 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04806 typedef ::IceProxy::Ice::Object _Base;
04807 return dynamic_cast<SeaBeePositionMessage*>(_Base::ice_collocationOptimized(__co).get());
04808 #else
04809 return dynamic_cast<SeaBeePositionMessage*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
04810 #endif
04811 }
04812
04813 ::IceInternal::ProxyHandle<SeaBeePositionMessage> ice_twoway() const
04814 {
04815 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04816 typedef ::IceProxy::Ice::Object _Base;
04817 return dynamic_cast<SeaBeePositionMessage*>(_Base::ice_twoway().get());
04818 #else
04819 return dynamic_cast<SeaBeePositionMessage*>(::IceProxy::Ice::Object::ice_twoway().get());
04820 #endif
04821 }
04822
04823 ::IceInternal::ProxyHandle<SeaBeePositionMessage> ice_oneway() const
04824 {
04825 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04826 typedef ::IceProxy::Ice::Object _Base;
04827 return dynamic_cast<SeaBeePositionMessage*>(_Base::ice_oneway().get());
04828 #else
04829 return dynamic_cast<SeaBeePositionMessage*>(::IceProxy::Ice::Object::ice_oneway().get());
04830 #endif
04831 }
04832
04833 ::IceInternal::ProxyHandle<SeaBeePositionMessage> ice_batchOneway() const
04834 {
04835 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04836 typedef ::IceProxy::Ice::Object _Base;
04837 return dynamic_cast<SeaBeePositionMessage*>(_Base::ice_batchOneway().get());
04838 #else
04839 return dynamic_cast<SeaBeePositionMessage*>(::IceProxy::Ice::Object::ice_batchOneway().get());
04840 #endif
04841 }
04842
04843 ::IceInternal::ProxyHandle<SeaBeePositionMessage> ice_datagram() const
04844 {
04845 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04846 typedef ::IceProxy::Ice::Object _Base;
04847 return dynamic_cast<SeaBeePositionMessage*>(_Base::ice_datagram().get());
04848 #else
04849 return dynamic_cast<SeaBeePositionMessage*>(::IceProxy::Ice::Object::ice_datagram().get());
04850 #endif
04851 }
04852
04853 ::IceInternal::ProxyHandle<SeaBeePositionMessage> ice_batchDatagram() const
04854 {
04855 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04856 typedef ::IceProxy::Ice::Object _Base;
04857 return dynamic_cast<SeaBeePositionMessage*>(_Base::ice_batchDatagram().get());
04858 #else
04859 return dynamic_cast<SeaBeePositionMessage*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
04860 #endif
04861 }
04862
04863 ::IceInternal::ProxyHandle<SeaBeePositionMessage> ice_compress(bool __compress) const
04864 {
04865 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04866 typedef ::IceProxy::Ice::Object _Base;
04867 return dynamic_cast<SeaBeePositionMessage*>(_Base::ice_compress(__compress).get());
04868 #else
04869 return dynamic_cast<SeaBeePositionMessage*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
04870 #endif
04871 }
04872
04873 ::IceInternal::ProxyHandle<SeaBeePositionMessage> ice_timeout(int __timeout) const
04874 {
04875 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04876 typedef ::IceProxy::Ice::Object _Base;
04877 return dynamic_cast<SeaBeePositionMessage*>(_Base::ice_timeout(__timeout).get());
04878 #else
04879 return dynamic_cast<SeaBeePositionMessage*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
04880 #endif
04881 }
04882
04883 ::IceInternal::ProxyHandle<SeaBeePositionMessage> ice_connectionId(const std::string& __id) const
04884 {
04885 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04886 typedef ::IceProxy::Ice::Object _Base;
04887 return dynamic_cast<SeaBeePositionMessage*>(_Base::ice_connectionId(__id).get());
04888 #else
04889 return dynamic_cast<SeaBeePositionMessage*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
04890 #endif
04891 }
04892
04893 static const ::std::string& ice_staticId();
04894
04895 private:
04896
04897 virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
04898 virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
04899 virtual ::IceProxy::Ice::Object* __newInstance() const;
04900 };
04901
04902 class SeaBeeStateConditionMessage : virtual public ::IceProxy::RobotSimEvents::EventMessage
04903 {
04904 public:
04905
04906 ::IceInternal::ProxyHandle<SeaBeeStateConditionMessage> ice_context(const ::Ice::Context& __context) const
04907 {
04908 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04909 typedef ::IceProxy::Ice::Object _Base;
04910 return dynamic_cast<SeaBeeStateConditionMessage*>(_Base::ice_context(__context).get());
04911 #else
04912 return dynamic_cast<SeaBeeStateConditionMessage*>(::IceProxy::Ice::Object::ice_context(__context).get());
04913 #endif
04914 }
04915
04916 ::IceInternal::ProxyHandle<SeaBeeStateConditionMessage> ice_adapterId(const std::string& __id) const
04917 {
04918 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04919 typedef ::IceProxy::Ice::Object _Base;
04920 return dynamic_cast<SeaBeeStateConditionMessage*>(_Base::ice_adapterId(__id).get());
04921 #else
04922 return dynamic_cast<SeaBeeStateConditionMessage*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
04923 #endif
04924 }
04925
04926 ::IceInternal::ProxyHandle<SeaBeeStateConditionMessage> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
04927 {
04928 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04929 typedef ::IceProxy::Ice::Object _Base;
04930 return dynamic_cast<SeaBeeStateConditionMessage*>(_Base::ice_endpoints(__endpoints).get());
04931 #else
04932 return dynamic_cast<SeaBeeStateConditionMessage*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
04933 #endif
04934 }
04935
04936 ::IceInternal::ProxyHandle<SeaBeeStateConditionMessage> ice_locatorCacheTimeout(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<SeaBeeStateConditionMessage*>(_Base::ice_locatorCacheTimeout(__timeout).get());
04941 #else
04942 return dynamic_cast<SeaBeeStateConditionMessage*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
04943 #endif
04944 }
04945
04946 ::IceInternal::ProxyHandle<SeaBeeStateConditionMessage> ice_connectionCached(bool __cached) const
04947 {
04948 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04949 typedef ::IceProxy::Ice::Object _Base;
04950 return dynamic_cast<SeaBeeStateConditionMessage*>(_Base::ice_connectionCached(__cached).get());
04951 #else
04952 return dynamic_cast<SeaBeeStateConditionMessage*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
04953 #endif
04954 }
04955
04956 ::IceInternal::ProxyHandle<SeaBeeStateConditionMessage> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
04957 {
04958 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04959 typedef ::IceProxy::Ice::Object _Base;
04960 return dynamic_cast<SeaBeeStateConditionMessage*>(_Base::ice_endpointSelection(__est).get());
04961 #else
04962 return dynamic_cast<SeaBeeStateConditionMessage*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
04963 #endif
04964 }
04965
04966 ::IceInternal::ProxyHandle<SeaBeeStateConditionMessage> ice_secure(bool __secure) const
04967 {
04968 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04969 typedef ::IceProxy::Ice::Object _Base;
04970 return dynamic_cast<SeaBeeStateConditionMessage*>(_Base::ice_secure(__secure).get());
04971 #else
04972 return dynamic_cast<SeaBeeStateConditionMessage*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
04973 #endif
04974 }
04975
04976 ::IceInternal::ProxyHandle<SeaBeeStateConditionMessage> ice_preferSecure(bool __preferSecure) const
04977 {
04978 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04979 typedef ::IceProxy::Ice::Object _Base;
04980 return dynamic_cast<SeaBeeStateConditionMessage*>(_Base::ice_preferSecure(__preferSecure).get());
04981 #else
04982 return dynamic_cast<SeaBeeStateConditionMessage*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
04983 #endif
04984 }
04985
04986 ::IceInternal::ProxyHandle<SeaBeeStateConditionMessage> ice_router(const ::Ice::RouterPrx& __router) const
04987 {
04988 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04989 typedef ::IceProxy::Ice::Object _Base;
04990 return dynamic_cast<SeaBeeStateConditionMessage*>(_Base::ice_router(__router).get());
04991 #else
04992 return dynamic_cast<SeaBeeStateConditionMessage*>(::IceProxy::Ice::Object::ice_router(__router).get());
04993 #endif
04994 }
04995
04996 ::IceInternal::ProxyHandle<SeaBeeStateConditionMessage> ice_locator(const ::Ice::LocatorPrx& __locator) const
04997 {
04998 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
04999 typedef ::IceProxy::Ice::Object _Base;
05000 return dynamic_cast<SeaBeeStateConditionMessage*>(_Base::ice_locator(__locator).get());
05001 #else
05002 return dynamic_cast<SeaBeeStateConditionMessage*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
05003 #endif
05004 }
05005
05006 ::IceInternal::ProxyHandle<SeaBeeStateConditionMessage> ice_collocationOptimized(bool __co) const
05007 {
05008 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05009 typedef ::IceProxy::Ice::Object _Base;
05010 return dynamic_cast<SeaBeeStateConditionMessage*>(_Base::ice_collocationOptimized(__co).get());
05011 #else
05012 return dynamic_cast<SeaBeeStateConditionMessage*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
05013 #endif
05014 }
05015
05016 ::IceInternal::ProxyHandle<SeaBeeStateConditionMessage> ice_twoway() const
05017 {
05018 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05019 typedef ::IceProxy::Ice::Object _Base;
05020 return dynamic_cast<SeaBeeStateConditionMessage*>(_Base::ice_twoway().get());
05021 #else
05022 return dynamic_cast<SeaBeeStateConditionMessage*>(::IceProxy::Ice::Object::ice_twoway().get());
05023 #endif
05024 }
05025
05026 ::IceInternal::ProxyHandle<SeaBeeStateConditionMessage> ice_oneway() const
05027 {
05028 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05029 typedef ::IceProxy::Ice::Object _Base;
05030 return dynamic_cast<SeaBeeStateConditionMessage*>(_Base::ice_oneway().get());
05031 #else
05032 return dynamic_cast<SeaBeeStateConditionMessage*>(::IceProxy::Ice::Object::ice_oneway().get());
05033 #endif
05034 }
05035
05036 ::IceInternal::ProxyHandle<SeaBeeStateConditionMessage> ice_batchOneway() const
05037 {
05038 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05039 typedef ::IceProxy::Ice::Object _Base;
05040 return dynamic_cast<SeaBeeStateConditionMessage*>(_Base::ice_batchOneway().get());
05041 #else
05042 return dynamic_cast<SeaBeeStateConditionMessage*>(::IceProxy::Ice::Object::ice_batchOneway().get());
05043 #endif
05044 }
05045
05046 ::IceInternal::ProxyHandle<SeaBeeStateConditionMessage> ice_datagram() const
05047 {
05048 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05049 typedef ::IceProxy::Ice::Object _Base;
05050 return dynamic_cast<SeaBeeStateConditionMessage*>(_Base::ice_datagram().get());
05051 #else
05052 return dynamic_cast<SeaBeeStateConditionMessage*>(::IceProxy::Ice::Object::ice_datagram().get());
05053 #endif
05054 }
05055
05056 ::IceInternal::ProxyHandle<SeaBeeStateConditionMessage> ice_batchDatagram() const
05057 {
05058 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05059 typedef ::IceProxy::Ice::Object _Base;
05060 return dynamic_cast<SeaBeeStateConditionMessage*>(_Base::ice_batchDatagram().get());
05061 #else
05062 return dynamic_cast<SeaBeeStateConditionMessage*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
05063 #endif
05064 }
05065
05066 ::IceInternal::ProxyHandle<SeaBeeStateConditionMessage> ice_compress(bool __compress) const
05067 {
05068 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05069 typedef ::IceProxy::Ice::Object _Base;
05070 return dynamic_cast<SeaBeeStateConditionMessage*>(_Base::ice_compress(__compress).get());
05071 #else
05072 return dynamic_cast<SeaBeeStateConditionMessage*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
05073 #endif
05074 }
05075
05076 ::IceInternal::ProxyHandle<SeaBeeStateConditionMessage> ice_timeout(int __timeout) const
05077 {
05078 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05079 typedef ::IceProxy::Ice::Object _Base;
05080 return dynamic_cast<SeaBeeStateConditionMessage*>(_Base::ice_timeout(__timeout).get());
05081 #else
05082 return dynamic_cast<SeaBeeStateConditionMessage*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
05083 #endif
05084 }
05085
05086 ::IceInternal::ProxyHandle<SeaBeeStateConditionMessage> ice_connectionId(const std::string& __id) const
05087 {
05088 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05089 typedef ::IceProxy::Ice::Object _Base;
05090 return dynamic_cast<SeaBeeStateConditionMessage*>(_Base::ice_connectionId(__id).get());
05091 #else
05092 return dynamic_cast<SeaBeeStateConditionMessage*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
05093 #endif
05094 }
05095
05096 static const ::std::string& ice_staticId();
05097
05098 private:
05099
05100 virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
05101 virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
05102 virtual ::IceProxy::Ice::Object* __newInstance() const;
05103 };
05104
05105 class VisionRectangleMessage : virtual public ::IceProxy::RobotSimEvents::EventMessage
05106 {
05107 public:
05108
05109 ::IceInternal::ProxyHandle<VisionRectangleMessage> ice_context(const ::Ice::Context& __context) const
05110 {
05111 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05112 typedef ::IceProxy::Ice::Object _Base;
05113 return dynamic_cast<VisionRectangleMessage*>(_Base::ice_context(__context).get());
05114 #else
05115 return dynamic_cast<VisionRectangleMessage*>(::IceProxy::Ice::Object::ice_context(__context).get());
05116 #endif
05117 }
05118
05119 ::IceInternal::ProxyHandle<VisionRectangleMessage> ice_adapterId(const std::string& __id) const
05120 {
05121 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05122 typedef ::IceProxy::Ice::Object _Base;
05123 return dynamic_cast<VisionRectangleMessage*>(_Base::ice_adapterId(__id).get());
05124 #else
05125 return dynamic_cast<VisionRectangleMessage*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
05126 #endif
05127 }
05128
05129 ::IceInternal::ProxyHandle<VisionRectangleMessage> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
05130 {
05131 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05132 typedef ::IceProxy::Ice::Object _Base;
05133 return dynamic_cast<VisionRectangleMessage*>(_Base::ice_endpoints(__endpoints).get());
05134 #else
05135 return dynamic_cast<VisionRectangleMessage*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
05136 #endif
05137 }
05138
05139 ::IceInternal::ProxyHandle<VisionRectangleMessage> ice_locatorCacheTimeout(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<VisionRectangleMessage*>(_Base::ice_locatorCacheTimeout(__timeout).get());
05144 #else
05145 return dynamic_cast<VisionRectangleMessage*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
05146 #endif
05147 }
05148
05149 ::IceInternal::ProxyHandle<VisionRectangleMessage> ice_connectionCached(bool __cached) const
05150 {
05151 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05152 typedef ::IceProxy::Ice::Object _Base;
05153 return dynamic_cast<VisionRectangleMessage*>(_Base::ice_connectionCached(__cached).get());
05154 #else
05155 return dynamic_cast<VisionRectangleMessage*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
05156 #endif
05157 }
05158
05159 ::IceInternal::ProxyHandle<VisionRectangleMessage> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
05160 {
05161 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05162 typedef ::IceProxy::Ice::Object _Base;
05163 return dynamic_cast<VisionRectangleMessage*>(_Base::ice_endpointSelection(__est).get());
05164 #else
05165 return dynamic_cast<VisionRectangleMessage*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
05166 #endif
05167 }
05168
05169 ::IceInternal::ProxyHandle<VisionRectangleMessage> ice_secure(bool __secure) const
05170 {
05171 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05172 typedef ::IceProxy::Ice::Object _Base;
05173 return dynamic_cast<VisionRectangleMessage*>(_Base::ice_secure(__secure).get());
05174 #else
05175 return dynamic_cast<VisionRectangleMessage*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
05176 #endif
05177 }
05178
05179 ::IceInternal::ProxyHandle<VisionRectangleMessage> ice_preferSecure(bool __preferSecure) const
05180 {
05181 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05182 typedef ::IceProxy::Ice::Object _Base;
05183 return dynamic_cast<VisionRectangleMessage*>(_Base::ice_preferSecure(__preferSecure).get());
05184 #else
05185 return dynamic_cast<VisionRectangleMessage*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
05186 #endif
05187 }
05188
05189 ::IceInternal::ProxyHandle<VisionRectangleMessage> ice_router(const ::Ice::RouterPrx& __router) const
05190 {
05191 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05192 typedef ::IceProxy::Ice::Object _Base;
05193 return dynamic_cast<VisionRectangleMessage*>(_Base::ice_router(__router).get());
05194 #else
05195 return dynamic_cast<VisionRectangleMessage*>(::IceProxy::Ice::Object::ice_router(__router).get());
05196 #endif
05197 }
05198
05199 ::IceInternal::ProxyHandle<VisionRectangleMessage> ice_locator(const ::Ice::LocatorPrx& __locator) const
05200 {
05201 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05202 typedef ::IceProxy::Ice::Object _Base;
05203 return dynamic_cast<VisionRectangleMessage*>(_Base::ice_locator(__locator).get());
05204 #else
05205 return dynamic_cast<VisionRectangleMessage*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
05206 #endif
05207 }
05208
05209 ::IceInternal::ProxyHandle<VisionRectangleMessage> ice_collocationOptimized(bool __co) const
05210 {
05211 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05212 typedef ::IceProxy::Ice::Object _Base;
05213 return dynamic_cast<VisionRectangleMessage*>(_Base::ice_collocationOptimized(__co).get());
05214 #else
05215 return dynamic_cast<VisionRectangleMessage*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
05216 #endif
05217 }
05218
05219 ::IceInternal::ProxyHandle<VisionRectangleMessage> ice_twoway() const
05220 {
05221 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05222 typedef ::IceProxy::Ice::Object _Base;
05223 return dynamic_cast<VisionRectangleMessage*>(_Base::ice_twoway().get());
05224 #else
05225 return dynamic_cast<VisionRectangleMessage*>(::IceProxy::Ice::Object::ice_twoway().get());
05226 #endif
05227 }
05228
05229 ::IceInternal::ProxyHandle<VisionRectangleMessage> ice_oneway() const
05230 {
05231 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05232 typedef ::IceProxy::Ice::Object _Base;
05233 return dynamic_cast<VisionRectangleMessage*>(_Base::ice_oneway().get());
05234 #else
05235 return dynamic_cast<VisionRectangleMessage*>(::IceProxy::Ice::Object::ice_oneway().get());
05236 #endif
05237 }
05238
05239 ::IceInternal::ProxyHandle<VisionRectangleMessage> ice_batchOneway() const
05240 {
05241 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05242 typedef ::IceProxy::Ice::Object _Base;
05243 return dynamic_cast<VisionRectangleMessage*>(_Base::ice_batchOneway().get());
05244 #else
05245 return dynamic_cast<VisionRectangleMessage*>(::IceProxy::Ice::Object::ice_batchOneway().get());
05246 #endif
05247 }
05248
05249 ::IceInternal::ProxyHandle<VisionRectangleMessage> ice_datagram() const
05250 {
05251 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05252 typedef ::IceProxy::Ice::Object _Base;
05253 return dynamic_cast<VisionRectangleMessage*>(_Base::ice_datagram().get());
05254 #else
05255 return dynamic_cast<VisionRectangleMessage*>(::IceProxy::Ice::Object::ice_datagram().get());
05256 #endif
05257 }
05258
05259 ::IceInternal::ProxyHandle<VisionRectangleMessage> ice_batchDatagram() const
05260 {
05261 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05262 typedef ::IceProxy::Ice::Object _Base;
05263 return dynamic_cast<VisionRectangleMessage*>(_Base::ice_batchDatagram().get());
05264 #else
05265 return dynamic_cast<VisionRectangleMessage*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
05266 #endif
05267 }
05268
05269 ::IceInternal::ProxyHandle<VisionRectangleMessage> ice_compress(bool __compress) const
05270 {
05271 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05272 typedef ::IceProxy::Ice::Object _Base;
05273 return dynamic_cast<VisionRectangleMessage*>(_Base::ice_compress(__compress).get());
05274 #else
05275 return dynamic_cast<VisionRectangleMessage*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
05276 #endif
05277 }
05278
05279 ::IceInternal::ProxyHandle<VisionRectangleMessage> ice_timeout(int __timeout) const
05280 {
05281 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05282 typedef ::IceProxy::Ice::Object _Base;
05283 return dynamic_cast<VisionRectangleMessage*>(_Base::ice_timeout(__timeout).get());
05284 #else
05285 return dynamic_cast<VisionRectangleMessage*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
05286 #endif
05287 }
05288
05289 ::IceInternal::ProxyHandle<VisionRectangleMessage> ice_connectionId(const std::string& __id) const
05290 {
05291 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05292 typedef ::IceProxy::Ice::Object _Base;
05293 return dynamic_cast<VisionRectangleMessage*>(_Base::ice_connectionId(__id).get());
05294 #else
05295 return dynamic_cast<VisionRectangleMessage*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
05296 #endif
05297 }
05298
05299 static const ::std::string& ice_staticId();
05300
05301 private:
05302
05303 virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
05304 virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
05305 virtual ::IceProxy::Ice::Object* __newInstance() const;
05306 };
05307
05308 class StraightEdgeMessage : virtual public ::IceProxy::RobotSimEvents::EventMessage
05309 {
05310 public:
05311
05312 ::IceInternal::ProxyHandle<StraightEdgeMessage> ice_context(const ::Ice::Context& __context) const
05313 {
05314 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05315 typedef ::IceProxy::Ice::Object _Base;
05316 return dynamic_cast<StraightEdgeMessage*>(_Base::ice_context(__context).get());
05317 #else
05318 return dynamic_cast<StraightEdgeMessage*>(::IceProxy::Ice::Object::ice_context(__context).get());
05319 #endif
05320 }
05321
05322 ::IceInternal::ProxyHandle<StraightEdgeMessage> ice_adapterId(const std::string& __id) const
05323 {
05324 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05325 typedef ::IceProxy::Ice::Object _Base;
05326 return dynamic_cast<StraightEdgeMessage*>(_Base::ice_adapterId(__id).get());
05327 #else
05328 return dynamic_cast<StraightEdgeMessage*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
05329 #endif
05330 }
05331
05332 ::IceInternal::ProxyHandle<StraightEdgeMessage> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
05333 {
05334 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05335 typedef ::IceProxy::Ice::Object _Base;
05336 return dynamic_cast<StraightEdgeMessage*>(_Base::ice_endpoints(__endpoints).get());
05337 #else
05338 return dynamic_cast<StraightEdgeMessage*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
05339 #endif
05340 }
05341
05342 ::IceInternal::ProxyHandle<StraightEdgeMessage> ice_locatorCacheTimeout(int __timeout) const
05343 {
05344 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05345 typedef ::IceProxy::Ice::Object _Base;
05346 return dynamic_cast<StraightEdgeMessage*>(_Base::ice_locatorCacheTimeout(__timeout).get());
05347 #else
05348 return dynamic_cast<StraightEdgeMessage*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
05349 #endif
05350 }
05351
05352 ::IceInternal::ProxyHandle<StraightEdgeMessage> ice_connectionCached(bool __cached) const
05353 {
05354 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05355 typedef ::IceProxy::Ice::Object _Base;
05356 return dynamic_cast<StraightEdgeMessage*>(_Base::ice_connectionCached(__cached).get());
05357 #else
05358 return dynamic_cast<StraightEdgeMessage*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
05359 #endif
05360 }
05361
05362 ::IceInternal::ProxyHandle<StraightEdgeMessage> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
05363 {
05364 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05365 typedef ::IceProxy::Ice::Object _Base;
05366 return dynamic_cast<StraightEdgeMessage*>(_Base::ice_endpointSelection(__est).get());
05367 #else
05368 return dynamic_cast<StraightEdgeMessage*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
05369 #endif
05370 }
05371
05372 ::IceInternal::ProxyHandle<StraightEdgeMessage> ice_secure(bool __secure) const
05373 {
05374 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05375 typedef ::IceProxy::Ice::Object _Base;
05376 return dynamic_cast<StraightEdgeMessage*>(_Base::ice_secure(__secure).get());
05377 #else
05378 return dynamic_cast<StraightEdgeMessage*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
05379 #endif
05380 }
05381
05382 ::IceInternal::ProxyHandle<StraightEdgeMessage> ice_preferSecure(bool __preferSecure) const
05383 {
05384 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05385 typedef ::IceProxy::Ice::Object _Base;
05386 return dynamic_cast<StraightEdgeMessage*>(_Base::ice_preferSecure(__preferSecure).get());
05387 #else
05388 return dynamic_cast<StraightEdgeMessage*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
05389 #endif
05390 }
05391
05392 ::IceInternal::ProxyHandle<StraightEdgeMessage> ice_router(const ::Ice::RouterPrx& __router) const
05393 {
05394 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05395 typedef ::IceProxy::Ice::Object _Base;
05396 return dynamic_cast<StraightEdgeMessage*>(_Base::ice_router(__router).get());
05397 #else
05398 return dynamic_cast<StraightEdgeMessage*>(::IceProxy::Ice::Object::ice_router(__router).get());
05399 #endif
05400 }
05401
05402 ::IceInternal::ProxyHandle<StraightEdgeMessage> ice_locator(const ::Ice::LocatorPrx& __locator) const
05403 {
05404 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05405 typedef ::IceProxy::Ice::Object _Base;
05406 return dynamic_cast<StraightEdgeMessage*>(_Base::ice_locator(__locator).get());
05407 #else
05408 return dynamic_cast<StraightEdgeMessage*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
05409 #endif
05410 }
05411
05412 ::IceInternal::ProxyHandle<StraightEdgeMessage> ice_collocationOptimized(bool __co) const
05413 {
05414 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05415 typedef ::IceProxy::Ice::Object _Base;
05416 return dynamic_cast<StraightEdgeMessage*>(_Base::ice_collocationOptimized(__co).get());
05417 #else
05418 return dynamic_cast<StraightEdgeMessage*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
05419 #endif
05420 }
05421
05422 ::IceInternal::ProxyHandle<StraightEdgeMessage> ice_twoway() const
05423 {
05424 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05425 typedef ::IceProxy::Ice::Object _Base;
05426 return dynamic_cast<StraightEdgeMessage*>(_Base::ice_twoway().get());
05427 #else
05428 return dynamic_cast<StraightEdgeMessage*>(::IceProxy::Ice::Object::ice_twoway().get());
05429 #endif
05430 }
05431
05432 ::IceInternal::ProxyHandle<StraightEdgeMessage> ice_oneway() const
05433 {
05434 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05435 typedef ::IceProxy::Ice::Object _Base;
05436 return dynamic_cast<StraightEdgeMessage*>(_Base::ice_oneway().get());
05437 #else
05438 return dynamic_cast<StraightEdgeMessage*>(::IceProxy::Ice::Object::ice_oneway().get());
05439 #endif
05440 }
05441
05442 ::IceInternal::ProxyHandle<StraightEdgeMessage> ice_batchOneway() const
05443 {
05444 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05445 typedef ::IceProxy::Ice::Object _Base;
05446 return dynamic_cast<StraightEdgeMessage*>(_Base::ice_batchOneway().get());
05447 #else
05448 return dynamic_cast<StraightEdgeMessage*>(::IceProxy::Ice::Object::ice_batchOneway().get());
05449 #endif
05450 }
05451
05452 ::IceInternal::ProxyHandle<StraightEdgeMessage> ice_datagram() const
05453 {
05454 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05455 typedef ::IceProxy::Ice::Object _Base;
05456 return dynamic_cast<StraightEdgeMessage*>(_Base::ice_datagram().get());
05457 #else
05458 return dynamic_cast<StraightEdgeMessage*>(::IceProxy::Ice::Object::ice_datagram().get());
05459 #endif
05460 }
05461
05462 ::IceInternal::ProxyHandle<StraightEdgeMessage> ice_batchDatagram() const
05463 {
05464 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05465 typedef ::IceProxy::Ice::Object _Base;
05466 return dynamic_cast<StraightEdgeMessage*>(_Base::ice_batchDatagram().get());
05467 #else
05468 return dynamic_cast<StraightEdgeMessage*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
05469 #endif
05470 }
05471
05472 ::IceInternal::ProxyHandle<StraightEdgeMessage> ice_compress(bool __compress) const
05473 {
05474 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05475 typedef ::IceProxy::Ice::Object _Base;
05476 return dynamic_cast<StraightEdgeMessage*>(_Base::ice_compress(__compress).get());
05477 #else
05478 return dynamic_cast<StraightEdgeMessage*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
05479 #endif
05480 }
05481
05482 ::IceInternal::ProxyHandle<StraightEdgeMessage> ice_timeout(int __timeout) const
05483 {
05484 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05485 typedef ::IceProxy::Ice::Object _Base;
05486 return dynamic_cast<StraightEdgeMessage*>(_Base::ice_timeout(__timeout).get());
05487 #else
05488 return dynamic_cast<StraightEdgeMessage*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
05489 #endif
05490 }
05491
05492 ::IceInternal::ProxyHandle<StraightEdgeMessage> ice_connectionId(const std::string& __id) const
05493 {
05494 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05495 typedef ::IceProxy::Ice::Object _Base;
05496 return dynamic_cast<StraightEdgeMessage*>(_Base::ice_connectionId(__id).get());
05497 #else
05498 return dynamic_cast<StraightEdgeMessage*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
05499 #endif
05500 }
05501
05502 static const ::std::string& ice_staticId();
05503
05504 private:
05505
05506 virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
05507 virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
05508 virtual ::IceProxy::Ice::Object* __newInstance() const;
05509 };
05510
05511 class VisionObjectMessage : virtual public ::IceProxy::RobotSimEvents::EventMessage
05512 {
05513 public:
05514
05515 ::IceInternal::ProxyHandle<VisionObjectMessage> ice_context(const ::Ice::Context& __context) const
05516 {
05517 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05518 typedef ::IceProxy::Ice::Object _Base;
05519 return dynamic_cast<VisionObjectMessage*>(_Base::ice_context(__context).get());
05520 #else
05521 return dynamic_cast<VisionObjectMessage*>(::IceProxy::Ice::Object::ice_context(__context).get());
05522 #endif
05523 }
05524
05525 ::IceInternal::ProxyHandle<VisionObjectMessage> ice_adapterId(const std::string& __id) const
05526 {
05527 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05528 typedef ::IceProxy::Ice::Object _Base;
05529 return dynamic_cast<VisionObjectMessage*>(_Base::ice_adapterId(__id).get());
05530 #else
05531 return dynamic_cast<VisionObjectMessage*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
05532 #endif
05533 }
05534
05535 ::IceInternal::ProxyHandle<VisionObjectMessage> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
05536 {
05537 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05538 typedef ::IceProxy::Ice::Object _Base;
05539 return dynamic_cast<VisionObjectMessage*>(_Base::ice_endpoints(__endpoints).get());
05540 #else
05541 return dynamic_cast<VisionObjectMessage*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
05542 #endif
05543 }
05544
05545 ::IceInternal::ProxyHandle<VisionObjectMessage> ice_locatorCacheTimeout(int __timeout) const
05546 {
05547 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05548 typedef ::IceProxy::Ice::Object _Base;
05549 return dynamic_cast<VisionObjectMessage*>(_Base::ice_locatorCacheTimeout(__timeout).get());
05550 #else
05551 return dynamic_cast<VisionObjectMessage*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
05552 #endif
05553 }
05554
05555 ::IceInternal::ProxyHandle<VisionObjectMessage> ice_connectionCached(bool __cached) const
05556 {
05557 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05558 typedef ::IceProxy::Ice::Object _Base;
05559 return dynamic_cast<VisionObjectMessage*>(_Base::ice_connectionCached(__cached).get());
05560 #else
05561 return dynamic_cast<VisionObjectMessage*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
05562 #endif
05563 }
05564
05565 ::IceInternal::ProxyHandle<VisionObjectMessage> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
05566 {
05567 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05568 typedef ::IceProxy::Ice::Object _Base;
05569 return dynamic_cast<VisionObjectMessage*>(_Base::ice_endpointSelection(__est).get());
05570 #else
05571 return dynamic_cast<VisionObjectMessage*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
05572 #endif
05573 }
05574
05575 ::IceInternal::ProxyHandle<VisionObjectMessage> ice_secure(bool __secure) const
05576 {
05577 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05578 typedef ::IceProxy::Ice::Object _Base;
05579 return dynamic_cast<VisionObjectMessage*>(_Base::ice_secure(__secure).get());
05580 #else
05581 return dynamic_cast<VisionObjectMessage*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
05582 #endif
05583 }
05584
05585 ::IceInternal::ProxyHandle<VisionObjectMessage> ice_preferSecure(bool __preferSecure) const
05586 {
05587 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05588 typedef ::IceProxy::Ice::Object _Base;
05589 return dynamic_cast<VisionObjectMessage*>(_Base::ice_preferSecure(__preferSecure).get());
05590 #else
05591 return dynamic_cast<VisionObjectMessage*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
05592 #endif
05593 }
05594
05595 ::IceInternal::ProxyHandle<VisionObjectMessage> ice_router(const ::Ice::RouterPrx& __router) const
05596 {
05597 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05598 typedef ::IceProxy::Ice::Object _Base;
05599 return dynamic_cast<VisionObjectMessage*>(_Base::ice_router(__router).get());
05600 #else
05601 return dynamic_cast<VisionObjectMessage*>(::IceProxy::Ice::Object::ice_router(__router).get());
05602 #endif
05603 }
05604
05605 ::IceInternal::ProxyHandle<VisionObjectMessage> ice_locator(const ::Ice::LocatorPrx& __locator) const
05606 {
05607 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05608 typedef ::IceProxy::Ice::Object _Base;
05609 return dynamic_cast<VisionObjectMessage*>(_Base::ice_locator(__locator).get());
05610 #else
05611 return dynamic_cast<VisionObjectMessage*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
05612 #endif
05613 }
05614
05615 ::IceInternal::ProxyHandle<VisionObjectMessage> ice_collocationOptimized(bool __co) const
05616 {
05617 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05618 typedef ::IceProxy::Ice::Object _Base;
05619 return dynamic_cast<VisionObjectMessage*>(_Base::ice_collocationOptimized(__co).get());
05620 #else
05621 return dynamic_cast<VisionObjectMessage*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
05622 #endif
05623 }
05624
05625 ::IceInternal::ProxyHandle<VisionObjectMessage> ice_twoway() const
05626 {
05627 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05628 typedef ::IceProxy::Ice::Object _Base;
05629 return dynamic_cast<VisionObjectMessage*>(_Base::ice_twoway().get());
05630 #else
05631 return dynamic_cast<VisionObjectMessage*>(::IceProxy::Ice::Object::ice_twoway().get());
05632 #endif
05633 }
05634
05635 ::IceInternal::ProxyHandle<VisionObjectMessage> ice_oneway() const
05636 {
05637 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05638 typedef ::IceProxy::Ice::Object _Base;
05639 return dynamic_cast<VisionObjectMessage*>(_Base::ice_oneway().get());
05640 #else
05641 return dynamic_cast<VisionObjectMessage*>(::IceProxy::Ice::Object::ice_oneway().get());
05642 #endif
05643 }
05644
05645 ::IceInternal::ProxyHandle<VisionObjectMessage> ice_batchOneway() const
05646 {
05647 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05648 typedef ::IceProxy::Ice::Object _Base;
05649 return dynamic_cast<VisionObjectMessage*>(_Base::ice_batchOneway().get());
05650 #else
05651 return dynamic_cast<VisionObjectMessage*>(::IceProxy::Ice::Object::ice_batchOneway().get());
05652 #endif
05653 }
05654
05655 ::IceInternal::ProxyHandle<VisionObjectMessage> ice_datagram() const
05656 {
05657 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05658 typedef ::IceProxy::Ice::Object _Base;
05659 return dynamic_cast<VisionObjectMessage*>(_Base::ice_datagram().get());
05660 #else
05661 return dynamic_cast<VisionObjectMessage*>(::IceProxy::Ice::Object::ice_datagram().get());
05662 #endif
05663 }
05664
05665 ::IceInternal::ProxyHandle<VisionObjectMessage> ice_batchDatagram() const
05666 {
05667 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05668 typedef ::IceProxy::Ice::Object _Base;
05669 return dynamic_cast<VisionObjectMessage*>(_Base::ice_batchDatagram().get());
05670 #else
05671 return dynamic_cast<VisionObjectMessage*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
05672 #endif
05673 }
05674
05675 ::IceInternal::ProxyHandle<VisionObjectMessage> ice_compress(bool __compress) const
05676 {
05677 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05678 typedef ::IceProxy::Ice::Object _Base;
05679 return dynamic_cast<VisionObjectMessage*>(_Base::ice_compress(__compress).get());
05680 #else
05681 return dynamic_cast<VisionObjectMessage*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
05682 #endif
05683 }
05684
05685 ::IceInternal::ProxyHandle<VisionObjectMessage> ice_timeout(int __timeout) const
05686 {
05687 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05688 typedef ::IceProxy::Ice::Object _Base;
05689 return dynamic_cast<VisionObjectMessage*>(_Base::ice_timeout(__timeout).get());
05690 #else
05691 return dynamic_cast<VisionObjectMessage*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
05692 #endif
05693 }
05694
05695 ::IceInternal::ProxyHandle<VisionObjectMessage> ice_connectionId(const std::string& __id) const
05696 {
05697 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05698 typedef ::IceProxy::Ice::Object _Base;
05699 return dynamic_cast<VisionObjectMessage*>(_Base::ice_connectionId(__id).get());
05700 #else
05701 return dynamic_cast<VisionObjectMessage*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
05702 #endif
05703 }
05704
05705 static const ::std::string& ice_staticId();
05706
05707 private:
05708
05709 virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
05710 virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
05711 virtual ::IceProxy::Ice::Object* __newInstance() const;
05712 };
05713
05714 class LandmarksMessage : virtual public ::IceProxy::RobotSimEvents::EventMessage
05715 {
05716 public:
05717
05718 ::IceInternal::ProxyHandle<LandmarksMessage> ice_context(const ::Ice::Context& __context) const
05719 {
05720 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05721 typedef ::IceProxy::Ice::Object _Base;
05722 return dynamic_cast<LandmarksMessage*>(_Base::ice_context(__context).get());
05723 #else
05724 return dynamic_cast<LandmarksMessage*>(::IceProxy::Ice::Object::ice_context(__context).get());
05725 #endif
05726 }
05727
05728 ::IceInternal::ProxyHandle<LandmarksMessage> ice_adapterId(const std::string& __id) const
05729 {
05730 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05731 typedef ::IceProxy::Ice::Object _Base;
05732 return dynamic_cast<LandmarksMessage*>(_Base::ice_adapterId(__id).get());
05733 #else
05734 return dynamic_cast<LandmarksMessage*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
05735 #endif
05736 }
05737
05738 ::IceInternal::ProxyHandle<LandmarksMessage> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
05739 {
05740 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05741 typedef ::IceProxy::Ice::Object _Base;
05742 return dynamic_cast<LandmarksMessage*>(_Base::ice_endpoints(__endpoints).get());
05743 #else
05744 return dynamic_cast<LandmarksMessage*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
05745 #endif
05746 }
05747
05748 ::IceInternal::ProxyHandle<LandmarksMessage> ice_locatorCacheTimeout(int __timeout) const
05749 {
05750 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05751 typedef ::IceProxy::Ice::Object _Base;
05752 return dynamic_cast<LandmarksMessage*>(_Base::ice_locatorCacheTimeout(__timeout).get());
05753 #else
05754 return dynamic_cast<LandmarksMessage*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
05755 #endif
05756 }
05757
05758 ::IceInternal::ProxyHandle<LandmarksMessage> ice_connectionCached(bool __cached) const
05759 {
05760 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05761 typedef ::IceProxy::Ice::Object _Base;
05762 return dynamic_cast<LandmarksMessage*>(_Base::ice_connectionCached(__cached).get());
05763 #else
05764 return dynamic_cast<LandmarksMessage*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
05765 #endif
05766 }
05767
05768 ::IceInternal::ProxyHandle<LandmarksMessage> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
05769 {
05770 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05771 typedef ::IceProxy::Ice::Object _Base;
05772 return dynamic_cast<LandmarksMessage*>(_Base::ice_endpointSelection(__est).get());
05773 #else
05774 return dynamic_cast<LandmarksMessage*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
05775 #endif
05776 }
05777
05778 ::IceInternal::ProxyHandle<LandmarksMessage> ice_secure(bool __secure) const
05779 {
05780 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05781 typedef ::IceProxy::Ice::Object _Base;
05782 return dynamic_cast<LandmarksMessage*>(_Base::ice_secure(__secure).get());
05783 #else
05784 return dynamic_cast<LandmarksMessage*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
05785 #endif
05786 }
05787
05788 ::IceInternal::ProxyHandle<LandmarksMessage> ice_preferSecure(bool __preferSecure) const
05789 {
05790 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05791 typedef ::IceProxy::Ice::Object _Base;
05792 return dynamic_cast<LandmarksMessage*>(_Base::ice_preferSecure(__preferSecure).get());
05793 #else
05794 return dynamic_cast<LandmarksMessage*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
05795 #endif
05796 }
05797
05798 ::IceInternal::ProxyHandle<LandmarksMessage> ice_router(const ::Ice::RouterPrx& __router) const
05799 {
05800 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05801 typedef ::IceProxy::Ice::Object _Base;
05802 return dynamic_cast<LandmarksMessage*>(_Base::ice_router(__router).get());
05803 #else
05804 return dynamic_cast<LandmarksMessage*>(::IceProxy::Ice::Object::ice_router(__router).get());
05805 #endif
05806 }
05807
05808 ::IceInternal::ProxyHandle<LandmarksMessage> ice_locator(const ::Ice::LocatorPrx& __locator) const
05809 {
05810 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05811 typedef ::IceProxy::Ice::Object _Base;
05812 return dynamic_cast<LandmarksMessage*>(_Base::ice_locator(__locator).get());
05813 #else
05814 return dynamic_cast<LandmarksMessage*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
05815 #endif
05816 }
05817
05818 ::IceInternal::ProxyHandle<LandmarksMessage> ice_collocationOptimized(bool __co) const
05819 {
05820 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05821 typedef ::IceProxy::Ice::Object _Base;
05822 return dynamic_cast<LandmarksMessage*>(_Base::ice_collocationOptimized(__co).get());
05823 #else
05824 return dynamic_cast<LandmarksMessage*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
05825 #endif
05826 }
05827
05828 ::IceInternal::ProxyHandle<LandmarksMessage> ice_twoway() const
05829 {
05830 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05831 typedef ::IceProxy::Ice::Object _Base;
05832 return dynamic_cast<LandmarksMessage*>(_Base::ice_twoway().get());
05833 #else
05834 return dynamic_cast<LandmarksMessage*>(::IceProxy::Ice::Object::ice_twoway().get());
05835 #endif
05836 }
05837
05838 ::IceInternal::ProxyHandle<LandmarksMessage> ice_oneway() const
05839 {
05840 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05841 typedef ::IceProxy::Ice::Object _Base;
05842 return dynamic_cast<LandmarksMessage*>(_Base::ice_oneway().get());
05843 #else
05844 return dynamic_cast<LandmarksMessage*>(::IceProxy::Ice::Object::ice_oneway().get());
05845 #endif
05846 }
05847
05848 ::IceInternal::ProxyHandle<LandmarksMessage> ice_batchOneway() const
05849 {
05850 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05851 typedef ::IceProxy::Ice::Object _Base;
05852 return dynamic_cast<LandmarksMessage*>(_Base::ice_batchOneway().get());
05853 #else
05854 return dynamic_cast<LandmarksMessage*>(::IceProxy::Ice::Object::ice_batchOneway().get());
05855 #endif
05856 }
05857
05858 ::IceInternal::ProxyHandle<LandmarksMessage> ice_datagram() const
05859 {
05860 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05861 typedef ::IceProxy::Ice::Object _Base;
05862 return dynamic_cast<LandmarksMessage*>(_Base::ice_datagram().get());
05863 #else
05864 return dynamic_cast<LandmarksMessage*>(::IceProxy::Ice::Object::ice_datagram().get());
05865 #endif
05866 }
05867
05868 ::IceInternal::ProxyHandle<LandmarksMessage> ice_batchDatagram() const
05869 {
05870 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05871 typedef ::IceProxy::Ice::Object _Base;
05872 return dynamic_cast<LandmarksMessage*>(_Base::ice_batchDatagram().get());
05873 #else
05874 return dynamic_cast<LandmarksMessage*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
05875 #endif
05876 }
05877
05878 ::IceInternal::ProxyHandle<LandmarksMessage> ice_compress(bool __compress) const
05879 {
05880 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05881 typedef ::IceProxy::Ice::Object _Base;
05882 return dynamic_cast<LandmarksMessage*>(_Base::ice_compress(__compress).get());
05883 #else
05884 return dynamic_cast<LandmarksMessage*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
05885 #endif
05886 }
05887
05888 ::IceInternal::ProxyHandle<LandmarksMessage> ice_timeout(int __timeout) const
05889 {
05890 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05891 typedef ::IceProxy::Ice::Object _Base;
05892 return dynamic_cast<LandmarksMessage*>(_Base::ice_timeout(__timeout).get());
05893 #else
05894 return dynamic_cast<LandmarksMessage*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
05895 #endif
05896 }
05897
05898 ::IceInternal::ProxyHandle<LandmarksMessage> ice_connectionId(const std::string& __id) const
05899 {
05900 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05901 typedef ::IceProxy::Ice::Object _Base;
05902 return dynamic_cast<LandmarksMessage*>(_Base::ice_connectionId(__id).get());
05903 #else
05904 return dynamic_cast<LandmarksMessage*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
05905 #endif
05906 }
05907
05908 static const ::std::string& ice_staticId();
05909
05910 private:
05911
05912 virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
05913 virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
05914 virtual ::IceProxy::Ice::Object* __newInstance() const;
05915 };
05916
05917 class CameraConfigMessage : virtual public ::IceProxy::RobotSimEvents::EventMessage
05918 {
05919 public:
05920
05921 ::IceInternal::ProxyHandle<CameraConfigMessage> ice_context(const ::Ice::Context& __context) const
05922 {
05923 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05924 typedef ::IceProxy::Ice::Object _Base;
05925 return dynamic_cast<CameraConfigMessage*>(_Base::ice_context(__context).get());
05926 #else
05927 return dynamic_cast<CameraConfigMessage*>(::IceProxy::Ice::Object::ice_context(__context).get());
05928 #endif
05929 }
05930
05931 ::IceInternal::ProxyHandle<CameraConfigMessage> ice_adapterId(const std::string& __id) const
05932 {
05933 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05934 typedef ::IceProxy::Ice::Object _Base;
05935 return dynamic_cast<CameraConfigMessage*>(_Base::ice_adapterId(__id).get());
05936 #else
05937 return dynamic_cast<CameraConfigMessage*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
05938 #endif
05939 }
05940
05941 ::IceInternal::ProxyHandle<CameraConfigMessage> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
05942 {
05943 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05944 typedef ::IceProxy::Ice::Object _Base;
05945 return dynamic_cast<CameraConfigMessage*>(_Base::ice_endpoints(__endpoints).get());
05946 #else
05947 return dynamic_cast<CameraConfigMessage*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
05948 #endif
05949 }
05950
05951 ::IceInternal::ProxyHandle<CameraConfigMessage> ice_locatorCacheTimeout(int __timeout) const
05952 {
05953 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05954 typedef ::IceProxy::Ice::Object _Base;
05955 return dynamic_cast<CameraConfigMessage*>(_Base::ice_locatorCacheTimeout(__timeout).get());
05956 #else
05957 return dynamic_cast<CameraConfigMessage*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
05958 #endif
05959 }
05960
05961 ::IceInternal::ProxyHandle<CameraConfigMessage> ice_connectionCached(bool __cached) const
05962 {
05963 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05964 typedef ::IceProxy::Ice::Object _Base;
05965 return dynamic_cast<CameraConfigMessage*>(_Base::ice_connectionCached(__cached).get());
05966 #else
05967 return dynamic_cast<CameraConfigMessage*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
05968 #endif
05969 }
05970
05971 ::IceInternal::ProxyHandle<CameraConfigMessage> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
05972 {
05973 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05974 typedef ::IceProxy::Ice::Object _Base;
05975 return dynamic_cast<CameraConfigMessage*>(_Base::ice_endpointSelection(__est).get());
05976 #else
05977 return dynamic_cast<CameraConfigMessage*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
05978 #endif
05979 }
05980
05981 ::IceInternal::ProxyHandle<CameraConfigMessage> ice_secure(bool __secure) const
05982 {
05983 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05984 typedef ::IceProxy::Ice::Object _Base;
05985 return dynamic_cast<CameraConfigMessage*>(_Base::ice_secure(__secure).get());
05986 #else
05987 return dynamic_cast<CameraConfigMessage*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
05988 #endif
05989 }
05990
05991 ::IceInternal::ProxyHandle<CameraConfigMessage> ice_preferSecure(bool __preferSecure) const
05992 {
05993 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
05994 typedef ::IceProxy::Ice::Object _Base;
05995 return dynamic_cast<CameraConfigMessage*>(_Base::ice_preferSecure(__preferSecure).get());
05996 #else
05997 return dynamic_cast<CameraConfigMessage*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
05998 #endif
05999 }
06000
06001 ::IceInternal::ProxyHandle<CameraConfigMessage> ice_router(const ::Ice::RouterPrx& __router) const
06002 {
06003 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06004 typedef ::IceProxy::Ice::Object _Base;
06005 return dynamic_cast<CameraConfigMessage*>(_Base::ice_router(__router).get());
06006 #else
06007 return dynamic_cast<CameraConfigMessage*>(::IceProxy::Ice::Object::ice_router(__router).get());
06008 #endif
06009 }
06010
06011 ::IceInternal::ProxyHandle<CameraConfigMessage> ice_locator(const ::Ice::LocatorPrx& __locator) const
06012 {
06013 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06014 typedef ::IceProxy::Ice::Object _Base;
06015 return dynamic_cast<CameraConfigMessage*>(_Base::ice_locator(__locator).get());
06016 #else
06017 return dynamic_cast<CameraConfigMessage*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
06018 #endif
06019 }
06020
06021 ::IceInternal::ProxyHandle<CameraConfigMessage> ice_collocationOptimized(bool __co) const
06022 {
06023 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06024 typedef ::IceProxy::Ice::Object _Base;
06025 return dynamic_cast<CameraConfigMessage*>(_Base::ice_collocationOptimized(__co).get());
06026 #else
06027 return dynamic_cast<CameraConfigMessage*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
06028 #endif
06029 }
06030
06031 ::IceInternal::ProxyHandle<CameraConfigMessage> ice_twoway() const
06032 {
06033 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06034 typedef ::IceProxy::Ice::Object _Base;
06035 return dynamic_cast<CameraConfigMessage*>(_Base::ice_twoway().get());
06036 #else
06037 return dynamic_cast<CameraConfigMessage*>(::IceProxy::Ice::Object::ice_twoway().get());
06038 #endif
06039 }
06040
06041 ::IceInternal::ProxyHandle<CameraConfigMessage> ice_oneway() const
06042 {
06043 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06044 typedef ::IceProxy::Ice::Object _Base;
06045 return dynamic_cast<CameraConfigMessage*>(_Base::ice_oneway().get());
06046 #else
06047 return dynamic_cast<CameraConfigMessage*>(::IceProxy::Ice::Object::ice_oneway().get());
06048 #endif
06049 }
06050
06051 ::IceInternal::ProxyHandle<CameraConfigMessage> ice_batchOneway() const
06052 {
06053 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06054 typedef ::IceProxy::Ice::Object _Base;
06055 return dynamic_cast<CameraConfigMessage*>(_Base::ice_batchOneway().get());
06056 #else
06057 return dynamic_cast<CameraConfigMessage*>(::IceProxy::Ice::Object::ice_batchOneway().get());
06058 #endif
06059 }
06060
06061 ::IceInternal::ProxyHandle<CameraConfigMessage> ice_datagram() const
06062 {
06063 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06064 typedef ::IceProxy::Ice::Object _Base;
06065 return dynamic_cast<CameraConfigMessage*>(_Base::ice_datagram().get());
06066 #else
06067 return dynamic_cast<CameraConfigMessage*>(::IceProxy::Ice::Object::ice_datagram().get());
06068 #endif
06069 }
06070
06071 ::IceInternal::ProxyHandle<CameraConfigMessage> ice_batchDatagram() const
06072 {
06073 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06074 typedef ::IceProxy::Ice::Object _Base;
06075 return dynamic_cast<CameraConfigMessage*>(_Base::ice_batchDatagram().get());
06076 #else
06077 return dynamic_cast<CameraConfigMessage*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
06078 #endif
06079 }
06080
06081 ::IceInternal::ProxyHandle<CameraConfigMessage> ice_compress(bool __compress) const
06082 {
06083 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06084 typedef ::IceProxy::Ice::Object _Base;
06085 return dynamic_cast<CameraConfigMessage*>(_Base::ice_compress(__compress).get());
06086 #else
06087 return dynamic_cast<CameraConfigMessage*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
06088 #endif
06089 }
06090
06091 ::IceInternal::ProxyHandle<CameraConfigMessage> ice_timeout(int __timeout) const
06092 {
06093 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06094 typedef ::IceProxy::Ice::Object _Base;
06095 return dynamic_cast<CameraConfigMessage*>(_Base::ice_timeout(__timeout).get());
06096 #else
06097 return dynamic_cast<CameraConfigMessage*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
06098 #endif
06099 }
06100
06101 ::IceInternal::ProxyHandle<CameraConfigMessage> ice_connectionId(const std::string& __id) const
06102 {
06103 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06104 typedef ::IceProxy::Ice::Object _Base;
06105 return dynamic_cast<CameraConfigMessage*>(_Base::ice_connectionId(__id).get());
06106 #else
06107 return dynamic_cast<CameraConfigMessage*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
06108 #endif
06109 }
06110
06111 static const ::std::string& ice_staticId();
06112
06113 private:
06114
06115 virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
06116 virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
06117 virtual ::IceProxy::Ice::Object* __newInstance() const;
06118 };
06119
06120 class SalientPointMessage : virtual public ::IceProxy::RobotSimEvents::EventMessage
06121 {
06122 public:
06123
06124 ::IceInternal::ProxyHandle<SalientPointMessage> ice_context(const ::Ice::Context& __context) const
06125 {
06126 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06127 typedef ::IceProxy::Ice::Object _Base;
06128 return dynamic_cast<SalientPointMessage*>(_Base::ice_context(__context).get());
06129 #else
06130 return dynamic_cast<SalientPointMessage*>(::IceProxy::Ice::Object::ice_context(__context).get());
06131 #endif
06132 }
06133
06134 ::IceInternal::ProxyHandle<SalientPointMessage> ice_adapterId(const std::string& __id) const
06135 {
06136 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06137 typedef ::IceProxy::Ice::Object _Base;
06138 return dynamic_cast<SalientPointMessage*>(_Base::ice_adapterId(__id).get());
06139 #else
06140 return dynamic_cast<SalientPointMessage*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
06141 #endif
06142 }
06143
06144 ::IceInternal::ProxyHandle<SalientPointMessage> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
06145 {
06146 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06147 typedef ::IceProxy::Ice::Object _Base;
06148 return dynamic_cast<SalientPointMessage*>(_Base::ice_endpoints(__endpoints).get());
06149 #else
06150 return dynamic_cast<SalientPointMessage*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
06151 #endif
06152 }
06153
06154 ::IceInternal::ProxyHandle<SalientPointMessage> ice_locatorCacheTimeout(int __timeout) const
06155 {
06156 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06157 typedef ::IceProxy::Ice::Object _Base;
06158 return dynamic_cast<SalientPointMessage*>(_Base::ice_locatorCacheTimeout(__timeout).get());
06159 #else
06160 return dynamic_cast<SalientPointMessage*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
06161 #endif
06162 }
06163
06164 ::IceInternal::ProxyHandle<SalientPointMessage> ice_connectionCached(bool __cached) const
06165 {
06166 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06167 typedef ::IceProxy::Ice::Object _Base;
06168 return dynamic_cast<SalientPointMessage*>(_Base::ice_connectionCached(__cached).get());
06169 #else
06170 return dynamic_cast<SalientPointMessage*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
06171 #endif
06172 }
06173
06174 ::IceInternal::ProxyHandle<SalientPointMessage> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
06175 {
06176 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06177 typedef ::IceProxy::Ice::Object _Base;
06178 return dynamic_cast<SalientPointMessage*>(_Base::ice_endpointSelection(__est).get());
06179 #else
06180 return dynamic_cast<SalientPointMessage*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
06181 #endif
06182 }
06183
06184 ::IceInternal::ProxyHandle<SalientPointMessage> ice_secure(bool __secure) const
06185 {
06186 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06187 typedef ::IceProxy::Ice::Object _Base;
06188 return dynamic_cast<SalientPointMessage*>(_Base::ice_secure(__secure).get());
06189 #else
06190 return dynamic_cast<SalientPointMessage*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
06191 #endif
06192 }
06193
06194 ::IceInternal::ProxyHandle<SalientPointMessage> ice_preferSecure(bool __preferSecure) const
06195 {
06196 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06197 typedef ::IceProxy::Ice::Object _Base;
06198 return dynamic_cast<SalientPointMessage*>(_Base::ice_preferSecure(__preferSecure).get());
06199 #else
06200 return dynamic_cast<SalientPointMessage*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
06201 #endif
06202 }
06203
06204 ::IceInternal::ProxyHandle<SalientPointMessage> ice_router(const ::Ice::RouterPrx& __router) const
06205 {
06206 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06207 typedef ::IceProxy::Ice::Object _Base;
06208 return dynamic_cast<SalientPointMessage*>(_Base::ice_router(__router).get());
06209 #else
06210 return dynamic_cast<SalientPointMessage*>(::IceProxy::Ice::Object::ice_router(__router).get());
06211 #endif
06212 }
06213
06214 ::IceInternal::ProxyHandle<SalientPointMessage> ice_locator(const ::Ice::LocatorPrx& __locator) const
06215 {
06216 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06217 typedef ::IceProxy::Ice::Object _Base;
06218 return dynamic_cast<SalientPointMessage*>(_Base::ice_locator(__locator).get());
06219 #else
06220 return dynamic_cast<SalientPointMessage*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
06221 #endif
06222 }
06223
06224 ::IceInternal::ProxyHandle<SalientPointMessage> ice_collocationOptimized(bool __co) const
06225 {
06226 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06227 typedef ::IceProxy::Ice::Object _Base;
06228 return dynamic_cast<SalientPointMessage*>(_Base::ice_collocationOptimized(__co).get());
06229 #else
06230 return dynamic_cast<SalientPointMessage*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
06231 #endif
06232 }
06233
06234 ::IceInternal::ProxyHandle<SalientPointMessage> ice_twoway() const
06235 {
06236 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06237 typedef ::IceProxy::Ice::Object _Base;
06238 return dynamic_cast<SalientPointMessage*>(_Base::ice_twoway().get());
06239 #else
06240 return dynamic_cast<SalientPointMessage*>(::IceProxy::Ice::Object::ice_twoway().get());
06241 #endif
06242 }
06243
06244 ::IceInternal::ProxyHandle<SalientPointMessage> ice_oneway() const
06245 {
06246 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06247 typedef ::IceProxy::Ice::Object _Base;
06248 return dynamic_cast<SalientPointMessage*>(_Base::ice_oneway().get());
06249 #else
06250 return dynamic_cast<SalientPointMessage*>(::IceProxy::Ice::Object::ice_oneway().get());
06251 #endif
06252 }
06253
06254 ::IceInternal::ProxyHandle<SalientPointMessage> ice_batchOneway() const
06255 {
06256 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06257 typedef ::IceProxy::Ice::Object _Base;
06258 return dynamic_cast<SalientPointMessage*>(_Base::ice_batchOneway().get());
06259 #else
06260 return dynamic_cast<SalientPointMessage*>(::IceProxy::Ice::Object::ice_batchOneway().get());
06261 #endif
06262 }
06263
06264 ::IceInternal::ProxyHandle<SalientPointMessage> ice_datagram() const
06265 {
06266 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06267 typedef ::IceProxy::Ice::Object _Base;
06268 return dynamic_cast<SalientPointMessage*>(_Base::ice_datagram().get());
06269 #else
06270 return dynamic_cast<SalientPointMessage*>(::IceProxy::Ice::Object::ice_datagram().get());
06271 #endif
06272 }
06273
06274 ::IceInternal::ProxyHandle<SalientPointMessage> ice_batchDatagram() const
06275 {
06276 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06277 typedef ::IceProxy::Ice::Object _Base;
06278 return dynamic_cast<SalientPointMessage*>(_Base::ice_batchDatagram().get());
06279 #else
06280 return dynamic_cast<SalientPointMessage*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
06281 #endif
06282 }
06283
06284 ::IceInternal::ProxyHandle<SalientPointMessage> ice_compress(bool __compress) const
06285 {
06286 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06287 typedef ::IceProxy::Ice::Object _Base;
06288 return dynamic_cast<SalientPointMessage*>(_Base::ice_compress(__compress).get());
06289 #else
06290 return dynamic_cast<SalientPointMessage*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
06291 #endif
06292 }
06293
06294 ::IceInternal::ProxyHandle<SalientPointMessage> ice_timeout(int __timeout) const
06295 {
06296 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06297 typedef ::IceProxy::Ice::Object _Base;
06298 return dynamic_cast<SalientPointMessage*>(_Base::ice_timeout(__timeout).get());
06299 #else
06300 return dynamic_cast<SalientPointMessage*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
06301 #endif
06302 }
06303
06304 ::IceInternal::ProxyHandle<SalientPointMessage> ice_connectionId(const std::string& __id) const
06305 {
06306 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06307 typedef ::IceProxy::Ice::Object _Base;
06308 return dynamic_cast<SalientPointMessage*>(_Base::ice_connectionId(__id).get());
06309 #else
06310 return dynamic_cast<SalientPointMessage*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
06311 #endif
06312 }
06313
06314 static const ::std::string& ice_staticId();
06315
06316 private:
06317
06318 virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
06319 virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
06320 virtual ::IceProxy::Ice::Object* __newInstance() const;
06321 };
06322
06323 class BuoyColorSegmentMessage : virtual public ::IceProxy::RobotSimEvents::EventMessage
06324 {
06325 public:
06326
06327 ::IceInternal::ProxyHandle<BuoyColorSegmentMessage> ice_context(const ::Ice::Context& __context) const
06328 {
06329 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06330 typedef ::IceProxy::Ice::Object _Base;
06331 return dynamic_cast<BuoyColorSegmentMessage*>(_Base::ice_context(__context).get());
06332 #else
06333 return dynamic_cast<BuoyColorSegmentMessage*>(::IceProxy::Ice::Object::ice_context(__context).get());
06334 #endif
06335 }
06336
06337 ::IceInternal::ProxyHandle<BuoyColorSegmentMessage> ice_adapterId(const std::string& __id) const
06338 {
06339 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06340 typedef ::IceProxy::Ice::Object _Base;
06341 return dynamic_cast<BuoyColorSegmentMessage*>(_Base::ice_adapterId(__id).get());
06342 #else
06343 return dynamic_cast<BuoyColorSegmentMessage*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
06344 #endif
06345 }
06346
06347 ::IceInternal::ProxyHandle<BuoyColorSegmentMessage> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
06348 {
06349 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06350 typedef ::IceProxy::Ice::Object _Base;
06351 return dynamic_cast<BuoyColorSegmentMessage*>(_Base::ice_endpoints(__endpoints).get());
06352 #else
06353 return dynamic_cast<BuoyColorSegmentMessage*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
06354 #endif
06355 }
06356
06357 ::IceInternal::ProxyHandle<BuoyColorSegmentMessage> ice_locatorCacheTimeout(int __timeout) const
06358 {
06359 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06360 typedef ::IceProxy::Ice::Object _Base;
06361 return dynamic_cast<BuoyColorSegmentMessage*>(_Base::ice_locatorCacheTimeout(__timeout).get());
06362 #else
06363 return dynamic_cast<BuoyColorSegmentMessage*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
06364 #endif
06365 }
06366
06367 ::IceInternal::ProxyHandle<BuoyColorSegmentMessage> ice_connectionCached(bool __cached) const
06368 {
06369 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06370 typedef ::IceProxy::Ice::Object _Base;
06371 return dynamic_cast<BuoyColorSegmentMessage*>(_Base::ice_connectionCached(__cached).get());
06372 #else
06373 return dynamic_cast<BuoyColorSegmentMessage*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
06374 #endif
06375 }
06376
06377 ::IceInternal::ProxyHandle<BuoyColorSegmentMessage> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
06378 {
06379 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06380 typedef ::IceProxy::Ice::Object _Base;
06381 return dynamic_cast<BuoyColorSegmentMessage*>(_Base::ice_endpointSelection(__est).get());
06382 #else
06383 return dynamic_cast<BuoyColorSegmentMessage*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
06384 #endif
06385 }
06386
06387 ::IceInternal::ProxyHandle<BuoyColorSegmentMessage> ice_secure(bool __secure) const
06388 {
06389 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06390 typedef ::IceProxy::Ice::Object _Base;
06391 return dynamic_cast<BuoyColorSegmentMessage*>(_Base::ice_secure(__secure).get());
06392 #else
06393 return dynamic_cast<BuoyColorSegmentMessage*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
06394 #endif
06395 }
06396
06397 ::IceInternal::ProxyHandle<BuoyColorSegmentMessage> ice_preferSecure(bool __preferSecure) const
06398 {
06399 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06400 typedef ::IceProxy::Ice::Object _Base;
06401 return dynamic_cast<BuoyColorSegmentMessage*>(_Base::ice_preferSecure(__preferSecure).get());
06402 #else
06403 return dynamic_cast<BuoyColorSegmentMessage*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
06404 #endif
06405 }
06406
06407 ::IceInternal::ProxyHandle<BuoyColorSegmentMessage> ice_router(const ::Ice::RouterPrx& __router) const
06408 {
06409 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06410 typedef ::IceProxy::Ice::Object _Base;
06411 return dynamic_cast<BuoyColorSegmentMessage*>(_Base::ice_router(__router).get());
06412 #else
06413 return dynamic_cast<BuoyColorSegmentMessage*>(::IceProxy::Ice::Object::ice_router(__router).get());
06414 #endif
06415 }
06416
06417 ::IceInternal::ProxyHandle<BuoyColorSegmentMessage> ice_locator(const ::Ice::LocatorPrx& __locator) const
06418 {
06419 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06420 typedef ::IceProxy::Ice::Object _Base;
06421 return dynamic_cast<BuoyColorSegmentMessage*>(_Base::ice_locator(__locator).get());
06422 #else
06423 return dynamic_cast<BuoyColorSegmentMessage*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
06424 #endif
06425 }
06426
06427 ::IceInternal::ProxyHandle<BuoyColorSegmentMessage> ice_collocationOptimized(bool __co) const
06428 {
06429 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06430 typedef ::IceProxy::Ice::Object _Base;
06431 return dynamic_cast<BuoyColorSegmentMessage*>(_Base::ice_collocationOptimized(__co).get());
06432 #else
06433 return dynamic_cast<BuoyColorSegmentMessage*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
06434 #endif
06435 }
06436
06437 ::IceInternal::ProxyHandle<BuoyColorSegmentMessage> ice_twoway() const
06438 {
06439 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06440 typedef ::IceProxy::Ice::Object _Base;
06441 return dynamic_cast<BuoyColorSegmentMessage*>(_Base::ice_twoway().get());
06442 #else
06443 return dynamic_cast<BuoyColorSegmentMessage*>(::IceProxy::Ice::Object::ice_twoway().get());
06444 #endif
06445 }
06446
06447 ::IceInternal::ProxyHandle<BuoyColorSegmentMessage> ice_oneway() const
06448 {
06449 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06450 typedef ::IceProxy::Ice::Object _Base;
06451 return dynamic_cast<BuoyColorSegmentMessage*>(_Base::ice_oneway().get());
06452 #else
06453 return dynamic_cast<BuoyColorSegmentMessage*>(::IceProxy::Ice::Object::ice_oneway().get());
06454 #endif
06455 }
06456
06457 ::IceInternal::ProxyHandle<BuoyColorSegmentMessage> ice_batchOneway() const
06458 {
06459 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06460 typedef ::IceProxy::Ice::Object _Base;
06461 return dynamic_cast<BuoyColorSegmentMessage*>(_Base::ice_batchOneway().get());
06462 #else
06463 return dynamic_cast<BuoyColorSegmentMessage*>(::IceProxy::Ice::Object::ice_batchOneway().get());
06464 #endif
06465 }
06466
06467 ::IceInternal::ProxyHandle<BuoyColorSegmentMessage> ice_datagram() const
06468 {
06469 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06470 typedef ::IceProxy::Ice::Object _Base;
06471 return dynamic_cast<BuoyColorSegmentMessage*>(_Base::ice_datagram().get());
06472 #else
06473 return dynamic_cast<BuoyColorSegmentMessage*>(::IceProxy::Ice::Object::ice_datagram().get());
06474 #endif
06475 }
06476
06477 ::IceInternal::ProxyHandle<BuoyColorSegmentMessage> ice_batchDatagram() const
06478 {
06479 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06480 typedef ::IceProxy::Ice::Object _Base;
06481 return dynamic_cast<BuoyColorSegmentMessage*>(_Base::ice_batchDatagram().get());
06482 #else
06483 return dynamic_cast<BuoyColorSegmentMessage*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
06484 #endif
06485 }
06486
06487 ::IceInternal::ProxyHandle<BuoyColorSegmentMessage> ice_compress(bool __compress) const
06488 {
06489 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06490 typedef ::IceProxy::Ice::Object _Base;
06491 return dynamic_cast<BuoyColorSegmentMessage*>(_Base::ice_compress(__compress).get());
06492 #else
06493 return dynamic_cast<BuoyColorSegmentMessage*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
06494 #endif
06495 }
06496
06497 ::IceInternal::ProxyHandle<BuoyColorSegmentMessage> ice_timeout(int __timeout) const
06498 {
06499 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06500 typedef ::IceProxy::Ice::Object _Base;
06501 return dynamic_cast<BuoyColorSegmentMessage*>(_Base::ice_timeout(__timeout).get());
06502 #else
06503 return dynamic_cast<BuoyColorSegmentMessage*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
06504 #endif
06505 }
06506
06507 ::IceInternal::ProxyHandle<BuoyColorSegmentMessage> ice_connectionId(const std::string& __id) const
06508 {
06509 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06510 typedef ::IceProxy::Ice::Object _Base;
06511 return dynamic_cast<BuoyColorSegmentMessage*>(_Base::ice_connectionId(__id).get());
06512 #else
06513 return dynamic_cast<BuoyColorSegmentMessage*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
06514 #endif
06515 }
06516
06517 static const ::std::string& ice_staticId();
06518
06519 private:
06520
06521 virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
06522 virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
06523 virtual ::IceProxy::Ice::Object* __newInstance() const;
06524 };
06525
06526 class PipeColorSegmentMessage : virtual public ::IceProxy::RobotSimEvents::EventMessage
06527 {
06528 public:
06529
06530 ::IceInternal::ProxyHandle<PipeColorSegmentMessage> ice_context(const ::Ice::Context& __context) const
06531 {
06532 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06533 typedef ::IceProxy::Ice::Object _Base;
06534 return dynamic_cast<PipeColorSegmentMessage*>(_Base::ice_context(__context).get());
06535 #else
06536 return dynamic_cast<PipeColorSegmentMessage*>(::IceProxy::Ice::Object::ice_context(__context).get());
06537 #endif
06538 }
06539
06540 ::IceInternal::ProxyHandle<PipeColorSegmentMessage> ice_adapterId(const std::string& __id) const
06541 {
06542 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06543 typedef ::IceProxy::Ice::Object _Base;
06544 return dynamic_cast<PipeColorSegmentMessage*>(_Base::ice_adapterId(__id).get());
06545 #else
06546 return dynamic_cast<PipeColorSegmentMessage*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
06547 #endif
06548 }
06549
06550 ::IceInternal::ProxyHandle<PipeColorSegmentMessage> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
06551 {
06552 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06553 typedef ::IceProxy::Ice::Object _Base;
06554 return dynamic_cast<PipeColorSegmentMessage*>(_Base::ice_endpoints(__endpoints).get());
06555 #else
06556 return dynamic_cast<PipeColorSegmentMessage*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
06557 #endif
06558 }
06559
06560 ::IceInternal::ProxyHandle<PipeColorSegmentMessage> ice_locatorCacheTimeout(int __timeout) const
06561 {
06562 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06563 typedef ::IceProxy::Ice::Object _Base;
06564 return dynamic_cast<PipeColorSegmentMessage*>(_Base::ice_locatorCacheTimeout(__timeout).get());
06565 #else
06566 return dynamic_cast<PipeColorSegmentMessage*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
06567 #endif
06568 }
06569
06570 ::IceInternal::ProxyHandle<PipeColorSegmentMessage> ice_connectionCached(bool __cached) const
06571 {
06572 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06573 typedef ::IceProxy::Ice::Object _Base;
06574 return dynamic_cast<PipeColorSegmentMessage*>(_Base::ice_connectionCached(__cached).get());
06575 #else
06576 return dynamic_cast<PipeColorSegmentMessage*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
06577 #endif
06578 }
06579
06580 ::IceInternal::ProxyHandle<PipeColorSegmentMessage> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
06581 {
06582 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06583 typedef ::IceProxy::Ice::Object _Base;
06584 return dynamic_cast<PipeColorSegmentMessage*>(_Base::ice_endpointSelection(__est).get());
06585 #else
06586 return dynamic_cast<PipeColorSegmentMessage*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
06587 #endif
06588 }
06589
06590 ::IceInternal::ProxyHandle<PipeColorSegmentMessage> ice_secure(bool __secure) const
06591 {
06592 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06593 typedef ::IceProxy::Ice::Object _Base;
06594 return dynamic_cast<PipeColorSegmentMessage*>(_Base::ice_secure(__secure).get());
06595 #else
06596 return dynamic_cast<PipeColorSegmentMessage*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
06597 #endif
06598 }
06599
06600 ::IceInternal::ProxyHandle<PipeColorSegmentMessage> ice_preferSecure(bool __preferSecure) const
06601 {
06602 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06603 typedef ::IceProxy::Ice::Object _Base;
06604 return dynamic_cast<PipeColorSegmentMessage*>(_Base::ice_preferSecure(__preferSecure).get());
06605 #else
06606 return dynamic_cast<PipeColorSegmentMessage*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
06607 #endif
06608 }
06609
06610 ::IceInternal::ProxyHandle<PipeColorSegmentMessage> ice_router(const ::Ice::RouterPrx& __router) const
06611 {
06612 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06613 typedef ::IceProxy::Ice::Object _Base;
06614 return dynamic_cast<PipeColorSegmentMessage*>(_Base::ice_router(__router).get());
06615 #else
06616 return dynamic_cast<PipeColorSegmentMessage*>(::IceProxy::Ice::Object::ice_router(__router).get());
06617 #endif
06618 }
06619
06620 ::IceInternal::ProxyHandle<PipeColorSegmentMessage> ice_locator(const ::Ice::LocatorPrx& __locator) const
06621 {
06622 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06623 typedef ::IceProxy::Ice::Object _Base;
06624 return dynamic_cast<PipeColorSegmentMessage*>(_Base::ice_locator(__locator).get());
06625 #else
06626 return dynamic_cast<PipeColorSegmentMessage*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
06627 #endif
06628 }
06629
06630 ::IceInternal::ProxyHandle<PipeColorSegmentMessage> ice_collocationOptimized(bool __co) const
06631 {
06632 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06633 typedef ::IceProxy::Ice::Object _Base;
06634 return dynamic_cast<PipeColorSegmentMessage*>(_Base::ice_collocationOptimized(__co).get());
06635 #else
06636 return dynamic_cast<PipeColorSegmentMessage*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
06637 #endif
06638 }
06639
06640 ::IceInternal::ProxyHandle<PipeColorSegmentMessage> ice_twoway() const
06641 {
06642 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06643 typedef ::IceProxy::Ice::Object _Base;
06644 return dynamic_cast<PipeColorSegmentMessage*>(_Base::ice_twoway().get());
06645 #else
06646 return dynamic_cast<PipeColorSegmentMessage*>(::IceProxy::Ice::Object::ice_twoway().get());
06647 #endif
06648 }
06649
06650 ::IceInternal::ProxyHandle<PipeColorSegmentMessage> ice_oneway() const
06651 {
06652 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06653 typedef ::IceProxy::Ice::Object _Base;
06654 return dynamic_cast<PipeColorSegmentMessage*>(_Base::ice_oneway().get());
06655 #else
06656 return dynamic_cast<PipeColorSegmentMessage*>(::IceProxy::Ice::Object::ice_oneway().get());
06657 #endif
06658 }
06659
06660 ::IceInternal::ProxyHandle<PipeColorSegmentMessage> ice_batchOneway() const
06661 {
06662 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06663 typedef ::IceProxy::Ice::Object _Base;
06664 return dynamic_cast<PipeColorSegmentMessage*>(_Base::ice_batchOneway().get());
06665 #else
06666 return dynamic_cast<PipeColorSegmentMessage*>(::IceProxy::Ice::Object::ice_batchOneway().get());
06667 #endif
06668 }
06669
06670 ::IceInternal::ProxyHandle<PipeColorSegmentMessage> ice_datagram() const
06671 {
06672 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06673 typedef ::IceProxy::Ice::Object _Base;
06674 return dynamic_cast<PipeColorSegmentMessage*>(_Base::ice_datagram().get());
06675 #else
06676 return dynamic_cast<PipeColorSegmentMessage*>(::IceProxy::Ice::Object::ice_datagram().get());
06677 #endif
06678 }
06679
06680 ::IceInternal::ProxyHandle<PipeColorSegmentMessage> ice_batchDatagram() const
06681 {
06682 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06683 typedef ::IceProxy::Ice::Object _Base;
06684 return dynamic_cast<PipeColorSegmentMessage*>(_Base::ice_batchDatagram().get());
06685 #else
06686 return dynamic_cast<PipeColorSegmentMessage*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
06687 #endif
06688 }
06689
06690 ::IceInternal::ProxyHandle<PipeColorSegmentMessage> ice_compress(bool __compress) const
06691 {
06692 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06693 typedef ::IceProxy::Ice::Object _Base;
06694 return dynamic_cast<PipeColorSegmentMessage*>(_Base::ice_compress(__compress).get());
06695 #else
06696 return dynamic_cast<PipeColorSegmentMessage*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
06697 #endif
06698 }
06699
06700 ::IceInternal::ProxyHandle<PipeColorSegmentMessage> ice_timeout(int __timeout) const
06701 {
06702 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06703 typedef ::IceProxy::Ice::Object _Base;
06704 return dynamic_cast<PipeColorSegmentMessage*>(_Base::ice_timeout(__timeout).get());
06705 #else
06706 return dynamic_cast<PipeColorSegmentMessage*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
06707 #endif
06708 }
06709
06710 ::IceInternal::ProxyHandle<PipeColorSegmentMessage> ice_connectionId(const std::string& __id) const
06711 {
06712 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06713 typedef ::IceProxy::Ice::Object _Base;
06714 return dynamic_cast<PipeColorSegmentMessage*>(_Base::ice_connectionId(__id).get());
06715 #else
06716 return dynamic_cast<PipeColorSegmentMessage*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
06717 #endif
06718 }
06719
06720 static const ::std::string& ice_staticId();
06721
06722 private:
06723
06724 virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
06725 virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
06726 virtual ::IceProxy::Ice::Object* __newInstance() const;
06727 };
06728
06729 class BuoyColorSegmentConfigMessage : virtual public ::IceProxy::RobotSimEvents::EventMessage
06730 {
06731 public:
06732
06733 ::IceInternal::ProxyHandle<BuoyColorSegmentConfigMessage> ice_context(const ::Ice::Context& __context) const
06734 {
06735 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06736 typedef ::IceProxy::Ice::Object _Base;
06737 return dynamic_cast<BuoyColorSegmentConfigMessage*>(_Base::ice_context(__context).get());
06738 #else
06739 return dynamic_cast<BuoyColorSegmentConfigMessage*>(::IceProxy::Ice::Object::ice_context(__context).get());
06740 #endif
06741 }
06742
06743 ::IceInternal::ProxyHandle<BuoyColorSegmentConfigMessage> ice_adapterId(const std::string& __id) const
06744 {
06745 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06746 typedef ::IceProxy::Ice::Object _Base;
06747 return dynamic_cast<BuoyColorSegmentConfigMessage*>(_Base::ice_adapterId(__id).get());
06748 #else
06749 return dynamic_cast<BuoyColorSegmentConfigMessage*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
06750 #endif
06751 }
06752
06753 ::IceInternal::ProxyHandle<BuoyColorSegmentConfigMessage> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
06754 {
06755 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06756 typedef ::IceProxy::Ice::Object _Base;
06757 return dynamic_cast<BuoyColorSegmentConfigMessage*>(_Base::ice_endpoints(__endpoints).get());
06758 #else
06759 return dynamic_cast<BuoyColorSegmentConfigMessage*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
06760 #endif
06761 }
06762
06763 ::IceInternal::ProxyHandle<BuoyColorSegmentConfigMessage> ice_locatorCacheTimeout(int __timeout) const
06764 {
06765 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06766 typedef ::IceProxy::Ice::Object _Base;
06767 return dynamic_cast<BuoyColorSegmentConfigMessage*>(_Base::ice_locatorCacheTimeout(__timeout).get());
06768 #else
06769 return dynamic_cast<BuoyColorSegmentConfigMessage*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
06770 #endif
06771 }
06772
06773 ::IceInternal::ProxyHandle<BuoyColorSegmentConfigMessage> ice_connectionCached(bool __cached) const
06774 {
06775 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06776 typedef ::IceProxy::Ice::Object _Base;
06777 return dynamic_cast<BuoyColorSegmentConfigMessage*>(_Base::ice_connectionCached(__cached).get());
06778 #else
06779 return dynamic_cast<BuoyColorSegmentConfigMessage*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
06780 #endif
06781 }
06782
06783 ::IceInternal::ProxyHandle<BuoyColorSegmentConfigMessage> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
06784 {
06785 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06786 typedef ::IceProxy::Ice::Object _Base;
06787 return dynamic_cast<BuoyColorSegmentConfigMessage*>(_Base::ice_endpointSelection(__est).get());
06788 #else
06789 return dynamic_cast<BuoyColorSegmentConfigMessage*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
06790 #endif
06791 }
06792
06793 ::IceInternal::ProxyHandle<BuoyColorSegmentConfigMessage> ice_secure(bool __secure) const
06794 {
06795 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06796 typedef ::IceProxy::Ice::Object _Base;
06797 return dynamic_cast<BuoyColorSegmentConfigMessage*>(_Base::ice_secure(__secure).get());
06798 #else
06799 return dynamic_cast<BuoyColorSegmentConfigMessage*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
06800 #endif
06801 }
06802
06803 ::IceInternal::ProxyHandle<BuoyColorSegmentConfigMessage> ice_preferSecure(bool __preferSecure) const
06804 {
06805 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06806 typedef ::IceProxy::Ice::Object _Base;
06807 return dynamic_cast<BuoyColorSegmentConfigMessage*>(_Base::ice_preferSecure(__preferSecure).get());
06808 #else
06809 return dynamic_cast<BuoyColorSegmentConfigMessage*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
06810 #endif
06811 }
06812
06813 ::IceInternal::ProxyHandle<BuoyColorSegmentConfigMessage> ice_router(const ::Ice::RouterPrx& __router) const
06814 {
06815 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06816 typedef ::IceProxy::Ice::Object _Base;
06817 return dynamic_cast<BuoyColorSegmentConfigMessage*>(_Base::ice_router(__router).get());
06818 #else
06819 return dynamic_cast<BuoyColorSegmentConfigMessage*>(::IceProxy::Ice::Object::ice_router(__router).get());
06820 #endif
06821 }
06822
06823 ::IceInternal::ProxyHandle<BuoyColorSegmentConfigMessage> ice_locator(const ::Ice::LocatorPrx& __locator) const
06824 {
06825 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06826 typedef ::IceProxy::Ice::Object _Base;
06827 return dynamic_cast<BuoyColorSegmentConfigMessage*>(_Base::ice_locator(__locator).get());
06828 #else
06829 return dynamic_cast<BuoyColorSegmentConfigMessage*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
06830 #endif
06831 }
06832
06833 ::IceInternal::ProxyHandle<BuoyColorSegmentConfigMessage> ice_collocationOptimized(bool __co) const
06834 {
06835 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06836 typedef ::IceProxy::Ice::Object _Base;
06837 return dynamic_cast<BuoyColorSegmentConfigMessage*>(_Base::ice_collocationOptimized(__co).get());
06838 #else
06839 return dynamic_cast<BuoyColorSegmentConfigMessage*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
06840 #endif
06841 }
06842
06843 ::IceInternal::ProxyHandle<BuoyColorSegmentConfigMessage> ice_twoway() const
06844 {
06845 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06846 typedef ::IceProxy::Ice::Object _Base;
06847 return dynamic_cast<BuoyColorSegmentConfigMessage*>(_Base::ice_twoway().get());
06848 #else
06849 return dynamic_cast<BuoyColorSegmentConfigMessage*>(::IceProxy::Ice::Object::ice_twoway().get());
06850 #endif
06851 }
06852
06853 ::IceInternal::ProxyHandle<BuoyColorSegmentConfigMessage> ice_oneway() const
06854 {
06855 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06856 typedef ::IceProxy::Ice::Object _Base;
06857 return dynamic_cast<BuoyColorSegmentConfigMessage*>(_Base::ice_oneway().get());
06858 #else
06859 return dynamic_cast<BuoyColorSegmentConfigMessage*>(::IceProxy::Ice::Object::ice_oneway().get());
06860 #endif
06861 }
06862
06863 ::IceInternal::ProxyHandle<BuoyColorSegmentConfigMessage> ice_batchOneway() const
06864 {
06865 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06866 typedef ::IceProxy::Ice::Object _Base;
06867 return dynamic_cast<BuoyColorSegmentConfigMessage*>(_Base::ice_batchOneway().get());
06868 #else
06869 return dynamic_cast<BuoyColorSegmentConfigMessage*>(::IceProxy::Ice::Object::ice_batchOneway().get());
06870 #endif
06871 }
06872
06873 ::IceInternal::ProxyHandle<BuoyColorSegmentConfigMessage> ice_datagram() const
06874 {
06875 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06876 typedef ::IceProxy::Ice::Object _Base;
06877 return dynamic_cast<BuoyColorSegmentConfigMessage*>(_Base::ice_datagram().get());
06878 #else
06879 return dynamic_cast<BuoyColorSegmentConfigMessage*>(::IceProxy::Ice::Object::ice_datagram().get());
06880 #endif
06881 }
06882
06883 ::IceInternal::ProxyHandle<BuoyColorSegmentConfigMessage> ice_batchDatagram() const
06884 {
06885 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06886 typedef ::IceProxy::Ice::Object _Base;
06887 return dynamic_cast<BuoyColorSegmentConfigMessage*>(_Base::ice_batchDatagram().get());
06888 #else
06889 return dynamic_cast<BuoyColorSegmentConfigMessage*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
06890 #endif
06891 }
06892
06893 ::IceInternal::ProxyHandle<BuoyColorSegmentConfigMessage> ice_compress(bool __compress) const
06894 {
06895 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06896 typedef ::IceProxy::Ice::Object _Base;
06897 return dynamic_cast<BuoyColorSegmentConfigMessage*>(_Base::ice_compress(__compress).get());
06898 #else
06899 return dynamic_cast<BuoyColorSegmentConfigMessage*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
06900 #endif
06901 }
06902
06903 ::IceInternal::ProxyHandle<BuoyColorSegmentConfigMessage> ice_timeout(int __timeout) const
06904 {
06905 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06906 typedef ::IceProxy::Ice::Object _Base;
06907 return dynamic_cast<BuoyColorSegmentConfigMessage*>(_Base::ice_timeout(__timeout).get());
06908 #else
06909 return dynamic_cast<BuoyColorSegmentConfigMessage*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
06910 #endif
06911 }
06912
06913 ::IceInternal::ProxyHandle<BuoyColorSegmentConfigMessage> ice_connectionId(const std::string& __id) const
06914 {
06915 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06916 typedef ::IceProxy::Ice::Object _Base;
06917 return dynamic_cast<BuoyColorSegmentConfigMessage*>(_Base::ice_connectionId(__id).get());
06918 #else
06919 return dynamic_cast<BuoyColorSegmentConfigMessage*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
06920 #endif
06921 }
06922
06923 static const ::std::string& ice_staticId();
06924
06925 private:
06926
06927 virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
06928 virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
06929 virtual ::IceProxy::Ice::Object* __newInstance() const;
06930 };
06931
06932 class PipeColorSegmentConfigMessage : virtual public ::IceProxy::RobotSimEvents::EventMessage
06933 {
06934 public:
06935
06936 ::IceInternal::ProxyHandle<PipeColorSegmentConfigMessage> ice_context(const ::Ice::Context& __context) const
06937 {
06938 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06939 typedef ::IceProxy::Ice::Object _Base;
06940 return dynamic_cast<PipeColorSegmentConfigMessage*>(_Base::ice_context(__context).get());
06941 #else
06942 return dynamic_cast<PipeColorSegmentConfigMessage*>(::IceProxy::Ice::Object::ice_context(__context).get());
06943 #endif
06944 }
06945
06946 ::IceInternal::ProxyHandle<PipeColorSegmentConfigMessage> ice_adapterId(const std::string& __id) const
06947 {
06948 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06949 typedef ::IceProxy::Ice::Object _Base;
06950 return dynamic_cast<PipeColorSegmentConfigMessage*>(_Base::ice_adapterId(__id).get());
06951 #else
06952 return dynamic_cast<PipeColorSegmentConfigMessage*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
06953 #endif
06954 }
06955
06956 ::IceInternal::ProxyHandle<PipeColorSegmentConfigMessage> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
06957 {
06958 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06959 typedef ::IceProxy::Ice::Object _Base;
06960 return dynamic_cast<PipeColorSegmentConfigMessage*>(_Base::ice_endpoints(__endpoints).get());
06961 #else
06962 return dynamic_cast<PipeColorSegmentConfigMessage*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
06963 #endif
06964 }
06965
06966 ::IceInternal::ProxyHandle<PipeColorSegmentConfigMessage> ice_locatorCacheTimeout(int __timeout) const
06967 {
06968 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06969 typedef ::IceProxy::Ice::Object _Base;
06970 return dynamic_cast<PipeColorSegmentConfigMessage*>(_Base::ice_locatorCacheTimeout(__timeout).get());
06971 #else
06972 return dynamic_cast<PipeColorSegmentConfigMessage*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
06973 #endif
06974 }
06975
06976 ::IceInternal::ProxyHandle<PipeColorSegmentConfigMessage> ice_connectionCached(bool __cached) const
06977 {
06978 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06979 typedef ::IceProxy::Ice::Object _Base;
06980 return dynamic_cast<PipeColorSegmentConfigMessage*>(_Base::ice_connectionCached(__cached).get());
06981 #else
06982 return dynamic_cast<PipeColorSegmentConfigMessage*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
06983 #endif
06984 }
06985
06986 ::IceInternal::ProxyHandle<PipeColorSegmentConfigMessage> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
06987 {
06988 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06989 typedef ::IceProxy::Ice::Object _Base;
06990 return dynamic_cast<PipeColorSegmentConfigMessage*>(_Base::ice_endpointSelection(__est).get());
06991 #else
06992 return dynamic_cast<PipeColorSegmentConfigMessage*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
06993 #endif
06994 }
06995
06996 ::IceInternal::ProxyHandle<PipeColorSegmentConfigMessage> ice_secure(bool __secure) const
06997 {
06998 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
06999 typedef ::IceProxy::Ice::Object _Base;
07000 return dynamic_cast<PipeColorSegmentConfigMessage*>(_Base::ice_secure(__secure).get());
07001 #else
07002 return dynamic_cast<PipeColorSegmentConfigMessage*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
07003 #endif
07004 }
07005
07006 ::IceInternal::ProxyHandle<PipeColorSegmentConfigMessage> ice_preferSecure(bool __preferSecure) const
07007 {
07008 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
07009 typedef ::IceProxy::Ice::Object _Base;
07010 return dynamic_cast<PipeColorSegmentConfigMessage*>(_Base::ice_preferSecure(__preferSecure).get());
07011 #else
07012 return dynamic_cast<PipeColorSegmentConfigMessage*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
07013 #endif
07014 }
07015
07016 ::IceInternal::ProxyHandle<PipeColorSegmentConfigMessage> ice_router(const ::Ice::RouterPrx& __router) const
07017 {
07018 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
07019 typedef ::IceProxy::Ice::Object _Base;
07020 return dynamic_cast<PipeColorSegmentConfigMessage*>(_Base::ice_router(__router).get());
07021 #else
07022 return dynamic_cast<PipeColorSegmentConfigMessage*>(::IceProxy::Ice::Object::ice_router(__router).get());
07023 #endif
07024 }
07025
07026 ::IceInternal::ProxyHandle<PipeColorSegmentConfigMessage> ice_locator(const ::Ice::LocatorPrx& __locator) const
07027 {
07028 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
07029 typedef ::IceProxy::Ice::Object _Base;
07030 return dynamic_cast<PipeColorSegmentConfigMessage*>(_Base::ice_locator(__locator).get());
07031 #else
07032 return dynamic_cast<PipeColorSegmentConfigMessage*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
07033 #endif
07034 }
07035
07036 ::IceInternal::ProxyHandle<PipeColorSegmentConfigMessage> ice_collocationOptimized(bool __co) const
07037 {
07038 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
07039 typedef ::IceProxy::Ice::Object _Base;
07040 return dynamic_cast<PipeColorSegmentConfigMessage*>(_Base::ice_collocationOptimized(__co).get());
07041 #else
07042 return dynamic_cast<PipeColorSegmentConfigMessage*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
07043 #endif
07044 }
07045
07046 ::IceInternal::ProxyHandle<PipeColorSegmentConfigMessage> ice_twoway() const
07047 {
07048 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
07049 typedef ::IceProxy::Ice::Object _Base;
07050 return dynamic_cast<PipeColorSegmentConfigMessage*>(_Base::ice_twoway().get());
07051 #else
07052 return dynamic_cast<PipeColorSegmentConfigMessage*>(::IceProxy::Ice::Object::ice_twoway().get());
07053 #endif
07054 }
07055
07056 ::IceInternal::ProxyHandle<PipeColorSegmentConfigMessage> ice_oneway() const
07057 {
07058 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
07059 typedef ::IceProxy::Ice::Object _Base;
07060 return dynamic_cast<PipeColorSegmentConfigMessage*>(_Base::ice_oneway().get());
07061 #else
07062 return dynamic_cast<PipeColorSegmentConfigMessage*>(::IceProxy::Ice::Object::ice_oneway().get());
07063 #endif
07064 }
07065
07066 ::IceInternal::ProxyHandle<PipeColorSegmentConfigMessage> ice_batchOneway() const
07067 {
07068 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
07069 typedef ::IceProxy::Ice::Object _Base;
07070 return dynamic_cast<PipeColorSegmentConfigMessage*>(_Base::ice_batchOneway().get());
07071 #else
07072 return dynamic_cast<PipeColorSegmentConfigMessage*>(::IceProxy::Ice::Object::ice_batchOneway().get());
07073 #endif
07074 }
07075
07076 ::IceInternal::ProxyHandle<PipeColorSegmentConfigMessage> ice_datagram() const
07077 {
07078 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
07079 typedef ::IceProxy::Ice::Object _Base;
07080 return dynamic_cast<PipeColorSegmentConfigMessage*>(_Base::ice_datagram().get());
07081 #else
07082 return dynamic_cast<PipeColorSegmentConfigMessage*>(::IceProxy::Ice::Object::ice_datagram().get());
07083 #endif
07084 }
07085
07086 ::IceInternal::ProxyHandle<PipeColorSegmentConfigMessage> ice_batchDatagram() const
07087 {
07088 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
07089 typedef ::IceProxy::Ice::Object _Base;
07090 return dynamic_cast<PipeColorSegmentConfigMessage*>(_Base::ice_batchDatagram().get());
07091 #else
07092 return dynamic_cast<PipeColorSegmentConfigMessage*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
07093 #endif
07094 }
07095
07096 ::IceInternal::ProxyHandle<PipeColorSegmentConfigMessage> ice_compress(bool __compress) const
07097 {
07098 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
07099 typedef ::IceProxy::Ice::Object _Base;
07100 return dynamic_cast<PipeColorSegmentConfigMessage*>(_Base::ice_compress(__compress).get());
07101 #else
07102 return dynamic_cast<PipeColorSegmentConfigMessage*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
07103 #endif
07104 }
07105
07106 ::IceInternal::ProxyHandle<PipeColorSegmentConfigMessage> ice_timeout(int __timeout) const
07107 {
07108 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
07109 typedef ::IceProxy::Ice::Object _Base;
07110 return dynamic_cast<PipeColorSegmentConfigMessage*>(_Base::ice_timeout(__timeout).get());
07111 #else
07112 return dynamic_cast<PipeColorSegmentConfigMessage*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
07113 #endif
07114 }
07115
07116 ::IceInternal::ProxyHandle<PipeColorSegmentConfigMessage> ice_connectionId(const std::string& __id) const
07117 {
07118 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
07119 typedef ::IceProxy::Ice::Object _Base;
07120 return dynamic_cast<PipeColorSegmentConfigMessage*>(_Base::ice_connectionId(__id).get());
07121 #else
07122 return dynamic_cast<PipeColorSegmentConfigMessage*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
07123 #endif
07124 }
07125
07126 static const ::std::string& ice_staticId();
07127
07128 private:
07129
07130 virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
07131 virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
07132 virtual ::IceProxy::Ice::Object* __newInstance() const;
07133 };
07134
07135 }
07136
07137 }
07138
07139 namespace IceDelegate
07140 {
07141
07142 namespace RobotSimEvents
07143 {
07144
07145 class EventMessage : virtual public ::IceDelegate::Ice::Object
07146 {
07147 public:
07148 };
07149
07150 class Events : virtual public ::IceDelegate::Ice::Object
07151 {
07152 public:
07153
07154 virtual void updateMessage(const ::RobotSimEvents::EventMessagePtr&, const ::Ice::Context*) = 0;
07155 };
07156
07157 class ActionMessage : virtual public ::IceDelegate::RobotSimEvents::EventMessage
07158 {
07159 public:
07160 };
07161
07162 class GPSMessage : virtual public ::IceDelegate::RobotSimEvents::EventMessage
07163 {
07164 public:
07165 };
07166
07167 class MotionMessage : virtual public ::IceDelegate::RobotSimEvents::EventMessage
07168 {
07169 public:
07170 };
07171
07172 class RetinaMessage : virtual public ::IceDelegate::RobotSimEvents::EventMessage
07173 {
07174 public:
07175 };
07176
07177 class MovementControllerMessage : virtual public ::IceDelegate::RobotSimEvents::EventMessage
07178 {
07179 public:
07180 };
07181
07182 class JoyStickControlMessage : virtual public ::IceDelegate::RobotSimEvents::EventMessage
07183 {
07184 public:
07185 };
07186
07187 class BeeStemConfigMessage : virtual public ::IceDelegate::RobotSimEvents::EventMessage
07188 {
07189 public:
07190 };
07191
07192 class IMUDataServerMessage : virtual public ::IceDelegate::RobotSimEvents::EventMessage
07193 {
07194 public:
07195 };
07196
07197 class BeeStemMotorControllerMessage : virtual public ::IceDelegate::RobotSimEvents::EventMessage
07198 {
07199 public:
07200 };
07201
07202 class LocalizationMessage : virtual public ::IceDelegate::RobotSimEvents::EventMessage
07203 {
07204 public:
07205 };
07206
07207 class BeeStemMessage : virtual public ::IceDelegate::RobotSimEvents::EventMessage
07208 {
07209 public:
07210 };
07211
07212 class ChatMessage : virtual public ::IceDelegate::RobotSimEvents::EventMessage
07213 {
07214 public:
07215 };
07216
07217 class RemoteControlMessage : virtual public ::IceDelegate::RobotSimEvents::EventMessage
07218 {
07219 public:
07220 };
07221
07222 class StateMessage : virtual public ::IceDelegate::RobotSimEvents::EventMessage
07223 {
07224 public:
07225 };
07226
07227 class GoalStateMessage : virtual public ::IceDelegate::RobotSimEvents::EventMessage
07228 {
07229 public:
07230 };
07231
07232 class GoalProgressMessage : virtual public ::IceDelegate::RobotSimEvents::EventMessage
07233 {
07234 public:
07235 };
07236
07237 class AttendedRegionMessage : virtual public ::IceDelegate::RobotSimEvents::EventMessage
07238 {
07239 public:
07240 };
07241
07242 class ObjectMessage : virtual public ::IceDelegate::RobotSimEvents::EventMessage
07243 {
07244 public:
07245 };
07246
07247 class SeaBeePositionMessage : virtual public ::IceDelegate::RobotSimEvents::EventMessage
07248 {
07249 public:
07250 };
07251
07252 class SeaBeeStateConditionMessage : virtual public ::IceDelegate::RobotSimEvents::EventMessage
07253 {
07254 public:
07255 };
07256
07257 class VisionRectangleMessage : virtual public ::IceDelegate::RobotSimEvents::EventMessage
07258 {
07259 public:
07260 };
07261
07262 class StraightEdgeMessage : virtual public ::IceDelegate::RobotSimEvents::EventMessage
07263 {
07264 public:
07265 };
07266
07267 class VisionObjectMessage : virtual public ::IceDelegate::RobotSimEvents::EventMessage
07268 {
07269 public:
07270 };
07271
07272 class LandmarksMessage : virtual public ::IceDelegate::RobotSimEvents::EventMessage
07273 {
07274 public:
07275 };
07276
07277 class CameraConfigMessage : virtual public ::IceDelegate::RobotSimEvents::EventMessage
07278 {
07279 public:
07280 };
07281
07282 class SalientPointMessage : virtual public ::IceDelegate::RobotSimEvents::EventMessage
07283 {
07284 public:
07285 };
07286
07287 class BuoyColorSegmentMessage : virtual public ::IceDelegate::RobotSimEvents::EventMessage
07288 {
07289 public:
07290 };
07291
07292 class PipeColorSegmentMessage : virtual public ::IceDelegate::RobotSimEvents::EventMessage
07293 {
07294 public:
07295 };
07296
07297 class BuoyColorSegmentConfigMessage : virtual public ::IceDelegate::RobotSimEvents::EventMessage
07298 {
07299 public:
07300 };
07301
07302 class PipeColorSegmentConfigMessage : virtual public ::IceDelegate::RobotSimEvents::EventMessage
07303 {
07304 public:
07305 };
07306
07307 }
07308
07309 }
07310
07311 namespace IceDelegateM
07312 {
07313
07314 namespace RobotSimEvents
07315 {
07316
07317 class EventMessage : virtual public ::IceDelegate::RobotSimEvents::EventMessage,
07318 virtual public ::IceDelegateM::Ice::Object
07319 {
07320 public:
07321 };
07322
07323 class Events : virtual public ::IceDelegate::RobotSimEvents::Events,
07324 virtual public ::IceDelegateM::Ice::Object
07325 {
07326 public:
07327
07328 virtual void updateMessage(const ::RobotSimEvents::EventMessagePtr&, const ::Ice::Context*);
07329 };
07330
07331 class ActionMessage : virtual public ::IceDelegate::RobotSimEvents::ActionMessage,
07332 virtual public ::IceDelegateM::RobotSimEvents::EventMessage
07333 {
07334 public:
07335 };
07336
07337 class GPSMessage : virtual public ::IceDelegate::RobotSimEvents::GPSMessage,
07338 virtual public ::IceDelegateM::RobotSimEvents::EventMessage
07339 {
07340 public:
07341 };
07342
07343 class MotionMessage : virtual public ::IceDelegate::RobotSimEvents::MotionMessage,
07344 virtual public ::IceDelegateM::RobotSimEvents::EventMessage
07345 {
07346 public:
07347 };
07348
07349 class RetinaMessage : virtual public ::IceDelegate::RobotSimEvents::RetinaMessage,
07350 virtual public ::IceDelegateM::RobotSimEvents::EventMessage
07351 {
07352 public:
07353 };
07354
07355 class MovementControllerMessage : virtual public ::IceDelegate::RobotSimEvents::MovementControllerMessage,
07356 virtual public ::IceDelegateM::RobotSimEvents::EventMessage
07357 {
07358 public:
07359 };
07360
07361 class JoyStickControlMessage : virtual public ::IceDelegate::RobotSimEvents::JoyStickControlMessage,
07362 virtual public ::IceDelegateM::RobotSimEvents::EventMessage
07363 {
07364 public:
07365 };
07366
07367 class BeeStemConfigMessage : virtual public ::IceDelegate::RobotSimEvents::BeeStemConfigMessage,
07368 virtual public ::IceDelegateM::RobotSimEvents::EventMessage
07369 {
07370 public:
07371 };
07372
07373 class IMUDataServerMessage : virtual public ::IceDelegate::RobotSimEvents::IMUDataServerMessage,
07374 virtual public ::IceDelegateM::RobotSimEvents::EventMessage
07375 {
07376 public:
07377 };
07378
07379 class BeeStemMotorControllerMessage : virtual public ::IceDelegate::RobotSimEvents::BeeStemMotorControllerMessage,
07380 virtual public ::IceDelegateM::RobotSimEvents::EventMessage
07381 {
07382 public:
07383 };
07384
07385 class LocalizationMessage : virtual public ::IceDelegate::RobotSimEvents::LocalizationMessage,
07386 virtual public ::IceDelegateM::RobotSimEvents::EventMessage
07387 {
07388 public:
07389 };
07390
07391 class BeeStemMessage : virtual public ::IceDelegate::RobotSimEvents::BeeStemMessage,
07392 virtual public ::IceDelegateM::RobotSimEvents::EventMessage
07393 {
07394 public:
07395 };
07396
07397 class ChatMessage : virtual public ::IceDelegate::RobotSimEvents::ChatMessage,
07398 virtual public ::IceDelegateM::RobotSimEvents::EventMessage
07399 {
07400 public:
07401 };
07402
07403 class RemoteControlMessage : virtual public ::IceDelegate::RobotSimEvents::RemoteControlMessage,
07404 virtual public ::IceDelegateM::RobotSimEvents::EventMessage
07405 {
07406 public:
07407 };
07408
07409 class StateMessage : virtual public ::IceDelegate::RobotSimEvents::StateMessage,
07410 virtual public ::IceDelegateM::RobotSimEvents::EventMessage
07411 {
07412 public:
07413 };
07414
07415 class GoalStateMessage : virtual public ::IceDelegate::RobotSimEvents::GoalStateMessage,
07416 virtual public ::IceDelegateM::RobotSimEvents::EventMessage
07417 {
07418 public:
07419 };
07420
07421 class GoalProgressMessage : virtual public ::IceDelegate::RobotSimEvents::GoalProgressMessage,
07422 virtual public ::IceDelegateM::RobotSimEvents::EventMessage
07423 {
07424 public:
07425 };
07426
07427 class AttendedRegionMessage : virtual public ::IceDelegate::RobotSimEvents::AttendedRegionMessage,
07428 virtual public ::IceDelegateM::RobotSimEvents::EventMessage
07429 {
07430 public:
07431 };
07432
07433 class ObjectMessage : virtual public ::IceDelegate::RobotSimEvents::ObjectMessage,
07434 virtual public ::IceDelegateM::RobotSimEvents::EventMessage
07435 {
07436 public:
07437 };
07438
07439 class SeaBeePositionMessage : virtual public ::IceDelegate::RobotSimEvents::SeaBeePositionMessage,
07440 virtual public ::IceDelegateM::RobotSimEvents::EventMessage
07441 {
07442 public:
07443 };
07444
07445 class SeaBeeStateConditionMessage : virtual public ::IceDelegate::RobotSimEvents::SeaBeeStateConditionMessage,
07446 virtual public ::IceDelegateM::RobotSimEvents::EventMessage
07447 {
07448 public:
07449 };
07450
07451 class VisionRectangleMessage : virtual public ::IceDelegate::RobotSimEvents::VisionRectangleMessage,
07452 virtual public ::IceDelegateM::RobotSimEvents::EventMessage
07453 {
07454 public:
07455 };
07456
07457 class StraightEdgeMessage : virtual public ::IceDelegate::RobotSimEvents::StraightEdgeMessage,
07458 virtual public ::IceDelegateM::RobotSimEvents::EventMessage
07459 {
07460 public:
07461 };
07462
07463 class VisionObjectMessage : virtual public ::IceDelegate::RobotSimEvents::VisionObjectMessage,
07464 virtual public ::IceDelegateM::RobotSimEvents::EventMessage
07465 {
07466 public:
07467 };
07468
07469 class LandmarksMessage : virtual public ::IceDelegate::RobotSimEvents::LandmarksMessage,
07470 virtual public ::IceDelegateM::RobotSimEvents::EventMessage
07471 {
07472 public:
07473 };
07474
07475 class CameraConfigMessage : virtual public ::IceDelegate::RobotSimEvents::CameraConfigMessage,
07476 virtual public ::IceDelegateM::RobotSimEvents::EventMessage
07477 {
07478 public:
07479 };
07480
07481 class SalientPointMessage : virtual public ::IceDelegate::RobotSimEvents::SalientPointMessage,
07482 virtual public ::IceDelegateM::RobotSimEvents::EventMessage
07483 {
07484 public:
07485 };
07486
07487 class BuoyColorSegmentMessage : virtual public ::IceDelegate::RobotSimEvents::BuoyColorSegmentMessage,
07488 virtual public ::IceDelegateM::RobotSimEvents::EventMessage
07489 {
07490 public:
07491 };
07492
07493 class PipeColorSegmentMessage : virtual public ::IceDelegate::RobotSimEvents::PipeColorSegmentMessage,
07494 virtual public ::IceDelegateM::RobotSimEvents::EventMessage
07495 {
07496 public:
07497 };
07498
07499 class BuoyColorSegmentConfigMessage : virtual public ::IceDelegate::RobotSimEvents::BuoyColorSegmentConfigMessage,
07500 virtual public ::IceDelegateM::RobotSimEvents::EventMessage
07501 {
07502 public:
07503 };
07504
07505 class PipeColorSegmentConfigMessage : virtual public ::IceDelegate::RobotSimEvents::PipeColorSegmentConfigMessage,
07506 virtual public ::IceDelegateM::RobotSimEvents::EventMessage
07507 {
07508 public:
07509 };
07510
07511 }
07512
07513 }
07514
07515 namespace IceDelegateD
07516 {
07517
07518 namespace RobotSimEvents
07519 {
07520
07521 class EventMessage : virtual public ::IceDelegate::RobotSimEvents::EventMessage,
07522 virtual public ::IceDelegateD::Ice::Object
07523 {
07524 public:
07525 };
07526
07527 class Events : virtual public ::IceDelegate::RobotSimEvents::Events,
07528 virtual public ::IceDelegateD::Ice::Object
07529 {
07530 public:
07531
07532 virtual void updateMessage(const ::RobotSimEvents::EventMessagePtr&, const ::Ice::Context*);
07533 };
07534
07535 class ActionMessage : virtual public ::IceDelegate::RobotSimEvents::ActionMessage,
07536 virtual public ::IceDelegateD::RobotSimEvents::EventMessage
07537 {
07538 public:
07539 };
07540
07541 class GPSMessage : virtual public ::IceDelegate::RobotSimEvents::GPSMessage,
07542 virtual public ::IceDelegateD::RobotSimEvents::EventMessage
07543 {
07544 public:
07545 };
07546
07547 class MotionMessage : virtual public ::IceDelegate::RobotSimEvents::MotionMessage,
07548 virtual public ::IceDelegateD::RobotSimEvents::EventMessage
07549 {
07550 public:
07551 };
07552
07553 class RetinaMessage : virtual public ::IceDelegate::RobotSimEvents::RetinaMessage,
07554 virtual public ::IceDelegateD::RobotSimEvents::EventMessage
07555 {
07556 public:
07557 };
07558
07559 class MovementControllerMessage : virtual public ::IceDelegate::RobotSimEvents::MovementControllerMessage,
07560 virtual public ::IceDelegateD::RobotSimEvents::EventMessage
07561 {
07562 public:
07563 };
07564
07565 class JoyStickControlMessage : virtual public ::IceDelegate::RobotSimEvents::JoyStickControlMessage,
07566 virtual public ::IceDelegateD::RobotSimEvents::EventMessage
07567 {
07568 public:
07569 };
07570
07571 class BeeStemConfigMessage : virtual public ::IceDelegate::RobotSimEvents::BeeStemConfigMessage,
07572 virtual public ::IceDelegateD::RobotSimEvents::EventMessage
07573 {
07574 public:
07575 };
07576
07577 class IMUDataServerMessage : virtual public ::IceDelegate::RobotSimEvents::IMUDataServerMessage,
07578 virtual public ::IceDelegateD::RobotSimEvents::EventMessage
07579 {
07580 public:
07581 };
07582
07583 class BeeStemMotorControllerMessage : virtual public ::IceDelegate::RobotSimEvents::BeeStemMotorControllerMessage,
07584 virtual public ::IceDelegateD::RobotSimEvents::EventMessage
07585 {
07586 public:
07587 };
07588
07589 class LocalizationMessage : virtual public ::IceDelegate::RobotSimEvents::LocalizationMessage,
07590 virtual public ::IceDelegateD::RobotSimEvents::EventMessage
07591 {
07592 public:
07593 };
07594
07595 class BeeStemMessage : virtual public ::IceDelegate::RobotSimEvents::BeeStemMessage,
07596 virtual public ::IceDelegateD::RobotSimEvents::EventMessage
07597 {
07598 public:
07599 };
07600
07601 class ChatMessage : virtual public ::IceDelegate::RobotSimEvents::ChatMessage,
07602 virtual public ::IceDelegateD::RobotSimEvents::EventMessage
07603 {
07604 public:
07605 };
07606
07607 class RemoteControlMessage : virtual public ::IceDelegate::RobotSimEvents::RemoteControlMessage,
07608 virtual public ::IceDelegateD::RobotSimEvents::EventMessage
07609 {
07610 public:
07611 };
07612
07613 class StateMessage : virtual public ::IceDelegate::RobotSimEvents::StateMessage,
07614 virtual public ::IceDelegateD::RobotSimEvents::EventMessage
07615 {
07616 public:
07617 };
07618
07619 class GoalStateMessage : virtual public ::IceDelegate::RobotSimEvents::GoalStateMessage,
07620 virtual public ::IceDelegateD::RobotSimEvents::EventMessage
07621 {
07622 public:
07623 };
07624
07625 class GoalProgressMessage : virtual public ::IceDelegate::RobotSimEvents::GoalProgressMessage,
07626 virtual public ::IceDelegateD::RobotSimEvents::EventMessage
07627 {
07628 public:
07629 };
07630
07631 class AttendedRegionMessage : virtual public ::IceDelegate::RobotSimEvents::AttendedRegionMessage,
07632 virtual public ::IceDelegateD::RobotSimEvents::EventMessage
07633 {
07634 public:
07635 };
07636
07637 class ObjectMessage : virtual public ::IceDelegate::RobotSimEvents::ObjectMessage,
07638 virtual public ::IceDelegateD::RobotSimEvents::EventMessage
07639 {
07640 public:
07641 };
07642
07643 class SeaBeePositionMessage : virtual public ::IceDelegate::RobotSimEvents::SeaBeePositionMessage,
07644 virtual public ::IceDelegateD::RobotSimEvents::EventMessage
07645 {
07646 public:
07647 };
07648
07649 class SeaBeeStateConditionMessage : virtual public ::IceDelegate::RobotSimEvents::SeaBeeStateConditionMessage,
07650 virtual public ::IceDelegateD::RobotSimEvents::EventMessage
07651 {
07652 public:
07653 };
07654
07655 class VisionRectangleMessage : virtual public ::IceDelegate::RobotSimEvents::VisionRectangleMessage,
07656 virtual public ::IceDelegateD::RobotSimEvents::EventMessage
07657 {
07658 public:
07659 };
07660
07661 class StraightEdgeMessage : virtual public ::IceDelegate::RobotSimEvents::StraightEdgeMessage,
07662 virtual public ::IceDelegateD::RobotSimEvents::EventMessage
07663 {
07664 public:
07665 };
07666
07667 class VisionObjectMessage : virtual public ::IceDelegate::RobotSimEvents::VisionObjectMessage,
07668 virtual public ::IceDelegateD::RobotSimEvents::EventMessage
07669 {
07670 public:
07671 };
07672
07673 class LandmarksMessage : virtual public ::IceDelegate::RobotSimEvents::LandmarksMessage,
07674 virtual public ::IceDelegateD::RobotSimEvents::EventMessage
07675 {
07676 public:
07677 };
07678
07679 class CameraConfigMessage : virtual public ::IceDelegate::RobotSimEvents::CameraConfigMessage,
07680 virtual public ::IceDelegateD::RobotSimEvents::EventMessage
07681 {
07682 public:
07683 };
07684
07685 class SalientPointMessage : virtual public ::IceDelegate::RobotSimEvents::SalientPointMessage,
07686 virtual public ::IceDelegateD::RobotSimEvents::EventMessage
07687 {
07688 public:
07689 };
07690
07691 class BuoyColorSegmentMessage : virtual public ::IceDelegate::RobotSimEvents::BuoyColorSegmentMessage,
07692 virtual public ::IceDelegateD::RobotSimEvents::EventMessage
07693 {
07694 public:
07695 };
07696
07697 class PipeColorSegmentMessage : virtual public ::IceDelegate::RobotSimEvents::PipeColorSegmentMessage,
07698 virtual public ::IceDelegateD::RobotSimEvents::EventMessage
07699 {
07700 public:
07701 };
07702
07703 class BuoyColorSegmentConfigMessage : virtual public ::IceDelegate::RobotSimEvents::BuoyColorSegmentConfigMessage,
07704 virtual public ::IceDelegateD::RobotSimEvents::EventMessage
07705 {
07706 public:
07707 };
07708
07709 class PipeColorSegmentConfigMessage : virtual public ::IceDelegate::RobotSimEvents::PipeColorSegmentConfigMessage,
07710 virtual public ::IceDelegateD::RobotSimEvents::EventMessage
07711 {
07712 public:
07713 };
07714
07715 }
07716
07717 }
07718
07719 namespace RobotSimEvents
07720 {
07721
07722 class EventMessage : virtual public ::Ice::Object
07723 {
07724 public:
07725
07726 typedef EventMessagePrx ProxyType;
07727 typedef EventMessagePtr PointerType;
07728
07729 EventMessage() {}
07730 virtual ::Ice::ObjectPtr ice_clone() const;
07731
07732 virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
07733 virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
07734 virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
07735 static const ::std::string& ice_staticId();
07736
07737 virtual void __write(::IceInternal::BasicStream*) const;
07738 virtual void __read(::IceInternal::BasicStream*, bool);
07739 virtual void __write(const ::Ice::OutputStreamPtr&) const;
07740 virtual void __read(const ::Ice::InputStreamPtr&, bool);
07741
07742 static const ::Ice::ObjectFactoryPtr& ice_factory();
07743
07744 protected:
07745
07746 virtual ~EventMessage() {}
07747
07748 friend class EventMessage__staticInit;
07749 };
07750
07751 class EventMessage__staticInit
07752 {
07753 public:
07754
07755 ::RobotSimEvents::EventMessage _init;
07756 };
07757
07758 static EventMessage__staticInit _EventMessage_init;
07759
07760 class Events : virtual public ::Ice::Object
07761 {
07762 public:
07763
07764 typedef EventsPrx ProxyType;
07765 typedef EventsPtr PointerType;
07766
07767 virtual ::Ice::ObjectPtr ice_clone() const;
07768
07769 virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
07770 virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
07771 virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
07772 static const ::std::string& ice_staticId();
07773
07774 virtual void updateMessage(const ::RobotSimEvents::EventMessagePtr&, const ::Ice::Current& = ::Ice::Current()) = 0;
07775 ::Ice::DispatchStatus ___updateMessage(::IceInternal::Incoming&, const ::Ice::Current&);
07776
07777 virtual ::Ice::DispatchStatus __dispatch(::IceInternal::Incoming&, const ::Ice::Current&);
07778
07779 virtual void __write(::IceInternal::BasicStream*) const;
07780 virtual void __read(::IceInternal::BasicStream*, bool);
07781 virtual void __write(const ::Ice::OutputStreamPtr&) const;
07782 virtual void __read(const ::Ice::InputStreamPtr&, bool);
07783 };
07784
07785 class ActionMessage : virtual public ::RobotSimEvents::EventMessage
07786 {
07787 public:
07788
07789 typedef ActionMessagePrx ProxyType;
07790 typedef ActionMessagePtr PointerType;
07791
07792 ActionMessage() {}
07793 ActionMessage(::Ice::Float, ::Ice::Float);
07794 virtual ::Ice::ObjectPtr ice_clone() const;
07795
07796 virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
07797 virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
07798 virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
07799 static const ::std::string& ice_staticId();
07800
07801
07802 virtual void __write(::IceInternal::BasicStream*) const;
07803 virtual void __read(::IceInternal::BasicStream*, bool);
07804 virtual void __write(const ::Ice::OutputStreamPtr&) const;
07805 virtual void __read(const ::Ice::InputStreamPtr&, bool);
07806
07807 static const ::Ice::ObjectFactoryPtr& ice_factory();
07808
07809 protected:
07810
07811 virtual ~ActionMessage() {}
07812
07813 public:
07814
07815 ::Ice::Float transVel;
07816
07817 ::Ice::Float rotVel;
07818 };
07819
07820 class GPSMessage : virtual public ::RobotSimEvents::EventMessage
07821 {
07822 public:
07823
07824 typedef GPSMessagePrx ProxyType;
07825 typedef GPSMessagePtr PointerType;
07826
07827 GPSMessage() {}
07828 GPSMessage(::Ice::Float, ::Ice::Float, ::Ice::Float);
07829 virtual ::Ice::ObjectPtr ice_clone() const;
07830
07831 virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
07832 virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
07833 virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
07834 static const ::std::string& ice_staticId();
07835
07836
07837 virtual void __write(::IceInternal::BasicStream*) const;
07838 virtual void __read(::IceInternal::BasicStream*, bool);
07839 virtual void __write(const ::Ice::OutputStreamPtr&) const;
07840 virtual void __read(const ::Ice::InputStreamPtr&, bool);
07841
07842 static const ::Ice::ObjectFactoryPtr& ice_factory();
07843
07844 protected:
07845
07846 virtual ~GPSMessage() {}
07847
07848 public:
07849
07850 ::Ice::Float xPos;
07851
07852 ::Ice::Float yPos;
07853
07854 ::Ice::Float orientation;
07855 };
07856
07857 class MotionMessage : virtual public ::RobotSimEvents::EventMessage
07858 {
07859 public:
07860
07861 typedef MotionMessagePrx ProxyType;
07862 typedef MotionMessagePtr PointerType;
07863
07864 MotionMessage() {}
07865 MotionMessage(::Ice::Float, ::Ice::Float);
07866 virtual ::Ice::ObjectPtr ice_clone() const;
07867
07868 virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
07869 virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
07870 virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
07871 static const ::std::string& ice_staticId();
07872
07873
07874 virtual void __write(::IceInternal::BasicStream*) const;
07875 virtual void __read(::IceInternal::BasicStream*, bool);
07876 virtual void __write(const ::Ice::OutputStreamPtr&) const;
07877 virtual void __read(const ::Ice::InputStreamPtr&, bool);
07878
07879 static const ::Ice::ObjectFactoryPtr& ice_factory();
07880
07881 protected:
07882
07883 virtual ~MotionMessage() {}
07884
07885 public:
07886
07887 ::Ice::Float distance;
07888
07889 ::Ice::Float angle;
07890 };
07891
07892 class RetinaMessage : virtual public ::RobotSimEvents::EventMessage
07893 {
07894 public:
07895
07896 typedef RetinaMessagePrx ProxyType;
07897 typedef RetinaMessagePtr PointerType;
07898
07899 RetinaMessage() {}
07900 RetinaMessage(const ::ImageIceMod::ImageIce&, const ::std::string&);
07901 virtual ::Ice::ObjectPtr ice_clone() const;
07902
07903 virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
07904 virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
07905 virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
07906 static const ::std::string& ice_staticId();
07907
07908
07909 virtual void __write(::IceInternal::BasicStream*) const;
07910 virtual void __read(::IceInternal::BasicStream*, bool);
07911 virtual void __write(const ::Ice::OutputStreamPtr&) const;
07912 virtual void __read(const ::Ice::InputStreamPtr&, bool);
07913
07914 static const ::Ice::ObjectFactoryPtr& ice_factory();
07915
07916 protected:
07917
07918 virtual ~RetinaMessage() {}
07919
07920 public:
07921
07922 ::ImageIceMod::ImageIce img;
07923
07924 ::std::string cameraID;
07925 };
07926
07927 class MovementControllerMessage : virtual public ::RobotSimEvents::EventMessage
07928 {
07929 public:
07930
07931 typedef MovementControllerMessagePrx ProxyType;
07932 typedef MovementControllerMessagePtr PointerType;
07933
07934 MovementControllerMessage() {}
07935 MovementControllerMessage(const ::RobotSimEvents::SensorVoteVector&, ::Ice::Float, ::Ice::Float);
07936 virtual ::Ice::ObjectPtr ice_clone() const;
07937
07938 virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
07939 virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
07940 virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
07941 static const ::std::string& ice_staticId();
07942
07943
07944 virtual void __write(::IceInternal::BasicStream*) const;
07945 virtual void __read(::IceInternal::BasicStream*, bool);
07946 virtual void __write(const ::Ice::OutputStreamPtr&) const;
07947 virtual void __read(const ::Ice::InputStreamPtr&, bool);
07948
07949 static const ::Ice::ObjectFactoryPtr& ice_factory();
07950
07951 protected:
07952
07953 virtual ~MovementControllerMessage() {}
07954
07955 public:
07956
07957 ::RobotSimEvents::SensorVoteVector votes;
07958
07959 ::Ice::Float compositeHeading;
07960
07961 ::Ice::Float compositeDepth;
07962 };
07963
07964 class JoyStickControlMessage : virtual public ::RobotSimEvents::EventMessage
07965 {
07966 public:
07967
07968 typedef JoyStickControlMessagePrx ProxyType;
07969 typedef JoyStickControlMessagePtr PointerType;
07970
07971 JoyStickControlMessage() {}
07972 JoyStickControlMessage(const ::std::string&, ::Ice::Int, ::Ice::Int, ::Ice::Int, ::Ice::Int);
07973 virtual ::Ice::ObjectPtr ice_clone() const;
07974
07975 virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
07976 virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
07977 virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
07978 static const ::std::string& ice_staticId();
07979
07980
07981 virtual void __write(::IceInternal::BasicStream*) const;
07982 virtual void __read(::IceInternal::BasicStream*, bool);
07983 virtual void __write(const ::Ice::OutputStreamPtr&) const;
07984 virtual void __read(const ::Ice::InputStreamPtr&, bool);
07985
07986 static const ::Ice::ObjectFactoryPtr& ice_factory();
07987
07988 protected:
07989
07990 virtual ~JoyStickControlMessage() {}
07991
07992 public:
07993
07994 ::std::string axisName;
07995
07996 ::Ice::Int axis;
07997
07998 ::Ice::Int axisVal;
07999
08000 ::Ice::Int button;
08001
08002 ::Ice::Int butVal;
08003 };
08004
08005 class BeeStemConfigMessage : virtual public ::RobotSimEvents::EventMessage
08006 {
08007 public:
08008
08009 typedef BeeStemConfigMessagePrx ProxyType;
08010 typedef BeeStemConfigMessagePtr PointerType;
08011
08012 BeeStemConfigMessage() {}
08013 BeeStemConfigMessage(::Ice::Int, ::Ice::Int, ::Ice::Int, ::Ice::Int, ::Ice::Int, ::Ice::Float, ::Ice::Float, ::Ice::Float, ::Ice::Float, ::Ice::Int, ::Ice::Float, ::Ice::Float, ::Ice::Float, ::Ice::Float, ::Ice::Int, ::Ice::Int, ::Ice::Int);
08014 virtual ::Ice::ObjectPtr ice_clone() const;
08015
08016 virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
08017 virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
08018 virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
08019 static const ::std::string& ice_staticId();
08020
08021
08022 virtual void __write(::IceInternal::BasicStream*) const;
08023 virtual void __read(::IceInternal::BasicStream*, bool);
08024 virtual void __write(const ::Ice::OutputStreamPtr&) const;
08025 virtual void __read(const ::Ice::InputStreamPtr&, bool);
08026
08027 static const ::Ice::ObjectFactoryPtr& ice_factory();
08028
08029 protected:
08030
08031 virtual ~BeeStemConfigMessage() {}
08032
08033 public:
08034
08035 ::Ice::Int deviceToFire;
08036
08037 ::Ice::Int desiredHeading;
08038
08039 ::Ice::Int desiredDepth;
08040
08041 ::Ice::Int desiredSpeed;
08042
08043 ::Ice::Int updateDesiredValue;
08044
08045 ::Ice::Float headingK;
08046
08047 ::Ice::Float headingP;
08048
08049 ::Ice::Float headingI;
08050
08051 ::Ice::Float headingD;
08052
08053 ::Ice::Int updateHeadingPID;
08054
08055 ::Ice::Float depthK;
08056
08057 ::Ice::Float depthP;
08058
08059 ::Ice::Float depthI;
08060
08061 ::Ice::Float depthD;
08062
08063 ::Ice::Int updateDepthPID;
08064
08065 ::Ice::Int enablePID;
08066
08067 ::Ice::Int enableVal;
08068 };
08069
08070 class IMUDataServerMessage : virtual public ::RobotSimEvents::EventMessage
08071 {
08072 public:
08073
08074 typedef IMUDataServerMessagePrx ProxyType;
08075 typedef IMUDataServerMessagePtr PointerType;
08076
08077 IMUDataServerMessage() {}
08078 IMUDataServerMessage(::Ice::Double, const ::ImageIceMod::Point3DIce&, const ::ImageIceMod::Point3DIce&, const ::ImageIceMod::Point3DIce&, ::Ice::Int, const ::RobotSimEvents::FloatVector&);
08079 virtual ::Ice::ObjectPtr ice_clone() const;
08080
08081 virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
08082 virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
08083 virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
08084 static const ::std::string& ice_staticId();
08085
08086
08087 virtual void __write(::IceInternal::BasicStream*) const;
08088 virtual void __read(::IceInternal::BasicStream*, bool);
08089 virtual void __write(const ::Ice::OutputStreamPtr&) const;
08090 virtual void __read(const ::Ice::InputStreamPtr&, bool);
08091
08092 static const ::Ice::ObjectFactoryPtr& ice_factory();
08093
08094 protected:
08095
08096 virtual ~IMUDataServerMessage() {}
08097
08098 public:
08099
08100 ::Ice::Double temp;
08101
08102 ::ImageIceMod::Point3DIce accel;
08103
08104 ::ImageIceMod::Point3DIce gyro;
08105
08106 ::ImageIceMod::Point3DIce mag;
08107
08108 ::Ice::Int angleMode;
08109
08110 ::RobotSimEvents::FloatVector orientation;
08111 };
08112
08113 class BeeStemMotorControllerMessage : virtual public ::RobotSimEvents::EventMessage
08114 {
08115 public:
08116
08117 typedef BeeStemMotorControllerMessagePrx ProxyType;
08118 typedef BeeStemMotorControllerMessagePtr PointerType;
08119
08120 BeeStemMotorControllerMessage() {}
08121 BeeStemMotorControllerMessage(const ::RobotSimEvents::IntVector&, const ::RobotSimEvents::IntVector&);
08122 virtual ::Ice::ObjectPtr ice_clone() const;
08123
08124 virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
08125 virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
08126 virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
08127 static const ::std::string& ice_staticId();
08128
08129
08130 virtual void __write(::IceInternal::BasicStream*) const;
08131 virtual void __read(::IceInternal::BasicStream*, bool);
08132 virtual void __write(const ::Ice::OutputStreamPtr&) const;
08133 virtual void __read(const ::Ice::InputStreamPtr&, bool);
08134
08135 static const ::Ice::ObjectFactoryPtr& ice_factory();
08136
08137 protected:
08138
08139 virtual ~BeeStemMotorControllerMessage() {}
08140
08141 public:
08142
08143 ::RobotSimEvents::IntVector mask;
08144
08145 ::RobotSimEvents::IntVector values;
08146 };
08147
08148 class LocalizationMessage : virtual public ::RobotSimEvents::EventMessage
08149 {
08150 public:
08151
08152 typedef LocalizationMessagePrx ProxyType;
08153 typedef LocalizationMessagePtr PointerType;
08154
08155 LocalizationMessage() {}
08156 LocalizationMessage(const ::ImageIceMod::Point2DIce&, ::Ice::Float, ::Ice::Int, const ::ImageIceMod::WaypointIce&);
08157 virtual ::Ice::ObjectPtr ice_clone() const;
08158
08159 virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
08160 virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
08161 virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
08162 static const ::std::string& ice_staticId();
08163
08164
08165 virtual void __write(::IceInternal::BasicStream*) const;
08166 virtual void __read(::IceInternal::BasicStream*, bool);
08167 virtual void __write(const ::Ice::OutputStreamPtr&) const;
08168 virtual void __read(const ::Ice::InputStreamPtr&, bool);
08169
08170 static const ::Ice::ObjectFactoryPtr& ice_factory();
08171
08172 protected:
08173
08174 virtual ~LocalizationMessage() {}
08175
08176 public:
08177
08178 ::ImageIceMod::Point2DIce pos;
08179
08180 ::Ice::Float heading;
08181
08182 ::Ice::Int mode;
08183
08184 ::ImageIceMod::WaypointIce currentWaypoint;
08185 };
08186
08187 class BeeStemMessage : virtual public ::RobotSimEvents::EventMessage
08188 {
08189 public:
08190
08191 typedef BeeStemMessagePrx ProxyType;
08192 typedef BeeStemMessagePtr PointerType;
08193
08194 BeeStemMessage() {}
08195 BeeStemMessage(::Ice::Int, ::Ice::Int, ::Ice::Int, ::Ice::Int, ::Ice::Int, ::Ice::Int, ::Ice::Int, ::Ice::Int, ::Ice::Int, ::Ice::Int, ::Ice::Int, ::Ice::Int, ::Ice::Int, ::Ice::Int, ::Ice::Int, ::Ice::Int, ::Ice::Int, ::Ice::Int, ::Ice::Int, ::Ice::Int, ::Ice::Int, ::Ice::Int, ::Ice::Int, ::Ice::Int, ::Ice::Int, ::Ice::Int, ::Ice::Int, ::Ice::Int);
08196 virtual ::Ice::ObjectPtr ice_clone() const;
08197
08198 virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
08199 virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
08200 virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
08201 static const ::std::string& ice_staticId();
08202
08203
08204 virtual void __write(::IceInternal::BasicStream*) const;
08205 virtual void __read(::IceInternal::BasicStream*, bool);
08206 virtual void __write(const ::Ice::OutputStreamPtr&) const;
08207 virtual void __read(const ::Ice::InputStreamPtr&, bool);
08208
08209 static const ::Ice::ObjectFactoryPtr& ice_factory();
08210
08211 protected:
08212
08213 virtual ~BeeStemMessage() {}
08214
08215 public:
08216
08217 ::Ice::Int accelX;
08218
08219 ::Ice::Int accelY;
08220
08221 ::Ice::Int accelZ;
08222
08223 ::Ice::Int compassHeading;
08224
08225 ::Ice::Int compassPitch;
08226
08227 ::Ice::Int compassRoll;
08228
08229 ::Ice::Int internalPressure;
08230
08231 ::Ice::Int externalPressure;
08232
08233 ::Ice::Int desiredHeading;
08234
08235 ::Ice::Int desiredDepth;
08236
08237 ::Ice::Int desiredSpeed;
08238
08239 ::Ice::Int headingK;
08240
08241 ::Ice::Int headingP;
08242
08243 ::Ice::Int headingD;
08244
08245 ::Ice::Int headingI;
08246
08247 ::Ice::Int headingOutput;
08248
08249 ::Ice::Int depthK;
08250
08251 ::Ice::Int depthP;
08252
08253 ::Ice::Int depthD;
08254
08255 ::Ice::Int depthI;
08256
08257 ::Ice::Int depthOutput;
08258
08259 ::Ice::Int thruster1;
08260
08261 ::Ice::Int thruster2;
08262
08263 ::Ice::Int thruster3;
08264
08265 ::Ice::Int thruster4;
08266
08267 ::Ice::Int thruster5;
08268
08269 ::Ice::Int thruster6;
08270
08271 ::Ice::Int killSwitch;
08272 };
08273
08274 class ChatMessage : virtual public ::RobotSimEvents::EventMessage
08275 {
08276 public:
08277
08278 typedef ChatMessagePrx ProxyType;
08279 typedef ChatMessagePtr PointerType;
08280
08281 ChatMessage() {}
08282 ChatMessage(const ::std::string&, const ::std::string&);
08283 virtual ::Ice::ObjectPtr ice_clone() const;
08284
08285 virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
08286 virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
08287 virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
08288 static const ::std::string& ice_staticId();
08289
08290
08291 virtual void __write(::IceInternal::BasicStream*) const;
08292 virtual void __read(::IceInternal::BasicStream*, bool);
08293 virtual void __write(const ::Ice::OutputStreamPtr&) const;
08294 virtual void __read(const ::Ice::InputStreamPtr&, bool);
08295
08296 static const ::Ice::ObjectFactoryPtr& ice_factory();
08297
08298 protected:
08299
08300 virtual ~ChatMessage() {}
08301
08302 public:
08303
08304 ::std::string text;
08305
08306 ::std::string from;
08307 };
08308
08309 class RemoteControlMessage : virtual public ::RobotSimEvents::EventMessage
08310 {
08311 public:
08312
08313 typedef RemoteControlMessagePrx ProxyType;
08314 typedef RemoteControlMessagePtr PointerType;
08315
08316 RemoteControlMessage() {}
08317 RemoteControlMessage(::Ice::Int, ::Ice::Int, ::Ice::Int);
08318 virtual ::Ice::ObjectPtr ice_clone() const;
08319
08320 virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
08321 virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
08322 virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
08323 static const ::std::string& ice_staticId();
08324
08325
08326 virtual void __write(::IceInternal::BasicStream*) const;
08327 virtual void __read(::IceInternal::BasicStream*, bool);
08328 virtual void __write(const ::Ice::OutputStreamPtr&) const;
08329 virtual void __read(const ::Ice::InputStreamPtr&, bool);
08330
08331 static const ::Ice::ObjectFactoryPtr& ice_factory();
08332
08333 protected:
08334
08335 virtual ~RemoteControlMessage() {}
08336
08337 public:
08338
08339 ::Ice::Int x;
08340
08341 ::Ice::Int y;
08342
08343 ::Ice::Int imgStreamId;
08344 };
08345
08346 class StateMessage : virtual public ::RobotSimEvents::EventMessage
08347 {
08348 public:
08349
08350 typedef StateMessagePrx ProxyType;
08351 typedef StateMessagePtr PointerType;
08352
08353 StateMessage() {}
08354 StateMessage(::Ice::Float, ::Ice::Float, ::Ice::Float);
08355 virtual ::Ice::ObjectPtr ice_clone() const;
08356
08357 virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
08358 virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
08359 virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
08360 static const ::std::string& ice_staticId();
08361
08362
08363 virtual void __write(::IceInternal::BasicStream*) const;
08364 virtual void __read(::IceInternal::BasicStream*, bool);
08365 virtual void __write(const ::Ice::OutputStreamPtr&) const;
08366 virtual void __read(const ::Ice::InputStreamPtr&, bool);
08367
08368 static const ::Ice::ObjectFactoryPtr& ice_factory();
08369
08370 protected:
08371
08372 virtual ~StateMessage() {}
08373
08374 public:
08375
08376 ::Ice::Float xPos;
08377
08378 ::Ice::Float yPos;
08379
08380 ::Ice::Float orientation;
08381 };
08382
08383 class GoalStateMessage : virtual public ::RobotSimEvents::EventMessage
08384 {
08385 public:
08386
08387 typedef GoalStateMessagePrx ProxyType;
08388 typedef GoalStateMessagePtr PointerType;
08389
08390 GoalStateMessage() {}
08391 GoalStateMessage(::Ice::Float, ::Ice::Float, ::Ice::Float);
08392 virtual ::Ice::ObjectPtr ice_clone() const;
08393
08394 virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
08395 virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
08396 virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
08397 static const ::std::string& ice_staticId();
08398
08399
08400 virtual void __write(::IceInternal::BasicStream*) const;
08401 virtual void __read(::IceInternal::BasicStream*, bool);
08402 virtual void __write(const ::Ice::OutputStreamPtr&) const;
08403 virtual void __read(const ::Ice::InputStreamPtr&, bool);
08404
08405 static const ::Ice::ObjectFactoryPtr& ice_factory();
08406
08407 protected:
08408
08409 virtual ~GoalStateMessage() {}
08410
08411 public:
08412
08413 ::Ice::Float xPos;
08414
08415 ::Ice::Float yPos;
08416
08417 ::Ice::Float orientation;
08418 };
08419
08420 class GoalProgressMessage : virtual public ::RobotSimEvents::EventMessage
08421 {
08422 public:
08423
08424 typedef GoalProgressMessagePrx ProxyType;
08425 typedef GoalProgressMessagePtr PointerType;
08426
08427 GoalProgressMessage() {}
08428 explicit GoalProgressMessage(::Ice::Float);
08429 virtual ::Ice::ObjectPtr ice_clone() const;
08430
08431 virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
08432 virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
08433 virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
08434 static const ::std::string& ice_staticId();
08435
08436
08437 virtual void __write(::IceInternal::BasicStream*) const;
08438 virtual void __read(::IceInternal::BasicStream*, bool);
08439 virtual void __write(const ::Ice::OutputStreamPtr&) const;
08440 virtual void __read(const ::Ice::InputStreamPtr&, bool);
08441
08442 static const ::Ice::ObjectFactoryPtr& ice_factory();
08443
08444 protected:
08445
08446 virtual ~GoalProgressMessage() {}
08447
08448 public:
08449
08450 ::Ice::Float err;
08451 };
08452
08453 class AttendedRegionMessage : virtual public ::RobotSimEvents::EventMessage
08454 {
08455 public:
08456
08457 typedef AttendedRegionMessagePrx ProxyType;
08458 typedef AttendedRegionMessagePtr PointerType;
08459
08460 AttendedRegionMessage() {}
08461 AttendedRegionMessage(const ::ImageIceMod::ImageIce&, ::Ice::Int, const ::std::string&, ::Ice::Float, ::Ice::Float, const ::ImageIceMod::Point2DIce&, ::Ice::Int, ::Ice::Int);
08462 virtual ::Ice::ObjectPtr ice_clone() const;
08463
08464 virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
08465 virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
08466 virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
08467 static const ::std::string& ice_staticId();
08468
08469
08470 virtual void __write(::IceInternal::BasicStream*) const;
08471 virtual void __read(::IceInternal::BasicStream*, bool);
08472 virtual void __write(const ::Ice::OutputStreamPtr&) const;
08473 virtual void __read(const ::Ice::InputStreamPtr&, bool);
08474
08475 static const ::Ice::ObjectFactoryPtr& ice_factory();
08476
08477 protected:
08478
08479 virtual ~AttendedRegionMessage() {}
08480
08481 public:
08482
08483 ::ImageIceMod::ImageIce img;
08484
08485 ::Ice::Int objId;
08486
08487 ::std::string name;
08488
08489 ::Ice::Float objWidth;
08490
08491 ::Ice::Float objHeight;
08492
08493 ::ImageIceMod::Point2DIce attTopLeft;
08494
08495 ::Ice::Int attWidth;
08496
08497 ::Ice::Int attHeight;
08498 };
08499
08500 class ObjectMessage : virtual public ::RobotSimEvents::EventMessage
08501 {
08502 public:
08503
08504 typedef ObjectMessagePrx ProxyType;
08505 typedef ObjectMessagePtr PointerType;
08506
08507 ObjectMessage() {}
08508 ObjectMessage(::Ice::Int, const ::std::string&, ::Ice::Float, ::Ice::Int, ::Ice::Float, const ::ImageIceMod::Point2DIce&, const ::ImageIceMod::Point2DIce&, const ::ImageIceMod::Point2DIce&, const ::ImageIceMod::Point2DIce&);
08509 virtual ::Ice::ObjectPtr ice_clone() const;
08510
08511 virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
08512 virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
08513 virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
08514 static const ::std::string& ice_staticId();
08515
08516
08517 virtual void __write(::IceInternal::BasicStream*) const;
08518 virtual void __read(::IceInternal::BasicStream*, bool);
08519 virtual void __write(const ::Ice::OutputStreamPtr&) const;
08520 virtual void __read(const ::Ice::InputStreamPtr&, bool);
08521
08522 static const ::Ice::ObjectFactoryPtr& ice_factory();
08523
08524 protected:
08525
08526 virtual ~ObjectMessage() {}
08527
08528 public:
08529
08530 ::Ice::Int id;
08531
08532 ::std::string name;
08533
08534 ::Ice::Float score;
08535
08536 ::Ice::Int nKeyp;
08537
08538 ::Ice::Float dist;
08539
08540 ::ImageIceMod::Point2DIce tl;
08541
08542 ::ImageIceMod::Point2DIce tr;
08543
08544 ::ImageIceMod::Point2DIce br;
08545
08546 ::ImageIceMod::Point2DIce bl;
08547 };
08548
08549 class SeaBeePositionMessage : virtual public ::RobotSimEvents::EventMessage
08550 {
08551 public:
08552
08553 typedef SeaBeePositionMessagePrx ProxyType;
08554 typedef SeaBeePositionMessagePtr PointerType;
08555
08556 SeaBeePositionMessage() {}
08557 SeaBeePositionMessage(::Ice::Float, ::Ice::Float, ::Ice::Float, ::Ice::Float, ::Ice::Float);
08558 virtual ::Ice::ObjectPtr ice_clone() const;
08559
08560 virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
08561 virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
08562 virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
08563 static const ::std::string& ice_staticId();
08564
08565
08566 virtual void __write(::IceInternal::BasicStream*) const;
08567 virtual void __read(::IceInternal::BasicStream*, bool);
08568 virtual void __write(const ::Ice::OutputStreamPtr&) const;
08569 virtual void __read(const ::Ice::InputStreamPtr&, bool);
08570
08571 static const ::Ice::ObjectFactoryPtr& ice_factory();
08572
08573 protected:
08574
08575 virtual ~SeaBeePositionMessage() {}
08576
08577 public:
08578
08579 ::Ice::Float x;
08580
08581 ::Ice::Float y;
08582
08583 ::Ice::Float orientation;
08584
08585 ::Ice::Float xVar;
08586
08587 ::Ice::Float yVar;
08588 };
08589
08590 class SeaBeeStateConditionMessage : virtual public ::RobotSimEvents::EventMessage
08591 {
08592 public:
08593
08594 typedef SeaBeeStateConditionMessagePrx ProxyType;
08595 typedef SeaBeeStateConditionMessagePtr PointerType;
08596
08597 SeaBeeStateConditionMessage() {}
08598 SeaBeeStateConditionMessage(::Ice::Int, ::Ice::Int, ::Ice::Int, ::Ice::Int, ::Ice::Int, ::Ice::Int, ::Ice::Int, ::Ice::Int, ::Ice::Int, ::Ice::Int, ::Ice::Int, ::Ice::Int, ::Ice::Int);
08599 virtual ::Ice::ObjectPtr ice_clone() const;
08600
08601 virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
08602 virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
08603 virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
08604 static const ::std::string& ice_staticId();
08605
08606
08607 virtual void __write(::IceInternal::BasicStream*) const;
08608 virtual void __read(::IceInternal::BasicStream*, bool);
08609 virtual void __write(const ::Ice::OutputStreamPtr&) const;
08610 virtual void __read(const ::Ice::InputStreamPtr&, bool);
08611
08612 static const ::Ice::ObjectFactoryPtr& ice_factory();
08613
08614 protected:
08615
08616 virtual ~SeaBeeStateConditionMessage() {}
08617
08618 public:
08619
08620 ::Ice::Int StartOver;
08621
08622 ::Ice::Int InitDone;
08623
08624 ::Ice::Int GateFound;
08625
08626 ::Ice::Int GateDone;
08627
08628 ::Ice::Int ContourFoundFlare;
08629
08630 ::Ice::Int FlareDone;
08631
08632 ::Ice::Int ContourFoundBarbwire;
08633
08634 ::Ice::Int BarbwireDone;
08635
08636 ::Ice::Int ContourFoundBoxes;
08637
08638 ::Ice::Int BombingRunDone;
08639
08640 ::Ice::Int BriefcaseFound;
08641
08642 ::Ice::Int TimeUp;
08643
08644 ::Ice::Int PathFollowFinished;
08645 };
08646
08647 class VisionRectangleMessage : virtual public ::RobotSimEvents::EventMessage
08648 {
08649 public:
08650
08651 typedef VisionRectangleMessagePrx ProxyType;
08652 typedef VisionRectangleMessagePtr PointerType;
08653
08654 VisionRectangleMessage() {}
08655 VisionRectangleMessage(const ::RobotSimEvents::QuadrilateralIceVector&, bool);
08656 virtual ::Ice::ObjectPtr ice_clone() const;
08657
08658 virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
08659 virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
08660 virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
08661 static const ::std::string& ice_staticId();
08662
08663
08664 virtual void __write(::IceInternal::BasicStream*) const;
08665 virtual void __read(::IceInternal::BasicStream*, bool);
08666 virtual void __write(const ::Ice::OutputStreamPtr&) const;
08667 virtual void __read(const ::Ice::InputStreamPtr&, bool);
08668
08669 static const ::Ice::ObjectFactoryPtr& ice_factory();
08670
08671 protected:
08672
08673 virtual ~VisionRectangleMessage() {}
08674
08675 public:
08676
08677 ::RobotSimEvents::QuadrilateralIceVector quads;
08678
08679 bool isFwdCamera;
08680 };
08681
08682 class StraightEdgeMessage : virtual public ::RobotSimEvents::EventMessage
08683 {
08684 public:
08685
08686 typedef StraightEdgeMessagePrx ProxyType;
08687 typedef StraightEdgeMessagePtr PointerType;
08688
08689 StraightEdgeMessage() {}
08690 StraightEdgeMessage(const ::ImageIceMod::LineIce&, bool);
08691 virtual ::Ice::ObjectPtr ice_clone() const;
08692
08693 virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
08694 virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
08695 virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
08696 static const ::std::string& ice_staticId();
08697
08698
08699 virtual void __write(::IceInternal::BasicStream*) const;
08700 virtual void __read(::IceInternal::BasicStream*, bool);
08701 virtual void __write(const ::Ice::OutputStreamPtr&) const;
08702 virtual void __read(const ::Ice::InputStreamPtr&, bool);
08703
08704 static const ::Ice::ObjectFactoryPtr& ice_factory();
08705
08706 protected:
08707
08708 virtual ~StraightEdgeMessage() {}
08709
08710 public:
08711
08712 ::ImageIceMod::LineIce line;
08713
08714 bool isFwdCamera;
08715 };
08716
08717 class VisionObjectMessage : virtual public ::RobotSimEvents::EventMessage
08718 {
08719 public:
08720
08721 typedef VisionObjectMessagePrx ProxyType;
08722 typedef VisionObjectMessagePtr PointerType;
08723
08724 VisionObjectMessage() {}
08725 VisionObjectMessage(::RobotSimEvents::SeaBeeObjectType, bool, const ::ImageIceMod::Point3DIce&, const ::ImageIceMod::Point3DIce&);
08726 virtual ::Ice::ObjectPtr ice_clone() const;
08727
08728 virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
08729 virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
08730 virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
08731 static const ::std::string& ice_staticId();
08732
08733
08734 virtual void __write(::IceInternal::BasicStream*) const;
08735 virtual void __read(::IceInternal::BasicStream*, bool);
08736 virtual void __write(const ::Ice::OutputStreamPtr&) const;
08737 virtual void __read(const ::Ice::InputStreamPtr&, bool);
08738
08739 static const ::Ice::ObjectFactoryPtr& ice_factory();
08740
08741 protected:
08742
08743 virtual ~VisionObjectMessage() {}
08744
08745 public:
08746
08747 ::RobotSimEvents::SeaBeeObjectType objectType;
08748
08749 bool forwardCamera;
08750
08751 ::ImageIceMod::Point3DIce objectPosition;
08752
08753 ::ImageIceMod::Point3DIce objectVariance;
08754 };
08755
08756 class LandmarksMessage : virtual public ::RobotSimEvents::EventMessage
08757 {
08758 public:
08759
08760 typedef LandmarksMessagePrx ProxyType;
08761 typedef LandmarksMessagePtr PointerType;
08762
08763 LandmarksMessage() {}
08764 explicit LandmarksMessage(const ::RobotSimEvents::LandmarksInfo&);
08765 virtual ::Ice::ObjectPtr ice_clone() const;
08766
08767 virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
08768 virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
08769 virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
08770 static const ::std::string& ice_staticId();
08771
08772
08773 virtual void __write(::IceInternal::BasicStream*) const;
08774 virtual void __read(::IceInternal::BasicStream*, bool);
08775 virtual void __write(const ::Ice::OutputStreamPtr&) const;
08776 virtual void __read(const ::Ice::InputStreamPtr&, bool);
08777
08778 static const ::Ice::ObjectFactoryPtr& ice_factory();
08779
08780 protected:
08781
08782 virtual ~LandmarksMessage() {}
08783
08784 public:
08785
08786 ::RobotSimEvents::LandmarksInfo landmarks;
08787 };
08788
08789 class CameraConfigMessage : virtual public ::RobotSimEvents::EventMessage
08790 {
08791 public:
08792
08793 typedef CameraConfigMessagePrx ProxyType;
08794 typedef CameraConfigMessagePtr PointerType;
08795
08796 CameraConfigMessage() {}
08797 CameraConfigMessage(const ::std::string&, bool);
08798 virtual ::Ice::ObjectPtr ice_clone() const;
08799
08800 virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
08801 virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
08802 virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
08803 static const ::std::string& ice_staticId();
08804
08805
08806 virtual void __write(::IceInternal::BasicStream*) const;
08807 virtual void __read(::IceInternal::BasicStream*, bool);
08808 virtual void __write(const ::Ice::OutputStreamPtr&) const;
08809 virtual void __read(const ::Ice::InputStreamPtr&, bool);
08810
08811 static const ::Ice::ObjectFactoryPtr& ice_factory();
08812
08813 protected:
08814
08815 virtual ~CameraConfigMessage() {}
08816
08817 public:
08818
08819 ::std::string cameraID;
08820
08821 bool active;
08822 };
08823
08824 class SalientPointMessage : virtual public ::RobotSimEvents::EventMessage
08825 {
08826 public:
08827
08828 typedef SalientPointMessagePrx ProxyType;
08829 typedef SalientPointMessagePtr PointerType;
08830
08831 SalientPointMessage() {}
08832 SalientPointMessage(::Ice::Float, ::Ice::Float, ::Ice::Int, const ::std::string&);
08833 virtual ::Ice::ObjectPtr ice_clone() const;
08834
08835 virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
08836 virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
08837 virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
08838 static const ::std::string& ice_staticId();
08839
08840
08841 virtual void __write(::IceInternal::BasicStream*) const;
08842 virtual void __read(::IceInternal::BasicStream*, bool);
08843 virtual void __write(const ::Ice::OutputStreamPtr&) const;
08844 virtual void __read(const ::Ice::InputStreamPtr&, bool);
08845
08846 static const ::Ice::ObjectFactoryPtr& ice_factory();
08847
08848 protected:
08849
08850 virtual ~SalientPointMessage() {}
08851
08852 public:
08853
08854 ::Ice::Float x;
08855
08856 ::Ice::Float y;
08857
08858 ::Ice::Int saliency;
08859
08860 ::std::string imageDescr;
08861 };
08862
08863 class BuoyColorSegmentMessage : virtual public ::RobotSimEvents::EventMessage
08864 {
08865 public:
08866
08867 typedef BuoyColorSegmentMessagePrx ProxyType;
08868 typedef BuoyColorSegmentMessagePtr PointerType;
08869
08870 BuoyColorSegmentMessage() {}
08871 BuoyColorSegmentMessage(::Ice::Float, ::Ice::Float, ::Ice::Float);
08872 virtual ::Ice::ObjectPtr ice_clone() const;
08873
08874 virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
08875 virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
08876 virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
08877 static const ::std::string& ice_staticId();
08878
08879
08880 virtual void __write(::IceInternal::BasicStream*) const;
08881 virtual void __read(::IceInternal::BasicStream*, bool);
08882 virtual void __write(const ::Ice::OutputStreamPtr&) const;
08883 virtual void __read(const ::Ice::InputStreamPtr&, bool);
08884
08885 static const ::Ice::ObjectFactoryPtr& ice_factory();
08886
08887 protected:
08888
08889 virtual ~BuoyColorSegmentMessage() {}
08890
08891 public:
08892
08893 ::Ice::Float x;
08894
08895 ::Ice::Float y;
08896
08897 ::Ice::Float size;
08898 };
08899
08900 class PipeColorSegmentMessage : virtual public ::RobotSimEvents::EventMessage
08901 {
08902 public:
08903
08904 typedef PipeColorSegmentMessagePrx ProxyType;
08905 typedef PipeColorSegmentMessagePtr PointerType;
08906
08907 PipeColorSegmentMessage() {}
08908 PipeColorSegmentMessage(::Ice::Float, ::Ice::Float, ::Ice::Float);
08909 virtual ::Ice::ObjectPtr ice_clone() const;
08910
08911 virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
08912 virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
08913 virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
08914 static const ::std::string& ice_staticId();
08915
08916
08917 virtual void __write(::IceInternal::BasicStream*) const;
08918 virtual void __read(::IceInternal::BasicStream*, bool);
08919 virtual void __write(const ::Ice::OutputStreamPtr&) const;
08920 virtual void __read(const ::Ice::InputStreamPtr&, bool);
08921
08922 static const ::Ice::ObjectFactoryPtr& ice_factory();
08923
08924 protected:
08925
08926 virtual ~PipeColorSegmentMessage() {}
08927
08928 public:
08929
08930 ::Ice::Float x;
08931
08932 ::Ice::Float y;
08933
08934 ::Ice::Float size;
08935 };
08936
08937 class BuoyColorSegmentConfigMessage : virtual public ::RobotSimEvents::EventMessage
08938 {
08939 public:
08940
08941 typedef BuoyColorSegmentConfigMessagePrx ProxyType;
08942 typedef BuoyColorSegmentConfigMessagePtr PointerType;
08943
08944 BuoyColorSegmentConfigMessage() {}
08945 BuoyColorSegmentConfigMessage(::Ice::Double, ::Ice::Double, ::Ice::Double, ::Ice::Double, ::Ice::Double, ::Ice::Double);
08946 virtual ::Ice::ObjectPtr ice_clone() const;
08947
08948 virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
08949 virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
08950 virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
08951 static const ::std::string& ice_staticId();
08952
08953
08954 virtual void __write(::IceInternal::BasicStream*) const;
08955 virtual void __read(::IceInternal::BasicStream*, bool);
08956 virtual void __write(const ::Ice::OutputStreamPtr&) const;
08957 virtual void __read(const ::Ice::InputStreamPtr&, bool);
08958
08959 static const ::Ice::ObjectFactoryPtr& ice_factory();
08960
08961 protected:
08962
08963 virtual ~BuoyColorSegmentConfigMessage() {}
08964
08965 public:
08966
08967 ::Ice::Double HUT;
08968
08969 ::Ice::Double HLT;
08970
08971 ::Ice::Double SUT;
08972
08973 ::Ice::Double SLT;
08974
08975 ::Ice::Double VUT;
08976
08977 ::Ice::Double VLT;
08978 };
08979
08980 class PipeColorSegmentConfigMessage : virtual public ::RobotSimEvents::EventMessage
08981 {
08982 public:
08983
08984 typedef PipeColorSegmentConfigMessagePrx ProxyType;
08985 typedef PipeColorSegmentConfigMessagePtr PointerType;
08986
08987 PipeColorSegmentConfigMessage() {}
08988 PipeColorSegmentConfigMessage(::Ice::Double, ::Ice::Double, ::Ice::Double, ::Ice::Double, ::Ice::Double, ::Ice::Double);
08989 virtual ::Ice::ObjectPtr ice_clone() const;
08990
08991 virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
08992 virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
08993 virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
08994 static const ::std::string& ice_staticId();
08995
08996
08997 virtual void __write(::IceInternal::BasicStream*) const;
08998 virtual void __read(::IceInternal::BasicStream*, bool);
08999 virtual void __write(const ::Ice::OutputStreamPtr&) const;
09000 virtual void __read(const ::Ice::InputStreamPtr&, bool);
09001
09002 static const ::Ice::ObjectFactoryPtr& ice_factory();
09003
09004 protected:
09005
09006 virtual ~PipeColorSegmentConfigMessage() {}
09007
09008 public:
09009
09010 ::Ice::Double HUT;
09011
09012 ::Ice::Double HLT;
09013
09014 ::Ice::Double SUT;
09015
09016 ::Ice::Double SLT;
09017
09018 ::Ice::Double VUT;
09019
09020 ::Ice::Double VLT;
09021 };
09022
09023 }
09024
09025 #endif
1.6.3