ImageIce.h

00001 // **********************************************************************
00002 //
00003 // Copyright (c) 2003-2007 ZeroC, Inc. All rights reserved.
00004 //
00005 // This copy of Ice-E is licensed to you under the terms described in the
00006 // ICEE_LICENSE file included in this distribution.
00007 //
00008 // **********************************************************************
00009 
00010 // Ice-E version 1.3.0
00011 // Generated from file `ImageIce.ice'
00012 
00013 #ifndef __ImageIce_h__
00014 #define __ImageIce_h__
00015 
00016 #include <IceE/ProxyF.h>
00017 #include <IceE/ObjectF.h>
00018 #include <IceE/Exception.h>
00019 #include <IceE/ScopedArray.h>
00020 #include <IceE/Proxy.h>
00021 #include <IceE/Object.h>
00022 #ifndef ICEE_PURE_CLIENT
00023 #  include <IceE/Incoming.h>
00024 #endif
00025 #include <IceE/Outgoing.h>
00026 #include <IceE/UndefSysMacros.h>
00027 
00028 #ifndef ICEE_IGNORE_VERSION
00029 #   if ICEE_INT_VERSION / 100 != 103
00030 #       error IceE version mismatch!
00031 #   endif
00032 #   if ICEE_INT_VERSION % 100 < 0
00033 #       error IceE patch level mismatch!
00034 #   endif
00035 #endif
00036 
00037 namespace IceProxy
00038 {
00039 
00040 namespace ImageIceMod
00041 {
00042 
00043 class ImageShuttle;
00044 
00045 }
00046 
00047 }
00048 
00049 namespace ImageIceMod
00050 {
00051 
00052 class ImageShuttle;
00053 bool operator==(const ImageShuttle&, const ImageShuttle&);
00054 bool operator<(const ImageShuttle&, const ImageShuttle&);
00055 
00056 }
00057 
00058 namespace IceInternal
00059 {
00060 
00061 ::Ice::Object* upCast(::ImageIceMod::ImageShuttle*);
00062 ::IceProxy::Ice::Object* upCast(::IceProxy::ImageIceMod::ImageShuttle*);
00063 
00064 }
00065 
00066 namespace ImageIceMod
00067 {
00068 
00069 typedef ::IceInternal::Handle< ::ImageIceMod::ImageShuttle> ImageShuttlePtr;
00070 typedef ::IceInternal::ProxyHandle< ::IceProxy::ImageIceMod::ImageShuttle> ImageShuttlePrx;
00071 
00072 void __read(::IceInternal::BasicStream*, ImageShuttlePrx&);
00073 void __patch__ImageShuttlePtr(void*, ::Ice::ObjectPtr&);
00074 
00075 }
00076 
00077 namespace ImageIceMod
00078 {
00079 
00080 typedef ::std::vector< ::Ice::Byte> ByteSeq;
00081 
00082 struct DimsIce
00083 {
00084     ::Ice::Int w;
00085     ::Ice::Int h;
00086 
00087     bool operator==(const DimsIce&) const;
00088     bool operator<(const DimsIce&) const;
00089     bool operator!=(const DimsIce& __rhs) const
00090     {
00091         return !operator==(__rhs);
00092     }
00093     bool operator<=(const DimsIce& __rhs) const
00094     {
00095         return operator<(__rhs) || operator==(__rhs);
00096     }
00097     bool operator>(const DimsIce& __rhs) const
00098     {
00099         return !operator<(__rhs) && !operator==(__rhs);
00100     }
00101     bool operator>=(const DimsIce& __rhs) const
00102     {
00103         return !operator<(__rhs);
00104     }
00105 
00106     void __write(::IceInternal::BasicStream*) const;
00107     void __read(::IceInternal::BasicStream*);
00108 };
00109 
00110 struct SensorPose
00111 {
00112     ::Ice::Int val;
00113     ::Ice::Float weight;
00114     ::Ice::Float decay;
00115 
00116     bool operator==(const SensorPose&) const;
00117     bool operator<(const SensorPose&) const;
00118     bool operator!=(const SensorPose& __rhs) const
00119     {
00120         return !operator==(__rhs);
00121     }
00122     bool operator<=(const SensorPose& __rhs) const
00123     {
00124         return operator<(__rhs) || operator==(__rhs);
00125     }
00126     bool operator>(const SensorPose& __rhs) const
00127     {
00128         return !operator<(__rhs) && !operator==(__rhs);
00129     }
00130     bool operator>=(const SensorPose& __rhs) const
00131     {
00132         return !operator<(__rhs);
00133     }
00134 
00135     void __write(::IceInternal::BasicStream*) const;
00136     void __read(::IceInternal::BasicStream*);
00137 };
00138 
00139 enum SensorType
00140 {
00141     PATH,
00142     SALIENCY,
00143     PINGER,
00144     BARBWIRE
00145 };
00146 
00147 void __write(::IceInternal::BasicStream*, SensorType);
00148 void __read(::IceInternal::BasicStream*, SensorType&);
00149 
00150 struct SensorVote
00151 {
00152     ::ImageIceMod::SensorType type;
00153     ::ImageIceMod::SensorPose heading;
00154     ::ImageIceMod::SensorPose depth;
00155 
00156     bool operator==(const SensorVote&) const;
00157     bool operator<(const SensorVote&) const;
00158     bool operator!=(const SensorVote& __rhs) const
00159     {
00160         return !operator==(__rhs);
00161     }
00162     bool operator<=(const SensorVote& __rhs) const
00163     {
00164         return operator<(__rhs) || operator==(__rhs);
00165     }
00166     bool operator>(const SensorVote& __rhs) const
00167     {
00168         return !operator<(__rhs) && !operator==(__rhs);
00169     }
00170     bool operator>=(const SensorVote& __rhs) const
00171     {
00172         return !operator<(__rhs);
00173     }
00174 
00175     void __write(::IceInternal::BasicStream*) const;
00176     void __read(::IceInternal::BasicStream*);
00177 };
00178 
00179 struct Point2DIce
00180 {
00181     ::Ice::Int i;
00182     ::Ice::Int j;
00183 
00184     bool operator==(const Point2DIce&) const;
00185     bool operator<(const Point2DIce&) const;
00186     bool operator!=(const Point2DIce& __rhs) const
00187     {
00188         return !operator==(__rhs);
00189     }
00190     bool operator<=(const Point2DIce& __rhs) const
00191     {
00192         return operator<(__rhs) || operator==(__rhs);
00193     }
00194     bool operator>(const Point2DIce& __rhs) const
00195     {
00196         return !operator<(__rhs) && !operator==(__rhs);
00197     }
00198     bool operator>=(const Point2DIce& __rhs) const
00199     {
00200         return !operator<(__rhs);
00201     }
00202 
00203     void __write(::IceInternal::BasicStream*) const;
00204     void __read(::IceInternal::BasicStream*);
00205 };
00206 
00207 struct Point3DIce
00208 {
00209     ::Ice::Float x;
00210     ::Ice::Float y;
00211     ::Ice::Float z;
00212 
00213     bool operator==(const Point3DIce&) const;
00214     bool operator<(const Point3DIce&) const;
00215     bool operator!=(const Point3DIce& __rhs) const
00216     {
00217         return !operator==(__rhs);
00218     }
00219     bool operator<=(const Point3DIce& __rhs) const
00220     {
00221         return operator<(__rhs) || operator==(__rhs);
00222     }
00223     bool operator>(const Point3DIce& __rhs) const
00224     {
00225         return !operator<(__rhs) && !operator==(__rhs);
00226     }
00227     bool operator>=(const Point3DIce& __rhs) const
00228     {
00229         return !operator<(__rhs);
00230     }
00231 
00232     void __write(::IceInternal::BasicStream*) const;
00233     void __read(::IceInternal::BasicStream*);
00234 };
00235 
00236 struct RectangleIce
00237 {
00238     ::ImageIceMod::Point2DIce tl;
00239     ::ImageIceMod::Point2DIce br;
00240 
00241     bool operator==(const RectangleIce&) const;
00242     bool operator<(const RectangleIce&) const;
00243     bool operator!=(const RectangleIce& __rhs) const
00244     {
00245         return !operator==(__rhs);
00246     }
00247     bool operator<=(const RectangleIce& __rhs) const
00248     {
00249         return operator<(__rhs) || operator==(__rhs);
00250     }
00251     bool operator>(const RectangleIce& __rhs) const
00252     {
00253         return !operator<(__rhs) && !operator==(__rhs);
00254     }
00255     bool operator>=(const RectangleIce& __rhs) const
00256     {
00257         return !operator<(__rhs);
00258     }
00259 
00260     void __write(::IceInternal::BasicStream*) const;
00261     void __read(::IceInternal::BasicStream*);
00262 };
00263 
00264 struct QuadrilateralIce
00265 {
00266     ::ImageIceMod::Point2DIce tl;
00267     ::ImageIceMod::Point2DIce tr;
00268     ::ImageIceMod::Point2DIce bl;
00269     ::ImageIceMod::Point2DIce br;
00270     ::ImageIceMod::Point2DIce center;
00271     ::Ice::Float ratio;
00272     ::Ice::Float angle;
00273 
00274     bool operator==(const QuadrilateralIce&) const;
00275     bool operator<(const QuadrilateralIce&) const;
00276     bool operator!=(const QuadrilateralIce& __rhs) const
00277     {
00278         return !operator==(__rhs);
00279     }
00280     bool operator<=(const QuadrilateralIce& __rhs) const
00281     {
00282         return operator<(__rhs) || operator==(__rhs);
00283     }
00284     bool operator>(const QuadrilateralIce& __rhs) const
00285     {
00286         return !operator<(__rhs) && !operator==(__rhs);
00287     }
00288     bool operator>=(const QuadrilateralIce& __rhs) const
00289     {
00290         return !operator<(__rhs);
00291     }
00292 
00293     void __write(::IceInternal::BasicStream*) const;
00294     void __read(::IceInternal::BasicStream*);
00295 };
00296 
00297 struct LineIce
00298 {
00299     ::ImageIceMod::Point2DIce pt1;
00300     ::ImageIceMod::Point2DIce pt2;
00301     ::Ice::Float angle;
00302 
00303     bool operator==(const LineIce&) const;
00304     bool operator<(const LineIce&) const;
00305     bool operator!=(const LineIce& __rhs) const
00306     {
00307         return !operator==(__rhs);
00308     }
00309     bool operator<=(const LineIce& __rhs) const
00310     {
00311         return operator<(__rhs) || operator==(__rhs);
00312     }
00313     bool operator>(const LineIce& __rhs) const
00314     {
00315         return !operator<(__rhs) && !operator==(__rhs);
00316     }
00317     bool operator>=(const LineIce& __rhs) const
00318     {
00319         return !operator<(__rhs);
00320     }
00321 
00322     void __write(::IceInternal::BasicStream*) const;
00323     void __read(::IceInternal::BasicStream*);
00324 };
00325 
00326 struct ImageIce
00327 {
00328     ::ImageIceMod::ByteSeq data;
00329     ::Ice::Int width;
00330     ::Ice::Int height;
00331     ::Ice::Int pixSize;
00332 
00333     bool operator==(const ImageIce&) const;
00334     bool operator<(const ImageIce&) const;
00335     bool operator!=(const ImageIce& __rhs) const
00336     {
00337         return !operator==(__rhs);
00338     }
00339     bool operator<=(const ImageIce& __rhs) const
00340     {
00341         return operator<(__rhs) || operator==(__rhs);
00342     }
00343     bool operator>(const ImageIce& __rhs) const
00344     {
00345         return !operator<(__rhs) && !operator==(__rhs);
00346     }
00347     bool operator>=(const ImageIce& __rhs) const
00348     {
00349         return !operator<(__rhs);
00350     }
00351 
00352     void __write(::IceInternal::BasicStream*) const;
00353     void __read(::IceInternal::BasicStream*);
00354 };
00355 
00356 typedef ::std::vector< ::ImageIceMod::ImageIce> ImageIceSeq;
00357 void __writeImageIceSeq(::IceInternal::BasicStream*, const ::ImageIceMod::ImageIce*, const ::ImageIceMod::ImageIce*);
00358 void __readImageIceSeq(::IceInternal::BasicStream*, ImageIceSeq&);
00359 
00360 }
00361 
00362 namespace ImageIceMod
00363 {
00364 
00365 class ImageShuttle : virtual public ::Ice::Object
00366 {
00367 public:
00368 
00369     typedef ImageShuttlePrx ProxyType;
00370     typedef ImageShuttlePtr PointerType;
00371 
00372 
00373     virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
00374     virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
00375     virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
00376     static const ::std::string& ice_staticId();
00377 
00378     virtual void transferImage(const ::ImageIceMod::ImageIce&, const ::Ice::Current& = ::Ice::Current()) = 0;
00379 #ifndef ICEE_PURE_CLIENT
00380     ::Ice::DispatchStatus ___transferImage(::IceInternal::Incoming&, const ::Ice::Current&);
00381 #endif // ICEE_PURE_CLIENT
00382 
00383 #ifndef ICEE_PURE_CLIENT
00384     virtual ::Ice::DispatchStatus __dispatch(::IceInternal::Incoming&, const ::Ice::Current&);
00385 #endif // ICEE_PURE_CLIENT
00386 
00387     virtual void __write(::IceInternal::BasicStream*) const;
00388     virtual void __read(::IceInternal::BasicStream*, bool);
00389 };
00390 
00391 }
00392 
00393 namespace IceProxy
00394 {
00395 
00396 namespace ImageIceMod
00397 {
00398 
00399 class ImageShuttle : virtual public ::IceProxy::Ice::Object
00400 {
00401 public:
00402 
00403     void transferImage(const ::ImageIceMod::ImageIce& i)
00404     {
00405         transferImage(i, 0);
00406     }
00407     void transferImage(const ::ImageIceMod::ImageIce& i, const ::Ice::Context& __ctx)
00408     {
00409         transferImage(i, &__ctx);
00410     }
00411 
00412 private:
00413 
00414     void transferImage(const ::ImageIceMod::ImageIce&, const ::Ice::Context*);
00415 
00416 public:
00417 
00418     ::IceInternal::ProxyHandle<ImageShuttle> ice_context(const ::Ice::Context& __context) const
00419     {
00420         return dynamic_cast<ImageShuttle*>(::IceProxy::Ice::Object::ice_context(__context).get());
00421     }
00422 
00423     ::IceInternal::ProxyHandle<ImageShuttle> ice_secure(bool __secure) const
00424     {
00425         return dynamic_cast<ImageShuttle*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
00426     }
00427 
00428 #ifdef ICEE_HAS_ROUTER
00429     ::IceInternal::ProxyHandle<ImageShuttle> ice_router(const ::Ice::RouterPrx& __router) const
00430     {
00431         return dynamic_cast<ImageShuttle*>(::IceProxy::Ice::Object::ice_router(__router).get());
00432     }
00433 #endif // ICEE_HAS_ROUTER
00434 
00435 #ifdef ICEE_HAS_LOCATOR
00436     ::IceInternal::ProxyHandle<ImageShuttle> ice_locator(const ::Ice::LocatorPrx& __locator) const
00437     {
00438         return dynamic_cast<ImageShuttle*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
00439     }
00440 
00441     ::IceInternal::ProxyHandle<ImageShuttle> ice_adapterId(const std::string& __id) const
00442     {
00443         return dynamic_cast<ImageShuttle*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
00444     }
00445 #endif // ICEE_HAS_LOCATOR
00446 
00447     ::IceInternal::ProxyHandle<ImageShuttle> ice_twoway() const
00448     {
00449         return dynamic_cast<ImageShuttle*>(::IceProxy::Ice::Object::ice_twoway().get());
00450     }
00451 
00452     ::IceInternal::ProxyHandle<ImageShuttle> ice_oneway() const
00453     {
00454         return dynamic_cast<ImageShuttle*>(::IceProxy::Ice::Object::ice_oneway().get());
00455     }
00456 
00457     ::IceInternal::ProxyHandle<ImageShuttle> ice_batchOneway() const
00458     {
00459         return dynamic_cast<ImageShuttle*>(::IceProxy::Ice::Object::ice_batchOneway().get());
00460     }
00461 
00462     ::IceInternal::ProxyHandle<ImageShuttle> ice_datagram() const
00463     {
00464         return dynamic_cast<ImageShuttle*>(::IceProxy::Ice::Object::ice_datagram().get());
00465     }
00466 
00467     ::IceInternal::ProxyHandle<ImageShuttle> ice_batchDatagram() const
00468     {
00469         return dynamic_cast<ImageShuttle*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
00470     }
00471 
00472     ::IceInternal::ProxyHandle<ImageShuttle> ice_timeout(int __timeout) const
00473     {
00474         return dynamic_cast<ImageShuttle*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
00475     }
00476 
00477     static const ::std::string& ice_staticId();
00478 
00479 private:
00480 
00481     virtual ::IceProxy::Ice::Object* __newInstance() const;
00482 };
00483 
00484 }
00485 
00486 }
00487 
00488 #endif
Generated on Sun May 8 08:41:21 2011 for iLab Neuromorphic Vision Toolkit by  doxygen 1.6.3