INTRODUCTION
Overview
Download and Install
Quick Start
Documentation
Publications

NONFRAMEWORK CODE
Driver Interfaces
Drivers
Libraries
Utilities

FRAMEWORK CODE
Interfaces
Components
Libraries
Utilities

Full Software Listings

DEVELOPER
Tutorials
Examples
Dev Guide
Dashboard

PEOPLE
Contributors
Users

SourceForge.net Logo
Project
Download
Mailing lists

 

         

pinger/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
 

Webmaster: Tobias Kaupp (tobasco at users.sourceforge.net)


Generated for Orca Robotics by  doxygen 1.4.5