ImageIce.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 `ImageIce.ice'
00012 
00013 #ifndef __src_Robots_Gumbot_GumbotService__ImageIce_ice_H__
00014 #define __src_Robots_Gumbot_GumbotService__ImageIce_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 ImageIceMod
00045 {
00046 
00047 class ImageShuttle;
00048 
00049 }
00050 
00051 }
00052 
00053 namespace ImageIceMod
00054 {
00055 
00056 class ImageShuttle;
00057 bool operator==(const ImageShuttle&, const ImageShuttle&);
00058 bool operator<(const ImageShuttle&, const ImageShuttle&);
00059 
00060 }
00061 
00062 namespace IceInternal
00063 {
00064 
00065 ::Ice::Object* upCast(::ImageIceMod::ImageShuttle*);
00066 ::IceProxy::Ice::Object* upCast(::IceProxy::ImageIceMod::ImageShuttle*);
00067 
00068 }
00069 
00070 namespace ImageIceMod
00071 {
00072 
00073 typedef ::IceInternal::Handle< ::ImageIceMod::ImageShuttle> ImageShuttlePtr;
00074 typedef ::IceInternal::ProxyHandle< ::IceProxy::ImageIceMod::ImageShuttle> ImageShuttlePrx;
00075 
00076 void __read(::IceInternal::BasicStream*, ImageShuttlePrx&);
00077 void __patch__ImageShuttlePtr(void*, ::Ice::ObjectPtr&);
00078 
00079 }
00080 
00081 namespace ImageIceMod
00082 {
00083 
00084 typedef ::std::vector< ::Ice::Byte> ByteSeq;
00085 
00086 struct DimsIce
00087 {
00088     ::Ice::Int w;
00089     ::Ice::Int h;
00090 
00091     bool operator==(const DimsIce&) const;
00092     bool operator<(const DimsIce&) const;
00093     bool operator!=(const DimsIce& __rhs) const
00094     {
00095         return !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) && !operator==(__rhs);
00104     }
00105     bool operator>=(const DimsIce& __rhs) const
00106     {
00107         return !operator<(__rhs);
00108     }
00109 
00110     void __write(::IceInternal::BasicStream*) const;
00111     void __read(::IceInternal::BasicStream*);
00112 };
00113 
00114 struct SensorPose
00115 {
00116     ::Ice::Int val;
00117     ::Ice::Float weight;
00118     ::Ice::Float decay;
00119 
00120     bool operator==(const SensorPose&) const;
00121     bool operator<(const SensorPose&) const;
00122     bool operator!=(const SensorPose& __rhs) const
00123     {
00124         return !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) && !operator==(__rhs);
00133     }
00134     bool operator>=(const SensorPose& __rhs) const
00135     {
00136         return !operator<(__rhs);
00137     }
00138 
00139     void __write(::IceInternal::BasicStream*) const;
00140     void __read(::IceInternal::BasicStream*);
00141 };
00142 
00143 enum SensorType
00144 {
00145     PATH,
00146     SALIENCY,
00147     PINGER,
00148     BARBWIRE
00149 };
00150 
00151 void __write(::IceInternal::BasicStream*, SensorType);
00152 void __read(::IceInternal::BasicStream*, SensorType&);
00153 
00154 struct SensorVote
00155 {
00156     ::ImageIceMod::SensorType type;
00157     ::ImageIceMod::SensorPose heading;
00158     ::ImageIceMod::SensorPose depth;
00159 
00160     bool operator==(const SensorVote&) const;
00161     bool operator<(const SensorVote&) const;
00162     bool operator!=(const SensorVote& __rhs) const
00163     {
00164         return !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) && !operator==(__rhs);
00173     }
00174     bool operator>=(const SensorVote& __rhs) const
00175     {
00176         return !operator<(__rhs);
00177     }
00178 
00179     void __write(::IceInternal::BasicStream*) const;
00180     void __read(::IceInternal::BasicStream*);
00181 };
00182 
00183 struct WaypointIce
00184 {
00185     ::Ice::Float x;
00186     ::Ice::Float y;
00187     ::Ice::Float depth;
00188     ::Ice::Float heading;
00189 
00190     bool operator==(const WaypointIce&) const;
00191     bool operator<(const WaypointIce&) const;
00192     bool operator!=(const WaypointIce& __rhs) const
00193     {
00194         return !operator==(__rhs);
00195     }
00196     bool operator<=(const WaypointIce& __rhs) const
00197     {
00198         return operator<(__rhs) || operator==(__rhs);
00199     }
00200     bool operator>(const WaypointIce& __rhs) const
00201     {
00202         return !operator<(__rhs) && !operator==(__rhs);
00203     }
00204     bool operator>=(const WaypointIce& __rhs) const
00205     {
00206         return !operator<(__rhs);
00207     }
00208 
00209     void __write(::IceInternal::BasicStream*) const;
00210     void __read(::IceInternal::BasicStream*);
00211 };
00212 
00213 struct Point2DIce
00214 {
00215     ::Ice::Int i;
00216     ::Ice::Int j;
00217 
00218     bool operator==(const Point2DIce&) const;
00219     bool operator<(const Point2DIce&) const;
00220     bool operator!=(const Point2DIce& __rhs) const
00221     {
00222         return !operator==(__rhs);
00223     }
00224     bool operator<=(const Point2DIce& __rhs) const
00225     {
00226         return operator<(__rhs) || operator==(__rhs);
00227     }
00228     bool operator>(const Point2DIce& __rhs) const
00229     {
00230         return !operator<(__rhs) && !operator==(__rhs);
00231     }
00232     bool operator>=(const Point2DIce& __rhs) const
00233     {
00234         return !operator<(__rhs);
00235     }
00236 
00237     void __write(::IceInternal::BasicStream*) const;
00238     void __read(::IceInternal::BasicStream*);
00239 };
00240 
00241 struct Point3DIce
00242 {
00243     ::Ice::Float x;
00244     ::Ice::Float y;
00245     ::Ice::Float z;
00246 
00247     bool operator==(const Point3DIce&) const;
00248     bool operator<(const Point3DIce&) const;
00249     bool operator!=(const Point3DIce& __rhs) const
00250     {
00251         return !operator==(__rhs);
00252     }
00253     bool operator<=(const Point3DIce& __rhs) const
00254     {
00255         return operator<(__rhs) || operator==(__rhs);
00256     }
00257     bool operator>(const Point3DIce& __rhs) const
00258     {
00259         return !operator<(__rhs) && !operator==(__rhs);
00260     }
00261     bool operator>=(const Point3DIce& __rhs) const
00262     {
00263         return !operator<(__rhs);
00264     }
00265 
00266     void __write(::IceInternal::BasicStream*) const;
00267     void __read(::IceInternal::BasicStream*);
00268 };
00269 
00270 struct RectangleIce
00271 {
00272     ::ImageIceMod::Point2DIce tl;
00273     ::ImageIceMod::Point2DIce br;
00274 
00275     bool operator==(const RectangleIce&) const;
00276     bool operator<(const RectangleIce&) const;
00277     bool operator!=(const RectangleIce& __rhs) const
00278     {
00279         return !operator==(__rhs);
00280     }
00281     bool operator<=(const RectangleIce& __rhs) const
00282     {
00283         return operator<(__rhs) || operator==(__rhs);
00284     }
00285     bool operator>(const RectangleIce& __rhs) const
00286     {
00287         return !operator<(__rhs) && !operator==(__rhs);
00288     }
00289     bool operator>=(const RectangleIce& __rhs) const
00290     {
00291         return !operator<(__rhs);
00292     }
00293 
00294     void __write(::IceInternal::BasicStream*) const;
00295     void __read(::IceInternal::BasicStream*);
00296 };
00297 
00298 struct QuadrilateralIce
00299 {
00300     ::ImageIceMod::Point2DIce tl;
00301     ::ImageIceMod::Point2DIce tr;
00302     ::ImageIceMod::Point2DIce bl;
00303     ::ImageIceMod::Point2DIce br;
00304     ::ImageIceMod::Point2DIce center;
00305     ::Ice::Float ratio;
00306     ::Ice::Float angle;
00307 
00308     bool operator==(const QuadrilateralIce&) const;
00309     bool operator<(const QuadrilateralIce&) const;
00310     bool operator!=(const QuadrilateralIce& __rhs) const
00311     {
00312         return !operator==(__rhs);
00313     }
00314     bool operator<=(const QuadrilateralIce& __rhs) const
00315     {
00316         return operator<(__rhs) || operator==(__rhs);
00317     }
00318     bool operator>(const QuadrilateralIce& __rhs) const
00319     {
00320         return !operator<(__rhs) && !operator==(__rhs);
00321     }
00322     bool operator>=(const QuadrilateralIce& __rhs) const
00323     {
00324         return !operator<(__rhs);
00325     }
00326 
00327     void __write(::IceInternal::BasicStream*) const;
00328     void __read(::IceInternal::BasicStream*);
00329 };
00330 
00331 struct LineIce
00332 {
00333     ::ImageIceMod::Point2DIce pt1;
00334     ::ImageIceMod::Point2DIce pt2;
00335     ::Ice::Float angle;
00336 
00337     bool operator==(const LineIce&) const;
00338     bool operator<(const LineIce&) const;
00339     bool operator!=(const LineIce& __rhs) const
00340     {
00341         return !operator==(__rhs);
00342     }
00343     bool operator<=(const LineIce& __rhs) const
00344     {
00345         return operator<(__rhs) || operator==(__rhs);
00346     }
00347     bool operator>(const LineIce& __rhs) const
00348     {
00349         return !operator<(__rhs) && !operator==(__rhs);
00350     }
00351     bool operator>=(const LineIce& __rhs) const
00352     {
00353         return !operator<(__rhs);
00354     }
00355 
00356     void __write(::IceInternal::BasicStream*) const;
00357     void __read(::IceInternal::BasicStream*);
00358 };
00359 
00360 struct ImageIce
00361 {
00362     ::ImageIceMod::ByteSeq data;
00363     ::Ice::Int width;
00364     ::Ice::Int height;
00365     ::Ice::Int pixSize;
00366 
00367     bool operator==(const ImageIce&) const;
00368     bool operator<(const ImageIce&) const;
00369     bool operator!=(const ImageIce& __rhs) const
00370     {
00371         return !operator==(__rhs);
00372     }
00373     bool operator<=(const ImageIce& __rhs) const
00374     {
00375         return operator<(__rhs) || operator==(__rhs);
00376     }
00377     bool operator>(const ImageIce& __rhs) const
00378     {
00379         return !operator<(__rhs) && !operator==(__rhs);
00380     }
00381     bool operator>=(const ImageIce& __rhs) const
00382     {
00383         return !operator<(__rhs);
00384     }
00385 
00386     void __write(::IceInternal::BasicStream*) const;
00387     void __read(::IceInternal::BasicStream*);
00388 };
00389 
00390 typedef ::std::vector< ::ImageIceMod::ImageIce> ImageIceSeq;
00391 void __writeImageIceSeq(::IceInternal::BasicStream*, const ::ImageIceMod::ImageIce*, const ::ImageIceMod::ImageIce*);
00392 void __readImageIceSeq(::IceInternal::BasicStream*, ImageIceSeq&);
00393 
00394 }
00395 
00396 namespace IceProxy
00397 {
00398 
00399 namespace ImageIceMod
00400 {
00401 
00402 class ImageShuttle : virtual public ::IceProxy::Ice::Object
00403 {
00404 public:
00405 
00406     void transferImage(const ::ImageIceMod::ImageIce& i)
00407     {
00408         transferImage(i, 0);
00409     }
00410     void transferImage(const ::ImageIceMod::ImageIce& i, const ::Ice::Context& __ctx)
00411     {
00412         transferImage(i, &__ctx);
00413     }
00414 
00415 private:
00416 
00417     void transferImage(const ::ImageIceMod::ImageIce&, const ::Ice::Context*);
00418 
00419 public:
00420 
00421     ::IceInternal::ProxyHandle<ImageShuttle> ice_context(const ::Ice::Context& __context) const
00422     {
00423     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00424         typedef ::IceProxy::Ice::Object _Base;
00425         return dynamic_cast<ImageShuttle*>(_Base::ice_context(__context).get());
00426     #else
00427         return dynamic_cast<ImageShuttle*>(::IceProxy::Ice::Object::ice_context(__context).get());
00428     #endif
00429     }
00430 
00431     ::IceInternal::ProxyHandle<ImageShuttle> ice_adapterId(const std::string& __id) const
00432     {
00433     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00434         typedef ::IceProxy::Ice::Object _Base;
00435         return dynamic_cast<ImageShuttle*>(_Base::ice_adapterId(__id).get());
00436     #else
00437         return dynamic_cast<ImageShuttle*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
00438     #endif
00439     }
00440 
00441     ::IceInternal::ProxyHandle<ImageShuttle> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
00442     {
00443     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00444         typedef ::IceProxy::Ice::Object _Base;
00445         return dynamic_cast<ImageShuttle*>(_Base::ice_endpoints(__endpoints).get());
00446     #else
00447         return dynamic_cast<ImageShuttle*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
00448     #endif
00449     }
00450 
00451     ::IceInternal::ProxyHandle<ImageShuttle> ice_locatorCacheTimeout(int __timeout) const
00452     {
00453     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00454         typedef ::IceProxy::Ice::Object _Base;
00455         return dynamic_cast<ImageShuttle*>(_Base::ice_locatorCacheTimeout(__timeout).get());
00456     #else
00457         return dynamic_cast<ImageShuttle*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
00458     #endif
00459     }
00460 
00461     ::IceInternal::ProxyHandle<ImageShuttle> ice_connectionCached(bool __cached) const
00462     {
00463     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00464         typedef ::IceProxy::Ice::Object _Base;
00465         return dynamic_cast<ImageShuttle*>(_Base::ice_connectionCached(__cached).get());
00466     #else
00467         return dynamic_cast<ImageShuttle*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
00468     #endif
00469     }
00470 
00471     ::IceInternal::ProxyHandle<ImageShuttle> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
00472     {
00473     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00474         typedef ::IceProxy::Ice::Object _Base;
00475         return dynamic_cast<ImageShuttle*>(_Base::ice_endpointSelection(__est).get());
00476     #else
00477         return dynamic_cast<ImageShuttle*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
00478     #endif
00479     }
00480 
00481     ::IceInternal::ProxyHandle<ImageShuttle> ice_secure(bool __secure) const
00482     {
00483     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00484         typedef ::IceProxy::Ice::Object _Base;
00485         return dynamic_cast<ImageShuttle*>(_Base::ice_secure(__secure).get());
00486     #else
00487         return dynamic_cast<ImageShuttle*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
00488     #endif
00489     }
00490 
00491     ::IceInternal::ProxyHandle<ImageShuttle> ice_preferSecure(bool __preferSecure) const
00492     {
00493     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00494         typedef ::IceProxy::Ice::Object _Base;
00495         return dynamic_cast<ImageShuttle*>(_Base::ice_preferSecure(__preferSecure).get());
00496     #else
00497         return dynamic_cast<ImageShuttle*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
00498     #endif
00499     }
00500 
00501     ::IceInternal::ProxyHandle<ImageShuttle> ice_router(const ::Ice::RouterPrx& __router) const
00502     {
00503     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00504         typedef ::IceProxy::Ice::Object _Base;
00505         return dynamic_cast<ImageShuttle*>(_Base::ice_router(__router).get());
00506     #else
00507         return dynamic_cast<ImageShuttle*>(::IceProxy::Ice::Object::ice_router(__router).get());
00508     #endif
00509     }
00510 
00511     ::IceInternal::ProxyHandle<ImageShuttle> ice_locator(const ::Ice::LocatorPrx& __locator) const
00512     {
00513     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00514         typedef ::IceProxy::Ice::Object _Base;
00515         return dynamic_cast<ImageShuttle*>(_Base::ice_locator(__locator).get());
00516     #else
00517         return dynamic_cast<ImageShuttle*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
00518     #endif
00519     }
00520 
00521     ::IceInternal::ProxyHandle<ImageShuttle> ice_collocationOptimized(bool __co) const
00522     {
00523     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00524         typedef ::IceProxy::Ice::Object _Base;
00525         return dynamic_cast<ImageShuttle*>(_Base::ice_collocationOptimized(__co).get());
00526     #else
00527         return dynamic_cast<ImageShuttle*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
00528     #endif
00529     }
00530 
00531     ::IceInternal::ProxyHandle<ImageShuttle> ice_twoway() const
00532     {
00533     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00534         typedef ::IceProxy::Ice::Object _Base;
00535         return dynamic_cast<ImageShuttle*>(_Base::ice_twoway().get());
00536     #else
00537         return dynamic_cast<ImageShuttle*>(::IceProxy::Ice::Object::ice_twoway().get());
00538     #endif
00539     }
00540 
00541     ::IceInternal::ProxyHandle<ImageShuttle> ice_oneway() const
00542     {
00543     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00544         typedef ::IceProxy::Ice::Object _Base;
00545         return dynamic_cast<ImageShuttle*>(_Base::ice_oneway().get());
00546     #else
00547         return dynamic_cast<ImageShuttle*>(::IceProxy::Ice::Object::ice_oneway().get());
00548     #endif
00549     }
00550 
00551     ::IceInternal::ProxyHandle<ImageShuttle> ice_batchOneway() const
00552     {
00553     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00554         typedef ::IceProxy::Ice::Object _Base;
00555         return dynamic_cast<ImageShuttle*>(_Base::ice_batchOneway().get());
00556     #else
00557         return dynamic_cast<ImageShuttle*>(::IceProxy::Ice::Object::ice_batchOneway().get());
00558     #endif
00559     }
00560 
00561     ::IceInternal::ProxyHandle<ImageShuttle> ice_datagram() const
00562     {
00563     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00564         typedef ::IceProxy::Ice::Object _Base;
00565         return dynamic_cast<ImageShuttle*>(_Base::ice_datagram().get());
00566     #else
00567         return dynamic_cast<ImageShuttle*>(::IceProxy::Ice::Object::ice_datagram().get());
00568     #endif
00569     }
00570 
00571     ::IceInternal::ProxyHandle<ImageShuttle> ice_batchDatagram() const
00572     {
00573     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00574         typedef ::IceProxy::Ice::Object _Base;
00575         return dynamic_cast<ImageShuttle*>(_Base::ice_batchDatagram().get());
00576     #else
00577         return dynamic_cast<ImageShuttle*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
00578     #endif
00579     }
00580 
00581     ::IceInternal::ProxyHandle<ImageShuttle> ice_compress(bool __compress) const
00582     {
00583     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00584         typedef ::IceProxy::Ice::Object _Base;
00585         return dynamic_cast<ImageShuttle*>(_Base::ice_compress(__compress).get());
00586     #else
00587         return dynamic_cast<ImageShuttle*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
00588     #endif
00589     }
00590 
00591     ::IceInternal::ProxyHandle<ImageShuttle> ice_timeout(int __timeout) const
00592     {
00593     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00594         typedef ::IceProxy::Ice::Object _Base;
00595         return dynamic_cast<ImageShuttle*>(_Base::ice_timeout(__timeout).get());
00596     #else
00597         return dynamic_cast<ImageShuttle*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
00598     #endif
00599     }
00600 
00601     ::IceInternal::ProxyHandle<ImageShuttle> ice_connectionId(const std::string& __id) const
00602     {
00603     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00604         typedef ::IceProxy::Ice::Object _Base;
00605         return dynamic_cast<ImageShuttle*>(_Base::ice_connectionId(__id).get());
00606     #else
00607         return dynamic_cast<ImageShuttle*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
00608     #endif
00609     }
00610 
00611     static const ::std::string& ice_staticId();
00612 
00613 private:
00614 
00615     virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
00616     virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
00617     virtual ::IceProxy::Ice::Object* __newInstance() const;
00618 };
00619 
00620 }
00621 
00622 }
00623 
00624 namespace IceDelegate
00625 {
00626 
00627 namespace ImageIceMod
00628 {
00629 
00630 class ImageShuttle : virtual public ::IceDelegate::Ice::Object
00631 {
00632 public:
00633 
00634     virtual void transferImage(const ::ImageIceMod::ImageIce&, const ::Ice::Context*) = 0;
00635 };
00636 
00637 }
00638 
00639 }
00640 
00641 namespace IceDelegateM
00642 {
00643 
00644 namespace ImageIceMod
00645 {
00646 
00647 class ImageShuttle : virtual public ::IceDelegate::ImageIceMod::ImageShuttle,
00648                      virtual public ::IceDelegateM::Ice::Object
00649 {
00650 public:
00651 
00652     virtual void transferImage(const ::ImageIceMod::ImageIce&, const ::Ice::Context*);
00653 };
00654 
00655 }
00656 
00657 }
00658 
00659 namespace IceDelegateD
00660 {
00661 
00662 namespace ImageIceMod
00663 {
00664 
00665 class ImageShuttle : virtual public ::IceDelegate::ImageIceMod::ImageShuttle,
00666                      virtual public ::IceDelegateD::Ice::Object
00667 {
00668 public:
00669 
00670     virtual void transferImage(const ::ImageIceMod::ImageIce&, const ::Ice::Context*);
00671 };
00672 
00673 }
00674 
00675 }
00676 
00677 namespace ImageIceMod
00678 {
00679 
00680 class ImageShuttle : virtual public ::Ice::Object
00681 {
00682 public:
00683 
00684     typedef ImageShuttlePrx ProxyType;
00685     typedef ImageShuttlePtr PointerType;
00686 
00687     virtual ::Ice::ObjectPtr ice_clone() const;
00688 
00689     virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
00690     virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
00691     virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
00692     static const ::std::string& ice_staticId();
00693 
00694     virtual void transferImage(const ::ImageIceMod::ImageIce&, const ::Ice::Current& = ::Ice::Current()) = 0;
00695     ::Ice::DispatchStatus ___transferImage(::IceInternal::Incoming&, const ::Ice::Current&);
00696 
00697     virtual ::Ice::DispatchStatus __dispatch(::IceInternal::Incoming&, const ::Ice::Current&);
00698 
00699     virtual void __write(::IceInternal::BasicStream*) const;
00700     virtual void __read(::IceInternal::BasicStream*, bool);
00701     virtual void __write(const ::Ice::OutputStreamPtr&) const;
00702     virtual void __read(const ::Ice::InputStreamPtr&, bool);
00703 };
00704 
00705 }
00706 
00707 #endif