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