replier/pingreply.h

00001 // **********************************************************************
00002 //
00003 // Copyright (c) 2003-2007 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.2.1
00011 // Generated from file `pingreply.ice'
00012 
00013 #ifndef __pingreply_h__
00014 #define __pingreply_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 != 302
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 orca
00045 {
00046 
00047 namespace util
00048 {
00049 
00050 class LatencyPinger;
00051 bool operator==(const LatencyPinger&, const LatencyPinger&);
00052 bool operator!=(const LatencyPinger&, const LatencyPinger&);
00053 bool operator<(const LatencyPinger&, const LatencyPinger&);
00054 bool operator<=(const LatencyPinger&, const LatencyPinger&);
00055 bool operator>(const LatencyPinger&, const LatencyPinger&);
00056 bool operator>=(const LatencyPinger&, const LatencyPinger&);
00057 
00058 class LatencyReplier;
00059 bool operator==(const LatencyReplier&, const LatencyReplier&);
00060 bool operator!=(const LatencyReplier&, const LatencyReplier&);
00061 bool operator<(const LatencyReplier&, const LatencyReplier&);
00062 bool operator<=(const LatencyReplier&, const LatencyReplier&);
00063 bool operator>(const LatencyReplier&, const LatencyReplier&);
00064 bool operator>=(const LatencyReplier&, const LatencyReplier&);
00065 
00066 }
00067 
00068 }
00069 
00070 }
00071 
00072 namespace orca
00073 {
00074 
00075 namespace util
00076 {
00077 
00078 class LatencyPinger;
00079 bool operator==(const LatencyPinger&, const LatencyPinger&);
00080 bool operator!=(const LatencyPinger&, const LatencyPinger&);
00081 bool operator<(const LatencyPinger&, const LatencyPinger&);
00082 bool operator<=(const LatencyPinger&, const LatencyPinger&);
00083 bool operator>(const LatencyPinger&, const LatencyPinger&);
00084 bool operator>=(const LatencyPinger&, const LatencyPinger&);
00085 
00086 class LatencyReplier;
00087 bool operator==(const LatencyReplier&, const LatencyReplier&);
00088 bool operator!=(const LatencyReplier&, const LatencyReplier&);
00089 bool operator<(const LatencyReplier&, const LatencyReplier&);
00090 bool operator<=(const LatencyReplier&, const LatencyReplier&);
00091 bool operator>(const LatencyReplier&, const LatencyReplier&);
00092 bool operator>=(const LatencyReplier&, const LatencyReplier&);
00093 
00094 }
00095 
00096 }
00097 
00098 namespace IceInternal
00099 {
00100 
00101 void incRef(::orca::util::LatencyPinger*);
00102 void decRef(::orca::util::LatencyPinger*);
00103 
00104 void incRef(::IceProxy::orca::util::LatencyPinger*);
00105 void decRef(::IceProxy::orca::util::LatencyPinger*);
00106 
00107 void incRef(::orca::util::LatencyReplier*);
00108 void decRef(::orca::util::LatencyReplier*);
00109 
00110 void incRef(::IceProxy::orca::util::LatencyReplier*);
00111 void decRef(::IceProxy::orca::util::LatencyReplier*);
00112 
00113 }
00114 
00115 namespace orca
00116 {
00117 
00118 namespace util
00119 {
00120 
00121 typedef ::IceInternal::Handle< ::orca::util::LatencyPinger> LatencyPingerPtr;
00122 typedef ::IceInternal::ProxyHandle< ::IceProxy::orca::util::LatencyPinger> LatencyPingerPrx;
00123 
00124 void __write(::IceInternal::BasicStream*, const LatencyPingerPrx&);
00125 void __read(::IceInternal::BasicStream*, LatencyPingerPrx&);
00126 void __write(::IceInternal::BasicStream*, const LatencyPingerPtr&);
00127 void __patch__LatencyPingerPtr(void*, ::Ice::ObjectPtr&);
00128 
00129 void __addObject(const LatencyPingerPtr&, ::IceInternal::GCCountMap&);
00130 bool __usesClasses(const LatencyPingerPtr&);
00131 void __decRefUnsafe(const LatencyPingerPtr&);
00132 void __clearHandleUnsafe(LatencyPingerPtr&);
00133 
00134 typedef ::IceInternal::Handle< ::orca::util::LatencyReplier> LatencyReplierPtr;
00135 typedef ::IceInternal::ProxyHandle< ::IceProxy::orca::util::LatencyReplier> LatencyReplierPrx;
00136 
00137 void __write(::IceInternal::BasicStream*, const LatencyReplierPrx&);
00138 void __read(::IceInternal::BasicStream*, LatencyReplierPrx&);
00139 void __write(::IceInternal::BasicStream*, const LatencyReplierPtr&);
00140 void __patch__LatencyReplierPtr(void*, ::Ice::ObjectPtr&);
00141 
00142 void __addObject(const LatencyReplierPtr&, ::IceInternal::GCCountMap&);
00143 bool __usesClasses(const LatencyReplierPtr&);
00144 void __decRefUnsafe(const LatencyReplierPtr&);
00145 void __clearHandleUnsafe(LatencyReplierPtr&);
00146 
00147 }
00148 
00149 }
00150 
00151 namespace orca
00152 {
00153 
00154 namespace util
00155 {
00156 
00157 typedef ::std::vector< ::Ice::Double> DoubleSequence;
00158 
00159 class __U__DoubleSequence { };
00160 
00161 struct PingReplyData
00162 {
00163     ::Ice::Int id;
00164     ::orca::util::DoubleSequence doubles;
00165 
00166     bool operator==(const PingReplyData&) const;
00167     bool operator!=(const PingReplyData&) const;
00168     bool operator<(const PingReplyData&) const;
00169     bool operator<=(const PingReplyData& __rhs) const
00170     {
00171         return operator<(__rhs) || operator==(__rhs);
00172     }
00173     bool operator>(const PingReplyData& __rhs) const
00174     {
00175         return !operator<(__rhs) && !operator==(__rhs);
00176     }
00177     bool operator>=(const PingReplyData& __rhs) const
00178     {
00179         return !operator<(__rhs);
00180     }
00181 
00182     void __write(::IceInternal::BasicStream*) const;
00183     void __read(::IceInternal::BasicStream*);
00184 };
00185 
00186 }
00187 
00188 }
00189 
00190 namespace IceProxy
00191 {
00192 
00193 namespace orca
00194 {
00195 
00196 namespace util
00197 {
00198 
00199 class LatencyPinger : virtual public ::IceProxy::Ice::Object
00200 {
00201 public:
00202 
00203     void takeItBack(const ::orca::util::PingReplyData& data)
00204     {
00205         takeItBack(data, 0);
00206     }
00207     void takeItBack(const ::orca::util::PingReplyData& data, const ::Ice::Context& __ctx)
00208     {
00209         takeItBack(data, &__ctx);
00210     }
00211     
00212 private:
00213 
00214     void takeItBack(const ::orca::util::PingReplyData&, const ::Ice::Context*);
00215     
00216 public:
00217     
00218     static const ::std::string& ice_staticId();
00219 
00220 private: 
00221 
00222     virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
00223     virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
00224 };
00225 
00226 class LatencyReplier : virtual public ::IceProxy::Ice::Object
00227 {
00228 public:
00229 
00230     void setPinger(const ::orca::util::LatencyPingerPrx& server)
00231     {
00232         setPinger(server, 0);
00233     }
00234     void setPinger(const ::orca::util::LatencyPingerPrx& server, const ::Ice::Context& __ctx)
00235     {
00236         setPinger(server, &__ctx);
00237     }
00238     
00239 private:
00240 
00241     void setPinger(const ::orca::util::LatencyPingerPrx&, const ::Ice::Context*);
00242     
00243 public:
00244 
00245     void takeIt(const ::orca::util::PingReplyData& data)
00246     {
00247         takeIt(data, 0);
00248     }
00249     void takeIt(const ::orca::util::PingReplyData& data, const ::Ice::Context& __ctx)
00250     {
00251         takeIt(data, &__ctx);
00252     }
00253     
00254 private:
00255 
00256     void takeIt(const ::orca::util::PingReplyData&, const ::Ice::Context*);
00257     
00258 public:
00259 
00260     ::orca::util::PingReplyData takeItAndReturn(const ::orca::util::PingReplyData& data)
00261     {
00262         return takeItAndReturn(data, 0);
00263     }
00264     ::orca::util::PingReplyData takeItAndReturn(const ::orca::util::PingReplyData& data, const ::Ice::Context& __ctx)
00265     {
00266         return takeItAndReturn(data, &__ctx);
00267     }
00268     
00269 private:
00270 
00271     ::orca::util::PingReplyData takeItAndReturn(const ::orca::util::PingReplyData&, const ::Ice::Context*);
00272     
00273 public:
00274 
00275     void shutdown()
00276     {
00277         shutdown(0);
00278     }
00279     void shutdown(const ::Ice::Context& __ctx)
00280     {
00281         shutdown(&__ctx);
00282     }
00283     
00284 private:
00285 
00286     void shutdown(const ::Ice::Context*);
00287     
00288 public:
00289     
00290     static const ::std::string& ice_staticId();
00291 
00292 private: 
00293 
00294     virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
00295     virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
00296 };
00297 
00298 }
00299 
00300 }
00301 
00302 }
00303 
00304 namespace IceDelegate
00305 {
00306 
00307 namespace orca
00308 {
00309 
00310 namespace util
00311 {
00312 
00313 class LatencyPinger : virtual public ::IceDelegate::Ice::Object
00314 {
00315 public:
00316 
00317     virtual void takeItBack(const ::orca::util::PingReplyData&, const ::Ice::Context*) = 0;
00318 };
00319 
00320 class LatencyReplier : virtual public ::IceDelegate::Ice::Object
00321 {
00322 public:
00323 
00324     virtual void setPinger(const ::orca::util::LatencyPingerPrx&, const ::Ice::Context*) = 0;
00325 
00326     virtual void takeIt(const ::orca::util::PingReplyData&, const ::Ice::Context*) = 0;
00327 
00328     virtual ::orca::util::PingReplyData takeItAndReturn(const ::orca::util::PingReplyData&, const ::Ice::Context*) = 0;
00329 
00330     virtual void shutdown(const ::Ice::Context*) = 0;
00331 };
00332 
00333 }
00334 
00335 }
00336 
00337 }
00338 
00339 namespace IceDelegateM
00340 {
00341 
00342 namespace orca
00343 {
00344 
00345 namespace util
00346 {
00347 
00348 class LatencyPinger : virtual public ::IceDelegate::orca::util::LatencyPinger,
00349                       virtual public ::IceDelegateM::Ice::Object
00350 {
00351 public:
00352 
00353     virtual void takeItBack(const ::orca::util::PingReplyData&, const ::Ice::Context*);
00354 };
00355 
00356 class LatencyReplier : virtual public ::IceDelegate::orca::util::LatencyReplier,
00357                        virtual public ::IceDelegateM::Ice::Object
00358 {
00359 public:
00360 
00361     virtual void setPinger(const ::orca::util::LatencyPingerPrx&, const ::Ice::Context*);
00362 
00363     virtual void takeIt(const ::orca::util::PingReplyData&, const ::Ice::Context*);
00364 
00365     virtual ::orca::util::PingReplyData takeItAndReturn(const ::orca::util::PingReplyData&, const ::Ice::Context*);
00366 
00367     virtual void shutdown(const ::Ice::Context*);
00368 };
00369 
00370 }
00371 
00372 }
00373 
00374 }
00375 
00376 namespace IceDelegateD
00377 {
00378 
00379 namespace orca
00380 {
00381 
00382 namespace util
00383 {
00384 
00385 class LatencyPinger : virtual public ::IceDelegate::orca::util::LatencyPinger,
00386                       virtual public ::IceDelegateD::Ice::Object
00387 {
00388 public:
00389 
00390     virtual void takeItBack(const ::orca::util::PingReplyData&, const ::Ice::Context*);
00391 };
00392 
00393 class LatencyReplier : virtual public ::IceDelegate::orca::util::LatencyReplier,
00394                        virtual public ::IceDelegateD::Ice::Object
00395 {
00396 public:
00397 
00398     virtual void setPinger(const ::orca::util::LatencyPingerPrx&, const ::Ice::Context*);
00399 
00400     virtual void takeIt(const ::orca::util::PingReplyData&, const ::Ice::Context*);
00401 
00402     virtual ::orca::util::PingReplyData takeItAndReturn(const ::orca::util::PingReplyData&, const ::Ice::Context*);
00403 
00404     virtual void shutdown(const ::Ice::Context*);
00405 };
00406 
00407 }
00408 
00409 }
00410 
00411 }
00412 
00413 namespace orca
00414 {
00415 
00416 namespace util
00417 {
00418 
00419 class LatencyPinger : virtual public ::Ice::Object
00420 {
00421 public:
00422 
00423     typedef LatencyPingerPrx ProxyType;
00424     typedef LatencyPingerPtr PointerType;
00425     
00426     virtual ::Ice::ObjectPtr ice_clone() const;
00427 
00428     virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
00429     virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
00430     virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
00431     static const ::std::string& ice_staticId();
00432 
00433     virtual void takeItBack(const ::orca::util::PingReplyData&, const ::Ice::Current& = ::Ice::Current()) = 0;
00434     ::IceInternal::DispatchStatus ___takeItBack(::IceInternal::Incoming&, const ::Ice::Current&);
00435 
00436     virtual ::IceInternal::DispatchStatus __dispatch(::IceInternal::Incoming&, const ::Ice::Current&);
00437 
00438     virtual void __write(::IceInternal::BasicStream*) const;
00439     virtual void __read(::IceInternal::BasicStream*, bool);
00440     virtual void __write(const ::Ice::OutputStreamPtr&) const;
00441     virtual void __read(const ::Ice::InputStreamPtr&, bool);
00442 };
00443 
00444 void __patch__LatencyPingerPtr(void*, ::Ice::ObjectPtr&);
00445 
00446 class LatencyReplier : virtual public ::Ice::Object
00447 {
00448 public:
00449 
00450     typedef LatencyReplierPrx ProxyType;
00451     typedef LatencyReplierPtr PointerType;
00452     
00453     virtual ::Ice::ObjectPtr ice_clone() const;
00454 
00455     virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
00456     virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
00457     virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
00458     static const ::std::string& ice_staticId();
00459 
00460     virtual void setPinger(const ::orca::util::LatencyPingerPrx&, const ::Ice::Current& = ::Ice::Current()) = 0;
00461     ::IceInternal::DispatchStatus ___setPinger(::IceInternal::Incoming&, const ::Ice::Current&);
00462 
00463     virtual void takeIt(const ::orca::util::PingReplyData&, const ::Ice::Current& = ::Ice::Current()) = 0;
00464     ::IceInternal::DispatchStatus ___takeIt(::IceInternal::Incoming&, const ::Ice::Current&);
00465 
00466     virtual ::orca::util::PingReplyData takeItAndReturn(const ::orca::util::PingReplyData&, const ::Ice::Current& = ::Ice::Current()) = 0;
00467     ::IceInternal::DispatchStatus ___takeItAndReturn(::IceInternal::Incoming&, const ::Ice::Current&);
00468 
00469     virtual void shutdown(const ::Ice::Current& = ::Ice::Current()) = 0;
00470     ::IceInternal::DispatchStatus ___shutdown(::IceInternal::Incoming&, const ::Ice::Current&);
00471 
00472     virtual ::IceInternal::DispatchStatus __dispatch(::IceInternal::Incoming&, const ::Ice::Current&);
00473 
00474     virtual void __write(::IceInternal::BasicStream*) const;
00475     virtual void __read(::IceInternal::BasicStream*, bool);
00476     virtual void __write(const ::Ice::OutputStreamPtr&) const;
00477     virtual void __read(const ::Ice::InputStreamPtr&, bool);
00478 };
00479 
00480 void __patch__LatencyReplierPtr(void*, ::Ice::ObjectPtr&);
00481 
00482 }
00483 
00484 }
00485 
00486 #endif