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