HawkMessages.ice.H

00001 // **********************************************************************
00002 //
00003 // Copyright (c) 2003-2009 ZeroC, Inc. All rights reserved.
00004 //
00005 // This copy of Ice is licensed to you under the terms described in the
00006 // ICE_LICENSE file included in this distribution.
00007 //
00008 // **********************************************************************
00009 
00010 // Ice version 3.3.1
00011 // Generated from file `HawkMessages.ice'
00012 
00013 #ifndef __src_Robots_BeoHawk_core__HawkMessages_ice_H__
00014 #define __src_Robots_BeoHawk_core__HawkMessages_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 HawkMessages
00047 {
00048 
00049 class Message;
00050 
00051 class MessageAgent;
00052 
00053 class CameraImageMessage;
00054 
00055 class ControlCameraMessage;
00056 
00057 class ControlDriveVisionMessage;
00058 
00059 class ControlLandMessage;
00060 
00061 class ControlMoveMessage;
00062 
00063 class ControlRoomVisionMessage;
00064 
00065 class ControlTakeOffMessage;
00066 
00067 class DriveFinderMessage;
00068 
00069 class ExampleMessage;
00070 
00071 class ExecuteMissionMessage;
00072 
00073 class MissionListMessage;
00074 
00075 class RoomFinderMessage;
00076 
00077 class SensorDataMessage;
00078 
00079 class SlamDataMessage;
00080 
00081 }
00082 
00083 }
00084 
00085 namespace HawkMessages
00086 {
00087 
00088 class Message;
00089 bool operator==(const Message&, const Message&);
00090 bool operator<(const Message&, const Message&);
00091 
00092 class MessageAgent;
00093 bool operator==(const MessageAgent&, const MessageAgent&);
00094 bool operator<(const MessageAgent&, const MessageAgent&);
00095 
00096 class CameraImageMessage;
00097 bool operator==(const CameraImageMessage&, const CameraImageMessage&);
00098 bool operator<(const CameraImageMessage&, const CameraImageMessage&);
00099 
00100 class ControlCameraMessage;
00101 bool operator==(const ControlCameraMessage&, const ControlCameraMessage&);
00102 bool operator<(const ControlCameraMessage&, const ControlCameraMessage&);
00103 
00104 class ControlDriveVisionMessage;
00105 bool operator==(const ControlDriveVisionMessage&, const ControlDriveVisionMessage&);
00106 bool operator<(const ControlDriveVisionMessage&, const ControlDriveVisionMessage&);
00107 
00108 class ControlLandMessage;
00109 bool operator==(const ControlLandMessage&, const ControlLandMessage&);
00110 bool operator<(const ControlLandMessage&, const ControlLandMessage&);
00111 
00112 class ControlMoveMessage;
00113 bool operator==(const ControlMoveMessage&, const ControlMoveMessage&);
00114 bool operator<(const ControlMoveMessage&, const ControlMoveMessage&);
00115 
00116 class ControlRoomVisionMessage;
00117 bool operator==(const ControlRoomVisionMessage&, const ControlRoomVisionMessage&);
00118 bool operator<(const ControlRoomVisionMessage&, const ControlRoomVisionMessage&);
00119 
00120 class ControlTakeOffMessage;
00121 bool operator==(const ControlTakeOffMessage&, const ControlTakeOffMessage&);
00122 bool operator<(const ControlTakeOffMessage&, const ControlTakeOffMessage&);
00123 
00124 class DriveFinderMessage;
00125 bool operator==(const DriveFinderMessage&, const DriveFinderMessage&);
00126 bool operator<(const DriveFinderMessage&, const DriveFinderMessage&);
00127 
00128 class ExampleMessage;
00129 bool operator==(const ExampleMessage&, const ExampleMessage&);
00130 bool operator<(const ExampleMessage&, const ExampleMessage&);
00131 
00132 class ExecuteMissionMessage;
00133 bool operator==(const ExecuteMissionMessage&, const ExecuteMissionMessage&);
00134 bool operator<(const ExecuteMissionMessage&, const ExecuteMissionMessage&);
00135 
00136 class MissionListMessage;
00137 bool operator==(const MissionListMessage&, const MissionListMessage&);
00138 bool operator<(const MissionListMessage&, const MissionListMessage&);
00139 
00140 class RoomFinderMessage;
00141 bool operator==(const RoomFinderMessage&, const RoomFinderMessage&);
00142 bool operator<(const RoomFinderMessage&, const RoomFinderMessage&);
00143 
00144 class SensorDataMessage;
00145 bool operator==(const SensorDataMessage&, const SensorDataMessage&);
00146 bool operator<(const SensorDataMessage&, const SensorDataMessage&);
00147 
00148 class SlamDataMessage;
00149 bool operator==(const SlamDataMessage&, const SlamDataMessage&);
00150 bool operator<(const SlamDataMessage&, const SlamDataMessage&);
00151 
00152 }
00153 
00154 namespace IceInternal
00155 {
00156 
00157 ::Ice::Object* upCast(::HawkMessages::Message*);
00158 ::IceProxy::Ice::Object* upCast(::IceProxy::HawkMessages::Message*);
00159 
00160 ::Ice::Object* upCast(::HawkMessages::MessageAgent*);
00161 ::IceProxy::Ice::Object* upCast(::IceProxy::HawkMessages::MessageAgent*);
00162 
00163 ::Ice::Object* upCast(::HawkMessages::CameraImageMessage*);
00164 ::IceProxy::Ice::Object* upCast(::IceProxy::HawkMessages::CameraImageMessage*);
00165 
00166 ::Ice::Object* upCast(::HawkMessages::ControlCameraMessage*);
00167 ::IceProxy::Ice::Object* upCast(::IceProxy::HawkMessages::ControlCameraMessage*);
00168 
00169 ::Ice::Object* upCast(::HawkMessages::ControlDriveVisionMessage*);
00170 ::IceProxy::Ice::Object* upCast(::IceProxy::HawkMessages::ControlDriveVisionMessage*);
00171 
00172 ::Ice::Object* upCast(::HawkMessages::ControlLandMessage*);
00173 ::IceProxy::Ice::Object* upCast(::IceProxy::HawkMessages::ControlLandMessage*);
00174 
00175 ::Ice::Object* upCast(::HawkMessages::ControlMoveMessage*);
00176 ::IceProxy::Ice::Object* upCast(::IceProxy::HawkMessages::ControlMoveMessage*);
00177 
00178 ::Ice::Object* upCast(::HawkMessages::ControlRoomVisionMessage*);
00179 ::IceProxy::Ice::Object* upCast(::IceProxy::HawkMessages::ControlRoomVisionMessage*);
00180 
00181 ::Ice::Object* upCast(::HawkMessages::ControlTakeOffMessage*);
00182 ::IceProxy::Ice::Object* upCast(::IceProxy::HawkMessages::ControlTakeOffMessage*);
00183 
00184 ::Ice::Object* upCast(::HawkMessages::DriveFinderMessage*);
00185 ::IceProxy::Ice::Object* upCast(::IceProxy::HawkMessages::DriveFinderMessage*);
00186 
00187 ::Ice::Object* upCast(::HawkMessages::ExampleMessage*);
00188 ::IceProxy::Ice::Object* upCast(::IceProxy::HawkMessages::ExampleMessage*);
00189 
00190 ::Ice::Object* upCast(::HawkMessages::ExecuteMissionMessage*);
00191 ::IceProxy::Ice::Object* upCast(::IceProxy::HawkMessages::ExecuteMissionMessage*);
00192 
00193 ::Ice::Object* upCast(::HawkMessages::MissionListMessage*);
00194 ::IceProxy::Ice::Object* upCast(::IceProxy::HawkMessages::MissionListMessage*);
00195 
00196 ::Ice::Object* upCast(::HawkMessages::RoomFinderMessage*);
00197 ::IceProxy::Ice::Object* upCast(::IceProxy::HawkMessages::RoomFinderMessage*);
00198 
00199 ::Ice::Object* upCast(::HawkMessages::SensorDataMessage*);
00200 ::IceProxy::Ice::Object* upCast(::IceProxy::HawkMessages::SensorDataMessage*);
00201 
00202 ::Ice::Object* upCast(::HawkMessages::SlamDataMessage*);
00203 ::IceProxy::Ice::Object* upCast(::IceProxy::HawkMessages::SlamDataMessage*);
00204 
00205 }
00206 
00207 namespace HawkMessages
00208 {
00209 
00210 typedef ::IceInternal::Handle< ::HawkMessages::Message> MessagePtr;
00211 typedef ::IceInternal::ProxyHandle< ::IceProxy::HawkMessages::Message> MessagePrx;
00212 
00213 void __read(::IceInternal::BasicStream*, MessagePrx&);
00214 void __patch__MessagePtr(void*, ::Ice::ObjectPtr&);
00215 
00216 typedef ::IceInternal::Handle< ::HawkMessages::MessageAgent> MessageAgentPtr;
00217 typedef ::IceInternal::ProxyHandle< ::IceProxy::HawkMessages::MessageAgent> MessageAgentPrx;
00218 
00219 void __read(::IceInternal::BasicStream*, MessageAgentPrx&);
00220 void __patch__MessageAgentPtr(void*, ::Ice::ObjectPtr&);
00221 
00222 typedef ::IceInternal::Handle< ::HawkMessages::CameraImageMessage> CameraImageMessagePtr;
00223 typedef ::IceInternal::ProxyHandle< ::IceProxy::HawkMessages::CameraImageMessage> CameraImageMessagePrx;
00224 
00225 void __read(::IceInternal::BasicStream*, CameraImageMessagePrx&);
00226 void __patch__CameraImageMessagePtr(void*, ::Ice::ObjectPtr&);
00227 
00228 typedef ::IceInternal::Handle< ::HawkMessages::ControlCameraMessage> ControlCameraMessagePtr;
00229 typedef ::IceInternal::ProxyHandle< ::IceProxy::HawkMessages::ControlCameraMessage> ControlCameraMessagePrx;
00230 
00231 void __read(::IceInternal::BasicStream*, ControlCameraMessagePrx&);
00232 void __patch__ControlCameraMessagePtr(void*, ::Ice::ObjectPtr&);
00233 
00234 typedef ::IceInternal::Handle< ::HawkMessages::ControlDriveVisionMessage> ControlDriveVisionMessagePtr;
00235 typedef ::IceInternal::ProxyHandle< ::IceProxy::HawkMessages::ControlDriveVisionMessage> ControlDriveVisionMessagePrx;
00236 
00237 void __read(::IceInternal::BasicStream*, ControlDriveVisionMessagePrx&);
00238 void __patch__ControlDriveVisionMessagePtr(void*, ::Ice::ObjectPtr&);
00239 
00240 typedef ::IceInternal::Handle< ::HawkMessages::ControlLandMessage> ControlLandMessagePtr;
00241 typedef ::IceInternal::ProxyHandle< ::IceProxy::HawkMessages::ControlLandMessage> ControlLandMessagePrx;
00242 
00243 void __read(::IceInternal::BasicStream*, ControlLandMessagePrx&);
00244 void __patch__ControlLandMessagePtr(void*, ::Ice::ObjectPtr&);
00245 
00246 typedef ::IceInternal::Handle< ::HawkMessages::ControlMoveMessage> ControlMoveMessagePtr;
00247 typedef ::IceInternal::ProxyHandle< ::IceProxy::HawkMessages::ControlMoveMessage> ControlMoveMessagePrx;
00248 
00249 void __read(::IceInternal::BasicStream*, ControlMoveMessagePrx&);
00250 void __patch__ControlMoveMessagePtr(void*, ::Ice::ObjectPtr&);
00251 
00252 typedef ::IceInternal::Handle< ::HawkMessages::ControlRoomVisionMessage> ControlRoomVisionMessagePtr;
00253 typedef ::IceInternal::ProxyHandle< ::IceProxy::HawkMessages::ControlRoomVisionMessage> ControlRoomVisionMessagePrx;
00254 
00255 void __read(::IceInternal::BasicStream*, ControlRoomVisionMessagePrx&);
00256 void __patch__ControlRoomVisionMessagePtr(void*, ::Ice::ObjectPtr&);
00257 
00258 typedef ::IceInternal::Handle< ::HawkMessages::ControlTakeOffMessage> ControlTakeOffMessagePtr;
00259 typedef ::IceInternal::ProxyHandle< ::IceProxy::HawkMessages::ControlTakeOffMessage> ControlTakeOffMessagePrx;
00260 
00261 void __read(::IceInternal::BasicStream*, ControlTakeOffMessagePrx&);
00262 void __patch__ControlTakeOffMessagePtr(void*, ::Ice::ObjectPtr&);
00263 
00264 typedef ::IceInternal::Handle< ::HawkMessages::DriveFinderMessage> DriveFinderMessagePtr;
00265 typedef ::IceInternal::ProxyHandle< ::IceProxy::HawkMessages::DriveFinderMessage> DriveFinderMessagePrx;
00266 
00267 void __read(::IceInternal::BasicStream*, DriveFinderMessagePrx&);
00268 void __patch__DriveFinderMessagePtr(void*, ::Ice::ObjectPtr&);
00269 
00270 typedef ::IceInternal::Handle< ::HawkMessages::ExampleMessage> ExampleMessagePtr;
00271 typedef ::IceInternal::ProxyHandle< ::IceProxy::HawkMessages::ExampleMessage> ExampleMessagePrx;
00272 
00273 void __read(::IceInternal::BasicStream*, ExampleMessagePrx&);
00274 void __patch__ExampleMessagePtr(void*, ::Ice::ObjectPtr&);
00275 
00276 typedef ::IceInternal::Handle< ::HawkMessages::ExecuteMissionMessage> ExecuteMissionMessagePtr;
00277 typedef ::IceInternal::ProxyHandle< ::IceProxy::HawkMessages::ExecuteMissionMessage> ExecuteMissionMessagePrx;
00278 
00279 void __read(::IceInternal::BasicStream*, ExecuteMissionMessagePrx&);
00280 void __patch__ExecuteMissionMessagePtr(void*, ::Ice::ObjectPtr&);
00281 
00282 typedef ::IceInternal::Handle< ::HawkMessages::MissionListMessage> MissionListMessagePtr;
00283 typedef ::IceInternal::ProxyHandle< ::IceProxy::HawkMessages::MissionListMessage> MissionListMessagePrx;
00284 
00285 void __read(::IceInternal::BasicStream*, MissionListMessagePrx&);
00286 void __patch__MissionListMessagePtr(void*, ::Ice::ObjectPtr&);
00287 
00288 typedef ::IceInternal::Handle< ::HawkMessages::RoomFinderMessage> RoomFinderMessagePtr;
00289 typedef ::IceInternal::ProxyHandle< ::IceProxy::HawkMessages::RoomFinderMessage> RoomFinderMessagePrx;
00290 
00291 void __read(::IceInternal::BasicStream*, RoomFinderMessagePrx&);
00292 void __patch__RoomFinderMessagePtr(void*, ::Ice::ObjectPtr&);
00293 
00294 typedef ::IceInternal::Handle< ::HawkMessages::SensorDataMessage> SensorDataMessagePtr;
00295 typedef ::IceInternal::ProxyHandle< ::IceProxy::HawkMessages::SensorDataMessage> SensorDataMessagePrx;
00296 
00297 void __read(::IceInternal::BasicStream*, SensorDataMessagePrx&);
00298 void __patch__SensorDataMessagePtr(void*, ::Ice::ObjectPtr&);
00299 
00300 typedef ::IceInternal::Handle< ::HawkMessages::SlamDataMessage> SlamDataMessagePtr;
00301 typedef ::IceInternal::ProxyHandle< ::IceProxy::HawkMessages::SlamDataMessage> SlamDataMessagePrx;
00302 
00303 void __read(::IceInternal::BasicStream*, SlamDataMessagePrx&);
00304 void __patch__SlamDataMessagePtr(void*, ::Ice::ObjectPtr&);
00305 
00306 }
00307 
00308 namespace HawkMessages
00309 {
00310 
00311 struct Pose
00312 {
00313     ::Ice::Double x;
00314     ::Ice::Double y;
00315     ::Ice::Double z;
00316     ::Ice::Double theta;
00317 
00318     bool operator==(const Pose&) const;
00319     bool operator<(const Pose&) const;
00320     bool operator!=(const Pose& __rhs) const
00321     {
00322         return !operator==(__rhs);
00323     }
00324     bool operator<=(const Pose& __rhs) const
00325     {
00326         return operator<(__rhs) || operator==(__rhs);
00327     }
00328     bool operator>(const Pose& __rhs) const
00329     {
00330         return !operator<(__rhs) && !operator==(__rhs);
00331     }
00332     bool operator>=(const Pose& __rhs) const
00333     {
00334         return !operator<(__rhs);
00335     }
00336 
00337     void __write(::IceInternal::BasicStream*) const;
00338     void __read(::IceInternal::BasicStream*);
00339 };
00340 
00341 struct Sonar
00342 {
00343     ::std::string sonarID;
00344     ::Ice::Double distance;
00345 
00346     bool operator==(const Sonar&) const;
00347     bool operator<(const Sonar&) const;
00348     bool operator!=(const Sonar& __rhs) const
00349     {
00350         return !operator==(__rhs);
00351     }
00352     bool operator<=(const Sonar& __rhs) const
00353     {
00354         return operator<(__rhs) || operator==(__rhs);
00355     }
00356     bool operator>(const Sonar& __rhs) const
00357     {
00358         return !operator<(__rhs) && !operator==(__rhs);
00359     }
00360     bool operator>=(const Sonar& __rhs) const
00361     {
00362         return !operator<(__rhs);
00363     }
00364 
00365     void __write(::IceInternal::BasicStream*) const;
00366     void __read(::IceInternal::BasicStream*);
00367 };
00368 
00369 typedef ::std::vector< ::HawkMessages::Sonar> SonarSeq;
00370 void __writeSonarSeq(::IceInternal::BasicStream*, const ::HawkMessages::Sonar*, const ::HawkMessages::Sonar*);
00371 void __readSonarSeq(::IceInternal::BasicStream*, SonarSeq&);
00372 
00373 typedef ::std::vector< ::std::string> StringSeq;
00374 
00375 typedef ::std::vector< ::Ice::Long> LongSeq;
00376 
00377 }
00378 
00379 namespace IceProxy
00380 {
00381 
00382 namespace HawkMessages
00383 {
00384 
00385 class Message : virtual public ::IceProxy::Ice::Object
00386 {
00387 public:
00388 
00389     ::IceInternal::ProxyHandle<Message> ice_context(const ::Ice::Context& __context) const
00390     {
00391     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00392         typedef ::IceProxy::Ice::Object _Base;
00393         return dynamic_cast<Message*>(_Base::ice_context(__context).get());
00394     #else
00395         return dynamic_cast<Message*>(::IceProxy::Ice::Object::ice_context(__context).get());
00396     #endif
00397     }
00398 
00399     ::IceInternal::ProxyHandle<Message> ice_adapterId(const std::string& __id) const
00400     {
00401     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00402         typedef ::IceProxy::Ice::Object _Base;
00403         return dynamic_cast<Message*>(_Base::ice_adapterId(__id).get());
00404     #else
00405         return dynamic_cast<Message*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
00406     #endif
00407     }
00408 
00409     ::IceInternal::ProxyHandle<Message> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
00410     {
00411     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00412         typedef ::IceProxy::Ice::Object _Base;
00413         return dynamic_cast<Message*>(_Base::ice_endpoints(__endpoints).get());
00414     #else
00415         return dynamic_cast<Message*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
00416     #endif
00417     }
00418 
00419     ::IceInternal::ProxyHandle<Message> ice_locatorCacheTimeout(int __timeout) const
00420     {
00421     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00422         typedef ::IceProxy::Ice::Object _Base;
00423         return dynamic_cast<Message*>(_Base::ice_locatorCacheTimeout(__timeout).get());
00424     #else
00425         return dynamic_cast<Message*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
00426     #endif
00427     }
00428 
00429     ::IceInternal::ProxyHandle<Message> ice_connectionCached(bool __cached) const
00430     {
00431     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00432         typedef ::IceProxy::Ice::Object _Base;
00433         return dynamic_cast<Message*>(_Base::ice_connectionCached(__cached).get());
00434     #else
00435         return dynamic_cast<Message*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
00436     #endif
00437     }
00438 
00439     ::IceInternal::ProxyHandle<Message> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
00440     {
00441     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00442         typedef ::IceProxy::Ice::Object _Base;
00443         return dynamic_cast<Message*>(_Base::ice_endpointSelection(__est).get());
00444     #else
00445         return dynamic_cast<Message*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
00446     #endif
00447     }
00448 
00449     ::IceInternal::ProxyHandle<Message> ice_secure(bool __secure) const
00450     {
00451     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00452         typedef ::IceProxy::Ice::Object _Base;
00453         return dynamic_cast<Message*>(_Base::ice_secure(__secure).get());
00454     #else
00455         return dynamic_cast<Message*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
00456     #endif
00457     }
00458 
00459     ::IceInternal::ProxyHandle<Message> ice_preferSecure(bool __preferSecure) const
00460     {
00461     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00462         typedef ::IceProxy::Ice::Object _Base;
00463         return dynamic_cast<Message*>(_Base::ice_preferSecure(__preferSecure).get());
00464     #else
00465         return dynamic_cast<Message*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
00466     #endif
00467     }
00468 
00469     ::IceInternal::ProxyHandle<Message> ice_router(const ::Ice::RouterPrx& __router) const
00470     {
00471     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00472         typedef ::IceProxy::Ice::Object _Base;
00473         return dynamic_cast<Message*>(_Base::ice_router(__router).get());
00474     #else
00475         return dynamic_cast<Message*>(::IceProxy::Ice::Object::ice_router(__router).get());
00476     #endif
00477     }
00478 
00479     ::IceInternal::ProxyHandle<Message> ice_locator(const ::Ice::LocatorPrx& __locator) const
00480     {
00481     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00482         typedef ::IceProxy::Ice::Object _Base;
00483         return dynamic_cast<Message*>(_Base::ice_locator(__locator).get());
00484     #else
00485         return dynamic_cast<Message*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
00486     #endif
00487     }
00488 
00489     ::IceInternal::ProxyHandle<Message> ice_collocationOptimized(bool __co) const
00490     {
00491     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00492         typedef ::IceProxy::Ice::Object _Base;
00493         return dynamic_cast<Message*>(_Base::ice_collocationOptimized(__co).get());
00494     #else
00495         return dynamic_cast<Message*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
00496     #endif
00497     }
00498 
00499     ::IceInternal::ProxyHandle<Message> ice_twoway() const
00500     {
00501     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00502         typedef ::IceProxy::Ice::Object _Base;
00503         return dynamic_cast<Message*>(_Base::ice_twoway().get());
00504     #else
00505         return dynamic_cast<Message*>(::IceProxy::Ice::Object::ice_twoway().get());
00506     #endif
00507     }
00508 
00509     ::IceInternal::ProxyHandle<Message> ice_oneway() const
00510     {
00511     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00512         typedef ::IceProxy::Ice::Object _Base;
00513         return dynamic_cast<Message*>(_Base::ice_oneway().get());
00514     #else
00515         return dynamic_cast<Message*>(::IceProxy::Ice::Object::ice_oneway().get());
00516     #endif
00517     }
00518 
00519     ::IceInternal::ProxyHandle<Message> ice_batchOneway() const
00520     {
00521     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00522         typedef ::IceProxy::Ice::Object _Base;
00523         return dynamic_cast<Message*>(_Base::ice_batchOneway().get());
00524     #else
00525         return dynamic_cast<Message*>(::IceProxy::Ice::Object::ice_batchOneway().get());
00526     #endif
00527     }
00528 
00529     ::IceInternal::ProxyHandle<Message> ice_datagram() const
00530     {
00531     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00532         typedef ::IceProxy::Ice::Object _Base;
00533         return dynamic_cast<Message*>(_Base::ice_datagram().get());
00534     #else
00535         return dynamic_cast<Message*>(::IceProxy::Ice::Object::ice_datagram().get());
00536     #endif
00537     }
00538 
00539     ::IceInternal::ProxyHandle<Message> ice_batchDatagram() const
00540     {
00541     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00542         typedef ::IceProxy::Ice::Object _Base;
00543         return dynamic_cast<Message*>(_Base::ice_batchDatagram().get());
00544     #else
00545         return dynamic_cast<Message*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
00546     #endif
00547     }
00548 
00549     ::IceInternal::ProxyHandle<Message> ice_compress(bool __compress) const
00550     {
00551     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00552         typedef ::IceProxy::Ice::Object _Base;
00553         return dynamic_cast<Message*>(_Base::ice_compress(__compress).get());
00554     #else
00555         return dynamic_cast<Message*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
00556     #endif
00557     }
00558 
00559     ::IceInternal::ProxyHandle<Message> ice_timeout(int __timeout) const
00560     {
00561     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00562         typedef ::IceProxy::Ice::Object _Base;
00563         return dynamic_cast<Message*>(_Base::ice_timeout(__timeout).get());
00564     #else
00565         return dynamic_cast<Message*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
00566     #endif
00567     }
00568 
00569     ::IceInternal::ProxyHandle<Message> ice_connectionId(const std::string& __id) const
00570     {
00571     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00572         typedef ::IceProxy::Ice::Object _Base;
00573         return dynamic_cast<Message*>(_Base::ice_connectionId(__id).get());
00574     #else
00575         return dynamic_cast<Message*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
00576     #endif
00577     }
00578 
00579     static const ::std::string& ice_staticId();
00580 
00581 private:
00582 
00583     virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
00584     virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
00585     virtual ::IceProxy::Ice::Object* __newInstance() const;
00586 };
00587 
00588 class MessageAgent : virtual public ::IceProxy::Ice::Object
00589 {
00590 public:
00591 
00592     void catchMessage(const ::HawkMessages::MessagePtr& msg)
00593     {
00594         catchMessage(msg, 0);
00595     }
00596     void catchMessage(const ::HawkMessages::MessagePtr& msg, const ::Ice::Context& __ctx)
00597     {
00598         catchMessage(msg, &__ctx);
00599     }
00600 
00601 private:
00602 
00603     void catchMessage(const ::HawkMessages::MessagePtr&, const ::Ice::Context*);
00604 
00605 public:
00606 
00607     ::IceInternal::ProxyHandle<MessageAgent> ice_context(const ::Ice::Context& __context) const
00608     {
00609     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00610         typedef ::IceProxy::Ice::Object _Base;
00611         return dynamic_cast<MessageAgent*>(_Base::ice_context(__context).get());
00612     #else
00613         return dynamic_cast<MessageAgent*>(::IceProxy::Ice::Object::ice_context(__context).get());
00614     #endif
00615     }
00616 
00617     ::IceInternal::ProxyHandle<MessageAgent> ice_adapterId(const std::string& __id) const
00618     {
00619     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00620         typedef ::IceProxy::Ice::Object _Base;
00621         return dynamic_cast<MessageAgent*>(_Base::ice_adapterId(__id).get());
00622     #else
00623         return dynamic_cast<MessageAgent*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
00624     #endif
00625     }
00626 
00627     ::IceInternal::ProxyHandle<MessageAgent> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
00628     {
00629     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00630         typedef ::IceProxy::Ice::Object _Base;
00631         return dynamic_cast<MessageAgent*>(_Base::ice_endpoints(__endpoints).get());
00632     #else
00633         return dynamic_cast<MessageAgent*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
00634     #endif
00635     }
00636 
00637     ::IceInternal::ProxyHandle<MessageAgent> ice_locatorCacheTimeout(int __timeout) const
00638     {
00639     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00640         typedef ::IceProxy::Ice::Object _Base;
00641         return dynamic_cast<MessageAgent*>(_Base::ice_locatorCacheTimeout(__timeout).get());
00642     #else
00643         return dynamic_cast<MessageAgent*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
00644     #endif
00645     }
00646 
00647     ::IceInternal::ProxyHandle<MessageAgent> ice_connectionCached(bool __cached) const
00648     {
00649     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00650         typedef ::IceProxy::Ice::Object _Base;
00651         return dynamic_cast<MessageAgent*>(_Base::ice_connectionCached(__cached).get());
00652     #else
00653         return dynamic_cast<MessageAgent*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
00654     #endif
00655     }
00656 
00657     ::IceInternal::ProxyHandle<MessageAgent> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
00658     {
00659     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00660         typedef ::IceProxy::Ice::Object _Base;
00661         return dynamic_cast<MessageAgent*>(_Base::ice_endpointSelection(__est).get());
00662     #else
00663         return dynamic_cast<MessageAgent*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
00664     #endif
00665     }
00666 
00667     ::IceInternal::ProxyHandle<MessageAgent> ice_secure(bool __secure) const
00668     {
00669     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00670         typedef ::IceProxy::Ice::Object _Base;
00671         return dynamic_cast<MessageAgent*>(_Base::ice_secure(__secure).get());
00672     #else
00673         return dynamic_cast<MessageAgent*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
00674     #endif
00675     }
00676 
00677     ::IceInternal::ProxyHandle<MessageAgent> ice_preferSecure(bool __preferSecure) const
00678     {
00679     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00680         typedef ::IceProxy::Ice::Object _Base;
00681         return dynamic_cast<MessageAgent*>(_Base::ice_preferSecure(__preferSecure).get());
00682     #else
00683         return dynamic_cast<MessageAgent*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
00684     #endif
00685     }
00686 
00687     ::IceInternal::ProxyHandle<MessageAgent> ice_router(const ::Ice::RouterPrx& __router) const
00688     {
00689     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00690         typedef ::IceProxy::Ice::Object _Base;
00691         return dynamic_cast<MessageAgent*>(_Base::ice_router(__router).get());
00692     #else
00693         return dynamic_cast<MessageAgent*>(::IceProxy::Ice::Object::ice_router(__router).get());
00694     #endif
00695     }
00696 
00697     ::IceInternal::ProxyHandle<MessageAgent> ice_locator(const ::Ice::LocatorPrx& __locator) const
00698     {
00699     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00700         typedef ::IceProxy::Ice::Object _Base;
00701         return dynamic_cast<MessageAgent*>(_Base::ice_locator(__locator).get());
00702     #else
00703         return dynamic_cast<MessageAgent*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
00704     #endif
00705     }
00706 
00707     ::IceInternal::ProxyHandle<MessageAgent> ice_collocationOptimized(bool __co) const
00708     {
00709     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00710         typedef ::IceProxy::Ice::Object _Base;
00711         return dynamic_cast<MessageAgent*>(_Base::ice_collocationOptimized(__co).get());
00712     #else
00713         return dynamic_cast<MessageAgent*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
00714     #endif
00715     }
00716 
00717     ::IceInternal::ProxyHandle<MessageAgent> ice_twoway() const
00718     {
00719     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00720         typedef ::IceProxy::Ice::Object _Base;
00721         return dynamic_cast<MessageAgent*>(_Base::ice_twoway().get());
00722     #else
00723         return dynamic_cast<MessageAgent*>(::IceProxy::Ice::Object::ice_twoway().get());
00724     #endif
00725     }
00726 
00727     ::IceInternal::ProxyHandle<MessageAgent> ice_oneway() const
00728     {
00729     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00730         typedef ::IceProxy::Ice::Object _Base;
00731         return dynamic_cast<MessageAgent*>(_Base::ice_oneway().get());
00732     #else
00733         return dynamic_cast<MessageAgent*>(::IceProxy::Ice::Object::ice_oneway().get());
00734     #endif
00735     }
00736 
00737     ::IceInternal::ProxyHandle<MessageAgent> ice_batchOneway() const
00738     {
00739     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00740         typedef ::IceProxy::Ice::Object _Base;
00741         return dynamic_cast<MessageAgent*>(_Base::ice_batchOneway().get());
00742     #else
00743         return dynamic_cast<MessageAgent*>(::IceProxy::Ice::Object::ice_batchOneway().get());
00744     #endif
00745     }
00746 
00747     ::IceInternal::ProxyHandle<MessageAgent> ice_datagram() const
00748     {
00749     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00750         typedef ::IceProxy::Ice::Object _Base;
00751         return dynamic_cast<MessageAgent*>(_Base::ice_datagram().get());
00752     #else
00753         return dynamic_cast<MessageAgent*>(::IceProxy::Ice::Object::ice_datagram().get());
00754     #endif
00755     }
00756 
00757     ::IceInternal::ProxyHandle<MessageAgent> ice_batchDatagram() const
00758     {
00759     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00760         typedef ::IceProxy::Ice::Object _Base;
00761         return dynamic_cast<MessageAgent*>(_Base::ice_batchDatagram().get());
00762     #else
00763         return dynamic_cast<MessageAgent*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
00764     #endif
00765     }
00766 
00767     ::IceInternal::ProxyHandle<MessageAgent> ice_compress(bool __compress) const
00768     {
00769     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00770         typedef ::IceProxy::Ice::Object _Base;
00771         return dynamic_cast<MessageAgent*>(_Base::ice_compress(__compress).get());
00772     #else
00773         return dynamic_cast<MessageAgent*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
00774     #endif
00775     }
00776 
00777     ::IceInternal::ProxyHandle<MessageAgent> ice_timeout(int __timeout) const
00778     {
00779     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00780         typedef ::IceProxy::Ice::Object _Base;
00781         return dynamic_cast<MessageAgent*>(_Base::ice_timeout(__timeout).get());
00782     #else
00783         return dynamic_cast<MessageAgent*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
00784     #endif
00785     }
00786 
00787     ::IceInternal::ProxyHandle<MessageAgent> ice_connectionId(const std::string& __id) const
00788     {
00789     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00790         typedef ::IceProxy::Ice::Object _Base;
00791         return dynamic_cast<MessageAgent*>(_Base::ice_connectionId(__id).get());
00792     #else
00793         return dynamic_cast<MessageAgent*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
00794     #endif
00795     }
00796 
00797     static const ::std::string& ice_staticId();
00798 
00799 private:
00800 
00801     virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
00802     virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
00803     virtual ::IceProxy::Ice::Object* __newInstance() const;
00804 };
00805 
00806 class CameraImageMessage : virtual public ::IceProxy::HawkMessages::Message
00807 {
00808 public:
00809 
00810     ::IceInternal::ProxyHandle<CameraImageMessage> ice_context(const ::Ice::Context& __context) const
00811     {
00812     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00813         typedef ::IceProxy::Ice::Object _Base;
00814         return dynamic_cast<CameraImageMessage*>(_Base::ice_context(__context).get());
00815     #else
00816         return dynamic_cast<CameraImageMessage*>(::IceProxy::Ice::Object::ice_context(__context).get());
00817     #endif
00818     }
00819 
00820     ::IceInternal::ProxyHandle<CameraImageMessage> ice_adapterId(const std::string& __id) const
00821     {
00822     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00823         typedef ::IceProxy::Ice::Object _Base;
00824         return dynamic_cast<CameraImageMessage*>(_Base::ice_adapterId(__id).get());
00825     #else
00826         return dynamic_cast<CameraImageMessage*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
00827     #endif
00828     }
00829 
00830     ::IceInternal::ProxyHandle<CameraImageMessage> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
00831     {
00832     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00833         typedef ::IceProxy::Ice::Object _Base;
00834         return dynamic_cast<CameraImageMessage*>(_Base::ice_endpoints(__endpoints).get());
00835     #else
00836         return dynamic_cast<CameraImageMessage*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
00837     #endif
00838     }
00839 
00840     ::IceInternal::ProxyHandle<CameraImageMessage> ice_locatorCacheTimeout(int __timeout) const
00841     {
00842     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00843         typedef ::IceProxy::Ice::Object _Base;
00844         return dynamic_cast<CameraImageMessage*>(_Base::ice_locatorCacheTimeout(__timeout).get());
00845     #else
00846         return dynamic_cast<CameraImageMessage*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
00847     #endif
00848     }
00849 
00850     ::IceInternal::ProxyHandle<CameraImageMessage> ice_connectionCached(bool __cached) const
00851     {
00852     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00853         typedef ::IceProxy::Ice::Object _Base;
00854         return dynamic_cast<CameraImageMessage*>(_Base::ice_connectionCached(__cached).get());
00855     #else
00856         return dynamic_cast<CameraImageMessage*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
00857     #endif
00858     }
00859 
00860     ::IceInternal::ProxyHandle<CameraImageMessage> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
00861     {
00862     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00863         typedef ::IceProxy::Ice::Object _Base;
00864         return dynamic_cast<CameraImageMessage*>(_Base::ice_endpointSelection(__est).get());
00865     #else
00866         return dynamic_cast<CameraImageMessage*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
00867     #endif
00868     }
00869 
00870     ::IceInternal::ProxyHandle<CameraImageMessage> ice_secure(bool __secure) const
00871     {
00872     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00873         typedef ::IceProxy::Ice::Object _Base;
00874         return dynamic_cast<CameraImageMessage*>(_Base::ice_secure(__secure).get());
00875     #else
00876         return dynamic_cast<CameraImageMessage*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
00877     #endif
00878     }
00879 
00880     ::IceInternal::ProxyHandle<CameraImageMessage> ice_preferSecure(bool __preferSecure) const
00881     {
00882     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00883         typedef ::IceProxy::Ice::Object _Base;
00884         return dynamic_cast<CameraImageMessage*>(_Base::ice_preferSecure(__preferSecure).get());
00885     #else
00886         return dynamic_cast<CameraImageMessage*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
00887     #endif
00888     }
00889 
00890     ::IceInternal::ProxyHandle<CameraImageMessage> ice_router(const ::Ice::RouterPrx& __router) const
00891     {
00892     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00893         typedef ::IceProxy::Ice::Object _Base;
00894         return dynamic_cast<CameraImageMessage*>(_Base::ice_router(__router).get());
00895     #else
00896         return dynamic_cast<CameraImageMessage*>(::IceProxy::Ice::Object::ice_router(__router).get());
00897     #endif
00898     }
00899 
00900     ::IceInternal::ProxyHandle<CameraImageMessage> ice_locator(const ::Ice::LocatorPrx& __locator) const
00901     {
00902     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00903         typedef ::IceProxy::Ice::Object _Base;
00904         return dynamic_cast<CameraImageMessage*>(_Base::ice_locator(__locator).get());
00905     #else
00906         return dynamic_cast<CameraImageMessage*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
00907     #endif
00908     }
00909 
00910     ::IceInternal::ProxyHandle<CameraImageMessage> ice_collocationOptimized(bool __co) const
00911     {
00912     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00913         typedef ::IceProxy::Ice::Object _Base;
00914         return dynamic_cast<CameraImageMessage*>(_Base::ice_collocationOptimized(__co).get());
00915     #else
00916         return dynamic_cast<CameraImageMessage*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
00917     #endif
00918     }
00919 
00920     ::IceInternal::ProxyHandle<CameraImageMessage> ice_twoway() const
00921     {
00922     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00923         typedef ::IceProxy::Ice::Object _Base;
00924         return dynamic_cast<CameraImageMessage*>(_Base::ice_twoway().get());
00925     #else
00926         return dynamic_cast<CameraImageMessage*>(::IceProxy::Ice::Object::ice_twoway().get());
00927     #endif
00928     }
00929 
00930     ::IceInternal::ProxyHandle<CameraImageMessage> ice_oneway() const
00931     {
00932     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00933         typedef ::IceProxy::Ice::Object _Base;
00934         return dynamic_cast<CameraImageMessage*>(_Base::ice_oneway().get());
00935     #else
00936         return dynamic_cast<CameraImageMessage*>(::IceProxy::Ice::Object::ice_oneway().get());
00937     #endif
00938     }
00939 
00940     ::IceInternal::ProxyHandle<CameraImageMessage> ice_batchOneway() const
00941     {
00942     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00943         typedef ::IceProxy::Ice::Object _Base;
00944         return dynamic_cast<CameraImageMessage*>(_Base::ice_batchOneway().get());
00945     #else
00946         return dynamic_cast<CameraImageMessage*>(::IceProxy::Ice::Object::ice_batchOneway().get());
00947     #endif
00948     }
00949 
00950     ::IceInternal::ProxyHandle<CameraImageMessage> ice_datagram() const
00951     {
00952     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00953         typedef ::IceProxy::Ice::Object _Base;
00954         return dynamic_cast<CameraImageMessage*>(_Base::ice_datagram().get());
00955     #else
00956         return dynamic_cast<CameraImageMessage*>(::IceProxy::Ice::Object::ice_datagram().get());
00957     #endif
00958     }
00959 
00960     ::IceInternal::ProxyHandle<CameraImageMessage> ice_batchDatagram() const
00961     {
00962     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00963         typedef ::IceProxy::Ice::Object _Base;
00964         return dynamic_cast<CameraImageMessage*>(_Base::ice_batchDatagram().get());
00965     #else
00966         return dynamic_cast<CameraImageMessage*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
00967     #endif
00968     }
00969 
00970     ::IceInternal::ProxyHandle<CameraImageMessage> ice_compress(bool __compress) const
00971     {
00972     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00973         typedef ::IceProxy::Ice::Object _Base;
00974         return dynamic_cast<CameraImageMessage*>(_Base::ice_compress(__compress).get());
00975     #else
00976         return dynamic_cast<CameraImageMessage*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
00977     #endif
00978     }
00979 
00980     ::IceInternal::ProxyHandle<CameraImageMessage> ice_timeout(int __timeout) const
00981     {
00982     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00983         typedef ::IceProxy::Ice::Object _Base;
00984         return dynamic_cast<CameraImageMessage*>(_Base::ice_timeout(__timeout).get());
00985     #else
00986         return dynamic_cast<CameraImageMessage*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
00987     #endif
00988     }
00989 
00990     ::IceInternal::ProxyHandle<CameraImageMessage> ice_connectionId(const std::string& __id) const
00991     {
00992     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00993         typedef ::IceProxy::Ice::Object _Base;
00994         return dynamic_cast<CameraImageMessage*>(_Base::ice_connectionId(__id).get());
00995     #else
00996         return dynamic_cast<CameraImageMessage*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
00997     #endif
00998     }
00999 
01000     static const ::std::string& ice_staticId();
01001 
01002 private:
01003 
01004     virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
01005     virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
01006     virtual ::IceProxy::Ice::Object* __newInstance() const;
01007 };
01008 
01009 class ControlCameraMessage : virtual public ::IceProxy::HawkMessages::Message
01010 {
01011 public:
01012 
01013     ::IceInternal::ProxyHandle<ControlCameraMessage> ice_context(const ::Ice::Context& __context) const
01014     {
01015     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01016         typedef ::IceProxy::Ice::Object _Base;
01017         return dynamic_cast<ControlCameraMessage*>(_Base::ice_context(__context).get());
01018     #else
01019         return dynamic_cast<ControlCameraMessage*>(::IceProxy::Ice::Object::ice_context(__context).get());
01020     #endif
01021     }
01022 
01023     ::IceInternal::ProxyHandle<ControlCameraMessage> ice_adapterId(const std::string& __id) const
01024     {
01025     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01026         typedef ::IceProxy::Ice::Object _Base;
01027         return dynamic_cast<ControlCameraMessage*>(_Base::ice_adapterId(__id).get());
01028     #else
01029         return dynamic_cast<ControlCameraMessage*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
01030     #endif
01031     }
01032 
01033     ::IceInternal::ProxyHandle<ControlCameraMessage> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
01034     {
01035     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01036         typedef ::IceProxy::Ice::Object _Base;
01037         return dynamic_cast<ControlCameraMessage*>(_Base::ice_endpoints(__endpoints).get());
01038     #else
01039         return dynamic_cast<ControlCameraMessage*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
01040     #endif
01041     }
01042 
01043     ::IceInternal::ProxyHandle<ControlCameraMessage> ice_locatorCacheTimeout(int __timeout) const
01044     {
01045     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01046         typedef ::IceProxy::Ice::Object _Base;
01047         return dynamic_cast<ControlCameraMessage*>(_Base::ice_locatorCacheTimeout(__timeout).get());
01048     #else
01049         return dynamic_cast<ControlCameraMessage*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
01050     #endif
01051     }
01052 
01053     ::IceInternal::ProxyHandle<ControlCameraMessage> ice_connectionCached(bool __cached) const
01054     {
01055     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01056         typedef ::IceProxy::Ice::Object _Base;
01057         return dynamic_cast<ControlCameraMessage*>(_Base::ice_connectionCached(__cached).get());
01058     #else
01059         return dynamic_cast<ControlCameraMessage*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
01060     #endif
01061     }
01062 
01063     ::IceInternal::ProxyHandle<ControlCameraMessage> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
01064     {
01065     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01066         typedef ::IceProxy::Ice::Object _Base;
01067         return dynamic_cast<ControlCameraMessage*>(_Base::ice_endpointSelection(__est).get());
01068     #else
01069         return dynamic_cast<ControlCameraMessage*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
01070     #endif
01071     }
01072 
01073     ::IceInternal::ProxyHandle<ControlCameraMessage> ice_secure(bool __secure) const
01074     {
01075     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01076         typedef ::IceProxy::Ice::Object _Base;
01077         return dynamic_cast<ControlCameraMessage*>(_Base::ice_secure(__secure).get());
01078     #else
01079         return dynamic_cast<ControlCameraMessage*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
01080     #endif
01081     }
01082 
01083     ::IceInternal::ProxyHandle<ControlCameraMessage> ice_preferSecure(bool __preferSecure) const
01084     {
01085     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01086         typedef ::IceProxy::Ice::Object _Base;
01087         return dynamic_cast<ControlCameraMessage*>(_Base::ice_preferSecure(__preferSecure).get());
01088     #else
01089         return dynamic_cast<ControlCameraMessage*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
01090     #endif
01091     }
01092 
01093     ::IceInternal::ProxyHandle<ControlCameraMessage> ice_router(const ::Ice::RouterPrx& __router) const
01094     {
01095     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01096         typedef ::IceProxy::Ice::Object _Base;
01097         return dynamic_cast<ControlCameraMessage*>(_Base::ice_router(__router).get());
01098     #else
01099         return dynamic_cast<ControlCameraMessage*>(::IceProxy::Ice::Object::ice_router(__router).get());
01100     #endif
01101     }
01102 
01103     ::IceInternal::ProxyHandle<ControlCameraMessage> ice_locator(const ::Ice::LocatorPrx& __locator) const
01104     {
01105     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01106         typedef ::IceProxy::Ice::Object _Base;
01107         return dynamic_cast<ControlCameraMessage*>(_Base::ice_locator(__locator).get());
01108     #else
01109         return dynamic_cast<ControlCameraMessage*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
01110     #endif
01111     }
01112 
01113     ::IceInternal::ProxyHandle<ControlCameraMessage> ice_collocationOptimized(bool __co) const
01114     {
01115     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01116         typedef ::IceProxy::Ice::Object _Base;
01117         return dynamic_cast<ControlCameraMessage*>(_Base::ice_collocationOptimized(__co).get());
01118     #else
01119         return dynamic_cast<ControlCameraMessage*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
01120     #endif
01121     }
01122 
01123     ::IceInternal::ProxyHandle<ControlCameraMessage> ice_twoway() const
01124     {
01125     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01126         typedef ::IceProxy::Ice::Object _Base;
01127         return dynamic_cast<ControlCameraMessage*>(_Base::ice_twoway().get());
01128     #else
01129         return dynamic_cast<ControlCameraMessage*>(::IceProxy::Ice::Object::ice_twoway().get());
01130     #endif
01131     }
01132 
01133     ::IceInternal::ProxyHandle<ControlCameraMessage> ice_oneway() const
01134     {
01135     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01136         typedef ::IceProxy::Ice::Object _Base;
01137         return dynamic_cast<ControlCameraMessage*>(_Base::ice_oneway().get());
01138     #else
01139         return dynamic_cast<ControlCameraMessage*>(::IceProxy::Ice::Object::ice_oneway().get());
01140     #endif
01141     }
01142 
01143     ::IceInternal::ProxyHandle<ControlCameraMessage> ice_batchOneway() const
01144     {
01145     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01146         typedef ::IceProxy::Ice::Object _Base;
01147         return dynamic_cast<ControlCameraMessage*>(_Base::ice_batchOneway().get());
01148     #else
01149         return dynamic_cast<ControlCameraMessage*>(::IceProxy::Ice::Object::ice_batchOneway().get());
01150     #endif
01151     }
01152 
01153     ::IceInternal::ProxyHandle<ControlCameraMessage> ice_datagram() const
01154     {
01155     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01156         typedef ::IceProxy::Ice::Object _Base;
01157         return dynamic_cast<ControlCameraMessage*>(_Base::ice_datagram().get());
01158     #else
01159         return dynamic_cast<ControlCameraMessage*>(::IceProxy::Ice::Object::ice_datagram().get());
01160     #endif
01161     }
01162 
01163     ::IceInternal::ProxyHandle<ControlCameraMessage> ice_batchDatagram() const
01164     {
01165     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01166         typedef ::IceProxy::Ice::Object _Base;
01167         return dynamic_cast<ControlCameraMessage*>(_Base::ice_batchDatagram().get());
01168     #else
01169         return dynamic_cast<ControlCameraMessage*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
01170     #endif
01171     }
01172 
01173     ::IceInternal::ProxyHandle<ControlCameraMessage> ice_compress(bool __compress) const
01174     {
01175     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01176         typedef ::IceProxy::Ice::Object _Base;
01177         return dynamic_cast<ControlCameraMessage*>(_Base::ice_compress(__compress).get());
01178     #else
01179         return dynamic_cast<ControlCameraMessage*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
01180     #endif
01181     }
01182 
01183     ::IceInternal::ProxyHandle<ControlCameraMessage> ice_timeout(int __timeout) const
01184     {
01185     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01186         typedef ::IceProxy::Ice::Object _Base;
01187         return dynamic_cast<ControlCameraMessage*>(_Base::ice_timeout(__timeout).get());
01188     #else
01189         return dynamic_cast<ControlCameraMessage*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
01190     #endif
01191     }
01192 
01193     ::IceInternal::ProxyHandle<ControlCameraMessage> ice_connectionId(const std::string& __id) const
01194     {
01195     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01196         typedef ::IceProxy::Ice::Object _Base;
01197         return dynamic_cast<ControlCameraMessage*>(_Base::ice_connectionId(__id).get());
01198     #else
01199         return dynamic_cast<ControlCameraMessage*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
01200     #endif
01201     }
01202 
01203     static const ::std::string& ice_staticId();
01204 
01205 private:
01206 
01207     virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
01208     virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
01209     virtual ::IceProxy::Ice::Object* __newInstance() const;
01210 };
01211 
01212 class ControlDriveVisionMessage : virtual public ::IceProxy::HawkMessages::Message
01213 {
01214 public:
01215 
01216     ::IceInternal::ProxyHandle<ControlDriveVisionMessage> ice_context(const ::Ice::Context& __context) const
01217     {
01218     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01219         typedef ::IceProxy::Ice::Object _Base;
01220         return dynamic_cast<ControlDriveVisionMessage*>(_Base::ice_context(__context).get());
01221     #else
01222         return dynamic_cast<ControlDriveVisionMessage*>(::IceProxy::Ice::Object::ice_context(__context).get());
01223     #endif
01224     }
01225 
01226     ::IceInternal::ProxyHandle<ControlDriveVisionMessage> ice_adapterId(const std::string& __id) const
01227     {
01228     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01229         typedef ::IceProxy::Ice::Object _Base;
01230         return dynamic_cast<ControlDriveVisionMessage*>(_Base::ice_adapterId(__id).get());
01231     #else
01232         return dynamic_cast<ControlDriveVisionMessage*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
01233     #endif
01234     }
01235 
01236     ::IceInternal::ProxyHandle<ControlDriveVisionMessage> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
01237     {
01238     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01239         typedef ::IceProxy::Ice::Object _Base;
01240         return dynamic_cast<ControlDriveVisionMessage*>(_Base::ice_endpoints(__endpoints).get());
01241     #else
01242         return dynamic_cast<ControlDriveVisionMessage*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
01243     #endif
01244     }
01245 
01246     ::IceInternal::ProxyHandle<ControlDriveVisionMessage> ice_locatorCacheTimeout(int __timeout) const
01247     {
01248     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01249         typedef ::IceProxy::Ice::Object _Base;
01250         return dynamic_cast<ControlDriveVisionMessage*>(_Base::ice_locatorCacheTimeout(__timeout).get());
01251     #else
01252         return dynamic_cast<ControlDriveVisionMessage*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
01253     #endif
01254     }
01255 
01256     ::IceInternal::ProxyHandle<ControlDriveVisionMessage> ice_connectionCached(bool __cached) const
01257     {
01258     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01259         typedef ::IceProxy::Ice::Object _Base;
01260         return dynamic_cast<ControlDriveVisionMessage*>(_Base::ice_connectionCached(__cached).get());
01261     #else
01262         return dynamic_cast<ControlDriveVisionMessage*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
01263     #endif
01264     }
01265 
01266     ::IceInternal::ProxyHandle<ControlDriveVisionMessage> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
01267     {
01268     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01269         typedef ::IceProxy::Ice::Object _Base;
01270         return dynamic_cast<ControlDriveVisionMessage*>(_Base::ice_endpointSelection(__est).get());
01271     #else
01272         return dynamic_cast<ControlDriveVisionMessage*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
01273     #endif
01274     }
01275 
01276     ::IceInternal::ProxyHandle<ControlDriveVisionMessage> ice_secure(bool __secure) const
01277     {
01278     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01279         typedef ::IceProxy::Ice::Object _Base;
01280         return dynamic_cast<ControlDriveVisionMessage*>(_Base::ice_secure(__secure).get());
01281     #else
01282         return dynamic_cast<ControlDriveVisionMessage*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
01283     #endif
01284     }
01285 
01286     ::IceInternal::ProxyHandle<ControlDriveVisionMessage> ice_preferSecure(bool __preferSecure) const
01287     {
01288     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01289         typedef ::IceProxy::Ice::Object _Base;
01290         return dynamic_cast<ControlDriveVisionMessage*>(_Base::ice_preferSecure(__preferSecure).get());
01291     #else
01292         return dynamic_cast<ControlDriveVisionMessage*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
01293     #endif
01294     }
01295 
01296     ::IceInternal::ProxyHandle<ControlDriveVisionMessage> ice_router(const ::Ice::RouterPrx& __router) const
01297     {
01298     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01299         typedef ::IceProxy::Ice::Object _Base;
01300         return dynamic_cast<ControlDriveVisionMessage*>(_Base::ice_router(__router).get());
01301     #else
01302         return dynamic_cast<ControlDriveVisionMessage*>(::IceProxy::Ice::Object::ice_router(__router).get());
01303     #endif
01304     }
01305 
01306     ::IceInternal::ProxyHandle<ControlDriveVisionMessage> ice_locator(const ::Ice::LocatorPrx& __locator) const
01307     {
01308     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01309         typedef ::IceProxy::Ice::Object _Base;
01310         return dynamic_cast<ControlDriveVisionMessage*>(_Base::ice_locator(__locator).get());
01311     #else
01312         return dynamic_cast<ControlDriveVisionMessage*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
01313     #endif
01314     }
01315 
01316     ::IceInternal::ProxyHandle<ControlDriveVisionMessage> ice_collocationOptimized(bool __co) const
01317     {
01318     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01319         typedef ::IceProxy::Ice::Object _Base;
01320         return dynamic_cast<ControlDriveVisionMessage*>(_Base::ice_collocationOptimized(__co).get());
01321     #else
01322         return dynamic_cast<ControlDriveVisionMessage*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
01323     #endif
01324     }
01325 
01326     ::IceInternal::ProxyHandle<ControlDriveVisionMessage> ice_twoway() const
01327     {
01328     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01329         typedef ::IceProxy::Ice::Object _Base;
01330         return dynamic_cast<ControlDriveVisionMessage*>(_Base::ice_twoway().get());
01331     #else
01332         return dynamic_cast<ControlDriveVisionMessage*>(::IceProxy::Ice::Object::ice_twoway().get());
01333     #endif
01334     }
01335 
01336     ::IceInternal::ProxyHandle<ControlDriveVisionMessage> ice_oneway() const
01337     {
01338     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01339         typedef ::IceProxy::Ice::Object _Base;
01340         return dynamic_cast<ControlDriveVisionMessage*>(_Base::ice_oneway().get());
01341     #else
01342         return dynamic_cast<ControlDriveVisionMessage*>(::IceProxy::Ice::Object::ice_oneway().get());
01343     #endif
01344     }
01345 
01346     ::IceInternal::ProxyHandle<ControlDriveVisionMessage> ice_batchOneway() const
01347     {
01348     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01349         typedef ::IceProxy::Ice::Object _Base;
01350         return dynamic_cast<ControlDriveVisionMessage*>(_Base::ice_batchOneway().get());
01351     #else
01352         return dynamic_cast<ControlDriveVisionMessage*>(::IceProxy::Ice::Object::ice_batchOneway().get());
01353     #endif
01354     }
01355 
01356     ::IceInternal::ProxyHandle<ControlDriveVisionMessage> ice_datagram() const
01357     {
01358     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01359         typedef ::IceProxy::Ice::Object _Base;
01360         return dynamic_cast<ControlDriveVisionMessage*>(_Base::ice_datagram().get());
01361     #else
01362         return dynamic_cast<ControlDriveVisionMessage*>(::IceProxy::Ice::Object::ice_datagram().get());
01363     #endif
01364     }
01365 
01366     ::IceInternal::ProxyHandle<ControlDriveVisionMessage> ice_batchDatagram() const
01367     {
01368     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01369         typedef ::IceProxy::Ice::Object _Base;
01370         return dynamic_cast<ControlDriveVisionMessage*>(_Base::ice_batchDatagram().get());
01371     #else
01372         return dynamic_cast<ControlDriveVisionMessage*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
01373     #endif
01374     }
01375 
01376     ::IceInternal::ProxyHandle<ControlDriveVisionMessage> ice_compress(bool __compress) const
01377     {
01378     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01379         typedef ::IceProxy::Ice::Object _Base;
01380         return dynamic_cast<ControlDriveVisionMessage*>(_Base::ice_compress(__compress).get());
01381     #else
01382         return dynamic_cast<ControlDriveVisionMessage*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
01383     #endif
01384     }
01385 
01386     ::IceInternal::ProxyHandle<ControlDriveVisionMessage> ice_timeout(int __timeout) const
01387     {
01388     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01389         typedef ::IceProxy::Ice::Object _Base;
01390         return dynamic_cast<ControlDriveVisionMessage*>(_Base::ice_timeout(__timeout).get());
01391     #else
01392         return dynamic_cast<ControlDriveVisionMessage*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
01393     #endif
01394     }
01395 
01396     ::IceInternal::ProxyHandle<ControlDriveVisionMessage> ice_connectionId(const std::string& __id) const
01397     {
01398     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01399         typedef ::IceProxy::Ice::Object _Base;
01400         return dynamic_cast<ControlDriveVisionMessage*>(_Base::ice_connectionId(__id).get());
01401     #else
01402         return dynamic_cast<ControlDriveVisionMessage*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
01403     #endif
01404     }
01405 
01406     static const ::std::string& ice_staticId();
01407 
01408 private:
01409 
01410     virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
01411     virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
01412     virtual ::IceProxy::Ice::Object* __newInstance() const;
01413 };
01414 
01415 class ControlLandMessage : virtual public ::IceProxy::HawkMessages::Message
01416 {
01417 public:
01418 
01419     ::IceInternal::ProxyHandle<ControlLandMessage> ice_context(const ::Ice::Context& __context) const
01420     {
01421     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01422         typedef ::IceProxy::Ice::Object _Base;
01423         return dynamic_cast<ControlLandMessage*>(_Base::ice_context(__context).get());
01424     #else
01425         return dynamic_cast<ControlLandMessage*>(::IceProxy::Ice::Object::ice_context(__context).get());
01426     #endif
01427     }
01428 
01429     ::IceInternal::ProxyHandle<ControlLandMessage> ice_adapterId(const std::string& __id) const
01430     {
01431     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01432         typedef ::IceProxy::Ice::Object _Base;
01433         return dynamic_cast<ControlLandMessage*>(_Base::ice_adapterId(__id).get());
01434     #else
01435         return dynamic_cast<ControlLandMessage*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
01436     #endif
01437     }
01438 
01439     ::IceInternal::ProxyHandle<ControlLandMessage> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
01440     {
01441     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01442         typedef ::IceProxy::Ice::Object _Base;
01443         return dynamic_cast<ControlLandMessage*>(_Base::ice_endpoints(__endpoints).get());
01444     #else
01445         return dynamic_cast<ControlLandMessage*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
01446     #endif
01447     }
01448 
01449     ::IceInternal::ProxyHandle<ControlLandMessage> ice_locatorCacheTimeout(int __timeout) const
01450     {
01451     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01452         typedef ::IceProxy::Ice::Object _Base;
01453         return dynamic_cast<ControlLandMessage*>(_Base::ice_locatorCacheTimeout(__timeout).get());
01454     #else
01455         return dynamic_cast<ControlLandMessage*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
01456     #endif
01457     }
01458 
01459     ::IceInternal::ProxyHandle<ControlLandMessage> ice_connectionCached(bool __cached) const
01460     {
01461     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01462         typedef ::IceProxy::Ice::Object _Base;
01463         return dynamic_cast<ControlLandMessage*>(_Base::ice_connectionCached(__cached).get());
01464     #else
01465         return dynamic_cast<ControlLandMessage*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
01466     #endif
01467     }
01468 
01469     ::IceInternal::ProxyHandle<ControlLandMessage> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
01470     {
01471     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01472         typedef ::IceProxy::Ice::Object _Base;
01473         return dynamic_cast<ControlLandMessage*>(_Base::ice_endpointSelection(__est).get());
01474     #else
01475         return dynamic_cast<ControlLandMessage*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
01476     #endif
01477     }
01478 
01479     ::IceInternal::ProxyHandle<ControlLandMessage> ice_secure(bool __secure) const
01480     {
01481     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01482         typedef ::IceProxy::Ice::Object _Base;
01483         return dynamic_cast<ControlLandMessage*>(_Base::ice_secure(__secure).get());
01484     #else
01485         return dynamic_cast<ControlLandMessage*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
01486     #endif
01487     }
01488 
01489     ::IceInternal::ProxyHandle<ControlLandMessage> ice_preferSecure(bool __preferSecure) const
01490     {
01491     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01492         typedef ::IceProxy::Ice::Object _Base;
01493         return dynamic_cast<ControlLandMessage*>(_Base::ice_preferSecure(__preferSecure).get());
01494     #else
01495         return dynamic_cast<ControlLandMessage*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
01496     #endif
01497     }
01498 
01499     ::IceInternal::ProxyHandle<ControlLandMessage> ice_router(const ::Ice::RouterPrx& __router) const
01500     {
01501     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01502         typedef ::IceProxy::Ice::Object _Base;
01503         return dynamic_cast<ControlLandMessage*>(_Base::ice_router(__router).get());
01504     #else
01505         return dynamic_cast<ControlLandMessage*>(::IceProxy::Ice::Object::ice_router(__router).get());
01506     #endif
01507     }
01508 
01509     ::IceInternal::ProxyHandle<ControlLandMessage> ice_locator(const ::Ice::LocatorPrx& __locator) const
01510     {
01511     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01512         typedef ::IceProxy::Ice::Object _Base;
01513         return dynamic_cast<ControlLandMessage*>(_Base::ice_locator(__locator).get());
01514     #else
01515         return dynamic_cast<ControlLandMessage*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
01516     #endif
01517     }
01518 
01519     ::IceInternal::ProxyHandle<ControlLandMessage> ice_collocationOptimized(bool __co) const
01520     {
01521     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01522         typedef ::IceProxy::Ice::Object _Base;
01523         return dynamic_cast<ControlLandMessage*>(_Base::ice_collocationOptimized(__co).get());
01524     #else
01525         return dynamic_cast<ControlLandMessage*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
01526     #endif
01527     }
01528 
01529     ::IceInternal::ProxyHandle<ControlLandMessage> ice_twoway() const
01530     {
01531     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01532         typedef ::IceProxy::Ice::Object _Base;
01533         return dynamic_cast<ControlLandMessage*>(_Base::ice_twoway().get());
01534     #else
01535         return dynamic_cast<ControlLandMessage*>(::IceProxy::Ice::Object::ice_twoway().get());
01536     #endif
01537     }
01538 
01539     ::IceInternal::ProxyHandle<ControlLandMessage> ice_oneway() const
01540     {
01541     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01542         typedef ::IceProxy::Ice::Object _Base;
01543         return dynamic_cast<ControlLandMessage*>(_Base::ice_oneway().get());
01544     #else
01545         return dynamic_cast<ControlLandMessage*>(::IceProxy::Ice::Object::ice_oneway().get());
01546     #endif
01547     }
01548 
01549     ::IceInternal::ProxyHandle<ControlLandMessage> ice_batchOneway() const
01550     {
01551     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01552         typedef ::IceProxy::Ice::Object _Base;
01553         return dynamic_cast<ControlLandMessage*>(_Base::ice_batchOneway().get());
01554     #else
01555         return dynamic_cast<ControlLandMessage*>(::IceProxy::Ice::Object::ice_batchOneway().get());
01556     #endif
01557     }
01558 
01559     ::IceInternal::ProxyHandle<ControlLandMessage> ice_datagram() const
01560     {
01561     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01562         typedef ::IceProxy::Ice::Object _Base;
01563         return dynamic_cast<ControlLandMessage*>(_Base::ice_datagram().get());
01564     #else
01565         return dynamic_cast<ControlLandMessage*>(::IceProxy::Ice::Object::ice_datagram().get());
01566     #endif
01567     }
01568 
01569     ::IceInternal::ProxyHandle<ControlLandMessage> ice_batchDatagram() const
01570     {
01571     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01572         typedef ::IceProxy::Ice::Object _Base;
01573         return dynamic_cast<ControlLandMessage*>(_Base::ice_batchDatagram().get());
01574     #else
01575         return dynamic_cast<ControlLandMessage*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
01576     #endif
01577     }
01578 
01579     ::IceInternal::ProxyHandle<ControlLandMessage> ice_compress(bool __compress) const
01580     {
01581     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01582         typedef ::IceProxy::Ice::Object _Base;
01583         return dynamic_cast<ControlLandMessage*>(_Base::ice_compress(__compress).get());
01584     #else
01585         return dynamic_cast<ControlLandMessage*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
01586     #endif
01587     }
01588 
01589     ::IceInternal::ProxyHandle<ControlLandMessage> ice_timeout(int __timeout) const
01590     {
01591     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01592         typedef ::IceProxy::Ice::Object _Base;
01593         return dynamic_cast<ControlLandMessage*>(_Base::ice_timeout(__timeout).get());
01594     #else
01595         return dynamic_cast<ControlLandMessage*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
01596     #endif
01597     }
01598 
01599     ::IceInternal::ProxyHandle<ControlLandMessage> ice_connectionId(const std::string& __id) const
01600     {
01601     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01602         typedef ::IceProxy::Ice::Object _Base;
01603         return dynamic_cast<ControlLandMessage*>(_Base::ice_connectionId(__id).get());
01604     #else
01605         return dynamic_cast<ControlLandMessage*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
01606     #endif
01607     }
01608 
01609     static const ::std::string& ice_staticId();
01610 
01611 private:
01612 
01613     virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
01614     virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
01615     virtual ::IceProxy::Ice::Object* __newInstance() const;
01616 };
01617 
01618 class ControlMoveMessage : virtual public ::IceProxy::HawkMessages::Message
01619 {
01620 public:
01621 
01622     ::IceInternal::ProxyHandle<ControlMoveMessage> ice_context(const ::Ice::Context& __context) const
01623     {
01624     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01625         typedef ::IceProxy::Ice::Object _Base;
01626         return dynamic_cast<ControlMoveMessage*>(_Base::ice_context(__context).get());
01627     #else
01628         return dynamic_cast<ControlMoveMessage*>(::IceProxy::Ice::Object::ice_context(__context).get());
01629     #endif
01630     }
01631 
01632     ::IceInternal::ProxyHandle<ControlMoveMessage> ice_adapterId(const std::string& __id) const
01633     {
01634     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01635         typedef ::IceProxy::Ice::Object _Base;
01636         return dynamic_cast<ControlMoveMessage*>(_Base::ice_adapterId(__id).get());
01637     #else
01638         return dynamic_cast<ControlMoveMessage*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
01639     #endif
01640     }
01641 
01642     ::IceInternal::ProxyHandle<ControlMoveMessage> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
01643     {
01644     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01645         typedef ::IceProxy::Ice::Object _Base;
01646         return dynamic_cast<ControlMoveMessage*>(_Base::ice_endpoints(__endpoints).get());
01647     #else
01648         return dynamic_cast<ControlMoveMessage*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
01649     #endif
01650     }
01651 
01652     ::IceInternal::ProxyHandle<ControlMoveMessage> ice_locatorCacheTimeout(int __timeout) const
01653     {
01654     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01655         typedef ::IceProxy::Ice::Object _Base;
01656         return dynamic_cast<ControlMoveMessage*>(_Base::ice_locatorCacheTimeout(__timeout).get());
01657     #else
01658         return dynamic_cast<ControlMoveMessage*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
01659     #endif
01660     }
01661 
01662     ::IceInternal::ProxyHandle<ControlMoveMessage> ice_connectionCached(bool __cached) const
01663     {
01664     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01665         typedef ::IceProxy::Ice::Object _Base;
01666         return dynamic_cast<ControlMoveMessage*>(_Base::ice_connectionCached(__cached).get());
01667     #else
01668         return dynamic_cast<ControlMoveMessage*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
01669     #endif
01670     }
01671 
01672     ::IceInternal::ProxyHandle<ControlMoveMessage> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
01673     {
01674     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01675         typedef ::IceProxy::Ice::Object _Base;
01676         return dynamic_cast<ControlMoveMessage*>(_Base::ice_endpointSelection(__est).get());
01677     #else
01678         return dynamic_cast<ControlMoveMessage*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
01679     #endif
01680     }
01681 
01682     ::IceInternal::ProxyHandle<ControlMoveMessage> ice_secure(bool __secure) const
01683     {
01684     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01685         typedef ::IceProxy::Ice::Object _Base;
01686         return dynamic_cast<ControlMoveMessage*>(_Base::ice_secure(__secure).get());
01687     #else
01688         return dynamic_cast<ControlMoveMessage*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
01689     #endif
01690     }
01691 
01692     ::IceInternal::ProxyHandle<ControlMoveMessage> ice_preferSecure(bool __preferSecure) const
01693     {
01694     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01695         typedef ::IceProxy::Ice::Object _Base;
01696         return dynamic_cast<ControlMoveMessage*>(_Base::ice_preferSecure(__preferSecure).get());
01697     #else
01698         return dynamic_cast<ControlMoveMessage*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
01699     #endif
01700     }
01701 
01702     ::IceInternal::ProxyHandle<ControlMoveMessage> ice_router(const ::Ice::RouterPrx& __router) const
01703     {
01704     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01705         typedef ::IceProxy::Ice::Object _Base;
01706         return dynamic_cast<ControlMoveMessage*>(_Base::ice_router(__router).get());
01707     #else
01708         return dynamic_cast<ControlMoveMessage*>(::IceProxy::Ice::Object::ice_router(__router).get());
01709     #endif
01710     }
01711 
01712     ::IceInternal::ProxyHandle<ControlMoveMessage> ice_locator(const ::Ice::LocatorPrx& __locator) const
01713     {
01714     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01715         typedef ::IceProxy::Ice::Object _Base;
01716         return dynamic_cast<ControlMoveMessage*>(_Base::ice_locator(__locator).get());
01717     #else
01718         return dynamic_cast<ControlMoveMessage*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
01719     #endif
01720     }
01721 
01722     ::IceInternal::ProxyHandle<ControlMoveMessage> ice_collocationOptimized(bool __co) const
01723     {
01724     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01725         typedef ::IceProxy::Ice::Object _Base;
01726         return dynamic_cast<ControlMoveMessage*>(_Base::ice_collocationOptimized(__co).get());
01727     #else
01728         return dynamic_cast<ControlMoveMessage*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
01729     #endif
01730     }
01731 
01732     ::IceInternal::ProxyHandle<ControlMoveMessage> ice_twoway() const
01733     {
01734     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01735         typedef ::IceProxy::Ice::Object _Base;
01736         return dynamic_cast<ControlMoveMessage*>(_Base::ice_twoway().get());
01737     #else
01738         return dynamic_cast<ControlMoveMessage*>(::IceProxy::Ice::Object::ice_twoway().get());
01739     #endif
01740     }
01741 
01742     ::IceInternal::ProxyHandle<ControlMoveMessage> ice_oneway() const
01743     {
01744     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01745         typedef ::IceProxy::Ice::Object _Base;
01746         return dynamic_cast<ControlMoveMessage*>(_Base::ice_oneway().get());
01747     #else
01748         return dynamic_cast<ControlMoveMessage*>(::IceProxy::Ice::Object::ice_oneway().get());
01749     #endif
01750     }
01751 
01752     ::IceInternal::ProxyHandle<ControlMoveMessage> ice_batchOneway() const
01753     {
01754     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01755         typedef ::IceProxy::Ice::Object _Base;
01756         return dynamic_cast<ControlMoveMessage*>(_Base::ice_batchOneway().get());
01757     #else
01758         return dynamic_cast<ControlMoveMessage*>(::IceProxy::Ice::Object::ice_batchOneway().get());
01759     #endif
01760     }
01761 
01762     ::IceInternal::ProxyHandle<ControlMoveMessage> ice_datagram() const
01763     {
01764     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01765         typedef ::IceProxy::Ice::Object _Base;
01766         return dynamic_cast<ControlMoveMessage*>(_Base::ice_datagram().get());
01767     #else
01768         return dynamic_cast<ControlMoveMessage*>(::IceProxy::Ice::Object::ice_datagram().get());
01769     #endif
01770     }
01771 
01772     ::IceInternal::ProxyHandle<ControlMoveMessage> ice_batchDatagram() const
01773     {
01774     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01775         typedef ::IceProxy::Ice::Object _Base;
01776         return dynamic_cast<ControlMoveMessage*>(_Base::ice_batchDatagram().get());
01777     #else
01778         return dynamic_cast<ControlMoveMessage*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
01779     #endif
01780     }
01781 
01782     ::IceInternal::ProxyHandle<ControlMoveMessage> ice_compress(bool __compress) const
01783     {
01784     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01785         typedef ::IceProxy::Ice::Object _Base;
01786         return dynamic_cast<ControlMoveMessage*>(_Base::ice_compress(__compress).get());
01787     #else
01788         return dynamic_cast<ControlMoveMessage*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
01789     #endif
01790     }
01791 
01792     ::IceInternal::ProxyHandle<ControlMoveMessage> ice_timeout(int __timeout) const
01793     {
01794     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01795         typedef ::IceProxy::Ice::Object _Base;
01796         return dynamic_cast<ControlMoveMessage*>(_Base::ice_timeout(__timeout).get());
01797     #else
01798         return dynamic_cast<ControlMoveMessage*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
01799     #endif
01800     }
01801 
01802     ::IceInternal::ProxyHandle<ControlMoveMessage> ice_connectionId(const std::string& __id) const
01803     {
01804     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01805         typedef ::IceProxy::Ice::Object _Base;
01806         return dynamic_cast<ControlMoveMessage*>(_Base::ice_connectionId(__id).get());
01807     #else
01808         return dynamic_cast<ControlMoveMessage*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
01809     #endif
01810     }
01811 
01812     static const ::std::string& ice_staticId();
01813 
01814 private:
01815 
01816     virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
01817     virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
01818     virtual ::IceProxy::Ice::Object* __newInstance() const;
01819 };
01820 
01821 class ControlRoomVisionMessage : virtual public ::IceProxy::HawkMessages::Message
01822 {
01823 public:
01824 
01825     ::IceInternal::ProxyHandle<ControlRoomVisionMessage> ice_context(const ::Ice::Context& __context) const
01826     {
01827     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01828         typedef ::IceProxy::Ice::Object _Base;
01829         return dynamic_cast<ControlRoomVisionMessage*>(_Base::ice_context(__context).get());
01830     #else
01831         return dynamic_cast<ControlRoomVisionMessage*>(::IceProxy::Ice::Object::ice_context(__context).get());
01832     #endif
01833     }
01834 
01835     ::IceInternal::ProxyHandle<ControlRoomVisionMessage> ice_adapterId(const std::string& __id) const
01836     {
01837     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01838         typedef ::IceProxy::Ice::Object _Base;
01839         return dynamic_cast<ControlRoomVisionMessage*>(_Base::ice_adapterId(__id).get());
01840     #else
01841         return dynamic_cast<ControlRoomVisionMessage*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
01842     #endif
01843     }
01844 
01845     ::IceInternal::ProxyHandle<ControlRoomVisionMessage> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
01846     {
01847     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01848         typedef ::IceProxy::Ice::Object _Base;
01849         return dynamic_cast<ControlRoomVisionMessage*>(_Base::ice_endpoints(__endpoints).get());
01850     #else
01851         return dynamic_cast<ControlRoomVisionMessage*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
01852     #endif
01853     }
01854 
01855     ::IceInternal::ProxyHandle<ControlRoomVisionMessage> ice_locatorCacheTimeout(int __timeout) const
01856     {
01857     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01858         typedef ::IceProxy::Ice::Object _Base;
01859         return dynamic_cast<ControlRoomVisionMessage*>(_Base::ice_locatorCacheTimeout(__timeout).get());
01860     #else
01861         return dynamic_cast<ControlRoomVisionMessage*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
01862     #endif
01863     }
01864 
01865     ::IceInternal::ProxyHandle<ControlRoomVisionMessage> ice_connectionCached(bool __cached) const
01866     {
01867     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01868         typedef ::IceProxy::Ice::Object _Base;
01869         return dynamic_cast<ControlRoomVisionMessage*>(_Base::ice_connectionCached(__cached).get());
01870     #else
01871         return dynamic_cast<ControlRoomVisionMessage*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
01872     #endif
01873     }
01874 
01875     ::IceInternal::ProxyHandle<ControlRoomVisionMessage> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
01876     {
01877     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01878         typedef ::IceProxy::Ice::Object _Base;
01879         return dynamic_cast<ControlRoomVisionMessage*>(_Base::ice_endpointSelection(__est).get());
01880     #else
01881         return dynamic_cast<ControlRoomVisionMessage*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
01882     #endif
01883     }
01884 
01885     ::IceInternal::ProxyHandle<ControlRoomVisionMessage> ice_secure(bool __secure) const
01886     {
01887     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01888         typedef ::IceProxy::Ice::Object _Base;
01889         return dynamic_cast<ControlRoomVisionMessage*>(_Base::ice_secure(__secure).get());
01890     #else
01891         return dynamic_cast<ControlRoomVisionMessage*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
01892     #endif
01893     }
01894 
01895     ::IceInternal::ProxyHandle<ControlRoomVisionMessage> ice_preferSecure(bool __preferSecure) const
01896     {
01897     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01898         typedef ::IceProxy::Ice::Object _Base;
01899         return dynamic_cast<ControlRoomVisionMessage*>(_Base::ice_preferSecure(__preferSecure).get());
01900     #else
01901         return dynamic_cast<ControlRoomVisionMessage*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
01902     #endif
01903     }
01904 
01905     ::IceInternal::ProxyHandle<ControlRoomVisionMessage> ice_router(const ::Ice::RouterPrx& __router) const
01906     {
01907     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01908         typedef ::IceProxy::Ice::Object _Base;
01909         return dynamic_cast<ControlRoomVisionMessage*>(_Base::ice_router(__router).get());
01910     #else
01911         return dynamic_cast<ControlRoomVisionMessage*>(::IceProxy::Ice::Object::ice_router(__router).get());
01912     #endif
01913     }
01914 
01915     ::IceInternal::ProxyHandle<ControlRoomVisionMessage> ice_locator(const ::Ice::LocatorPrx& __locator) const
01916     {
01917     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01918         typedef ::IceProxy::Ice::Object _Base;
01919         return dynamic_cast<ControlRoomVisionMessage*>(_Base::ice_locator(__locator).get());
01920     #else
01921         return dynamic_cast<ControlRoomVisionMessage*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
01922     #endif
01923     }
01924 
01925     ::IceInternal::ProxyHandle<ControlRoomVisionMessage> ice_collocationOptimized(bool __co) const
01926     {
01927     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01928         typedef ::IceProxy::Ice::Object _Base;
01929         return dynamic_cast<ControlRoomVisionMessage*>(_Base::ice_collocationOptimized(__co).get());
01930     #else
01931         return dynamic_cast<ControlRoomVisionMessage*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
01932     #endif
01933     }
01934 
01935     ::IceInternal::ProxyHandle<ControlRoomVisionMessage> ice_twoway() const
01936     {
01937     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01938         typedef ::IceProxy::Ice::Object _Base;
01939         return dynamic_cast<ControlRoomVisionMessage*>(_Base::ice_twoway().get());
01940     #else
01941         return dynamic_cast<ControlRoomVisionMessage*>(::IceProxy::Ice::Object::ice_twoway().get());
01942     #endif
01943     }
01944 
01945     ::IceInternal::ProxyHandle<ControlRoomVisionMessage> ice_oneway() const
01946     {
01947     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01948         typedef ::IceProxy::Ice::Object _Base;
01949         return dynamic_cast<ControlRoomVisionMessage*>(_Base::ice_oneway().get());
01950     #else
01951         return dynamic_cast<ControlRoomVisionMessage*>(::IceProxy::Ice::Object::ice_oneway().get());
01952     #endif
01953     }
01954 
01955     ::IceInternal::ProxyHandle<ControlRoomVisionMessage> ice_batchOneway() const
01956     {
01957     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01958         typedef ::IceProxy::Ice::Object _Base;
01959         return dynamic_cast<ControlRoomVisionMessage*>(_Base::ice_batchOneway().get());
01960     #else
01961         return dynamic_cast<ControlRoomVisionMessage*>(::IceProxy::Ice::Object::ice_batchOneway().get());
01962     #endif
01963     }
01964 
01965     ::IceInternal::ProxyHandle<ControlRoomVisionMessage> ice_datagram() const
01966     {
01967     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01968         typedef ::IceProxy::Ice::Object _Base;
01969         return dynamic_cast<ControlRoomVisionMessage*>(_Base::ice_datagram().get());
01970     #else
01971         return dynamic_cast<ControlRoomVisionMessage*>(::IceProxy::Ice::Object::ice_datagram().get());
01972     #endif
01973     }
01974 
01975     ::IceInternal::ProxyHandle<ControlRoomVisionMessage> ice_batchDatagram() const
01976     {
01977     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01978         typedef ::IceProxy::Ice::Object _Base;
01979         return dynamic_cast<ControlRoomVisionMessage*>(_Base::ice_batchDatagram().get());
01980     #else
01981         return dynamic_cast<ControlRoomVisionMessage*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
01982     #endif
01983     }
01984 
01985     ::IceInternal::ProxyHandle<ControlRoomVisionMessage> ice_compress(bool __compress) const
01986     {
01987     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01988         typedef ::IceProxy::Ice::Object _Base;
01989         return dynamic_cast<ControlRoomVisionMessage*>(_Base::ice_compress(__compress).get());
01990     #else
01991         return dynamic_cast<ControlRoomVisionMessage*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
01992     #endif
01993     }
01994 
01995     ::IceInternal::ProxyHandle<ControlRoomVisionMessage> ice_timeout(int __timeout) const
01996     {
01997     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01998         typedef ::IceProxy::Ice::Object _Base;
01999         return dynamic_cast<ControlRoomVisionMessage*>(_Base::ice_timeout(__timeout).get());
02000     #else
02001         return dynamic_cast<ControlRoomVisionMessage*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
02002     #endif
02003     }
02004 
02005     ::IceInternal::ProxyHandle<ControlRoomVisionMessage> ice_connectionId(const std::string& __id) const
02006     {
02007     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02008         typedef ::IceProxy::Ice::Object _Base;
02009         return dynamic_cast<ControlRoomVisionMessage*>(_Base::ice_connectionId(__id).get());
02010     #else
02011         return dynamic_cast<ControlRoomVisionMessage*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
02012     #endif
02013     }
02014 
02015     static const ::std::string& ice_staticId();
02016 
02017 private:
02018 
02019     virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
02020     virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
02021     virtual ::IceProxy::Ice::Object* __newInstance() const;
02022 };
02023 
02024 class ControlTakeOffMessage : virtual public ::IceProxy::HawkMessages::Message
02025 {
02026 public:
02027 
02028     ::IceInternal::ProxyHandle<ControlTakeOffMessage> ice_context(const ::Ice::Context& __context) const
02029     {
02030     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02031         typedef ::IceProxy::Ice::Object _Base;
02032         return dynamic_cast<ControlTakeOffMessage*>(_Base::ice_context(__context).get());
02033     #else
02034         return dynamic_cast<ControlTakeOffMessage*>(::IceProxy::Ice::Object::ice_context(__context).get());
02035     #endif
02036     }
02037 
02038     ::IceInternal::ProxyHandle<ControlTakeOffMessage> ice_adapterId(const std::string& __id) const
02039     {
02040     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02041         typedef ::IceProxy::Ice::Object _Base;
02042         return dynamic_cast<ControlTakeOffMessage*>(_Base::ice_adapterId(__id).get());
02043     #else
02044         return dynamic_cast<ControlTakeOffMessage*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
02045     #endif
02046     }
02047 
02048     ::IceInternal::ProxyHandle<ControlTakeOffMessage> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
02049     {
02050     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02051         typedef ::IceProxy::Ice::Object _Base;
02052         return dynamic_cast<ControlTakeOffMessage*>(_Base::ice_endpoints(__endpoints).get());
02053     #else
02054         return dynamic_cast<ControlTakeOffMessage*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
02055     #endif
02056     }
02057 
02058     ::IceInternal::ProxyHandle<ControlTakeOffMessage> ice_locatorCacheTimeout(int __timeout) const
02059     {
02060     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02061         typedef ::IceProxy::Ice::Object _Base;
02062         return dynamic_cast<ControlTakeOffMessage*>(_Base::ice_locatorCacheTimeout(__timeout).get());
02063     #else
02064         return dynamic_cast<ControlTakeOffMessage*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
02065     #endif
02066     }
02067 
02068     ::IceInternal::ProxyHandle<ControlTakeOffMessage> ice_connectionCached(bool __cached) const
02069     {
02070     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02071         typedef ::IceProxy::Ice::Object _Base;
02072         return dynamic_cast<ControlTakeOffMessage*>(_Base::ice_connectionCached(__cached).get());
02073     #else
02074         return dynamic_cast<ControlTakeOffMessage*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
02075     #endif
02076     }
02077 
02078     ::IceInternal::ProxyHandle<ControlTakeOffMessage> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
02079     {
02080     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02081         typedef ::IceProxy::Ice::Object _Base;
02082         return dynamic_cast<ControlTakeOffMessage*>(_Base::ice_endpointSelection(__est).get());
02083     #else
02084         return dynamic_cast<ControlTakeOffMessage*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
02085     #endif
02086     }
02087 
02088     ::IceInternal::ProxyHandle<ControlTakeOffMessage> ice_secure(bool __secure) const
02089     {
02090     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02091         typedef ::IceProxy::Ice::Object _Base;
02092         return dynamic_cast<ControlTakeOffMessage*>(_Base::ice_secure(__secure).get());
02093     #else
02094         return dynamic_cast<ControlTakeOffMessage*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
02095     #endif
02096     }
02097 
02098     ::IceInternal::ProxyHandle<ControlTakeOffMessage> ice_preferSecure(bool __preferSecure) const
02099     {
02100     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02101         typedef ::IceProxy::Ice::Object _Base;
02102         return dynamic_cast<ControlTakeOffMessage*>(_Base::ice_preferSecure(__preferSecure).get());
02103     #else
02104         return dynamic_cast<ControlTakeOffMessage*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
02105     #endif
02106     }
02107 
02108     ::IceInternal::ProxyHandle<ControlTakeOffMessage> ice_router(const ::Ice::RouterPrx& __router) const
02109     {
02110     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02111         typedef ::IceProxy::Ice::Object _Base;
02112         return dynamic_cast<ControlTakeOffMessage*>(_Base::ice_router(__router).get());
02113     #else
02114         return dynamic_cast<ControlTakeOffMessage*>(::IceProxy::Ice::Object::ice_router(__router).get());
02115     #endif
02116     }
02117 
02118     ::IceInternal::ProxyHandle<ControlTakeOffMessage> ice_locator(const ::Ice::LocatorPrx& __locator) const
02119     {
02120     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02121         typedef ::IceProxy::Ice::Object _Base;
02122         return dynamic_cast<ControlTakeOffMessage*>(_Base::ice_locator(__locator).get());
02123     #else
02124         return dynamic_cast<ControlTakeOffMessage*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
02125     #endif
02126     }
02127 
02128     ::IceInternal::ProxyHandle<ControlTakeOffMessage> ice_collocationOptimized(bool __co) const
02129     {
02130     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02131         typedef ::IceProxy::Ice::Object _Base;
02132         return dynamic_cast<ControlTakeOffMessage*>(_Base::ice_collocationOptimized(__co).get());
02133     #else
02134         return dynamic_cast<ControlTakeOffMessage*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
02135     #endif
02136     }
02137 
02138     ::IceInternal::ProxyHandle<ControlTakeOffMessage> ice_twoway() const
02139     {
02140     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02141         typedef ::IceProxy::Ice::Object _Base;
02142         return dynamic_cast<ControlTakeOffMessage*>(_Base::ice_twoway().get());
02143     #else
02144         return dynamic_cast<ControlTakeOffMessage*>(::IceProxy::Ice::Object::ice_twoway().get());
02145     #endif
02146     }
02147 
02148     ::IceInternal::ProxyHandle<ControlTakeOffMessage> ice_oneway() const
02149     {
02150     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02151         typedef ::IceProxy::Ice::Object _Base;
02152         return dynamic_cast<ControlTakeOffMessage*>(_Base::ice_oneway().get());
02153     #else
02154         return dynamic_cast<ControlTakeOffMessage*>(::IceProxy::Ice::Object::ice_oneway().get());
02155     #endif
02156     }
02157 
02158     ::IceInternal::ProxyHandle<ControlTakeOffMessage> ice_batchOneway() const
02159     {
02160     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02161         typedef ::IceProxy::Ice::Object _Base;
02162         return dynamic_cast<ControlTakeOffMessage*>(_Base::ice_batchOneway().get());
02163     #else
02164         return dynamic_cast<ControlTakeOffMessage*>(::IceProxy::Ice::Object::ice_batchOneway().get());
02165     #endif
02166     }
02167 
02168     ::IceInternal::ProxyHandle<ControlTakeOffMessage> ice_datagram() const
02169     {
02170     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02171         typedef ::IceProxy::Ice::Object _Base;
02172         return dynamic_cast<ControlTakeOffMessage*>(_Base::ice_datagram().get());
02173     #else
02174         return dynamic_cast<ControlTakeOffMessage*>(::IceProxy::Ice::Object::ice_datagram().get());
02175     #endif
02176     }
02177 
02178     ::IceInternal::ProxyHandle<ControlTakeOffMessage> ice_batchDatagram() const
02179     {
02180     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02181         typedef ::IceProxy::Ice::Object _Base;
02182         return dynamic_cast<ControlTakeOffMessage*>(_Base::ice_batchDatagram().get());
02183     #else
02184         return dynamic_cast<ControlTakeOffMessage*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
02185     #endif
02186     }
02187 
02188     ::IceInternal::ProxyHandle<ControlTakeOffMessage> ice_compress(bool __compress) const
02189     {
02190     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02191         typedef ::IceProxy::Ice::Object _Base;
02192         return dynamic_cast<ControlTakeOffMessage*>(_Base::ice_compress(__compress).get());
02193     #else
02194         return dynamic_cast<ControlTakeOffMessage*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
02195     #endif
02196     }
02197 
02198     ::IceInternal::ProxyHandle<ControlTakeOffMessage> ice_timeout(int __timeout) const
02199     {
02200     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02201         typedef ::IceProxy::Ice::Object _Base;
02202         return dynamic_cast<ControlTakeOffMessage*>(_Base::ice_timeout(__timeout).get());
02203     #else
02204         return dynamic_cast<ControlTakeOffMessage*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
02205     #endif
02206     }
02207 
02208     ::IceInternal::ProxyHandle<ControlTakeOffMessage> ice_connectionId(const std::string& __id) const
02209     {
02210     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02211         typedef ::IceProxy::Ice::Object _Base;
02212         return dynamic_cast<ControlTakeOffMessage*>(_Base::ice_connectionId(__id).get());
02213     #else
02214         return dynamic_cast<ControlTakeOffMessage*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
02215     #endif
02216     }
02217 
02218     static const ::std::string& ice_staticId();
02219 
02220 private:
02221 
02222     virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
02223     virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
02224     virtual ::IceProxy::Ice::Object* __newInstance() const;
02225 };
02226 
02227 class DriveFinderMessage : virtual public ::IceProxy::HawkMessages::Message
02228 {
02229 public:
02230 
02231     ::IceInternal::ProxyHandle<DriveFinderMessage> ice_context(const ::Ice::Context& __context) const
02232     {
02233     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02234         typedef ::IceProxy::Ice::Object _Base;
02235         return dynamic_cast<DriveFinderMessage*>(_Base::ice_context(__context).get());
02236     #else
02237         return dynamic_cast<DriveFinderMessage*>(::IceProxy::Ice::Object::ice_context(__context).get());
02238     #endif
02239     }
02240 
02241     ::IceInternal::ProxyHandle<DriveFinderMessage> ice_adapterId(const std::string& __id) const
02242     {
02243     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02244         typedef ::IceProxy::Ice::Object _Base;
02245         return dynamic_cast<DriveFinderMessage*>(_Base::ice_adapterId(__id).get());
02246     #else
02247         return dynamic_cast<DriveFinderMessage*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
02248     #endif
02249     }
02250 
02251     ::IceInternal::ProxyHandle<DriveFinderMessage> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
02252     {
02253     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02254         typedef ::IceProxy::Ice::Object _Base;
02255         return dynamic_cast<DriveFinderMessage*>(_Base::ice_endpoints(__endpoints).get());
02256     #else
02257         return dynamic_cast<DriveFinderMessage*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
02258     #endif
02259     }
02260 
02261     ::IceInternal::ProxyHandle<DriveFinderMessage> ice_locatorCacheTimeout(int __timeout) const
02262     {
02263     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02264         typedef ::IceProxy::Ice::Object _Base;
02265         return dynamic_cast<DriveFinderMessage*>(_Base::ice_locatorCacheTimeout(__timeout).get());
02266     #else
02267         return dynamic_cast<DriveFinderMessage*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
02268     #endif
02269     }
02270 
02271     ::IceInternal::ProxyHandle<DriveFinderMessage> ice_connectionCached(bool __cached) const
02272     {
02273     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02274         typedef ::IceProxy::Ice::Object _Base;
02275         return dynamic_cast<DriveFinderMessage*>(_Base::ice_connectionCached(__cached).get());
02276     #else
02277         return dynamic_cast<DriveFinderMessage*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
02278     #endif
02279     }
02280 
02281     ::IceInternal::ProxyHandle<DriveFinderMessage> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
02282     {
02283     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02284         typedef ::IceProxy::Ice::Object _Base;
02285         return dynamic_cast<DriveFinderMessage*>(_Base::ice_endpointSelection(__est).get());
02286     #else
02287         return dynamic_cast<DriveFinderMessage*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
02288     #endif
02289     }
02290 
02291     ::IceInternal::ProxyHandle<DriveFinderMessage> ice_secure(bool __secure) const
02292     {
02293     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02294         typedef ::IceProxy::Ice::Object _Base;
02295         return dynamic_cast<DriveFinderMessage*>(_Base::ice_secure(__secure).get());
02296     #else
02297         return dynamic_cast<DriveFinderMessage*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
02298     #endif
02299     }
02300 
02301     ::IceInternal::ProxyHandle<DriveFinderMessage> ice_preferSecure(bool __preferSecure) const
02302     {
02303     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02304         typedef ::IceProxy::Ice::Object _Base;
02305         return dynamic_cast<DriveFinderMessage*>(_Base::ice_preferSecure(__preferSecure).get());
02306     #else
02307         return dynamic_cast<DriveFinderMessage*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
02308     #endif
02309     }
02310 
02311     ::IceInternal::ProxyHandle<DriveFinderMessage> ice_router(const ::Ice::RouterPrx& __router) const
02312     {
02313     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02314         typedef ::IceProxy::Ice::Object _Base;
02315         return dynamic_cast<DriveFinderMessage*>(_Base::ice_router(__router).get());
02316     #else
02317         return dynamic_cast<DriveFinderMessage*>(::IceProxy::Ice::Object::ice_router(__router).get());
02318     #endif
02319     }
02320 
02321     ::IceInternal::ProxyHandle<DriveFinderMessage> ice_locator(const ::Ice::LocatorPrx& __locator) const
02322     {
02323     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02324         typedef ::IceProxy::Ice::Object _Base;
02325         return dynamic_cast<DriveFinderMessage*>(_Base::ice_locator(__locator).get());
02326     #else
02327         return dynamic_cast<DriveFinderMessage*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
02328     #endif
02329     }
02330 
02331     ::IceInternal::ProxyHandle<DriveFinderMessage> ice_collocationOptimized(bool __co) const
02332     {
02333     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02334         typedef ::IceProxy::Ice::Object _Base;
02335         return dynamic_cast<DriveFinderMessage*>(_Base::ice_collocationOptimized(__co).get());
02336     #else
02337         return dynamic_cast<DriveFinderMessage*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
02338     #endif
02339     }
02340 
02341     ::IceInternal::ProxyHandle<DriveFinderMessage> ice_twoway() const
02342     {
02343     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02344         typedef ::IceProxy::Ice::Object _Base;
02345         return dynamic_cast<DriveFinderMessage*>(_Base::ice_twoway().get());
02346     #else
02347         return dynamic_cast<DriveFinderMessage*>(::IceProxy::Ice::Object::ice_twoway().get());
02348     #endif
02349     }
02350 
02351     ::IceInternal::ProxyHandle<DriveFinderMessage> ice_oneway() const
02352     {
02353     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02354         typedef ::IceProxy::Ice::Object _Base;
02355         return dynamic_cast<DriveFinderMessage*>(_Base::ice_oneway().get());
02356     #else
02357         return dynamic_cast<DriveFinderMessage*>(::IceProxy::Ice::Object::ice_oneway().get());
02358     #endif
02359     }
02360 
02361     ::IceInternal::ProxyHandle<DriveFinderMessage> ice_batchOneway() const
02362     {
02363     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02364         typedef ::IceProxy::Ice::Object _Base;
02365         return dynamic_cast<DriveFinderMessage*>(_Base::ice_batchOneway().get());
02366     #else
02367         return dynamic_cast<DriveFinderMessage*>(::IceProxy::Ice::Object::ice_batchOneway().get());
02368     #endif
02369     }
02370 
02371     ::IceInternal::ProxyHandle<DriveFinderMessage> ice_datagram() const
02372     {
02373     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02374         typedef ::IceProxy::Ice::Object _Base;
02375         return dynamic_cast<DriveFinderMessage*>(_Base::ice_datagram().get());
02376     #else
02377         return dynamic_cast<DriveFinderMessage*>(::IceProxy::Ice::Object::ice_datagram().get());
02378     #endif
02379     }
02380 
02381     ::IceInternal::ProxyHandle<DriveFinderMessage> ice_batchDatagram() const
02382     {
02383     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02384         typedef ::IceProxy::Ice::Object _Base;
02385         return dynamic_cast<DriveFinderMessage*>(_Base::ice_batchDatagram().get());
02386     #else
02387         return dynamic_cast<DriveFinderMessage*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
02388     #endif
02389     }
02390 
02391     ::IceInternal::ProxyHandle<DriveFinderMessage> ice_compress(bool __compress) const
02392     {
02393     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02394         typedef ::IceProxy::Ice::Object _Base;
02395         return dynamic_cast<DriveFinderMessage*>(_Base::ice_compress(__compress).get());
02396     #else
02397         return dynamic_cast<DriveFinderMessage*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
02398     #endif
02399     }
02400 
02401     ::IceInternal::ProxyHandle<DriveFinderMessage> ice_timeout(int __timeout) const
02402     {
02403     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02404         typedef ::IceProxy::Ice::Object _Base;
02405         return dynamic_cast<DriveFinderMessage*>(_Base::ice_timeout(__timeout).get());
02406     #else
02407         return dynamic_cast<DriveFinderMessage*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
02408     #endif
02409     }
02410 
02411     ::IceInternal::ProxyHandle<DriveFinderMessage> ice_connectionId(const std::string& __id) const
02412     {
02413     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02414         typedef ::IceProxy::Ice::Object _Base;
02415         return dynamic_cast<DriveFinderMessage*>(_Base::ice_connectionId(__id).get());
02416     #else
02417         return dynamic_cast<DriveFinderMessage*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
02418     #endif
02419     }
02420 
02421     static const ::std::string& ice_staticId();
02422 
02423 private:
02424 
02425     virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
02426     virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
02427     virtual ::IceProxy::Ice::Object* __newInstance() const;
02428 };
02429 
02430 class ExampleMessage : virtual public ::IceProxy::HawkMessages::Message
02431 {
02432 public:
02433 
02434     ::IceInternal::ProxyHandle<ExampleMessage> ice_context(const ::Ice::Context& __context) const
02435     {
02436     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02437         typedef ::IceProxy::Ice::Object _Base;
02438         return dynamic_cast<ExampleMessage*>(_Base::ice_context(__context).get());
02439     #else
02440         return dynamic_cast<ExampleMessage*>(::IceProxy::Ice::Object::ice_context(__context).get());
02441     #endif
02442     }
02443 
02444     ::IceInternal::ProxyHandle<ExampleMessage> ice_adapterId(const std::string& __id) const
02445     {
02446     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02447         typedef ::IceProxy::Ice::Object _Base;
02448         return dynamic_cast<ExampleMessage*>(_Base::ice_adapterId(__id).get());
02449     #else
02450         return dynamic_cast<ExampleMessage*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
02451     #endif
02452     }
02453 
02454     ::IceInternal::ProxyHandle<ExampleMessage> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
02455     {
02456     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02457         typedef ::IceProxy::Ice::Object _Base;
02458         return dynamic_cast<ExampleMessage*>(_Base::ice_endpoints(__endpoints).get());
02459     #else
02460         return dynamic_cast<ExampleMessage*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
02461     #endif
02462     }
02463 
02464     ::IceInternal::ProxyHandle<ExampleMessage> ice_locatorCacheTimeout(int __timeout) const
02465     {
02466     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02467         typedef ::IceProxy::Ice::Object _Base;
02468         return dynamic_cast<ExampleMessage*>(_Base::ice_locatorCacheTimeout(__timeout).get());
02469     #else
02470         return dynamic_cast<ExampleMessage*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
02471     #endif
02472     }
02473 
02474     ::IceInternal::ProxyHandle<ExampleMessage> ice_connectionCached(bool __cached) const
02475     {
02476     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02477         typedef ::IceProxy::Ice::Object _Base;
02478         return dynamic_cast<ExampleMessage*>(_Base::ice_connectionCached(__cached).get());
02479     #else
02480         return dynamic_cast<ExampleMessage*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
02481     #endif
02482     }
02483 
02484     ::IceInternal::ProxyHandle<ExampleMessage> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
02485     {
02486     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02487         typedef ::IceProxy::Ice::Object _Base;
02488         return dynamic_cast<ExampleMessage*>(_Base::ice_endpointSelection(__est).get());
02489     #else
02490         return dynamic_cast<ExampleMessage*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
02491     #endif
02492     }
02493 
02494     ::IceInternal::ProxyHandle<ExampleMessage> ice_secure(bool __secure) const
02495     {
02496     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02497         typedef ::IceProxy::Ice::Object _Base;
02498         return dynamic_cast<ExampleMessage*>(_Base::ice_secure(__secure).get());
02499     #else
02500         return dynamic_cast<ExampleMessage*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
02501     #endif
02502     }
02503 
02504     ::IceInternal::ProxyHandle<ExampleMessage> ice_preferSecure(bool __preferSecure) const
02505     {
02506     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02507         typedef ::IceProxy::Ice::Object _Base;
02508         return dynamic_cast<ExampleMessage*>(_Base::ice_preferSecure(__preferSecure).get());
02509     #else
02510         return dynamic_cast<ExampleMessage*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
02511     #endif
02512     }
02513 
02514     ::IceInternal::ProxyHandle<ExampleMessage> ice_router(const ::Ice::RouterPrx& __router) const
02515     {
02516     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02517         typedef ::IceProxy::Ice::Object _Base;
02518         return dynamic_cast<ExampleMessage*>(_Base::ice_router(__router).get());
02519     #else
02520         return dynamic_cast<ExampleMessage*>(::IceProxy::Ice::Object::ice_router(__router).get());
02521     #endif
02522     }
02523 
02524     ::IceInternal::ProxyHandle<ExampleMessage> ice_locator(const ::Ice::LocatorPrx& __locator) const
02525     {
02526     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02527         typedef ::IceProxy::Ice::Object _Base;
02528         return dynamic_cast<ExampleMessage*>(_Base::ice_locator(__locator).get());
02529     #else
02530         return dynamic_cast<ExampleMessage*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
02531     #endif
02532     }
02533 
02534     ::IceInternal::ProxyHandle<ExampleMessage> ice_collocationOptimized(bool __co) const
02535     {
02536     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02537         typedef ::IceProxy::Ice::Object _Base;
02538         return dynamic_cast<ExampleMessage*>(_Base::ice_collocationOptimized(__co).get());
02539     #else
02540         return dynamic_cast<ExampleMessage*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
02541     #endif
02542     }
02543 
02544     ::IceInternal::ProxyHandle<ExampleMessage> ice_twoway() const
02545     {
02546     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02547         typedef ::IceProxy::Ice::Object _Base;
02548         return dynamic_cast<ExampleMessage*>(_Base::ice_twoway().get());
02549     #else
02550         return dynamic_cast<ExampleMessage*>(::IceProxy::Ice::Object::ice_twoway().get());
02551     #endif
02552     }
02553 
02554     ::IceInternal::ProxyHandle<ExampleMessage> ice_oneway() const
02555     {
02556     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02557         typedef ::IceProxy::Ice::Object _Base;
02558         return dynamic_cast<ExampleMessage*>(_Base::ice_oneway().get());
02559     #else
02560         return dynamic_cast<ExampleMessage*>(::IceProxy::Ice::Object::ice_oneway().get());
02561     #endif
02562     }
02563 
02564     ::IceInternal::ProxyHandle<ExampleMessage> ice_batchOneway() const
02565     {
02566     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02567         typedef ::IceProxy::Ice::Object _Base;
02568         return dynamic_cast<ExampleMessage*>(_Base::ice_batchOneway().get());
02569     #else
02570         return dynamic_cast<ExampleMessage*>(::IceProxy::Ice::Object::ice_batchOneway().get());
02571     #endif
02572     }
02573 
02574     ::IceInternal::ProxyHandle<ExampleMessage> ice_datagram() const
02575     {
02576     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02577         typedef ::IceProxy::Ice::Object _Base;
02578         return dynamic_cast<ExampleMessage*>(_Base::ice_datagram().get());
02579     #else
02580         return dynamic_cast<ExampleMessage*>(::IceProxy::Ice::Object::ice_datagram().get());
02581     #endif
02582     }
02583 
02584     ::IceInternal::ProxyHandle<ExampleMessage> ice_batchDatagram() const
02585     {
02586     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02587         typedef ::IceProxy::Ice::Object _Base;
02588         return dynamic_cast<ExampleMessage*>(_Base::ice_batchDatagram().get());
02589     #else
02590         return dynamic_cast<ExampleMessage*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
02591     #endif
02592     }
02593 
02594     ::IceInternal::ProxyHandle<ExampleMessage> ice_compress(bool __compress) const
02595     {
02596     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02597         typedef ::IceProxy::Ice::Object _Base;
02598         return dynamic_cast<ExampleMessage*>(_Base::ice_compress(__compress).get());
02599     #else
02600         return dynamic_cast<ExampleMessage*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
02601     #endif
02602     }
02603 
02604     ::IceInternal::ProxyHandle<ExampleMessage> ice_timeout(int __timeout) const
02605     {
02606     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02607         typedef ::IceProxy::Ice::Object _Base;
02608         return dynamic_cast<ExampleMessage*>(_Base::ice_timeout(__timeout).get());
02609     #else
02610         return dynamic_cast<ExampleMessage*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
02611     #endif
02612     }
02613 
02614     ::IceInternal::ProxyHandle<ExampleMessage> ice_connectionId(const std::string& __id) const
02615     {
02616     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02617         typedef ::IceProxy::Ice::Object _Base;
02618         return dynamic_cast<ExampleMessage*>(_Base::ice_connectionId(__id).get());
02619     #else
02620         return dynamic_cast<ExampleMessage*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
02621     #endif
02622     }
02623 
02624     static const ::std::string& ice_staticId();
02625 
02626 private:
02627 
02628     virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
02629     virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
02630     virtual ::IceProxy::Ice::Object* __newInstance() const;
02631 };
02632 
02633 class ExecuteMissionMessage : virtual public ::IceProxy::HawkMessages::Message
02634 {
02635 public:
02636 
02637     ::IceInternal::ProxyHandle<ExecuteMissionMessage> ice_context(const ::Ice::Context& __context) const
02638     {
02639     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02640         typedef ::IceProxy::Ice::Object _Base;
02641         return dynamic_cast<ExecuteMissionMessage*>(_Base::ice_context(__context).get());
02642     #else
02643         return dynamic_cast<ExecuteMissionMessage*>(::IceProxy::Ice::Object::ice_context(__context).get());
02644     #endif
02645     }
02646 
02647     ::IceInternal::ProxyHandle<ExecuteMissionMessage> ice_adapterId(const std::string& __id) const
02648     {
02649     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02650         typedef ::IceProxy::Ice::Object _Base;
02651         return dynamic_cast<ExecuteMissionMessage*>(_Base::ice_adapterId(__id).get());
02652     #else
02653         return dynamic_cast<ExecuteMissionMessage*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
02654     #endif
02655     }
02656 
02657     ::IceInternal::ProxyHandle<ExecuteMissionMessage> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
02658     {
02659     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02660         typedef ::IceProxy::Ice::Object _Base;
02661         return dynamic_cast<ExecuteMissionMessage*>(_Base::ice_endpoints(__endpoints).get());
02662     #else
02663         return dynamic_cast<ExecuteMissionMessage*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
02664     #endif
02665     }
02666 
02667     ::IceInternal::ProxyHandle<ExecuteMissionMessage> ice_locatorCacheTimeout(int __timeout) const
02668     {
02669     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02670         typedef ::IceProxy::Ice::Object _Base;
02671         return dynamic_cast<ExecuteMissionMessage*>(_Base::ice_locatorCacheTimeout(__timeout).get());
02672     #else
02673         return dynamic_cast<ExecuteMissionMessage*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
02674     #endif
02675     }
02676 
02677     ::IceInternal::ProxyHandle<ExecuteMissionMessage> ice_connectionCached(bool __cached) const
02678     {
02679     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02680         typedef ::IceProxy::Ice::Object _Base;
02681         return dynamic_cast<ExecuteMissionMessage*>(_Base::ice_connectionCached(__cached).get());
02682     #else
02683         return dynamic_cast<ExecuteMissionMessage*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
02684     #endif
02685     }
02686 
02687     ::IceInternal::ProxyHandle<ExecuteMissionMessage> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
02688     {
02689     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02690         typedef ::IceProxy::Ice::Object _Base;
02691         return dynamic_cast<ExecuteMissionMessage*>(_Base::ice_endpointSelection(__est).get());
02692     #else
02693         return dynamic_cast<ExecuteMissionMessage*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
02694     #endif
02695     }
02696 
02697     ::IceInternal::ProxyHandle<ExecuteMissionMessage> ice_secure(bool __secure) const
02698     {
02699     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02700         typedef ::IceProxy::Ice::Object _Base;
02701         return dynamic_cast<ExecuteMissionMessage*>(_Base::ice_secure(__secure).get());
02702     #else
02703         return dynamic_cast<ExecuteMissionMessage*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
02704     #endif
02705     }
02706 
02707     ::IceInternal::ProxyHandle<ExecuteMissionMessage> ice_preferSecure(bool __preferSecure) const
02708     {
02709     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02710         typedef ::IceProxy::Ice::Object _Base;
02711         return dynamic_cast<ExecuteMissionMessage*>(_Base::ice_preferSecure(__preferSecure).get());
02712     #else
02713         return dynamic_cast<ExecuteMissionMessage*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
02714     #endif
02715     }
02716 
02717     ::IceInternal::ProxyHandle<ExecuteMissionMessage> ice_router(const ::Ice::RouterPrx& __router) const
02718     {
02719     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02720         typedef ::IceProxy::Ice::Object _Base;
02721         return dynamic_cast<ExecuteMissionMessage*>(_Base::ice_router(__router).get());
02722     #else
02723         return dynamic_cast<ExecuteMissionMessage*>(::IceProxy::Ice::Object::ice_router(__router).get());
02724     #endif
02725     }
02726 
02727     ::IceInternal::ProxyHandle<ExecuteMissionMessage> ice_locator(const ::Ice::LocatorPrx& __locator) const
02728     {
02729     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02730         typedef ::IceProxy::Ice::Object _Base;
02731         return dynamic_cast<ExecuteMissionMessage*>(_Base::ice_locator(__locator).get());
02732     #else
02733         return dynamic_cast<ExecuteMissionMessage*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
02734     #endif
02735     }
02736 
02737     ::IceInternal::ProxyHandle<ExecuteMissionMessage> ice_collocationOptimized(bool __co) const
02738     {
02739     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02740         typedef ::IceProxy::Ice::Object _Base;
02741         return dynamic_cast<ExecuteMissionMessage*>(_Base::ice_collocationOptimized(__co).get());
02742     #else
02743         return dynamic_cast<ExecuteMissionMessage*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
02744     #endif
02745     }
02746 
02747     ::IceInternal::ProxyHandle<ExecuteMissionMessage> ice_twoway() const
02748     {
02749     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02750         typedef ::IceProxy::Ice::Object _Base;
02751         return dynamic_cast<ExecuteMissionMessage*>(_Base::ice_twoway().get());
02752     #else
02753         return dynamic_cast<ExecuteMissionMessage*>(::IceProxy::Ice::Object::ice_twoway().get());
02754     #endif
02755     }
02756 
02757     ::IceInternal::ProxyHandle<ExecuteMissionMessage> ice_oneway() const
02758     {
02759     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02760         typedef ::IceProxy::Ice::Object _Base;
02761         return dynamic_cast<ExecuteMissionMessage*>(_Base::ice_oneway().get());
02762     #else
02763         return dynamic_cast<ExecuteMissionMessage*>(::IceProxy::Ice::Object::ice_oneway().get());
02764     #endif
02765     }
02766 
02767     ::IceInternal::ProxyHandle<ExecuteMissionMessage> ice_batchOneway() const
02768     {
02769     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02770         typedef ::IceProxy::Ice::Object _Base;
02771         return dynamic_cast<ExecuteMissionMessage*>(_Base::ice_batchOneway().get());
02772     #else
02773         return dynamic_cast<ExecuteMissionMessage*>(::IceProxy::Ice::Object::ice_batchOneway().get());
02774     #endif
02775     }
02776 
02777     ::IceInternal::ProxyHandle<ExecuteMissionMessage> ice_datagram() const
02778     {
02779     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02780         typedef ::IceProxy::Ice::Object _Base;
02781         return dynamic_cast<ExecuteMissionMessage*>(_Base::ice_datagram().get());
02782     #else
02783         return dynamic_cast<ExecuteMissionMessage*>(::IceProxy::Ice::Object::ice_datagram().get());
02784     #endif
02785     }
02786 
02787     ::IceInternal::ProxyHandle<ExecuteMissionMessage> ice_batchDatagram() const
02788     {
02789     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02790         typedef ::IceProxy::Ice::Object _Base;
02791         return dynamic_cast<ExecuteMissionMessage*>(_Base::ice_batchDatagram().get());
02792     #else
02793         return dynamic_cast<ExecuteMissionMessage*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
02794     #endif
02795     }
02796 
02797     ::IceInternal::ProxyHandle<ExecuteMissionMessage> ice_compress(bool __compress) const
02798     {
02799     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02800         typedef ::IceProxy::Ice::Object _Base;
02801         return dynamic_cast<ExecuteMissionMessage*>(_Base::ice_compress(__compress).get());
02802     #else
02803         return dynamic_cast<ExecuteMissionMessage*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
02804     #endif
02805     }
02806 
02807     ::IceInternal::ProxyHandle<ExecuteMissionMessage> ice_timeout(int __timeout) const
02808     {
02809     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02810         typedef ::IceProxy::Ice::Object _Base;
02811         return dynamic_cast<ExecuteMissionMessage*>(_Base::ice_timeout(__timeout).get());
02812     #else
02813         return dynamic_cast<ExecuteMissionMessage*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
02814     #endif
02815     }
02816 
02817     ::IceInternal::ProxyHandle<ExecuteMissionMessage> ice_connectionId(const std::string& __id) const
02818     {
02819     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02820         typedef ::IceProxy::Ice::Object _Base;
02821         return dynamic_cast<ExecuteMissionMessage*>(_Base::ice_connectionId(__id).get());
02822     #else
02823         return dynamic_cast<ExecuteMissionMessage*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
02824     #endif
02825     }
02826 
02827     static const ::std::string& ice_staticId();
02828 
02829 private:
02830 
02831     virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
02832     virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
02833     virtual ::IceProxy::Ice::Object* __newInstance() const;
02834 };
02835 
02836 class MissionListMessage : virtual public ::IceProxy::HawkMessages::Message
02837 {
02838 public:
02839 
02840     ::IceInternal::ProxyHandle<MissionListMessage> ice_context(const ::Ice::Context& __context) const
02841     {
02842     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02843         typedef ::IceProxy::Ice::Object _Base;
02844         return dynamic_cast<MissionListMessage*>(_Base::ice_context(__context).get());
02845     #else
02846         return dynamic_cast<MissionListMessage*>(::IceProxy::Ice::Object::ice_context(__context).get());
02847     #endif
02848     }
02849 
02850     ::IceInternal::ProxyHandle<MissionListMessage> ice_adapterId(const std::string& __id) const
02851     {
02852     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02853         typedef ::IceProxy::Ice::Object _Base;
02854         return dynamic_cast<MissionListMessage*>(_Base::ice_adapterId(__id).get());
02855     #else
02856         return dynamic_cast<MissionListMessage*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
02857     #endif
02858     }
02859 
02860     ::IceInternal::ProxyHandle<MissionListMessage> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
02861     {
02862     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02863         typedef ::IceProxy::Ice::Object _Base;
02864         return dynamic_cast<MissionListMessage*>(_Base::ice_endpoints(__endpoints).get());
02865     #else
02866         return dynamic_cast<MissionListMessage*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
02867     #endif
02868     }
02869 
02870     ::IceInternal::ProxyHandle<MissionListMessage> ice_locatorCacheTimeout(int __timeout) const
02871     {
02872     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02873         typedef ::IceProxy::Ice::Object _Base;
02874         return dynamic_cast<MissionListMessage*>(_Base::ice_locatorCacheTimeout(__timeout).get());
02875     #else
02876         return dynamic_cast<MissionListMessage*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
02877     #endif
02878     }
02879 
02880     ::IceInternal::ProxyHandle<MissionListMessage> ice_connectionCached(bool __cached) const
02881     {
02882     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02883         typedef ::IceProxy::Ice::Object _Base;
02884         return dynamic_cast<MissionListMessage*>(_Base::ice_connectionCached(__cached).get());
02885     #else
02886         return dynamic_cast<MissionListMessage*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
02887     #endif
02888     }
02889 
02890     ::IceInternal::ProxyHandle<MissionListMessage> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
02891     {
02892     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02893         typedef ::IceProxy::Ice::Object _Base;
02894         return dynamic_cast<MissionListMessage*>(_Base::ice_endpointSelection(__est).get());
02895     #else
02896         return dynamic_cast<MissionListMessage*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
02897     #endif
02898     }
02899 
02900     ::IceInternal::ProxyHandle<MissionListMessage> ice_secure(bool __secure) const
02901     {
02902     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02903         typedef ::IceProxy::Ice::Object _Base;
02904         return dynamic_cast<MissionListMessage*>(_Base::ice_secure(__secure).get());
02905     #else
02906         return dynamic_cast<MissionListMessage*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
02907     #endif
02908     }
02909 
02910     ::IceInternal::ProxyHandle<MissionListMessage> ice_preferSecure(bool __preferSecure) const
02911     {
02912     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02913         typedef ::IceProxy::Ice::Object _Base;
02914         return dynamic_cast<MissionListMessage*>(_Base::ice_preferSecure(__preferSecure).get());
02915     #else
02916         return dynamic_cast<MissionListMessage*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
02917     #endif
02918     }
02919 
02920     ::IceInternal::ProxyHandle<MissionListMessage> ice_router(const ::Ice::RouterPrx& __router) const
02921     {
02922     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02923         typedef ::IceProxy::Ice::Object _Base;
02924         return dynamic_cast<MissionListMessage*>(_Base::ice_router(__router).get());
02925     #else
02926         return dynamic_cast<MissionListMessage*>(::IceProxy::Ice::Object::ice_router(__router).get());
02927     #endif
02928     }
02929 
02930     ::IceInternal::ProxyHandle<MissionListMessage> ice_locator(const ::Ice::LocatorPrx& __locator) const
02931     {
02932     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02933         typedef ::IceProxy::Ice::Object _Base;
02934         return dynamic_cast<MissionListMessage*>(_Base::ice_locator(__locator).get());
02935     #else
02936         return dynamic_cast<MissionListMessage*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
02937     #endif
02938     }
02939 
02940     ::IceInternal::ProxyHandle<MissionListMessage> ice_collocationOptimized(bool __co) const
02941     {
02942     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02943         typedef ::IceProxy::Ice::Object _Base;
02944         return dynamic_cast<MissionListMessage*>(_Base::ice_collocationOptimized(__co).get());
02945     #else
02946         return dynamic_cast<MissionListMessage*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
02947     #endif
02948     }
02949 
02950     ::IceInternal::ProxyHandle<MissionListMessage> ice_twoway() const
02951     {
02952     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02953         typedef ::IceProxy::Ice::Object _Base;
02954         return dynamic_cast<MissionListMessage*>(_Base::ice_twoway().get());
02955     #else
02956         return dynamic_cast<MissionListMessage*>(::IceProxy::Ice::Object::ice_twoway().get());
02957     #endif
02958     }
02959 
02960     ::IceInternal::ProxyHandle<MissionListMessage> ice_oneway() const
02961     {
02962     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02963         typedef ::IceProxy::Ice::Object _Base;
02964         return dynamic_cast<MissionListMessage*>(_Base::ice_oneway().get());
02965     #else
02966         return dynamic_cast<MissionListMessage*>(::IceProxy::Ice::Object::ice_oneway().get());
02967     #endif
02968     }
02969 
02970     ::IceInternal::ProxyHandle<MissionListMessage> ice_batchOneway() const
02971     {
02972     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02973         typedef ::IceProxy::Ice::Object _Base;
02974         return dynamic_cast<MissionListMessage*>(_Base::ice_batchOneway().get());
02975     #else
02976         return dynamic_cast<MissionListMessage*>(::IceProxy::Ice::Object::ice_batchOneway().get());
02977     #endif
02978     }
02979 
02980     ::IceInternal::ProxyHandle<MissionListMessage> ice_datagram() const
02981     {
02982     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02983         typedef ::IceProxy::Ice::Object _Base;
02984         return dynamic_cast<MissionListMessage*>(_Base::ice_datagram().get());
02985     #else
02986         return dynamic_cast<MissionListMessage*>(::IceProxy::Ice::Object::ice_datagram().get());
02987     #endif
02988     }
02989 
02990     ::IceInternal::ProxyHandle<MissionListMessage> ice_batchDatagram() const
02991     {
02992     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02993         typedef ::IceProxy::Ice::Object _Base;
02994         return dynamic_cast<MissionListMessage*>(_Base::ice_batchDatagram().get());
02995     #else
02996         return dynamic_cast<MissionListMessage*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
02997     #endif
02998     }
02999 
03000     ::IceInternal::ProxyHandle<MissionListMessage> ice_compress(bool __compress) const
03001     {
03002     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03003         typedef ::IceProxy::Ice::Object _Base;
03004         return dynamic_cast<MissionListMessage*>(_Base::ice_compress(__compress).get());
03005     #else
03006         return dynamic_cast<MissionListMessage*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
03007     #endif
03008     }
03009 
03010     ::IceInternal::ProxyHandle<MissionListMessage> ice_timeout(int __timeout) const
03011     {
03012     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03013         typedef ::IceProxy::Ice::Object _Base;
03014         return dynamic_cast<MissionListMessage*>(_Base::ice_timeout(__timeout).get());
03015     #else
03016         return dynamic_cast<MissionListMessage*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
03017     #endif
03018     }
03019 
03020     ::IceInternal::ProxyHandle<MissionListMessage> ice_connectionId(const std::string& __id) const
03021     {
03022     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03023         typedef ::IceProxy::Ice::Object _Base;
03024         return dynamic_cast<MissionListMessage*>(_Base::ice_connectionId(__id).get());
03025     #else
03026         return dynamic_cast<MissionListMessage*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
03027     #endif
03028     }
03029 
03030     static const ::std::string& ice_staticId();
03031 
03032 private:
03033 
03034     virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
03035     virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
03036     virtual ::IceProxy::Ice::Object* __newInstance() const;
03037 };
03038 
03039 class RoomFinderMessage : virtual public ::IceProxy::HawkMessages::Message
03040 {
03041 public:
03042 
03043     ::IceInternal::ProxyHandle<RoomFinderMessage> ice_context(const ::Ice::Context& __context) const
03044     {
03045     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03046         typedef ::IceProxy::Ice::Object _Base;
03047         return dynamic_cast<RoomFinderMessage*>(_Base::ice_context(__context).get());
03048     #else
03049         return dynamic_cast<RoomFinderMessage*>(::IceProxy::Ice::Object::ice_context(__context).get());
03050     #endif
03051     }
03052 
03053     ::IceInternal::ProxyHandle<RoomFinderMessage> ice_adapterId(const std::string& __id) const
03054     {
03055     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03056         typedef ::IceProxy::Ice::Object _Base;
03057         return dynamic_cast<RoomFinderMessage*>(_Base::ice_adapterId(__id).get());
03058     #else
03059         return dynamic_cast<RoomFinderMessage*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
03060     #endif
03061     }
03062 
03063     ::IceInternal::ProxyHandle<RoomFinderMessage> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
03064     {
03065     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03066         typedef ::IceProxy::Ice::Object _Base;
03067         return dynamic_cast<RoomFinderMessage*>(_Base::ice_endpoints(__endpoints).get());
03068     #else
03069         return dynamic_cast<RoomFinderMessage*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
03070     #endif
03071     }
03072 
03073     ::IceInternal::ProxyHandle<RoomFinderMessage> ice_locatorCacheTimeout(int __timeout) const
03074     {
03075     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03076         typedef ::IceProxy::Ice::Object _Base;
03077         return dynamic_cast<RoomFinderMessage*>(_Base::ice_locatorCacheTimeout(__timeout).get());
03078     #else
03079         return dynamic_cast<RoomFinderMessage*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
03080     #endif
03081     }
03082 
03083     ::IceInternal::ProxyHandle<RoomFinderMessage> ice_connectionCached(bool __cached) const
03084     {
03085     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03086         typedef ::IceProxy::Ice::Object _Base;
03087         return dynamic_cast<RoomFinderMessage*>(_Base::ice_connectionCached(__cached).get());
03088     #else
03089         return dynamic_cast<RoomFinderMessage*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
03090     #endif
03091     }
03092 
03093     ::IceInternal::ProxyHandle<RoomFinderMessage> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
03094     {
03095     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03096         typedef ::IceProxy::Ice::Object _Base;
03097         return dynamic_cast<RoomFinderMessage*>(_Base::ice_endpointSelection(__est).get());
03098     #else
03099         return dynamic_cast<RoomFinderMessage*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
03100     #endif
03101     }
03102 
03103     ::IceInternal::ProxyHandle<RoomFinderMessage> ice_secure(bool __secure) const
03104     {
03105     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03106         typedef ::IceProxy::Ice::Object _Base;
03107         return dynamic_cast<RoomFinderMessage*>(_Base::ice_secure(__secure).get());
03108     #else
03109         return dynamic_cast<RoomFinderMessage*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
03110     #endif
03111     }
03112 
03113     ::IceInternal::ProxyHandle<RoomFinderMessage> ice_preferSecure(bool __preferSecure) const
03114     {
03115     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03116         typedef ::IceProxy::Ice::Object _Base;
03117         return dynamic_cast<RoomFinderMessage*>(_Base::ice_preferSecure(__preferSecure).get());
03118     #else
03119         return dynamic_cast<RoomFinderMessage*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
03120     #endif
03121     }
03122 
03123     ::IceInternal::ProxyHandle<RoomFinderMessage> ice_router(const ::Ice::RouterPrx& __router) const
03124     {
03125     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03126         typedef ::IceProxy::Ice::Object _Base;
03127         return dynamic_cast<RoomFinderMessage*>(_Base::ice_router(__router).get());
03128     #else
03129         return dynamic_cast<RoomFinderMessage*>(::IceProxy::Ice::Object::ice_router(__router).get());
03130     #endif
03131     }
03132 
03133     ::IceInternal::ProxyHandle<RoomFinderMessage> ice_locator(const ::Ice::LocatorPrx& __locator) const
03134     {
03135     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03136         typedef ::IceProxy::Ice::Object _Base;
03137         return dynamic_cast<RoomFinderMessage*>(_Base::ice_locator(__locator).get());
03138     #else
03139         return dynamic_cast<RoomFinderMessage*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
03140     #endif
03141     }
03142 
03143     ::IceInternal::ProxyHandle<RoomFinderMessage> ice_collocationOptimized(bool __co) const
03144     {
03145     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03146         typedef ::IceProxy::Ice::Object _Base;
03147         return dynamic_cast<RoomFinderMessage*>(_Base::ice_collocationOptimized(__co).get());
03148     #else
03149         return dynamic_cast<RoomFinderMessage*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
03150     #endif
03151     }
03152 
03153     ::IceInternal::ProxyHandle<RoomFinderMessage> ice_twoway() const
03154     {
03155     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03156         typedef ::IceProxy::Ice::Object _Base;
03157         return dynamic_cast<RoomFinderMessage*>(_Base::ice_twoway().get());
03158     #else
03159         return dynamic_cast<RoomFinderMessage*>(::IceProxy::Ice::Object::ice_twoway().get());
03160     #endif
03161     }
03162 
03163     ::IceInternal::ProxyHandle<RoomFinderMessage> ice_oneway() const
03164     {
03165     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03166         typedef ::IceProxy::Ice::Object _Base;
03167         return dynamic_cast<RoomFinderMessage*>(_Base::ice_oneway().get());
03168     #else
03169         return dynamic_cast<RoomFinderMessage*>(::IceProxy::Ice::Object::ice_oneway().get());
03170     #endif
03171     }
03172 
03173     ::IceInternal::ProxyHandle<RoomFinderMessage> ice_batchOneway() const
03174     {
03175     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03176         typedef ::IceProxy::Ice::Object _Base;
03177         return dynamic_cast<RoomFinderMessage*>(_Base::ice_batchOneway().get());
03178     #else
03179         return dynamic_cast<RoomFinderMessage*>(::IceProxy::Ice::Object::ice_batchOneway().get());
03180     #endif
03181     }
03182 
03183     ::IceInternal::ProxyHandle<RoomFinderMessage> ice_datagram() const
03184     {
03185     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03186         typedef ::IceProxy::Ice::Object _Base;
03187         return dynamic_cast<RoomFinderMessage*>(_Base::ice_datagram().get());
03188     #else
03189         return dynamic_cast<RoomFinderMessage*>(::IceProxy::Ice::Object::ice_datagram().get());
03190     #endif
03191     }
03192 
03193     ::IceInternal::ProxyHandle<RoomFinderMessage> ice_batchDatagram() const
03194     {
03195     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03196         typedef ::IceProxy::Ice::Object _Base;
03197         return dynamic_cast<RoomFinderMessage*>(_Base::ice_batchDatagram().get());
03198     #else
03199         return dynamic_cast<RoomFinderMessage*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
03200     #endif
03201     }
03202 
03203     ::IceInternal::ProxyHandle<RoomFinderMessage> ice_compress(bool __compress) const
03204     {
03205     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03206         typedef ::IceProxy::Ice::Object _Base;
03207         return dynamic_cast<RoomFinderMessage*>(_Base::ice_compress(__compress).get());
03208     #else
03209         return dynamic_cast<RoomFinderMessage*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
03210     #endif
03211     }
03212 
03213     ::IceInternal::ProxyHandle<RoomFinderMessage> ice_timeout(int __timeout) const
03214     {
03215     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03216         typedef ::IceProxy::Ice::Object _Base;
03217         return dynamic_cast<RoomFinderMessage*>(_Base::ice_timeout(__timeout).get());
03218     #else
03219         return dynamic_cast<RoomFinderMessage*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
03220     #endif
03221     }
03222 
03223     ::IceInternal::ProxyHandle<RoomFinderMessage> ice_connectionId(const std::string& __id) const
03224     {
03225     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03226         typedef ::IceProxy::Ice::Object _Base;
03227         return dynamic_cast<RoomFinderMessage*>(_Base::ice_connectionId(__id).get());
03228     #else
03229         return dynamic_cast<RoomFinderMessage*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
03230     #endif
03231     }
03232 
03233     static const ::std::string& ice_staticId();
03234 
03235 private:
03236 
03237     virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
03238     virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
03239     virtual ::IceProxy::Ice::Object* __newInstance() const;
03240 };
03241 
03242 class SensorDataMessage : virtual public ::IceProxy::HawkMessages::Message
03243 {
03244 public:
03245 
03246     ::IceInternal::ProxyHandle<SensorDataMessage> ice_context(const ::Ice::Context& __context) const
03247     {
03248     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03249         typedef ::IceProxy::Ice::Object _Base;
03250         return dynamic_cast<SensorDataMessage*>(_Base::ice_context(__context).get());
03251     #else
03252         return dynamic_cast<SensorDataMessage*>(::IceProxy::Ice::Object::ice_context(__context).get());
03253     #endif
03254     }
03255 
03256     ::IceInternal::ProxyHandle<SensorDataMessage> ice_adapterId(const std::string& __id) const
03257     {
03258     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03259         typedef ::IceProxy::Ice::Object _Base;
03260         return dynamic_cast<SensorDataMessage*>(_Base::ice_adapterId(__id).get());
03261     #else
03262         return dynamic_cast<SensorDataMessage*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
03263     #endif
03264     }
03265 
03266     ::IceInternal::ProxyHandle<SensorDataMessage> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
03267     {
03268     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03269         typedef ::IceProxy::Ice::Object _Base;
03270         return dynamic_cast<SensorDataMessage*>(_Base::ice_endpoints(__endpoints).get());
03271     #else
03272         return dynamic_cast<SensorDataMessage*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
03273     #endif
03274     }
03275 
03276     ::IceInternal::ProxyHandle<SensorDataMessage> ice_locatorCacheTimeout(int __timeout) const
03277     {
03278     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03279         typedef ::IceProxy::Ice::Object _Base;
03280         return dynamic_cast<SensorDataMessage*>(_Base::ice_locatorCacheTimeout(__timeout).get());
03281     #else
03282         return dynamic_cast<SensorDataMessage*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
03283     #endif
03284     }
03285 
03286     ::IceInternal::ProxyHandle<SensorDataMessage> ice_connectionCached(bool __cached) const
03287     {
03288     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03289         typedef ::IceProxy::Ice::Object _Base;
03290         return dynamic_cast<SensorDataMessage*>(_Base::ice_connectionCached(__cached).get());
03291     #else
03292         return dynamic_cast<SensorDataMessage*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
03293     #endif
03294     }
03295 
03296     ::IceInternal::ProxyHandle<SensorDataMessage> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
03297     {
03298     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03299         typedef ::IceProxy::Ice::Object _Base;
03300         return dynamic_cast<SensorDataMessage*>(_Base::ice_endpointSelection(__est).get());
03301     #else
03302         return dynamic_cast<SensorDataMessage*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
03303     #endif
03304     }
03305 
03306     ::IceInternal::ProxyHandle<SensorDataMessage> ice_secure(bool __secure) const
03307     {
03308     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03309         typedef ::IceProxy::Ice::Object _Base;
03310         return dynamic_cast<SensorDataMessage*>(_Base::ice_secure(__secure).get());
03311     #else
03312         return dynamic_cast<SensorDataMessage*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
03313     #endif
03314     }
03315 
03316     ::IceInternal::ProxyHandle<SensorDataMessage> ice_preferSecure(bool __preferSecure) const
03317     {
03318     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03319         typedef ::IceProxy::Ice::Object _Base;
03320         return dynamic_cast<SensorDataMessage*>(_Base::ice_preferSecure(__preferSecure).get());
03321     #else
03322         return dynamic_cast<SensorDataMessage*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
03323     #endif
03324     }
03325 
03326     ::IceInternal::ProxyHandle<SensorDataMessage> ice_router(const ::Ice::RouterPrx& __router) const
03327     {
03328     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03329         typedef ::IceProxy::Ice::Object _Base;
03330         return dynamic_cast<SensorDataMessage*>(_Base::ice_router(__router).get());
03331     #else
03332         return dynamic_cast<SensorDataMessage*>(::IceProxy::Ice::Object::ice_router(__router).get());
03333     #endif
03334     }
03335 
03336     ::IceInternal::ProxyHandle<SensorDataMessage> ice_locator(const ::Ice::LocatorPrx& __locator) const
03337     {
03338     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03339         typedef ::IceProxy::Ice::Object _Base;
03340         return dynamic_cast<SensorDataMessage*>(_Base::ice_locator(__locator).get());
03341     #else
03342         return dynamic_cast<SensorDataMessage*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
03343     #endif
03344     }
03345 
03346     ::IceInternal::ProxyHandle<SensorDataMessage> ice_collocationOptimized(bool __co) const
03347     {
03348     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03349         typedef ::IceProxy::Ice::Object _Base;
03350         return dynamic_cast<SensorDataMessage*>(_Base::ice_collocationOptimized(__co).get());
03351     #else
03352         return dynamic_cast<SensorDataMessage*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
03353     #endif
03354     }
03355 
03356     ::IceInternal::ProxyHandle<SensorDataMessage> ice_twoway() const
03357     {
03358     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03359         typedef ::IceProxy::Ice::Object _Base;
03360         return dynamic_cast<SensorDataMessage*>(_Base::ice_twoway().get());
03361     #else
03362         return dynamic_cast<SensorDataMessage*>(::IceProxy::Ice::Object::ice_twoway().get());
03363     #endif
03364     }
03365 
03366     ::IceInternal::ProxyHandle<SensorDataMessage> ice_oneway() const
03367     {
03368     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03369         typedef ::IceProxy::Ice::Object _Base;
03370         return dynamic_cast<SensorDataMessage*>(_Base::ice_oneway().get());
03371     #else
03372         return dynamic_cast<SensorDataMessage*>(::IceProxy::Ice::Object::ice_oneway().get());
03373     #endif
03374     }
03375 
03376     ::IceInternal::ProxyHandle<SensorDataMessage> ice_batchOneway() const
03377     {
03378     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03379         typedef ::IceProxy::Ice::Object _Base;
03380         return dynamic_cast<SensorDataMessage*>(_Base::ice_batchOneway().get());
03381     #else
03382         return dynamic_cast<SensorDataMessage*>(::IceProxy::Ice::Object::ice_batchOneway().get());
03383     #endif
03384     }
03385 
03386     ::IceInternal::ProxyHandle<SensorDataMessage> ice_datagram() const
03387     {
03388     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03389         typedef ::IceProxy::Ice::Object _Base;
03390         return dynamic_cast<SensorDataMessage*>(_Base::ice_datagram().get());
03391     #else
03392         return dynamic_cast<SensorDataMessage*>(::IceProxy::Ice::Object::ice_datagram().get());
03393     #endif
03394     }
03395 
03396     ::IceInternal::ProxyHandle<SensorDataMessage> ice_batchDatagram() const
03397     {
03398     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03399         typedef ::IceProxy::Ice::Object _Base;
03400         return dynamic_cast<SensorDataMessage*>(_Base::ice_batchDatagram().get());
03401     #else
03402         return dynamic_cast<SensorDataMessage*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
03403     #endif
03404     }
03405 
03406     ::IceInternal::ProxyHandle<SensorDataMessage> ice_compress(bool __compress) const
03407     {
03408     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03409         typedef ::IceProxy::Ice::Object _Base;
03410         return dynamic_cast<SensorDataMessage*>(_Base::ice_compress(__compress).get());
03411     #else
03412         return dynamic_cast<SensorDataMessage*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
03413     #endif
03414     }
03415 
03416     ::IceInternal::ProxyHandle<SensorDataMessage> ice_timeout(int __timeout) const
03417     {
03418     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03419         typedef ::IceProxy::Ice::Object _Base;
03420         return dynamic_cast<SensorDataMessage*>(_Base::ice_timeout(__timeout).get());
03421     #else
03422         return dynamic_cast<SensorDataMessage*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
03423     #endif
03424     }
03425 
03426     ::IceInternal::ProxyHandle<SensorDataMessage> ice_connectionId(const std::string& __id) const
03427     {
03428     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03429         typedef ::IceProxy::Ice::Object _Base;
03430         return dynamic_cast<SensorDataMessage*>(_Base::ice_connectionId(__id).get());
03431     #else
03432         return dynamic_cast<SensorDataMessage*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
03433     #endif
03434     }
03435 
03436     static const ::std::string& ice_staticId();
03437 
03438 private:
03439 
03440     virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
03441     virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
03442     virtual ::IceProxy::Ice::Object* __newInstance() const;
03443 };
03444 
03445 class SlamDataMessage : virtual public ::IceProxy::HawkMessages::Message
03446 {
03447 public:
03448 
03449     ::IceInternal::ProxyHandle<SlamDataMessage> ice_context(const ::Ice::Context& __context) const
03450     {
03451     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03452         typedef ::IceProxy::Ice::Object _Base;
03453         return dynamic_cast<SlamDataMessage*>(_Base::ice_context(__context).get());
03454     #else
03455         return dynamic_cast<SlamDataMessage*>(::IceProxy::Ice::Object::ice_context(__context).get());
03456     #endif
03457     }
03458 
03459     ::IceInternal::ProxyHandle<SlamDataMessage> ice_adapterId(const std::string& __id) const
03460     {
03461     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03462         typedef ::IceProxy::Ice::Object _Base;
03463         return dynamic_cast<SlamDataMessage*>(_Base::ice_adapterId(__id).get());
03464     #else
03465         return dynamic_cast<SlamDataMessage*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
03466     #endif
03467     }
03468 
03469     ::IceInternal::ProxyHandle<SlamDataMessage> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
03470     {
03471     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03472         typedef ::IceProxy::Ice::Object _Base;
03473         return dynamic_cast<SlamDataMessage*>(_Base::ice_endpoints(__endpoints).get());
03474     #else
03475         return dynamic_cast<SlamDataMessage*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
03476     #endif
03477     }
03478 
03479     ::IceInternal::ProxyHandle<SlamDataMessage> ice_locatorCacheTimeout(int __timeout) const
03480     {
03481     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03482         typedef ::IceProxy::Ice::Object _Base;
03483         return dynamic_cast<SlamDataMessage*>(_Base::ice_locatorCacheTimeout(__timeout).get());
03484     #else
03485         return dynamic_cast<SlamDataMessage*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
03486     #endif
03487     }
03488 
03489     ::IceInternal::ProxyHandle<SlamDataMessage> ice_connectionCached(bool __cached) const
03490     {
03491     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03492         typedef ::IceProxy::Ice::Object _Base;
03493         return dynamic_cast<SlamDataMessage*>(_Base::ice_connectionCached(__cached).get());
03494     #else
03495         return dynamic_cast<SlamDataMessage*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
03496     #endif
03497     }
03498 
03499     ::IceInternal::ProxyHandle<SlamDataMessage> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
03500     {
03501     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03502         typedef ::IceProxy::Ice::Object _Base;
03503         return dynamic_cast<SlamDataMessage*>(_Base::ice_endpointSelection(__est).get());
03504     #else
03505         return dynamic_cast<SlamDataMessage*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
03506     #endif
03507     }
03508 
03509     ::IceInternal::ProxyHandle<SlamDataMessage> ice_secure(bool __secure) const
03510     {
03511     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03512         typedef ::IceProxy::Ice::Object _Base;
03513         return dynamic_cast<SlamDataMessage*>(_Base::ice_secure(__secure).get());
03514     #else
03515         return dynamic_cast<SlamDataMessage*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
03516     #endif
03517     }
03518 
03519     ::IceInternal::ProxyHandle<SlamDataMessage> ice_preferSecure(bool __preferSecure) const
03520     {
03521     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03522         typedef ::IceProxy::Ice::Object _Base;
03523         return dynamic_cast<SlamDataMessage*>(_Base::ice_preferSecure(__preferSecure).get());
03524     #else
03525         return dynamic_cast<SlamDataMessage*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
03526     #endif
03527     }
03528 
03529     ::IceInternal::ProxyHandle<SlamDataMessage> ice_router(const ::Ice::RouterPrx& __router) const
03530     {
03531     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03532         typedef ::IceProxy::Ice::Object _Base;
03533         return dynamic_cast<SlamDataMessage*>(_Base::ice_router(__router).get());
03534     #else
03535         return dynamic_cast<SlamDataMessage*>(::IceProxy::Ice::Object::ice_router(__router).get());
03536     #endif
03537     }
03538 
03539     ::IceInternal::ProxyHandle<SlamDataMessage> ice_locator(const ::Ice::LocatorPrx& __locator) const
03540     {
03541     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03542         typedef ::IceProxy::Ice::Object _Base;
03543         return dynamic_cast<SlamDataMessage*>(_Base::ice_locator(__locator).get());
03544     #else
03545         return dynamic_cast<SlamDataMessage*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
03546     #endif
03547     }
03548 
03549     ::IceInternal::ProxyHandle<SlamDataMessage> ice_collocationOptimized(bool __co) const
03550     {
03551     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03552         typedef ::IceProxy::Ice::Object _Base;
03553         return dynamic_cast<SlamDataMessage*>(_Base::ice_collocationOptimized(__co).get());
03554     #else
03555         return dynamic_cast<SlamDataMessage*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
03556     #endif
03557     }
03558 
03559     ::IceInternal::ProxyHandle<SlamDataMessage> ice_twoway() const
03560     {
03561     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03562         typedef ::IceProxy::Ice::Object _Base;
03563         return dynamic_cast<SlamDataMessage*>(_Base::ice_twoway().get());
03564     #else
03565         return dynamic_cast<SlamDataMessage*>(::IceProxy::Ice::Object::ice_twoway().get());
03566     #endif
03567     }
03568 
03569     ::IceInternal::ProxyHandle<SlamDataMessage> ice_oneway() const
03570     {
03571     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03572         typedef ::IceProxy::Ice::Object _Base;
03573         return dynamic_cast<SlamDataMessage*>(_Base::ice_oneway().get());
03574     #else
03575         return dynamic_cast<SlamDataMessage*>(::IceProxy::Ice::Object::ice_oneway().get());
03576     #endif
03577     }
03578 
03579     ::IceInternal::ProxyHandle<SlamDataMessage> ice_batchOneway() const
03580     {
03581     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03582         typedef ::IceProxy::Ice::Object _Base;
03583         return dynamic_cast<SlamDataMessage*>(_Base::ice_batchOneway().get());
03584     #else
03585         return dynamic_cast<SlamDataMessage*>(::IceProxy::Ice::Object::ice_batchOneway().get());
03586     #endif
03587     }
03588 
03589     ::IceInternal::ProxyHandle<SlamDataMessage> ice_datagram() const
03590     {
03591     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03592         typedef ::IceProxy::Ice::Object _Base;
03593         return dynamic_cast<SlamDataMessage*>(_Base::ice_datagram().get());
03594     #else
03595         return dynamic_cast<SlamDataMessage*>(::IceProxy::Ice::Object::ice_datagram().get());
03596     #endif
03597     }
03598 
03599     ::IceInternal::ProxyHandle<SlamDataMessage> ice_batchDatagram() const
03600     {
03601     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03602         typedef ::IceProxy::Ice::Object _Base;
03603         return dynamic_cast<SlamDataMessage*>(_Base::ice_batchDatagram().get());
03604     #else
03605         return dynamic_cast<SlamDataMessage*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
03606     #endif
03607     }
03608 
03609     ::IceInternal::ProxyHandle<SlamDataMessage> ice_compress(bool __compress) const
03610     {
03611     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03612         typedef ::IceProxy::Ice::Object _Base;
03613         return dynamic_cast<SlamDataMessage*>(_Base::ice_compress(__compress).get());
03614     #else
03615         return dynamic_cast<SlamDataMessage*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
03616     #endif
03617     }
03618 
03619     ::IceInternal::ProxyHandle<SlamDataMessage> ice_timeout(int __timeout) const
03620     {
03621     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03622         typedef ::IceProxy::Ice::Object _Base;
03623         return dynamic_cast<SlamDataMessage*>(_Base::ice_timeout(__timeout).get());
03624     #else
03625         return dynamic_cast<SlamDataMessage*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
03626     #endif
03627     }
03628 
03629     ::IceInternal::ProxyHandle<SlamDataMessage> ice_connectionId(const std::string& __id) const
03630     {
03631     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
03632         typedef ::IceProxy::Ice::Object _Base;
03633         return dynamic_cast<SlamDataMessage*>(_Base::ice_connectionId(__id).get());
03634     #else
03635         return dynamic_cast<SlamDataMessage*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
03636     #endif
03637     }
03638 
03639     static const ::std::string& ice_staticId();
03640 
03641 private:
03642 
03643     virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
03644     virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
03645     virtual ::IceProxy::Ice::Object* __newInstance() const;
03646 };
03647 
03648 }
03649 
03650 }
03651 
03652 namespace IceDelegate
03653 {
03654 
03655 namespace HawkMessages
03656 {
03657 
03658 class Message : virtual public ::IceDelegate::Ice::Object
03659 {
03660 public:
03661 };
03662 
03663 class MessageAgent : virtual public ::IceDelegate::Ice::Object
03664 {
03665 public:
03666 
03667     virtual void catchMessage(const ::HawkMessages::MessagePtr&, const ::Ice::Context*) = 0;
03668 };
03669 
03670 class CameraImageMessage : virtual public ::IceDelegate::HawkMessages::Message
03671 {
03672 public:
03673 };
03674 
03675 class ControlCameraMessage : virtual public ::IceDelegate::HawkMessages::Message
03676 {
03677 public:
03678 };
03679 
03680 class ControlDriveVisionMessage : virtual public ::IceDelegate::HawkMessages::Message
03681 {
03682 public:
03683 };
03684 
03685 class ControlLandMessage : virtual public ::IceDelegate::HawkMessages::Message
03686 {
03687 public:
03688 };
03689 
03690 class ControlMoveMessage : virtual public ::IceDelegate::HawkMessages::Message
03691 {
03692 public:
03693 };
03694 
03695 class ControlRoomVisionMessage : virtual public ::IceDelegate::HawkMessages::Message
03696 {
03697 public:
03698 };
03699 
03700 class ControlTakeOffMessage : virtual public ::IceDelegate::HawkMessages::Message
03701 {
03702 public:
03703 };
03704 
03705 class DriveFinderMessage : virtual public ::IceDelegate::HawkMessages::Message
03706 {
03707 public:
03708 };
03709 
03710 class ExampleMessage : virtual public ::IceDelegate::HawkMessages::Message
03711 {
03712 public:
03713 };
03714 
03715 class ExecuteMissionMessage : virtual public ::IceDelegate::HawkMessages::Message
03716 {
03717 public:
03718 };
03719 
03720 class MissionListMessage : virtual public ::IceDelegate::HawkMessages::Message
03721 {
03722 public:
03723 };
03724 
03725 class RoomFinderMessage : virtual public ::IceDelegate::HawkMessages::Message
03726 {
03727 public:
03728 };
03729 
03730 class SensorDataMessage : virtual public ::IceDelegate::HawkMessages::Message
03731 {
03732 public:
03733 };
03734 
03735 class SlamDataMessage : virtual public ::IceDelegate::HawkMessages::Message
03736 {
03737 public:
03738 };
03739 
03740 }
03741 
03742 }
03743 
03744 namespace IceDelegateM
03745 {
03746 
03747 namespace HawkMessages
03748 {
03749 
03750 class Message : virtual public ::IceDelegate::HawkMessages::Message,
03751                 virtual public ::IceDelegateM::Ice::Object
03752 {
03753 public:
03754 };
03755 
03756 class MessageAgent : virtual public ::IceDelegate::HawkMessages::MessageAgent,
03757                      virtual public ::IceDelegateM::Ice::Object
03758 {
03759 public:
03760 
03761     virtual void catchMessage(const ::HawkMessages::MessagePtr&, const ::Ice::Context*);
03762 };
03763 
03764 class CameraImageMessage : virtual public ::IceDelegate::HawkMessages::CameraImageMessage,
03765                            virtual public ::IceDelegateM::HawkMessages::Message
03766 {
03767 public:
03768 };
03769 
03770 class ControlCameraMessage : virtual public ::IceDelegate::HawkMessages::ControlCameraMessage,
03771                              virtual public ::IceDelegateM::HawkMessages::Message
03772 {
03773 public:
03774 };
03775 
03776 class ControlDriveVisionMessage : virtual public ::IceDelegate::HawkMessages::ControlDriveVisionMessage,
03777                                   virtual public ::IceDelegateM::HawkMessages::Message
03778 {
03779 public:
03780 };
03781 
03782 class ControlLandMessage : virtual public ::IceDelegate::HawkMessages::ControlLandMessage,
03783                            virtual public ::IceDelegateM::HawkMessages::Message
03784 {
03785 public:
03786 };
03787 
03788 class ControlMoveMessage : virtual public ::IceDelegate::HawkMessages::ControlMoveMessage,
03789                            virtual public ::IceDelegateM::HawkMessages::Message
03790 {
03791 public:
03792 };
03793 
03794 class ControlRoomVisionMessage : virtual public ::IceDelegate::HawkMessages::ControlRoomVisionMessage,
03795                                  virtual public ::IceDelegateM::HawkMessages::Message
03796 {
03797 public:
03798 };
03799 
03800 class ControlTakeOffMessage : virtual public ::IceDelegate::HawkMessages::ControlTakeOffMessage,
03801                               virtual public ::IceDelegateM::HawkMessages::Message
03802 {
03803 public:
03804 };
03805 
03806 class DriveFinderMessage : virtual public ::IceDelegate::HawkMessages::DriveFinderMessage,
03807                            virtual public ::IceDelegateM::HawkMessages::Message
03808 {
03809 public:
03810 };
03811 
03812 class ExampleMessage : virtual public ::IceDelegate::HawkMessages::ExampleMessage,
03813                        virtual public ::IceDelegateM::HawkMessages::Message
03814 {
03815 public:
03816 };
03817 
03818 class ExecuteMissionMessage : virtual public ::IceDelegate::HawkMessages::ExecuteMissionMessage,
03819                               virtual public ::IceDelegateM::HawkMessages::Message
03820 {
03821 public:
03822 };
03823 
03824 class MissionListMessage : virtual public ::IceDelegate::HawkMessages::MissionListMessage,
03825                            virtual public ::IceDelegateM::HawkMessages::Message
03826 {
03827 public:
03828 };
03829 
03830 class RoomFinderMessage : virtual public ::IceDelegate::HawkMessages::RoomFinderMessage,
03831                           virtual public ::IceDelegateM::HawkMessages::Message
03832 {
03833 public:
03834 };
03835 
03836 class SensorDataMessage : virtual public ::IceDelegate::HawkMessages::SensorDataMessage,
03837                           virtual public ::IceDelegateM::HawkMessages::Message
03838 {
03839 public:
03840 };
03841 
03842 class SlamDataMessage : virtual public ::IceDelegate::HawkMessages::SlamDataMessage,
03843                         virtual public ::IceDelegateM::HawkMessages::Message
03844 {
03845 public:
03846 };
03847 
03848 }
03849 
03850 }
03851 
03852 namespace IceDelegateD
03853 {
03854 
03855 namespace HawkMessages
03856 {
03857 
03858 class Message : virtual public ::IceDelegate::HawkMessages::Message,
03859                 virtual public ::IceDelegateD::Ice::Object
03860 {
03861 public:
03862 };
03863 
03864 class MessageAgent : virtual public ::IceDelegate::HawkMessages::MessageAgent,
03865                      virtual public ::IceDelegateD::Ice::Object
03866 {
03867 public:
03868 
03869     virtual void catchMessage(const ::HawkMessages::MessagePtr&, const ::Ice::Context*);
03870 };
03871 
03872 class CameraImageMessage : virtual public ::IceDelegate::HawkMessages::CameraImageMessage,
03873                            virtual public ::IceDelegateD::HawkMessages::Message
03874 {
03875 public:
03876 };
03877 
03878 class ControlCameraMessage : virtual public ::IceDelegate::HawkMessages::ControlCameraMessage,
03879                              virtual public ::IceDelegateD::HawkMessages::Message
03880 {
03881 public:
03882 };
03883 
03884 class ControlDriveVisionMessage : virtual public ::IceDelegate::HawkMessages::ControlDriveVisionMessage,
03885                                   virtual public ::IceDelegateD::HawkMessages::Message
03886 {
03887 public:
03888 };
03889 
03890 class ControlLandMessage : virtual public ::IceDelegate::HawkMessages::ControlLandMessage,
03891                            virtual public ::IceDelegateD::HawkMessages::Message
03892 {
03893 public:
03894 };
03895 
03896 class ControlMoveMessage : virtual public ::IceDelegate::HawkMessages::ControlMoveMessage,
03897                            virtual public ::IceDelegateD::HawkMessages::Message
03898 {
03899 public:
03900 };
03901 
03902 class ControlRoomVisionMessage : virtual public ::IceDelegate::HawkMessages::ControlRoomVisionMessage,
03903                                  virtual public ::IceDelegateD::HawkMessages::Message
03904 {
03905 public:
03906 };
03907 
03908 class ControlTakeOffMessage : virtual public ::IceDelegate::HawkMessages::ControlTakeOffMessage,
03909                               virtual public ::IceDelegateD::HawkMessages::Message
03910 {
03911 public:
03912 };
03913 
03914 class DriveFinderMessage : virtual public ::IceDelegate::HawkMessages::DriveFinderMessage,
03915                            virtual public ::IceDelegateD::HawkMessages::Message
03916 {
03917 public:
03918 };
03919 
03920 class ExampleMessage : virtual public ::IceDelegate::HawkMessages::ExampleMessage,
03921                        virtual public ::IceDelegateD::HawkMessages::Message
03922 {
03923 public:
03924 };
03925 
03926 class ExecuteMissionMessage : virtual public ::IceDelegate::HawkMessages::ExecuteMissionMessage,
03927                               virtual public ::IceDelegateD::HawkMessages::Message
03928 {
03929 public:
03930 };
03931 
03932 class MissionListMessage : virtual public ::IceDelegate::HawkMessages::MissionListMessage,
03933                            virtual public ::IceDelegateD::HawkMessages::Message
03934 {
03935 public:
03936 };
03937 
03938 class RoomFinderMessage : virtual public ::IceDelegate::HawkMessages::RoomFinderMessage,
03939                           virtual public ::IceDelegateD::HawkMessages::Message
03940 {
03941 public:
03942 };
03943 
03944 class SensorDataMessage : virtual public ::IceDelegate::HawkMessages::SensorDataMessage,
03945                           virtual public ::IceDelegateD::HawkMessages::Message
03946 {
03947 public:
03948 };
03949 
03950 class SlamDataMessage : virtual public ::IceDelegate::HawkMessages::SlamDataMessage,
03951                         virtual public ::IceDelegateD::HawkMessages::Message
03952 {
03953 public:
03954 };
03955 
03956 }
03957 
03958 }
03959 
03960 namespace HawkMessages
03961 {
03962 
03963 class Message : virtual public ::Ice::Object
03964 {
03965 public:
03966 
03967     typedef MessagePrx ProxyType;
03968     typedef MessagePtr PointerType;
03969 
03970     Message() {}
03971     virtual ::Ice::ObjectPtr ice_clone() const;
03972 
03973     virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
03974     virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
03975     virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
03976     static const ::std::string& ice_staticId();
03977 
03978     virtual void __write(::IceInternal::BasicStream*) const;
03979     virtual void __read(::IceInternal::BasicStream*, bool);
03980     virtual void __write(const ::Ice::OutputStreamPtr&) const;
03981     virtual void __read(const ::Ice::InputStreamPtr&, bool);
03982 
03983     static const ::Ice::ObjectFactoryPtr& ice_factory();
03984 
03985 protected:
03986 
03987     virtual ~Message() {}
03988 
03989     friend class Message__staticInit;
03990 };
03991 
03992 class Message__staticInit
03993 {
03994 public:
03995 
03996     ::HawkMessages::Message _init;
03997 };
03998 
03999 static Message__staticInit _Message_init;
04000 
04001 class MessageAgent : virtual public ::Ice::Object
04002 {
04003 public:
04004 
04005     typedef MessageAgentPrx ProxyType;
04006     typedef MessageAgentPtr PointerType;
04007 
04008     virtual ::Ice::ObjectPtr ice_clone() const;
04009 
04010     virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
04011     virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
04012     virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
04013     static const ::std::string& ice_staticId();
04014 
04015     virtual void catchMessage(const ::HawkMessages::MessagePtr&, const ::Ice::Current& = ::Ice::Current()) = 0;
04016     ::Ice::DispatchStatus ___catchMessage(::IceInternal::Incoming&, const ::Ice::Current&);
04017 
04018     virtual ::Ice::DispatchStatus __dispatch(::IceInternal::Incoming&, const ::Ice::Current&);
04019 
04020     virtual void __write(::IceInternal::BasicStream*) const;
04021     virtual void __read(::IceInternal::BasicStream*, bool);
04022     virtual void __write(const ::Ice::OutputStreamPtr&) const;
04023     virtual void __read(const ::Ice::InputStreamPtr&, bool);
04024 };
04025 
04026 class CameraImageMessage : virtual public ::HawkMessages::Message
04027 {
04028 public:
04029 
04030     typedef CameraImageMessagePrx ProxyType;
04031     typedef CameraImageMessagePtr PointerType;
04032 
04033     CameraImageMessage() {}
04034     CameraImageMessage(const ::std::string&, const ::std::string&, const ::ImageIceMod::ImageIce&);
04035     virtual ::Ice::ObjectPtr ice_clone() const;
04036 
04037     virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
04038     virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
04039     virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
04040     static const ::std::string& ice_staticId();
04041 
04042 
04043     virtual void __write(::IceInternal::BasicStream*) const;
04044     virtual void __read(::IceInternal::BasicStream*, bool);
04045     virtual void __write(const ::Ice::OutputStreamPtr&) const;
04046     virtual void __read(const ::Ice::InputStreamPtr&, bool);
04047 
04048     static const ::Ice::ObjectFactoryPtr& ice_factory();
04049 
04050 protected:
04051 
04052     virtual ~CameraImageMessage() {}
04053 
04054 public:
04055 
04056     ::std::string cameraID;
04057 
04058     ::std::string compression;
04059 
04060     ::ImageIceMod::ImageIce image;
04061 };
04062 
04063 class ControlCameraMessage : virtual public ::HawkMessages::Message
04064 {
04065 public:
04066 
04067     typedef ControlCameraMessagePrx ProxyType;
04068     typedef ControlCameraMessagePtr PointerType;
04069 
04070     ControlCameraMessage() {}
04071     ControlCameraMessage(const ::std::string&, const ::std::string&, ::Ice::Int, bool);
04072     virtual ::Ice::ObjectPtr ice_clone() const;
04073 
04074     virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
04075     virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
04076     virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
04077     static const ::std::string& ice_staticId();
04078 
04079 
04080     virtual void __write(::IceInternal::BasicStream*) const;
04081     virtual void __read(::IceInternal::BasicStream*, bool);
04082     virtual void __write(const ::Ice::OutputStreamPtr&) const;
04083     virtual void __read(const ::Ice::InputStreamPtr&, bool);
04084 
04085     static const ::Ice::ObjectFactoryPtr& ice_factory();
04086 
04087 protected:
04088 
04089     virtual ~ControlCameraMessage() {}
04090 
04091 public:
04092 
04093     ::std::string cameraID;
04094 
04095     ::std::string compression;
04096 
04097     ::Ice::Int fps;
04098 
04099     bool cameraOn;
04100 };
04101 
04102 class ControlDriveVisionMessage : virtual public ::HawkMessages::Message
04103 {
04104 public:
04105 
04106     typedef ControlDriveVisionMessagePrx ProxyType;
04107     typedef ControlDriveVisionMessagePtr PointerType;
04108 
04109     ControlDriveVisionMessage() {}
04110     explicit ControlDriveVisionMessage(bool);
04111     virtual ::Ice::ObjectPtr ice_clone() const;
04112 
04113     virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
04114     virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
04115     virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
04116     static const ::std::string& ice_staticId();
04117 
04118 
04119     virtual void __write(::IceInternal::BasicStream*) const;
04120     virtual void __read(::IceInternal::BasicStream*, bool);
04121     virtual void __write(const ::Ice::OutputStreamPtr&) const;
04122     virtual void __read(const ::Ice::InputStreamPtr&, bool);
04123 
04124     static const ::Ice::ObjectFactoryPtr& ice_factory();
04125 
04126 protected:
04127 
04128     virtual ~ControlDriveVisionMessage() {}
04129 
04130 public:
04131 
04132     bool driveVisionOn;
04133 };
04134 
04135 class ControlLandMessage : virtual public ::HawkMessages::Message
04136 {
04137 public:
04138 
04139     typedef ControlLandMessagePrx ProxyType;
04140     typedef ControlLandMessagePtr PointerType;
04141 
04142     ControlLandMessage() {}
04143     virtual ::Ice::ObjectPtr ice_clone() const;
04144 
04145     virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
04146     virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
04147     virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
04148     static const ::std::string& ice_staticId();
04149 
04150     virtual void __write(::IceInternal::BasicStream*) const;
04151     virtual void __read(::IceInternal::BasicStream*, bool);
04152     virtual void __write(const ::Ice::OutputStreamPtr&) const;
04153     virtual void __read(const ::Ice::InputStreamPtr&, bool);
04154 
04155     static const ::Ice::ObjectFactoryPtr& ice_factory();
04156 
04157 protected:
04158 
04159     virtual ~ControlLandMessage() {}
04160 };
04161 
04162 class ControlMoveMessage : virtual public ::HawkMessages::Message
04163 {
04164 public:
04165 
04166     typedef ControlMoveMessagePrx ProxyType;
04167     typedef ControlMoveMessagePtr PointerType;
04168 
04169     ControlMoveMessage() {}
04170     explicit ControlMoveMessage(const ::HawkMessages::Pose&);
04171     virtual ::Ice::ObjectPtr ice_clone() const;
04172 
04173     virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
04174     virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
04175     virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
04176     static const ::std::string& ice_staticId();
04177 
04178 
04179     virtual void __write(::IceInternal::BasicStream*) const;
04180     virtual void __read(::IceInternal::BasicStream*, bool);
04181     virtual void __write(const ::Ice::OutputStreamPtr&) const;
04182     virtual void __read(const ::Ice::InputStreamPtr&, bool);
04183 
04184     static const ::Ice::ObjectFactoryPtr& ice_factory();
04185 
04186 protected:
04187 
04188     virtual ~ControlMoveMessage() {}
04189 
04190 public:
04191 
04192     ::HawkMessages::Pose move;
04193 };
04194 
04195 class ControlRoomVisionMessage : virtual public ::HawkMessages::Message
04196 {
04197 public:
04198 
04199     typedef ControlRoomVisionMessagePrx ProxyType;
04200     typedef ControlRoomVisionMessagePtr PointerType;
04201 
04202     ControlRoomVisionMessage() {}
04203     explicit ControlRoomVisionMessage(bool);
04204     virtual ::Ice::ObjectPtr ice_clone() const;
04205 
04206     virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
04207     virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
04208     virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
04209     static const ::std::string& ice_staticId();
04210 
04211 
04212     virtual void __write(::IceInternal::BasicStream*) const;
04213     virtual void __read(::IceInternal::BasicStream*, bool);
04214     virtual void __write(const ::Ice::OutputStreamPtr&) const;
04215     virtual void __read(const ::Ice::InputStreamPtr&, bool);
04216 
04217     static const ::Ice::ObjectFactoryPtr& ice_factory();
04218 
04219 protected:
04220 
04221     virtual ~ControlRoomVisionMessage() {}
04222 
04223 public:
04224 
04225     bool roomVisionOn;
04226 };
04227 
04228 class ControlTakeOffMessage : virtual public ::HawkMessages::Message
04229 {
04230 public:
04231 
04232     typedef ControlTakeOffMessagePrx ProxyType;
04233     typedef ControlTakeOffMessagePtr PointerType;
04234 
04235     ControlTakeOffMessage() {}
04236     explicit ControlTakeOffMessage(::Ice::Double);
04237     virtual ::Ice::ObjectPtr ice_clone() const;
04238 
04239     virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
04240     virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
04241     virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
04242     static const ::std::string& ice_staticId();
04243 
04244 
04245     virtual void __write(::IceInternal::BasicStream*) const;
04246     virtual void __read(::IceInternal::BasicStream*, bool);
04247     virtual void __write(const ::Ice::OutputStreamPtr&) const;
04248     virtual void __read(const ::Ice::InputStreamPtr&, bool);
04249 
04250     static const ::Ice::ObjectFactoryPtr& ice_factory();
04251 
04252 protected:
04253 
04254     virtual ~ControlTakeOffMessage() {}
04255 
04256 public:
04257 
04258     ::Ice::Double altitude;
04259 };
04260 
04261 class DriveFinderMessage : virtual public ::HawkMessages::Message
04262 {
04263 public:
04264 
04265     typedef DriveFinderMessagePrx ProxyType;
04266     typedef DriveFinderMessagePtr PointerType;
04267 
04268     DriveFinderMessage() {}
04269     DriveFinderMessage(bool, const ::HawkMessages::Pose&);
04270     virtual ::Ice::ObjectPtr ice_clone() const;
04271 
04272     virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
04273     virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
04274     virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
04275     static const ::std::string& ice_staticId();
04276 
04277 
04278     virtual void __write(::IceInternal::BasicStream*) const;
04279     virtual void __read(::IceInternal::BasicStream*, bool);
04280     virtual void __write(const ::Ice::OutputStreamPtr&) const;
04281     virtual void __read(const ::Ice::InputStreamPtr&, bool);
04282 
04283     static const ::Ice::ObjectFactoryPtr& ice_factory();
04284 
04285 protected:
04286 
04287     virtual ~DriveFinderMessage() {}
04288 
04289 public:
04290 
04291     bool driveFound;
04292 
04293     ::HawkMessages::Pose drivePose;
04294 };
04295 
04296 class ExampleMessage : virtual public ::HawkMessages::Message
04297 {
04298 public:
04299 
04300     typedef ExampleMessagePrx ProxyType;
04301     typedef ExampleMessagePtr PointerType;
04302 
04303     ExampleMessage() {}
04304     ExampleMessage(const ::std::string&, const ::std::string&);
04305     virtual ::Ice::ObjectPtr ice_clone() const;
04306 
04307     virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
04308     virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
04309     virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
04310     static const ::std::string& ice_staticId();
04311 
04312 
04313     virtual void __write(::IceInternal::BasicStream*) const;
04314     virtual void __read(::IceInternal::BasicStream*, bool);
04315     virtual void __write(const ::Ice::OutputStreamPtr&) const;
04316     virtual void __read(const ::Ice::InputStreamPtr&, bool);
04317 
04318     static const ::Ice::ObjectFactoryPtr& ice_factory();
04319 
04320 protected:
04321 
04322     virtual ~ExampleMessage() {}
04323 
04324 public:
04325 
04326     ::std::string name;
04327 
04328     ::std::string chatter;
04329 };
04330 
04331 class ExecuteMissionMessage : virtual public ::HawkMessages::Message
04332 {
04333 public:
04334 
04335     typedef ExecuteMissionMessagePrx ProxyType;
04336     typedef ExecuteMissionMessagePtr PointerType;
04337 
04338     ExecuteMissionMessage() {}
04339     explicit ExecuteMissionMessage(const ::std::string&);
04340     virtual ::Ice::ObjectPtr ice_clone() const;
04341 
04342     virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
04343     virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
04344     virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
04345     static const ::std::string& ice_staticId();
04346 
04347 
04348     virtual void __write(::IceInternal::BasicStream*) const;
04349     virtual void __read(::IceInternal::BasicStream*, bool);
04350     virtual void __write(const ::Ice::OutputStreamPtr&) const;
04351     virtual void __read(const ::Ice::InputStreamPtr&, bool);
04352 
04353     static const ::Ice::ObjectFactoryPtr& ice_factory();
04354 
04355 protected:
04356 
04357     virtual ~ExecuteMissionMessage() {}
04358 
04359 public:
04360 
04361     ::std::string mission;
04362 };
04363 
04364 class MissionListMessage : virtual public ::HawkMessages::Message
04365 {
04366 public:
04367 
04368     typedef MissionListMessagePrx ProxyType;
04369     typedef MissionListMessagePtr PointerType;
04370 
04371     MissionListMessage() {}
04372     explicit MissionListMessage(const ::HawkMessages::StringSeq&);
04373     virtual ::Ice::ObjectPtr ice_clone() const;
04374 
04375     virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
04376     virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
04377     virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
04378     static const ::std::string& ice_staticId();
04379 
04380 
04381     virtual void __write(::IceInternal::BasicStream*) const;
04382     virtual void __read(::IceInternal::BasicStream*, bool);
04383     virtual void __write(const ::Ice::OutputStreamPtr&) const;
04384     virtual void __read(const ::Ice::InputStreamPtr&, bool);
04385 
04386     static const ::Ice::ObjectFactoryPtr& ice_factory();
04387 
04388 protected:
04389 
04390     virtual ~MissionListMessage() {}
04391 
04392 public:
04393 
04394     ::HawkMessages::StringSeq missions;
04395 };
04396 
04397 class RoomFinderMessage : virtual public ::HawkMessages::Message
04398 {
04399 public:
04400 
04401     typedef RoomFinderMessagePrx ProxyType;
04402     typedef RoomFinderMessagePtr PointerType;
04403 
04404     RoomFinderMessage() {}
04405     RoomFinderMessage(bool, const ::HawkMessages::Pose&);
04406     virtual ::Ice::ObjectPtr ice_clone() const;
04407 
04408     virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
04409     virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
04410     virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
04411     static const ::std::string& ice_staticId();
04412 
04413 
04414     virtual void __write(::IceInternal::BasicStream*) const;
04415     virtual void __read(::IceInternal::BasicStream*, bool);
04416     virtual void __write(const ::Ice::OutputStreamPtr&) const;
04417     virtual void __read(const ::Ice::InputStreamPtr&, bool);
04418 
04419     static const ::Ice::ObjectFactoryPtr& ice_factory();
04420 
04421 protected:
04422 
04423     virtual ~RoomFinderMessage() {}
04424 
04425 public:
04426 
04427     bool roomFound;
04428 
04429     ::HawkMessages::Pose roomPose;
04430 };
04431 
04432 class SensorDataMessage : virtual public ::HawkMessages::Message
04433 {
04434 public:
04435 
04436     typedef SensorDataMessagePrx ProxyType;
04437     typedef SensorDataMessagePtr PointerType;
04438 
04439     SensorDataMessage() {}
04440     SensorDataMessage(const ::HawkMessages::Pose&, ::Ice::Double, ::Ice::Double, bool, ::Ice::Double, ::Ice::Double, ::Ice::Double, bool, ::Ice::Double, ::Ice::Double, ::Ice::Double, bool, ::Ice::Double, ::Ice::Double, ::Ice::Double, bool, ::Ice::Double, ::Ice::Double, ::Ice::Double, ::Ice::Double, ::Ice::Double, const ::HawkMessages::LongSeq&, const ::HawkMessages::SonarSeq&);
04441     virtual ::Ice::ObjectPtr ice_clone() const;
04442 
04443     virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
04444     virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
04445     virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
04446     static const ::std::string& ice_staticId();
04447 
04448 
04449     virtual void __write(::IceInternal::BasicStream*) const;
04450     virtual void __read(::IceInternal::BasicStream*, bool);
04451     virtual void __write(const ::Ice::OutputStreamPtr&) const;
04452     virtual void __read(const ::Ice::InputStreamPtr&, bool);
04453 
04454     static const ::Ice::ObjectFactoryPtr& ice_factory();
04455 
04456 protected:
04457 
04458     virtual ~SensorDataMessage() {}
04459 
04460 public:
04461 
04462     ::HawkMessages::Pose attemptedMove;
04463 
04464     ::Ice::Double motorSpeeds;
04465 
04466     ::Ice::Double batterVoltage;
04467 
04468     bool validAccel;
04469 
04470     ::Ice::Double accelX;
04471 
04472     ::Ice::Double accelY;
04473 
04474     ::Ice::Double accelZ;
04475 
04476     bool validGyro;
04477 
04478     ::Ice::Double gyroX;
04479 
04480     ::Ice::Double gyroY;
04481 
04482     ::Ice::Double gyroZ;
04483 
04484     bool validMag;
04485 
04486     ::Ice::Double magX;
04487 
04488     ::Ice::Double magY;
04489 
04490     ::Ice::Double magZ;
04491 
04492     bool validAhr;
04493 
04494     ::Ice::Double roll;
04495 
04496     ::Ice::Double pitch;
04497 
04498     ::Ice::Double yaw;
04499 
04500     ::Ice::Double heading;
04501 
04502     ::Ice::Double angularResolution;
04503 
04504     ::HawkMessages::LongSeq scannerData;
04505 
04506     ::HawkMessages::SonarSeq sonarData;
04507 };
04508 
04509 class SlamDataMessage : virtual public ::HawkMessages::Message
04510 {
04511 public:
04512 
04513     typedef SlamDataMessagePrx ProxyType;
04514     typedef SlamDataMessagePtr PointerType;
04515 
04516     SlamDataMessage() {}
04517     explicit SlamDataMessage(const ::HawkMessages::Pose&);
04518     virtual ::Ice::ObjectPtr ice_clone() const;
04519 
04520     virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
04521     virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
04522     virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
04523     static const ::std::string& ice_staticId();
04524 
04525 
04526     virtual void __write(::IceInternal::BasicStream*) const;
04527     virtual void __read(::IceInternal::BasicStream*, bool);
04528     virtual void __write(const ::Ice::OutputStreamPtr&) const;
04529     virtual void __read(const ::Ice::InputStreamPtr&, bool);
04530 
04531     static const ::Ice::ObjectFactoryPtr& ice_factory();
04532 
04533 protected:
04534 
04535     virtual ~SlamDataMessage() {}
04536 
04537 public:
04538 
04539     ::HawkMessages::Pose hawkPose;
04540 };
04541 
04542 }
04543 
04544 #endif