SeaBeeMessages.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 `SeaBeeMessages.ice'
00012 
00013 #ifndef __src_Robots_SeaBeeIII_Ice__SeaBeeMessages_ice_H__
00014 #define __src_Robots_SeaBeeIII_Ice__SeaBeeMessages_ice_H__
00015 
00016 #include <Ice/LocalObjectF.h>
00017 #include <Ice/ProxyF.h>
00018 #include <Ice/ObjectF.h>
00019 #include <Ice/Exception.h>
00020 #include <Ice/LocalObject.h>
00021 #include <Ice/Proxy.h>
00022 #include <Ice/Object.h>
00023 #include <Ice/Outgoing.h>
00024 #include <Ice/Incoming.h>
00025 #include <Ice/Direct.h>
00026 #include <Ice/FactoryTable.h>
00027 #include <Ice/StreamF.h>
00028 #include <Ice/ImageIce.ice.H>
00029 #include <Ice/RobotSimEvents.ice.H>
00030 #include <Ice/UndefSysMacros.h>
00031 
00032 #ifndef ICE_IGNORE_VERSION
00033 #   if ICE_INT_VERSION / 100 != 303
00034 #       error Ice version mismatch!
00035 #   endif
00036 #   if ICE_INT_VERSION % 100 > 50
00037 #       error Beta header file detected
00038 #   endif
00039 #   if ICE_INT_VERSION % 100 < 1
00040 #       error Ice patch level mismatch!
00041 #   endif
00042 #endif
00043 
00044 namespace IceProxy
00045 {
00046 
00047 namespace SeaBeeSimEvents
00048 {
00049 
00050 class CameraConfigMessage;
00051 
00052 }
00053 
00054 }
00055 
00056 namespace SeaBeeSimEvents
00057 {
00058 
00059 class CameraConfigMessage;
00060 bool operator==(const CameraConfigMessage&, const CameraConfigMessage&);
00061 bool operator<(const CameraConfigMessage&, const CameraConfigMessage&);
00062 
00063 }
00064 
00065 namespace IceInternal
00066 {
00067 
00068 ::Ice::Object* upCast(::SeaBeeSimEvents::CameraConfigMessage*);
00069 ::IceProxy::Ice::Object* upCast(::IceProxy::SeaBeeSimEvents::CameraConfigMessage*);
00070 
00071 }
00072 
00073 namespace SeaBeeSimEvents
00074 {
00075 
00076 typedef ::IceInternal::Handle< ::SeaBeeSimEvents::CameraConfigMessage> CameraConfigMessagePtr;
00077 typedef ::IceInternal::ProxyHandle< ::IceProxy::SeaBeeSimEvents::CameraConfigMessage> CameraConfigMessagePrx;
00078 
00079 void __read(::IceInternal::BasicStream*, CameraConfigMessagePrx&);
00080 void __patch__CameraConfigMessagePtr(void*, ::Ice::ObjectPtr&);
00081 
00082 }
00083 
00084 namespace IceProxy
00085 {
00086 
00087 namespace SeaBeeSimEvents
00088 {
00089 
00090 class CameraConfigMessage : virtual public ::IceProxy::RobotSimEvents::EventMessage
00091 {
00092 public:
00093 
00094     ::IceInternal::ProxyHandle<CameraConfigMessage> ice_context(const ::Ice::Context& __context) const
00095     {
00096     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00097         typedef ::IceProxy::Ice::Object _Base;
00098         return dynamic_cast<CameraConfigMessage*>(_Base::ice_context(__context).get());
00099     #else
00100         return dynamic_cast<CameraConfigMessage*>(::IceProxy::Ice::Object::ice_context(__context).get());
00101     #endif
00102     }
00103 
00104     ::IceInternal::ProxyHandle<CameraConfigMessage> ice_adapterId(const std::string& __id) const
00105     {
00106     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00107         typedef ::IceProxy::Ice::Object _Base;
00108         return dynamic_cast<CameraConfigMessage*>(_Base::ice_adapterId(__id).get());
00109     #else
00110         return dynamic_cast<CameraConfigMessage*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
00111     #endif
00112     }
00113 
00114     ::IceInternal::ProxyHandle<CameraConfigMessage> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
00115     {
00116     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00117         typedef ::IceProxy::Ice::Object _Base;
00118         return dynamic_cast<CameraConfigMessage*>(_Base::ice_endpoints(__endpoints).get());
00119     #else
00120         return dynamic_cast<CameraConfigMessage*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
00121     #endif
00122     }
00123 
00124     ::IceInternal::ProxyHandle<CameraConfigMessage> ice_locatorCacheTimeout(int __timeout) const
00125     {
00126     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00127         typedef ::IceProxy::Ice::Object _Base;
00128         return dynamic_cast<CameraConfigMessage*>(_Base::ice_locatorCacheTimeout(__timeout).get());
00129     #else
00130         return dynamic_cast<CameraConfigMessage*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
00131     #endif
00132     }
00133 
00134     ::IceInternal::ProxyHandle<CameraConfigMessage> ice_connectionCached(bool __cached) const
00135     {
00136     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00137         typedef ::IceProxy::Ice::Object _Base;
00138         return dynamic_cast<CameraConfigMessage*>(_Base::ice_connectionCached(__cached).get());
00139     #else
00140         return dynamic_cast<CameraConfigMessage*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
00141     #endif
00142     }
00143 
00144     ::IceInternal::ProxyHandle<CameraConfigMessage> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
00145     {
00146     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00147         typedef ::IceProxy::Ice::Object _Base;
00148         return dynamic_cast<CameraConfigMessage*>(_Base::ice_endpointSelection(__est).get());
00149     #else
00150         return dynamic_cast<CameraConfigMessage*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
00151     #endif
00152     }
00153 
00154     ::IceInternal::ProxyHandle<CameraConfigMessage> ice_secure(bool __secure) const
00155     {
00156     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00157         typedef ::IceProxy::Ice::Object _Base;
00158         return dynamic_cast<CameraConfigMessage*>(_Base::ice_secure(__secure).get());
00159     #else
00160         return dynamic_cast<CameraConfigMessage*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
00161     #endif
00162     }
00163 
00164     ::IceInternal::ProxyHandle<CameraConfigMessage> ice_preferSecure(bool __preferSecure) const
00165     {
00166     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00167         typedef ::IceProxy::Ice::Object _Base;
00168         return dynamic_cast<CameraConfigMessage*>(_Base::ice_preferSecure(__preferSecure).get());
00169     #else
00170         return dynamic_cast<CameraConfigMessage*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
00171     #endif
00172     }
00173 
00174     ::IceInternal::ProxyHandle<CameraConfigMessage> ice_router(const ::Ice::RouterPrx& __router) const
00175     {
00176     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00177         typedef ::IceProxy::Ice::Object _Base;
00178         return dynamic_cast<CameraConfigMessage*>(_Base::ice_router(__router).get());
00179     #else
00180         return dynamic_cast<CameraConfigMessage*>(::IceProxy::Ice::Object::ice_router(__router).get());
00181     #endif
00182     }
00183 
00184     ::IceInternal::ProxyHandle<CameraConfigMessage> ice_locator(const ::Ice::LocatorPrx& __locator) const
00185     {
00186     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00187         typedef ::IceProxy::Ice::Object _Base;
00188         return dynamic_cast<CameraConfigMessage*>(_Base::ice_locator(__locator).get());
00189     #else
00190         return dynamic_cast<CameraConfigMessage*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
00191     #endif
00192     }
00193 
00194     ::IceInternal::ProxyHandle<CameraConfigMessage> ice_collocationOptimized(bool __co) const
00195     {
00196     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00197         typedef ::IceProxy::Ice::Object _Base;
00198         return dynamic_cast<CameraConfigMessage*>(_Base::ice_collocationOptimized(__co).get());
00199     #else
00200         return dynamic_cast<CameraConfigMessage*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
00201     #endif
00202     }
00203 
00204     ::IceInternal::ProxyHandle<CameraConfigMessage> ice_twoway() const
00205     {
00206     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00207         typedef ::IceProxy::Ice::Object _Base;
00208         return dynamic_cast<CameraConfigMessage*>(_Base::ice_twoway().get());
00209     #else
00210         return dynamic_cast<CameraConfigMessage*>(::IceProxy::Ice::Object::ice_twoway().get());
00211     #endif
00212     }
00213 
00214     ::IceInternal::ProxyHandle<CameraConfigMessage> ice_oneway() const
00215     {
00216     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00217         typedef ::IceProxy::Ice::Object _Base;
00218         return dynamic_cast<CameraConfigMessage*>(_Base::ice_oneway().get());
00219     #else
00220         return dynamic_cast<CameraConfigMessage*>(::IceProxy::Ice::Object::ice_oneway().get());
00221     #endif
00222     }
00223 
00224     ::IceInternal::ProxyHandle<CameraConfigMessage> ice_batchOneway() const
00225     {
00226     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00227         typedef ::IceProxy::Ice::Object _Base;
00228         return dynamic_cast<CameraConfigMessage*>(_Base::ice_batchOneway().get());
00229     #else
00230         return dynamic_cast<CameraConfigMessage*>(::IceProxy::Ice::Object::ice_batchOneway().get());
00231     #endif
00232     }
00233 
00234     ::IceInternal::ProxyHandle<CameraConfigMessage> ice_datagram() const
00235     {
00236     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00237         typedef ::IceProxy::Ice::Object _Base;
00238         return dynamic_cast<CameraConfigMessage*>(_Base::ice_datagram().get());
00239     #else
00240         return dynamic_cast<CameraConfigMessage*>(::IceProxy::Ice::Object::ice_datagram().get());
00241     #endif
00242     }
00243 
00244     ::IceInternal::ProxyHandle<CameraConfigMessage> ice_batchDatagram() const
00245     {
00246     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00247         typedef ::IceProxy::Ice::Object _Base;
00248         return dynamic_cast<CameraConfigMessage*>(_Base::ice_batchDatagram().get());
00249     #else
00250         return dynamic_cast<CameraConfigMessage*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
00251     #endif
00252     }
00253 
00254     ::IceInternal::ProxyHandle<CameraConfigMessage> ice_compress(bool __compress) const
00255     {
00256     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00257         typedef ::IceProxy::Ice::Object _Base;
00258         return dynamic_cast<CameraConfigMessage*>(_Base::ice_compress(__compress).get());
00259     #else
00260         return dynamic_cast<CameraConfigMessage*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
00261     #endif
00262     }
00263 
00264     ::IceInternal::ProxyHandle<CameraConfigMessage> ice_timeout(int __timeout) const
00265     {
00266     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00267         typedef ::IceProxy::Ice::Object _Base;
00268         return dynamic_cast<CameraConfigMessage*>(_Base::ice_timeout(__timeout).get());
00269     #else
00270         return dynamic_cast<CameraConfigMessage*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
00271     #endif
00272     }
00273 
00274     ::IceInternal::ProxyHandle<CameraConfigMessage> ice_connectionId(const std::string& __id) const
00275     {
00276     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00277         typedef ::IceProxy::Ice::Object _Base;
00278         return dynamic_cast<CameraConfigMessage*>(_Base::ice_connectionId(__id).get());
00279     #else
00280         return dynamic_cast<CameraConfigMessage*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
00281     #endif
00282     }
00283 
00284     static const ::std::string& ice_staticId();
00285 
00286 private:
00287 
00288     virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
00289     virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
00290     virtual ::IceProxy::Ice::Object* __newInstance() const;
00291 };
00292 
00293 }
00294 
00295 }
00296 
00297 namespace IceDelegate
00298 {
00299 
00300 namespace SeaBeeSimEvents
00301 {
00302 
00303 class CameraConfigMessage : virtual public ::IceDelegate::RobotSimEvents::EventMessage
00304 {
00305 public:
00306 };
00307 
00308 }
00309 
00310 }
00311 
00312 namespace IceDelegateM
00313 {
00314 
00315 namespace SeaBeeSimEvents
00316 {
00317 
00318 class CameraConfigMessage : virtual public ::IceDelegate::SeaBeeSimEvents::CameraConfigMessage,
00319                             virtual public ::IceDelegateM::RobotSimEvents::EventMessage
00320 {
00321 public:
00322 };
00323 
00324 }
00325 
00326 }
00327 
00328 namespace IceDelegateD
00329 {
00330 
00331 namespace SeaBeeSimEvents
00332 {
00333 
00334 class CameraConfigMessage : virtual public ::IceDelegate::SeaBeeSimEvents::CameraConfigMessage,
00335                             virtual public ::IceDelegateD::RobotSimEvents::EventMessage
00336 {
00337 public:
00338 };
00339 
00340 }
00341 
00342 }
00343 
00344 namespace SeaBeeSimEvents
00345 {
00346 
00347 class CameraConfigMessage : virtual public ::RobotSimEvents::EventMessage
00348 {
00349 public:
00350 
00351     typedef CameraConfigMessagePrx ProxyType;
00352     typedef CameraConfigMessagePtr PointerType;
00353 
00354     CameraConfigMessage() {}
00355     CameraConfigMessage(::Ice::Int, bool);
00356     virtual ::Ice::ObjectPtr ice_clone() const;
00357 
00358     virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
00359     virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
00360     virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
00361     static const ::std::string& ice_staticId();
00362 
00363 
00364     virtual void __write(::IceInternal::BasicStream*) const;
00365     virtual void __read(::IceInternal::BasicStream*, bool);
00366     virtual void __write(const ::Ice::OutputStreamPtr&) const;
00367     virtual void __read(const ::Ice::InputStreamPtr&, bool);
00368 
00369     static const ::Ice::ObjectFactoryPtr& ice_factory();
00370 
00371 protected:
00372 
00373     virtual ~CameraConfigMessage() {}
00374 
00375     friend class CameraConfigMessage__staticInit;
00376 
00377 public:
00378 
00379     ::Ice::Int cameraID;
00380 
00381     bool active;
00382 };
00383 
00384 class CameraConfigMessage__staticInit
00385 {
00386 public:
00387 
00388     ::SeaBeeSimEvents::CameraConfigMessage _init;
00389 };
00390 
00391 static CameraConfigMessage__staticInit _CameraConfigMessage_init;
00392 
00393 }
00394 
00395 #endif