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