Horus Doc || IDL Reference || C++ Binding   Java Binding || Doxygen's quick Index  

HxCorbaDatabaseSessions.h

Go to the documentation of this file.
00001 // **********************************************************************
00002 //
00003 // Generated by the ORBacus IDL-to-C++ Translator
00004 //
00005 // Copyright (c) 2001
00006 // IONA Technologies, Inc.
00007 // Waltham, MA, USA
00008 //
00009 // All Rights Reserved
00010 //
00011 // **********************************************************************
00012 
00013 // Version: 4.1.0
00014 
00015 #ifndef ___HxCorbaDatabaseSessions_h__
00016 #define ___HxCorbaDatabaseSessions_h__
00017 
00018 #include <HxCorbaDatabase.h>
00019 
00020 #ifndef OB_INTEGER_VERSION
00021 #   error No ORBacus version defined! Is <OB/CORBA.h> included?
00022 #endif
00023 
00024 #ifndef OB_NO_VERSION_CHECK
00025 #   if (OB_INTEGER_VERSION != 4010000L)
00026 #       error ORBacus version mismatch!
00027 #   endif
00028 #endif
00029 
00030 namespace HxCorba
00031 {
00032 
00033 class VxSegmentBuilder;
00034 typedef VxSegmentBuilder* VxSegmentBuilder_ptr;
00035 typedef VxSegmentBuilder* VxSegmentBuilderRef;
00036 
00037 extern OB::TypeCodeConst _tc_VxSegmentBuilder;
00038 
00039 class VxSegmentationBuilder;
00040 typedef VxSegmentationBuilder* VxSegmentationBuilder_ptr;
00041 typedef VxSegmentationBuilder* VxSegmentationBuilderRef;
00042 
00043 extern OB::TypeCodeConst _tc_VxSegmentationBuilder;
00044 
00045 class StoreSession;
00046 typedef StoreSession* StoreSession_ptr;
00047 typedef StoreSession* StoreSessionRef;
00048 
00049 extern OB::TypeCodeConst _tc_StoreSession;
00050 
00051 class VxMutableSegment;
00052 typedef VxMutableSegment* VxMutableSegment_ptr;
00053 typedef VxMutableSegment* VxMutableSegmentRef;
00054 
00055 extern OB::TypeCodeConst _tc_VxMutableSegment;
00056 
00057 class VxMutableSegmentation;
00058 typedef VxMutableSegmentation* VxMutableSegmentation_ptr;
00059 typedef VxMutableSegmentation* VxMutableSegmentationRef;
00060 
00061 extern OB::TypeCodeConst _tc_VxMutableSegmentation;
00062 
00063 class UpdateSession;
00064 typedef UpdateSession* UpdateSession_ptr;
00065 typedef UpdateSession* UpdateSessionRef;
00066 
00067 extern OB::TypeCodeConst _tc_UpdateSession;
00068 
00069 class XMLSession;
00070 typedef XMLSession* XMLSession_ptr;
00071 typedef XMLSession* XMLSessionRef;
00072 
00073 extern OB::TypeCodeConst _tc_XMLSession;
00074 
00075 class HistogramSession;
00076 typedef HistogramSession* HistogramSession_ptr;
00077 typedef HistogramSession* HistogramSessionRef;
00078 
00079 extern OB::TypeCodeConst _tc_HistogramSession;
00080 
00081 class VxSimilarityBuilder;
00082 typedef VxSimilarityBuilder* VxSimilarityBuilder_ptr;
00083 typedef VxSimilarityBuilder* VxSimilarityBuilderRef;
00084 
00085 extern OB::TypeCodeConst _tc_VxSimilarityBuilder;
00086 
00087 class VxSimilaritySession;
00088 typedef VxSimilaritySession* VxSimilaritySession_ptr;
00089 typedef VxSimilaritySession* VxSimilaritySessionRef;
00090 
00091 extern OB::TypeCodeConst _tc_VxSimilaritySession;
00092 
00093 class FullSession;
00094 typedef FullSession* FullSession_ptr;
00095 typedef FullSession* FullSessionRef;
00096 
00097 extern OB::TypeCodeConst _tc_FullSession;
00098 
00099 } // End of namespace HxCorba
00100 
00101 void OBDuplicate(HxCorba::VxSegmentBuilder_ptr);
00102 void OBRelease(HxCorba::VxSegmentBuilder_ptr);
00103 
00104 void OBMarshal(HxCorba::VxSegmentBuilder_ptr, OB::OutputStreamImpl*);
00105 void OBUnmarshal(HxCorba::VxSegmentBuilder_ptr&, OB::InputStreamImpl*);
00106 
00107 void OBDuplicate(HxCorba::VxSegmentationBuilder_ptr);
00108 void OBRelease(HxCorba::VxSegmentationBuilder_ptr);
00109 
00110 void OBMarshal(HxCorba::VxSegmentationBuilder_ptr, OB::OutputStreamImpl*);
00111 void OBUnmarshal(HxCorba::VxSegmentationBuilder_ptr&, OB::InputStreamImpl*);
00112 
00113 void OBDuplicate(HxCorba::StoreSession_ptr);
00114 void OBRelease(HxCorba::StoreSession_ptr);
00115 
00116 void OBMarshal(HxCorba::StoreSession_ptr, OB::OutputStreamImpl*);
00117 void OBUnmarshal(HxCorba::StoreSession_ptr&, OB::InputStreamImpl*);
00118 
00119 void OBDuplicate(HxCorba::VxMutableSegment_ptr);
00120 void OBRelease(HxCorba::VxMutableSegment_ptr);
00121 
00122 void OBMarshal(HxCorba::VxMutableSegment_ptr, OB::OutputStreamImpl*);
00123 void OBUnmarshal(HxCorba::VxMutableSegment_ptr&, OB::InputStreamImpl*);
00124 
00125 void OBDuplicate(HxCorba::VxMutableSegmentation_ptr);
00126 void OBRelease(HxCorba::VxMutableSegmentation_ptr);
00127 
00128 void OBMarshal(HxCorba::VxMutableSegmentation_ptr, OB::OutputStreamImpl*);
00129 void OBUnmarshal(HxCorba::VxMutableSegmentation_ptr&, OB::InputStreamImpl*);
00130 
00131 void OBDuplicate(HxCorba::UpdateSession_ptr);
00132 void OBRelease(HxCorba::UpdateSession_ptr);
00133 
00134 void OBMarshal(HxCorba::UpdateSession_ptr, OB::OutputStreamImpl*);
00135 void OBUnmarshal(HxCorba::UpdateSession_ptr&, OB::InputStreamImpl*);
00136 
00137 void OBDuplicate(HxCorba::XMLSession_ptr);
00138 void OBRelease(HxCorba::XMLSession_ptr);
00139 
00140 void OBMarshal(HxCorba::XMLSession_ptr, OB::OutputStreamImpl*);
00141 void OBUnmarshal(HxCorba::XMLSession_ptr&, OB::InputStreamImpl*);
00142 
00143 void OBDuplicate(HxCorba::HistogramSession_ptr);
00144 void OBRelease(HxCorba::HistogramSession_ptr);
00145 
00146 void OBMarshal(HxCorba::HistogramSession_ptr, OB::OutputStreamImpl*);
00147 void OBUnmarshal(HxCorba::HistogramSession_ptr&, OB::InputStreamImpl*);
00148 
00149 void OBDuplicate(HxCorba::VxSimilarityBuilder_ptr);
00150 void OBRelease(HxCorba::VxSimilarityBuilder_ptr);
00151 
00152 void OBMarshal(HxCorba::VxSimilarityBuilder_ptr, OB::OutputStreamImpl*);
00153 void OBUnmarshal(HxCorba::VxSimilarityBuilder_ptr&, OB::InputStreamImpl*);
00154 
00155 void OBDuplicate(HxCorba::VxSimilaritySession_ptr);
00156 void OBRelease(HxCorba::VxSimilaritySession_ptr);
00157 
00158 void OBMarshal(HxCorba::VxSimilaritySession_ptr, OB::OutputStreamImpl*);
00159 void OBUnmarshal(HxCorba::VxSimilaritySession_ptr&, OB::InputStreamImpl*);
00160 
00161 void OBDuplicate(HxCorba::FullSession_ptr);
00162 void OBRelease(HxCorba::FullSession_ptr);
00163 
00164 void OBMarshal(HxCorba::FullSession_ptr, OB::OutputStreamImpl*);
00165 void OBUnmarshal(HxCorba::FullSession_ptr&, OB::InputStreamImpl*);
00166 
00167 namespace HxCorba
00168 {
00169 
00170 typedef OB::ObjVar< VxSegmentBuilder > VxSegmentBuilder_var;
00171 typedef OB::ObjOut< VxSegmentBuilder > VxSegmentBuilder_out;
00172 
00173 typedef OB::ObjVar< VxSegmentationBuilder > VxSegmentationBuilder_var;
00174 typedef OB::ObjOut< VxSegmentationBuilder > VxSegmentationBuilder_out;
00175 
00176 typedef OB::ObjVar< StoreSession > StoreSession_var;
00177 typedef OB::ObjOut< StoreSession > StoreSession_out;
00178 
00179 typedef OB::ObjVar< VxMutableSegment > VxMutableSegment_var;
00180 typedef OB::ObjOut< VxMutableSegment > VxMutableSegment_out;
00181 
00182 typedef OB::ObjVar< VxMutableSegmentation > VxMutableSegmentation_var;
00183 typedef OB::ObjOut< VxMutableSegmentation > VxMutableSegmentation_out;
00184 
00185 typedef OB::ObjVar< UpdateSession > UpdateSession_var;
00186 typedef OB::ObjOut< UpdateSession > UpdateSession_out;
00187 
00188 typedef OB::ObjVar< XMLSession > XMLSession_var;
00189 typedef OB::ObjOut< XMLSession > XMLSession_out;
00190 
00191 typedef OB::ObjVar< HistogramSession > HistogramSession_var;
00192 typedef OB::ObjOut< HistogramSession > HistogramSession_out;
00193 
00194 typedef OB::ObjVar< VxSimilarityBuilder > VxSimilarityBuilder_var;
00195 typedef OB::ObjOut< VxSimilarityBuilder > VxSimilarityBuilder_out;
00196 
00197 typedef OB::ObjVar< VxSimilaritySession > VxSimilaritySession_var;
00198 typedef OB::ObjOut< VxSimilaritySession > VxSimilaritySession_out;
00199 
00200 typedef OB::ObjVar< FullSession > FullSession_var;
00201 typedef OB::ObjOut< FullSession > FullSession_out;
00202 
00203 } // End of namespace HxCorba
00204 
00205 namespace OBStubImpl_HxCorba
00206 {
00207 
00208 class VxSegmentBuilder;
00209 typedef VxSegmentBuilder* VxSegmentBuilder_ptr;
00210 
00211 class VxSegmentationBuilder;
00212 typedef VxSegmentationBuilder* VxSegmentationBuilder_ptr;
00213 
00214 class StoreSession;
00215 typedef StoreSession* StoreSession_ptr;
00216 
00217 class VxMutableSegment;
00218 typedef VxMutableSegment* VxMutableSegment_ptr;
00219 
00220 class VxMutableSegmentation;
00221 typedef VxMutableSegmentation* VxMutableSegmentation_ptr;
00222 
00223 class UpdateSession;
00224 typedef UpdateSession* UpdateSession_ptr;
00225 
00226 class XMLSession;
00227 typedef XMLSession* XMLSession_ptr;
00228 
00229 class HistogramSession;
00230 typedef HistogramSession* HistogramSession_ptr;
00231 
00232 class VxSimilarityBuilder;
00233 typedef VxSimilarityBuilder* VxSimilarityBuilder_ptr;
00234 
00235 class VxSimilaritySession;
00236 typedef VxSimilaritySession* VxSimilaritySession_ptr;
00237 
00238 class FullSession;
00239 typedef FullSession* FullSession_ptr;
00240 
00241 } // End of namespace OBStubImpl_HxCorba
00242 
00243 void OBDuplicate(OBStubImpl_HxCorba::VxSegmentBuilder_ptr);
00244 void OBRelease(OBStubImpl_HxCorba::VxSegmentBuilder_ptr);
00245 
00246 void OBDuplicate(OBStubImpl_HxCorba::VxSegmentationBuilder_ptr);
00247 void OBRelease(OBStubImpl_HxCorba::VxSegmentationBuilder_ptr);
00248 
00249 void OBDuplicate(OBStubImpl_HxCorba::StoreSession_ptr);
00250 void OBRelease(OBStubImpl_HxCorba::StoreSession_ptr);
00251 
00252 void OBDuplicate(OBStubImpl_HxCorba::VxMutableSegment_ptr);
00253 void OBRelease(OBStubImpl_HxCorba::VxMutableSegment_ptr);
00254 
00255 void OBDuplicate(OBStubImpl_HxCorba::VxMutableSegmentation_ptr);
00256 void OBRelease(OBStubImpl_HxCorba::VxMutableSegmentation_ptr);
00257 
00258 void OBDuplicate(OBStubImpl_HxCorba::UpdateSession_ptr);
00259 void OBRelease(OBStubImpl_HxCorba::UpdateSession_ptr);
00260 
00261 void OBDuplicate(OBStubImpl_HxCorba::XMLSession_ptr);
00262 void OBRelease(OBStubImpl_HxCorba::XMLSession_ptr);
00263 
00264 void OBDuplicate(OBStubImpl_HxCorba::HistogramSession_ptr);
00265 void OBRelease(OBStubImpl_HxCorba::HistogramSession_ptr);
00266 
00267 void OBDuplicate(OBStubImpl_HxCorba::VxSimilarityBuilder_ptr);
00268 void OBRelease(OBStubImpl_HxCorba::VxSimilarityBuilder_ptr);
00269 
00270 void OBDuplicate(OBStubImpl_HxCorba::VxSimilaritySession_ptr);
00271 void OBRelease(OBStubImpl_HxCorba::VxSimilaritySession_ptr);
00272 
00273 void OBDuplicate(OBStubImpl_HxCorba::FullSession_ptr);
00274 void OBRelease(OBStubImpl_HxCorba::FullSession_ptr);
00275 
00276 namespace OBStubImpl_HxCorba
00277 {
00278 
00279 typedef OB::ObjVar< VxSegmentBuilder > VxSegmentBuilder_var;
00280 
00281 typedef OB::ObjVar< VxSegmentationBuilder > VxSegmentationBuilder_var;
00282 
00283 typedef OB::ObjVar< StoreSession > StoreSession_var;
00284 
00285 typedef OB::ObjVar< VxMutableSegment > VxMutableSegment_var;
00286 
00287 typedef OB::ObjVar< VxMutableSegmentation > VxMutableSegmentation_var;
00288 
00289 typedef OB::ObjVar< UpdateSession > UpdateSession_var;
00290 
00291 typedef OB::ObjVar< XMLSession > XMLSession_var;
00292 
00293 typedef OB::ObjVar< HistogramSession > HistogramSession_var;
00294 
00295 typedef OB::ObjVar< VxSimilarityBuilder > VxSimilarityBuilder_var;
00296 
00297 typedef OB::ObjVar< VxSimilaritySession > VxSimilaritySession_var;
00298 
00299 typedef OB::ObjVar< FullSession > FullSession_var;
00300 
00301 } // End of namespace OBStubImpl_HxCorba
00302 
00303 //
00304 // IDL:HxCorba:1.0
00305 //
00306 namespace HxCorba
00307 {
00308 
00309 //
00310 // IDL:HxCorba/VxSegmentBuilder:1.0
00311 //
00312 class VxSegmentBuilder : virtual public CORBA::Object
00313 {
00314     VxSegmentBuilder(const VxSegmentBuilder&);
00315     void operator=(const VxSegmentBuilder&);
00316 
00317 protected:
00318 
00319     static const char* ids_[];
00320 
00321 public:
00322 
00323     VxSegmentBuilder() { }
00324     virtual ~VxSegmentBuilder() { }
00325 
00326     typedef VxSegmentBuilder_ptr _ptr_type;
00327     typedef VxSegmentBuilder_var _var_type;
00328 
00329     static inline VxSegmentBuilder_ptr
00330     _duplicate(VxSegmentBuilder_ptr p)
00331     {
00332         if(p)
00333             p -> _add_ref();
00334         return p;
00335     }
00336 
00337     static inline VxSegmentBuilder_ptr
00338     _nil()
00339     {
00340         return 0;
00341     }
00342 
00343     static VxSegmentBuilder_ptr _narrow(CORBA::Object_ptr);
00344     static VxSegmentBuilder_ptr _unchecked_narrow(CORBA::Object_ptr);
00345 
00346     static VxSegmentBuilder_ptr _narrow(CORBA::AbstractBase_ptr);
00347     static VxSegmentBuilder_ptr _unchecked_narrow(CORBA::AbstractBase_ptr);
00348 
00349     static const char** _OB_staticIds();
00350 
00351     //
00352     // IDL:HxCorba/VxSegmentBuilder/addInt:1.0
00353     //
00354     virtual void addInt(const char* id,
00355                         CORBA::Long value) = 0;
00356 
00357     //
00358     // IDL:HxCorba/VxSegmentBuilder/addDouble:1.0
00359     //
00360     virtual void addDouble(const char* id,
00361                            CORBA::Double value) = 0;
00362 
00363     //
00364     // IDL:HxCorba/VxSegmentBuilder/addString:1.0
00365     //
00366     virtual void addString(const char* id,
00367                            const char* value) = 0;
00368 };
00369 
00370 //
00371 // IDL:HxCorba/VxSegmentationBuilder:1.0
00372 //
00373 class VxSegmentationBuilder : virtual public CORBA::Object
00374 {
00375     VxSegmentationBuilder(const VxSegmentationBuilder&);
00376     void operator=(const VxSegmentationBuilder&);
00377 
00378 protected:
00379 
00380     static const char* ids_[];
00381 
00382 public:
00383 
00384     VxSegmentationBuilder() { }
00385     virtual ~VxSegmentationBuilder() { }
00386 
00387     typedef VxSegmentationBuilder_ptr _ptr_type;
00388     typedef VxSegmentationBuilder_var _var_type;
00389 
00390     static inline VxSegmentationBuilder_ptr
00391     _duplicate(VxSegmentationBuilder_ptr p)
00392     {
00393         if(p)
00394             p -> _add_ref();
00395         return p;
00396     }
00397 
00398     static inline VxSegmentationBuilder_ptr
00399     _nil()
00400     {
00401         return 0;
00402     }
00403 
00404     static VxSegmentationBuilder_ptr _narrow(CORBA::Object_ptr);
00405     static VxSegmentationBuilder_ptr _unchecked_narrow(CORBA::Object_ptr);
00406 
00407     static VxSegmentationBuilder_ptr _narrow(CORBA::AbstractBase_ptr);
00408     static VxSegmentationBuilder_ptr _unchecked_narrow(CORBA::AbstractBase_ptr);
00409 
00410     static const char** _OB_staticIds();
00411 
00412     //
00413     // IDL:HxCorba/VxSegmentationBuilder/setDescription:1.0
00414     //
00415     virtual void setDescription(const char* description) = 0;
00416 
00417     //
00418     // IDL:HxCorba/VxSegmentationBuilder/buildSegment:1.0
00419     //
00420     virtual VxSegmentBuilder_ptr buildSegment(CORBA::Long start,
00421                                               CORBA::Long end) = 0;
00422 };
00423 
00424 //
00425 // IDL:HxCorba/StoreSession:1.0
00426 //
00427 class StoreSession : virtual public ::HxCorba::DatabaseSession
00428 {
00429     StoreSession(const StoreSession&);
00430     void operator=(const StoreSession&);
00431 
00432 protected:
00433 
00434     static const char* ids_[];
00435 
00436 public:
00437 
00438     StoreSession() { }
00439     virtual ~StoreSession() { }
00440 
00441     typedef StoreSession_ptr _ptr_type;
00442     typedef StoreSession_var _var_type;
00443 
00444     static inline StoreSession_ptr
00445     _duplicate(StoreSession_ptr p)
00446     {
00447         if(p)
00448             p -> _add_ref();
00449         return p;
00450     }
00451 
00452     static inline StoreSession_ptr
00453     _nil()
00454     {
00455         return 0;
00456     }
00457 
00458     static StoreSession_ptr _narrow(CORBA::Object_ptr);
00459     static StoreSession_ptr _unchecked_narrow(CORBA::Object_ptr);
00460 
00461     static StoreSession_ptr _narrow(CORBA::AbstractBase_ptr);
00462     static StoreSession_ptr _unchecked_narrow(CORBA::AbstractBase_ptr);
00463 
00464     static const char** _OB_staticIds();
00465 
00466     //
00467     // IDL:HxCorba/StoreSession/addSegmentation:1.0
00468     //
00469     virtual void addSegmentation(VxSegmentation_ptr seg,
00470                                  const char* videoName,
00471                                  const char* segName,
00472                                  const char* description) = 0;
00473 
00474     //
00475     // IDL:HxCorba/StoreSession/buildSegmentation:1.0
00476     //
00477     virtual VxSegmentationBuilder_ptr buildSegmentation(const char* videoName,
00478                                                         const char* segName) = 0;
00479 };
00480 
00481 //
00482 // IDL:HxCorba/VxMutableSegment:1.0
00483 //
00484 class VxMutableSegment : virtual public ::HxCorba::VxSegmentBuilder,
00485                          virtual public ::HxCorba::VxSegment
00486 {
00487     VxMutableSegment(const VxMutableSegment&);
00488     void operator=(const VxMutableSegment&);
00489 
00490 protected:
00491 
00492     static const char* ids_[];
00493 
00494 public:
00495 
00496     VxMutableSegment() { }
00497     virtual ~VxMutableSegment() { }
00498 
00499     typedef VxMutableSegment_ptr _ptr_type;
00500     typedef VxMutableSegment_var _var_type;
00501 
00502     static inline VxMutableSegment_ptr
00503     _duplicate(VxMutableSegment_ptr p)
00504     {
00505         if(p)
00506             p -> _add_ref();
00507         return p;
00508     }
00509 
00510     static inline VxMutableSegment_ptr
00511     _nil()
00512     {
00513         return 0;
00514     }
00515 
00516     static VxMutableSegment_ptr _narrow(CORBA::Object_ptr);
00517     static VxMutableSegment_ptr _unchecked_narrow(CORBA::Object_ptr);
00518 
00519     static VxMutableSegment_ptr _narrow(CORBA::AbstractBase_ptr);
00520     static VxMutableSegment_ptr _unchecked_narrow(CORBA::AbstractBase_ptr);
00521 
00522     static const char** _OB_staticIds();
00523 
00524     //
00525     // IDL:HxCorba/VxMutableSegment/setStart:1.0
00526     //
00527     virtual void setStart(CORBA::Long start) = 0;
00528 
00529     //
00530     // IDL:HxCorba/VxMutableSegment/setEnd:1.0
00531     //
00532     virtual void setEnd(CORBA::Long end) = 0;
00533 
00534     //
00535     // IDL:HxCorba/VxMutableSegment/removeInt:1.0
00536     //
00537     virtual void removeInt(const char* id) = 0;
00538 
00539     //
00540     // IDL:HxCorba/VxMutableSegment/removeDouble:1.0
00541     //
00542     virtual void removeDouble(const char* id) = 0;
00543 
00544     //
00545     // IDL:HxCorba/VxMutableSegment/removeString:1.0
00546     //
00547     virtual void removeString(const char* id) = 0;
00548 
00549     //
00550     // IDL:HxCorba/VxMutableSegment/changeInt:1.0
00551     //
00552     virtual void changeInt(const char* id,
00553                            CORBA::Long newValue) = 0;
00554 
00555     //
00556     // IDL:HxCorba/VxMutableSegment/changeDouble:1.0
00557     //
00558     virtual void changeDouble(const char* id,
00559                               CORBA::Double newValue) = 0;
00560 
00561     //
00562     // IDL:HxCorba/VxMutableSegment/changeString:1.0
00563     //
00564     virtual void changeString(const char* id,
00565                               const char* newValue) = 0;
00566 };
00567 
00568 //
00569 // IDL:HxCorba/VxMutableSegmentation:1.0
00570 //
00571 class VxMutableSegmentation : virtual public ::HxCorba::VxSegmentationBuilder,
00572                               virtual public ::HxCorba::VxSegmentation
00573 {
00574     VxMutableSegmentation(const VxMutableSegmentation&);
00575     void operator=(const VxMutableSegmentation&);
00576 
00577 protected:
00578 
00579     static const char* ids_[];
00580 
00581 public:
00582 
00583     VxMutableSegmentation() { }
00584     virtual ~VxMutableSegmentation() { }
00585 
00586     typedef VxMutableSegmentation_ptr _ptr_type;
00587     typedef VxMutableSegmentation_var _var_type;
00588 
00589     static inline VxMutableSegmentation_ptr
00590     _duplicate(VxMutableSegmentation_ptr p)
00591     {
00592         if(p)
00593             p -> _add_ref();
00594         return p;
00595     }
00596 
00597     static inline VxMutableSegmentation_ptr
00598     _nil()
00599     {
00600         return 0;
00601     }
00602 
00603     static VxMutableSegmentation_ptr _narrow(CORBA::Object_ptr);
00604     static VxMutableSegmentation_ptr _unchecked_narrow(CORBA::Object_ptr);
00605 
00606     static VxMutableSegmentation_ptr _narrow(CORBA::AbstractBase_ptr);
00607     static VxMutableSegmentation_ptr _unchecked_narrow(CORBA::AbstractBase_ptr);
00608 
00609     static const char** _OB_staticIds();
00610 
00611     //
00612     // IDL:HxCorba/VxMutableSegmentation/removeSegment:1.0
00613     //
00614     virtual void removeSegment(CORBA::Long index) = 0;
00615 };
00616 
00617 //
00618 // IDL:HxCorba/UpdateSession:1.0
00619 //
00620 class UpdateSession : virtual public ::HxCorba::StoreSession
00621 {
00622     UpdateSession(const UpdateSession&);
00623     void operator=(const UpdateSession&);
00624 
00625 protected:
00626 
00627     static const char* ids_[];
00628 
00629 public:
00630 
00631     UpdateSession() { }
00632     virtual ~UpdateSession() { }
00633 
00634     typedef UpdateSession_ptr _ptr_type;
00635     typedef UpdateSession_var _var_type;
00636 
00637     static inline UpdateSession_ptr
00638     _duplicate(UpdateSession_ptr p)
00639     {
00640         if(p)
00641             p -> _add_ref();
00642         return p;
00643     }
00644 
00645     static inline UpdateSession_ptr
00646     _nil()
00647     {
00648         return 0;
00649     }
00650 
00651     static UpdateSession_ptr _narrow(CORBA::Object_ptr);
00652     static UpdateSession_ptr _unchecked_narrow(CORBA::Object_ptr);
00653 
00654     static UpdateSession_ptr _narrow(CORBA::AbstractBase_ptr);
00655     static UpdateSession_ptr _unchecked_narrow(CORBA::AbstractBase_ptr);
00656 
00657     static const char** _OB_staticIds();
00658 
00659     //
00660     // IDL:HxCorba/UpdateSession/removeVideo:1.0
00661     //
00662     virtual void removeVideo(const char* videoName) = 0;
00663 
00664     //
00665     // IDL:HxCorba/UpdateSession/removeSegmentation:1.0
00666     //
00667     virtual void removeSegmentation(VxSegmentation_ptr seg) = 0;
00668 
00669     //
00670     // IDL:HxCorba/UpdateSession/removeSegment:1.0
00671     //
00672     virtual void removeSegment(VxSegment_ptr segment) = 0;
00673 };
00674 
00675 //
00676 // IDL:HxCorba/DBDataTag:1.0
00677 //
00678 enum DBDataTag
00679 {
00680     DBINT,
00681     DBDOUBLE,
00682     DBSTRING,
00683     DBSEGMENTATION,
00684     DBSEGMENT
00685 };
00686 
00687 typedef DBDataTag& DBDataTag_out;
00688 
00689 extern OB::TypeCodeConst _tc_DBDataTag;
00690 
00691 //
00692 // IDL:HxCorba/DBData:1.0
00693 //
00694 struct DBData;
00695 typedef OB::VarVar< DBData > DBData_var;
00696 typedef OB::VarOut< DBData > DBData_out;
00697 
00698 struct DBData
00699 {
00700 private:
00701 
00702     union
00703     {
00704         CORBA::Long intData;
00705         CORBA::Double doubleData;
00706         char* stringData;
00707         VxSegmentation_ptr segmentation;
00708         VxSegment_ptr segment;
00709     } _ob_v_;
00710 
00711     bool _ob_i_;
00712     DBDataTag _ob_d_;
00713 
00714     void _OB_remove();
00715     bool _OB_check(DBDataTag) const;
00716 
00717 public:
00718 
00719     typedef DBData_var _var_type;
00720 
00721 #ifdef OB_CLEAR_MEM
00722     DBData();
00723 #else
00724     DBData() : _ob_i_(false) { }
00725 #endif
00726     DBData(const DBData&);
00727     ~DBData() { _OB_remove(); }
00728 
00729     DBData& operator=(const DBData&);
00730 
00731     void _d(DBDataTag);
00732     DBDataTag _d() const;
00733 
00734     void intData(CORBA::Long);
00735     CORBA::Long intData() const;
00736 
00737     void doubleData(CORBA::Double);
00738     CORBA::Double doubleData() const;
00739 
00740     void stringData(char*);
00741     void stringData(const char*);
00742     void stringData(const CORBA::String_var&);
00743     const char* stringData() const;
00744 
00745     void segmentation(VxSegmentation_ptr);
00746     VxSegmentation_ptr segmentation() const;
00747 
00748     void segment(VxSegment_ptr);
00749     VxSegment_ptr segment() const;
00750 
00751     void _OB_marshal(OB::OutputStreamImpl*) const;
00752     static void _OB_unmarshal(DBData&, OB::InputStreamImpl*);
00753 };
00754 
00755 extern OB::TypeCodeConst _tc_DBData;
00756 
00757 //
00758 // IDL:HxCorba/DBDataTagSeq:1.0
00759 //
00760 class OBUnique_DBDataTagSeq { };
00761 
00762 typedef OB::FixSeq< DBDataTag, OBUnique_DBDataTagSeq > DBDataTagSeq;
00763 typedef OB::SeqVar< OB::FixSeq< DBDataTag, OBUnique_DBDataTagSeq > > DBDataTagSeq_var;
00764 typedef OB::SeqOut< OB::FixSeq< DBDataTag, OBUnique_DBDataTagSeq > > DBDataTagSeq_out;
00765 extern OB::TypeCodeConst _tc_DBDataTagSeq;
00766 
00767 struct OBInfo_DBDataTagSeq : public OB::ConstructedInfo
00768 {
00769     OBInfo_DBDataTagSeq() { }
00770 
00771     virtual void free(void* p) const
00772     {
00773         delete (DBDataTagSeq*)p;
00774     }
00775 
00776     virtual void* dup(const void* p) const
00777     {
00778         return new DBDataTagSeq(*(const DBDataTagSeq*)p);
00779     }
00780 
00781     virtual void marshal(const void*, OB::OutputStreamImpl*) const;
00782     virtual void unmarshal(void*, OB::InputStreamImpl*) const;
00783 };
00784 
00785 //
00786 // IDL:HxCorba/DBDataRow:1.0
00787 //
00788 class OBUnique_DBDataRow { };
00789 
00790 typedef OB::VarSeq< DBData, OBUnique_DBDataRow > DBDataRow;
00791 typedef OB::SeqVar< OB::VarSeq< DBData, OBUnique_DBDataRow > > DBDataRow_var;
00792 typedef OB::SeqOut< OB::VarSeq< DBData, OBUnique_DBDataRow > > DBDataRow_out;
00793 extern OB::TypeCodeConst _tc_DBDataRow;
00794 
00795 struct OBInfo_DBDataRow : public OB::ConstructedInfo
00796 {
00797     OBInfo_DBDataRow() { }
00798 
00799     virtual void free(void* p) const
00800     {
00801         delete (DBDataRow*)p;
00802     }
00803 
00804     virtual void* dup(const void* p) const
00805     {
00806         return new DBDataRow(*(const DBDataRow*)p);
00807     }
00808 
00809     virtual void marshal(const void*, OB::OutputStreamImpl*) const;
00810     virtual void unmarshal(void*, OB::InputStreamImpl*) const;
00811 };
00812 
00813 //
00814 // IDL:HxCorba/DBDataRowSeq:1.0
00815 //
00816 class OBUnique_DBDataRowSeq { };
00817 
00818 typedef OB::VarSeq< OB::VarSeq< DBData, OBUnique_DBDataRow >, OBUnique_DBDataRowSeq > DBDataRowSeq;
00819 typedef OB::SeqVar< OB::VarSeq< OB::VarSeq< DBData, OBUnique_DBDataRow >, OBUnique_DBDataRowSeq > > DBDataRowSeq_var;
00820 typedef OB::SeqOut< OB::VarSeq< OB::VarSeq< DBData, OBUnique_DBDataRow >, OBUnique_DBDataRowSeq > > DBDataRowSeq_out;
00821 extern OB::TypeCodeConst _tc_DBDataRowSeq;
00822 
00823 struct OBInfo_DBDataRowSeq : public OB::ConstructedInfo
00824 {
00825     OBInfo_DBDataRowSeq() { }
00826 
00827     virtual void free(void* p) const
00828     {
00829         delete (DBDataRowSeq*)p;
00830     }
00831 
00832     virtual void* dup(const void* p) const
00833     {
00834         return new DBDataRowSeq(*(const DBDataRowSeq*)p);
00835     }
00836 
00837     virtual void marshal(const void*, OB::OutputStreamImpl*) const;
00838     virtual void unmarshal(void*, OB::InputStreamImpl*) const;
00839 };
00840 
00841 //
00842 // IDL:HxCorba/XMLSession:1.0
00843 //
00844 class XMLSession : virtual public ::HxCorba::DatabaseSession
00845 {
00846     XMLSession(const XMLSession&);
00847     void operator=(const XMLSession&);
00848 
00849 protected:
00850 
00851     static const char* ids_[];
00852 
00853 public:
00854 
00855     XMLSession() { }
00856     virtual ~XMLSession() { }
00857 
00858     typedef XMLSession_ptr _ptr_type;
00859     typedef XMLSession_var _var_type;
00860 
00861     static inline XMLSession_ptr
00862     _duplicate(XMLSession_ptr p)
00863     {
00864         if(p)
00865             p -> _add_ref();
00866         return p;
00867     }
00868 
00869     static inline XMLSession_ptr
00870     _nil()
00871     {
00872         return 0;
00873     }
00874 
00875     static XMLSession_ptr _narrow(CORBA::Object_ptr);
00876     static XMLSession_ptr _unchecked_narrow(CORBA::Object_ptr);
00877 
00878     static XMLSession_ptr _narrow(CORBA::AbstractBase_ptr);
00879     static XMLSession_ptr _unchecked_narrow(CORBA::AbstractBase_ptr);
00880 
00881     static const char** _OB_staticIds();
00882 
00883     //
00884     // IDL:HxCorba/XMLSession/queryXML:1.0
00885     //
00886     virtual char* queryXML(const char* sqlQuery) = 0;
00887 
00888     //
00889     // IDL:HxCorba/XMLSession/queryDBData:1.0
00890     //
00891     virtual DBDataRowSeq* queryDBData(const char* sqlQuery,
00892                                       const DBDataTagSeq& resultType) = 0;
00893 };
00894 
00895 //
00896 // IDL:HxCorba/HistogramSession:1.0
00897 //
00898 class HistogramSession : virtual public ::HxCorba::DatabaseSession
00899 {
00900     HistogramSession(const HistogramSession&);
00901     void operator=(const HistogramSession&);
00902 
00903 protected:
00904 
00905     static const char* ids_[];
00906 
00907 public:
00908 
00909     HistogramSession() { }
00910     virtual ~HistogramSession() { }
00911 
00912     typedef HistogramSession_ptr _ptr_type;
00913     typedef HistogramSession_var _var_type;
00914 
00915     static inline HistogramSession_ptr
00916     _duplicate(HistogramSession_ptr p)
00917     {
00918         if(p)
00919             p -> _add_ref();
00920         return p;
00921     }
00922 
00923     static inline HistogramSession_ptr
00924     _nil()
00925     {
00926         return 0;
00927     }
00928 
00929     static HistogramSession_ptr _narrow(CORBA::Object_ptr);
00930     static HistogramSession_ptr _unchecked_narrow(CORBA::Object_ptr);
00931 
00932     static HistogramSession_ptr _narrow(CORBA::AbstractBase_ptr);
00933     static HistogramSession_ptr _unchecked_narrow(CORBA::AbstractBase_ptr);
00934 
00935     static const char** _OB_staticIds();
00936 
00937     //
00938     // IDL:HxCorba/HistogramSession/addHistogram:1.0
00939     //
00940     virtual void addHistogram(const char* imageName,
00941                               const char* setName,
00942                               const FloatSeq& histoData) = 0;
00943 
00944     //
00945     // IDL:HxCorba/HistogramSession/getHistogram:1.0
00946     //
00947     virtual FloatSeq* getHistogram(const char* imageName,
00948                                    const char* setName) = 0;
00949 
00950     //
00951     // IDL:HxCorba/HistogramSession/nearest:1.0
00952     //
00953     virtual StringSeq* nearest(const char* imageName,
00954                                const char* setName,
00955                                CORBA::Long count) = 0;
00956 
00957     //
00958     // IDL:HxCorba/HistogramSession/random:1.0
00959     //
00960     virtual StringSeq* random(const char* setName,
00961                               CORBA::Long count) = 0;
00962 
00963     //
00964     // IDL:HxCorba/HistogramSession/search:1.0
00965     //
00966     virtual StringSeq* search(CORBA::Long count,
00967                               const FloatSeq& sample) = 0;
00968 };
00969 
00970 //
00971 // IDL:HxCorba/VxSimilarityBuilder:1.0
00972 //
00973 class VxSimilarityBuilder : virtual public CORBA::Object
00974 {
00975     VxSimilarityBuilder(const VxSimilarityBuilder&);
00976     void operator=(const VxSimilarityBuilder&);
00977 
00978 protected:
00979 
00980     static const char* ids_[];
00981 
00982 public:
00983 
00984     VxSimilarityBuilder() { }
00985     virtual ~VxSimilarityBuilder() { }
00986 
00987     typedef VxSimilarityBuilder_ptr _ptr_type;
00988     typedef VxSimilarityBuilder_var _var_type;
00989 
00990     static inline VxSimilarityBuilder_ptr
00991     _duplicate(VxSimilarityBuilder_ptr p)
00992     {
00993         if(p)
00994             p -> _add_ref();
00995         return p;
00996     }
00997 
00998     static inline VxSimilarityBuilder_ptr
00999     _nil()
01000     {
01001         return 0;
01002     }
01003 
01004     static VxSimilarityBuilder_ptr _narrow(CORBA::Object_ptr);
01005     static VxSimilarityBuilder_ptr _unchecked_narrow(CORBA::Object_ptr);
01006 
01007     static VxSimilarityBuilder_ptr _narrow(CORBA::AbstractBase_ptr);
01008     static VxSimilarityBuilder_ptr _unchecked_narrow(CORBA::AbstractBase_ptr);
01009 
01010     static const char** _OB_staticIds();
01011 
01012     //
01013     // IDL:HxCorba/VxSimilarityBuilder/addSimilarity:1.0
01014     //
01015     virtual void addSimilarity(CORBA::Long index1,
01016                                CORBA::Long index2,
01017                                CORBA::Double value,
01018                                CORBA::Long keyFrame1,
01019                                CORBA::Long keyFrame2) = 0;
01020 };
01021 
01022 //
01023 // IDL:HxCorba/VxSimilaritySession:1.0
01024 //
01025 class VxSimilaritySession : virtual public ::HxCorba::DatabaseSession
01026 {
01027     VxSimilaritySession(const VxSimilaritySession&);
01028     void operator=(const VxSimilaritySession&);
01029 
01030 protected:
01031 
01032     static const char* ids_[];
01033 
01034 public:
01035 
01036     VxSimilaritySession() { }
01037     virtual ~VxSimilaritySession() { }
01038 
01039     typedef VxSimilaritySession_ptr _ptr_type;
01040     typedef VxSimilaritySession_var _var_type;
01041 
01042     static inline VxSimilaritySession_ptr
01043     _duplicate(VxSimilaritySession_ptr p)
01044     {
01045         if(p)
01046             p -> _add_ref();
01047         return p;
01048     }
01049 
01050     static inline VxSimilaritySession_ptr
01051     _nil()
01052     {
01053         return 0;
01054     }
01055 
01056     static VxSimilaritySession_ptr _narrow(CORBA::Object_ptr);
01057     static VxSimilaritySession_ptr _unchecked_narrow(CORBA::Object_ptr);
01058 
01059     static VxSimilaritySession_ptr _narrow(CORBA::AbstractBase_ptr);
01060     static VxSimilaritySession_ptr _unchecked_narrow(CORBA::AbstractBase_ptr);
01061 
01062     static const char** _OB_staticIds();
01063 
01064     //
01065     // IDL:HxCorba/VxSimilaritySession/addSimilarities:1.0
01066     //
01067     virtual VxSimilarityBuilder_ptr addSimilarities(const char* videoName,
01068                                                     const char* segName,
01069                                                     const char* featureName) = 0;
01070 };
01071 
01072 //
01073 // IDL:HxCorba/FullSession:1.0
01074 //
01075 class FullSession : virtual public ::HxCorba::UpdateSession,
01076                     virtual public ::HxCorba::XMLSession,
01077                     virtual public ::HxCorba::HistogramSession,
01078                     virtual public ::HxCorba::VxSimilaritySession
01079 {
01080     FullSession(const FullSession&);
01081     void operator=(const FullSession&);
01082 
01083 protected:
01084 
01085     static const char* ids_[];
01086 
01087 public:
01088 
01089     FullSession() { }
01090     virtual ~FullSession() { }
01091 
01092     typedef FullSession_ptr _ptr_type;
01093     typedef FullSession_var _var_type;
01094 
01095     static inline FullSession_ptr
01096     _duplicate(FullSession_ptr p)
01097     {
01098         if(p)
01099             p -> _add_ref();
01100         return p;
01101     }
01102 
01103     static inline FullSession_ptr
01104     _nil()
01105     {
01106         return 0;
01107     }
01108 
01109     static FullSession_ptr _narrow(CORBA::Object_ptr);
01110     static FullSession_ptr _unchecked_narrow(CORBA::Object_ptr);
01111 
01112     static FullSession_ptr _narrow(CORBA::AbstractBase_ptr);
01113     static FullSession_ptr _unchecked_narrow(CORBA::AbstractBase_ptr);
01114 
01115     static const char** _OB_staticIds();
01116 };
01117 
01118 } // End of namespace HxCorba
01119 
01120 //
01121 // IDL:HxCorba:1.0
01122 //
01123 namespace OBProxy_HxCorba
01124 {
01125 
01126 //
01127 // IDL:HxCorba/VxSegmentBuilder:1.0
01128 //
01129 class VxSegmentBuilder : virtual public ::HxCorba::VxSegmentBuilder,
01130                          virtual public OBCORBA::Object
01131 {
01132     VxSegmentBuilder(const VxSegmentBuilder&);
01133     void operator=(const VxSegmentBuilder&);
01134 
01135 protected:
01136 
01137     virtual OB::MarshalStubImpl_ptr _OB_createMarshalStubImpl();
01138 
01139 public:
01140 
01141     VxSegmentBuilder() { }
01142     virtual ~VxSegmentBuilder() { }
01143 
01144     virtual const char** _OB_ids() const;
01145 
01146     //
01147     // IDL:HxCorba/VxSegmentBuilder/addInt:1.0
01148     //
01149     void addInt(const char* id,
01150                 CORBA::Long value);
01151 
01152     //
01153     // IDL:HxCorba/VxSegmentBuilder/addDouble:1.0
01154     //
01155     void addDouble(const char* id,
01156                    CORBA::Double value);
01157 
01158     //
01159     // IDL:HxCorba/VxSegmentBuilder/addString:1.0
01160     //
01161     void addString(const char* id,
01162                    const char* value);
01163 };
01164 
01165 //
01166 // IDL:HxCorba/VxSegmentationBuilder:1.0
01167 //
01168 class VxSegmentationBuilder : virtual public ::HxCorba::VxSegmentationBuilder,
01169                               virtual public OBCORBA::Object
01170 {
01171     VxSegmentationBuilder(const VxSegmentationBuilder&);
01172     void operator=(const VxSegmentationBuilder&);
01173 
01174 protected:
01175 
01176     virtual OB::MarshalStubImpl_ptr _OB_createMarshalStubImpl();
01177 
01178 public:
01179 
01180     VxSegmentationBuilder() { }
01181     virtual ~VxSegmentationBuilder() { }
01182 
01183     virtual const char** _OB_ids() const;
01184 
01185     //
01186     // IDL:HxCorba/VxSegmentationBuilder/setDescription:1.0
01187     //
01188     void setDescription(const char* description);
01189 
01190     //
01191     // IDL:HxCorba/VxSegmentationBuilder/buildSegment:1.0
01192     //
01193     ::HxCorba::VxSegmentBuilder_ptr buildSegment(CORBA::Long start,
01194                                                  CORBA::Long end);
01195 };
01196 
01197 //
01198 // IDL:HxCorba/StoreSession:1.0
01199 //
01200 class StoreSession : virtual public ::HxCorba::StoreSession,
01201                      virtual public OBProxy_HxCorba::DatabaseSession
01202 {
01203     StoreSession(const StoreSession&);
01204     void operator=(const StoreSession&);
01205 
01206 protected:
01207 
01208     virtual OB::MarshalStubImpl_ptr _OB_createMarshalStubImpl();
01209 
01210 public:
01211 
01212     StoreSession() { }
01213     virtual ~StoreSession() { }
01214 
01215     virtual const char** _OB_ids() const;
01216 
01217     //
01218     // IDL:HxCorba/StoreSession/addSegmentation:1.0
01219     //
01220     void addSegmentation(::HxCorba::VxSegmentation_ptr seg,
01221                          const char* videoName,
01222                          const char* segName,
01223                          const char* description);
01224 
01225     //
01226     // IDL:HxCorba/StoreSession/buildSegmentation:1.0
01227     //
01228     ::HxCorba::VxSegmentationBuilder_ptr buildSegmentation(const char* videoName,
01229                                                            const char* segName);
01230 };
01231 
01232 //
01233 // IDL:HxCorba/VxMutableSegment:1.0
01234 //
01235 class VxMutableSegment : virtual public ::HxCorba::VxMutableSegment,
01236                          virtual public OBProxy_HxCorba::VxSegmentBuilder,
01237                          virtual public OBProxy_HxCorba::VxSegment
01238 {
01239     VxMutableSegment(const VxMutableSegment&);
01240     void operator=(const VxMutableSegment&);
01241 
01242 protected:
01243 
01244     virtual OB::MarshalStubImpl_ptr _OB_createMarshalStubImpl();
01245 
01246 public:
01247 
01248     VxMutableSegment() { }
01249     virtual ~VxMutableSegment() { }
01250 
01251     virtual const char** _OB_ids() const;
01252 
01253     //
01254     // IDL:HxCorba/VxMutableSegment/setStart:1.0
01255     //
01256     void setStart(CORBA::Long start);
01257 
01258     //
01259     // IDL:HxCorba/VxMutableSegment/setEnd:1.0
01260     //
01261     void setEnd(CORBA::Long end);
01262 
01263     //
01264     // IDL:HxCorba/VxMutableSegment/removeInt:1.0
01265     //
01266     void removeInt(const char* id);
01267 
01268     //
01269     // IDL:HxCorba/VxMutableSegment/removeDouble:1.0
01270     //
01271     void removeDouble(const char* id);
01272 
01273     //
01274     // IDL:HxCorba/VxMutableSegment/removeString:1.0
01275     //
01276     void removeString(const char* id);
01277 
01278     //
01279     // IDL:HxCorba/VxMutableSegment/changeInt:1.0
01280     //
01281     void changeInt(const char* id,
01282                    CORBA::Long newValue);
01283 
01284     //
01285     // IDL:HxCorba/VxMutableSegment/changeDouble:1.0
01286     //
01287     void changeDouble(const char* id,
01288                       CORBA::Double newValue);
01289 
01290     //
01291     // IDL:HxCorba/VxMutableSegment/changeString:1.0
01292     //
01293     void changeString(const char* id,
01294                       const char* newValue);
01295 };
01296 
01297 //
01298 // IDL:HxCorba/VxMutableSegmentation:1.0
01299 //
01300 class VxMutableSegmentation : virtual public ::HxCorba::VxMutableSegmentation,
01301                               virtual public OBProxy_HxCorba::VxSegmentationBuilder,
01302                               virtual public OBProxy_HxCorba::VxSegmentation
01303 {
01304     VxMutableSegmentation(const VxMutableSegmentation&);
01305     void operator=(const VxMutableSegmentation&);
01306 
01307 protected:
01308 
01309     virtual OB::MarshalStubImpl_ptr _OB_createMarshalStubImpl();
01310 
01311 public:
01312 
01313     VxMutableSegmentation() { }
01314     virtual ~VxMutableSegmentation() { }
01315 
01316     virtual const char** _OB_ids() const;
01317 
01318     //
01319     // IDL:HxCorba/VxMutableSegmentation/removeSegment:1.0
01320     //
01321     void removeSegment(CORBA::Long index);
01322 };
01323 
01324 //
01325 // IDL:HxCorba/UpdateSession:1.0
01326 //
01327 class UpdateSession : virtual public ::HxCorba::UpdateSession,
01328                       virtual public OBProxy_HxCorba::StoreSession
01329 {
01330     UpdateSession(const UpdateSession&);
01331     void operator=(const UpdateSession&);
01332 
01333 protected:
01334 
01335     virtual OB::MarshalStubImpl_ptr _OB_createMarshalStubImpl();
01336 
01337 public:
01338 
01339     UpdateSession() { }
01340     virtual ~UpdateSession() { }
01341 
01342     virtual const char** _OB_ids() const;
01343 
01344     //
01345     // IDL:HxCorba/UpdateSession/removeVideo:1.0
01346     //
01347     void removeVideo(const char* videoName);
01348 
01349     //
01350     // IDL:HxCorba/UpdateSession/removeSegmentation:1.0
01351     //
01352     void removeSegmentation(::HxCorba::VxSegmentation_ptr seg);
01353 
01354     //
01355     // IDL:HxCorba/UpdateSession/removeSegment:1.0
01356     //
01357     void removeSegment(::HxCorba::VxSegment_ptr segment);
01358 };
01359 
01360 //
01361 // IDL:HxCorba/XMLSession:1.0
01362 //
01363 class XMLSession : virtual public ::HxCorba::XMLSession,
01364                    virtual public OBProxy_HxCorba::DatabaseSession
01365 {
01366     XMLSession(const XMLSession&);
01367     void operator=(const XMLSession&);
01368 
01369 protected:
01370 
01371     virtual OB::MarshalStubImpl_ptr _OB_createMarshalStubImpl();
01372 
01373 public:
01374 
01375     XMLSession() { }
01376     virtual ~XMLSession() { }
01377 
01378     virtual const char** _OB_ids() const;
01379 
01380     //
01381     // IDL:HxCorba/XMLSession/queryXML:1.0
01382     //
01383     char* queryXML(const char* sqlQuery);
01384 
01385     //
01386     // IDL:HxCorba/XMLSession/queryDBData:1.0
01387     //
01388     ::HxCorba::DBDataRowSeq* queryDBData(const char* sqlQuery,
01389                                          const ::HxCorba::DBDataTagSeq& resultType);
01390 };
01391 
01392 //
01393 // IDL:HxCorba/HistogramSession:1.0
01394 //
01395 class HistogramSession : virtual public ::HxCorba::HistogramSession,
01396                          virtual public OBProxy_HxCorba::DatabaseSession
01397 {
01398     HistogramSession(const HistogramSession&);
01399     void operator=(const HistogramSession&);
01400 
01401 protected:
01402 
01403     virtual OB::MarshalStubImpl_ptr _OB_createMarshalStubImpl();
01404 
01405 public:
01406 
01407     HistogramSession() { }
01408     virtual ~HistogramSession() { }
01409 
01410     virtual const char** _OB_ids() const;
01411 
01412     //
01413     // IDL:HxCorba/HistogramSession/addHistogram:1.0
01414     //
01415     void addHistogram(const char* imageName,
01416                       const char* setName,
01417                       const ::HxCorba::FloatSeq& histoData);
01418 
01419     //
01420     // IDL:HxCorba/HistogramSession/getHistogram:1.0
01421     //
01422     ::HxCorba::FloatSeq* getHistogram(const char* imageName,
01423                                       const char* setName);
01424 
01425     //
01426     // IDL:HxCorba/HistogramSession/nearest:1.0
01427     //
01428     ::HxCorba::StringSeq* nearest(const char* imageName,
01429                                   const char* setName,
01430                                   CORBA::Long count);
01431 
01432     //
01433     // IDL:HxCorba/HistogramSession/random:1.0
01434     //
01435     ::HxCorba::StringSeq* random(const char* setName,
01436                                  CORBA::Long count);
01437 
01438     //
01439     // IDL:HxCorba/HistogramSession/search:1.0
01440     //
01441     ::HxCorba::StringSeq* search(CORBA::Long count,
01442                                  const ::HxCorba::FloatSeq& sample);
01443 };
01444 
01445 //
01446 // IDL:HxCorba/VxSimilarityBuilder:1.0
01447 //
01448 class VxSimilarityBuilder : virtual public ::HxCorba::VxSimilarityBuilder,
01449                             virtual public OBCORBA::Object
01450 {
01451     VxSimilarityBuilder(const VxSimilarityBuilder&);
01452     void operator=(const VxSimilarityBuilder&);
01453 
01454 protected:
01455 
01456     virtual OB::MarshalStubImpl_ptr _OB_createMarshalStubImpl();
01457 
01458 public:
01459 
01460     VxSimilarityBuilder() { }
01461     virtual ~VxSimilarityBuilder() { }
01462 
01463     virtual const char** _OB_ids() const;
01464 
01465     //
01466     // IDL:HxCorba/VxSimilarityBuilder/addSimilarity:1.0
01467     //
01468     void addSimilarity(CORBA::Long index1,
01469                        CORBA::Long index2,
01470                        CORBA::Double value,
01471                        CORBA::Long keyFrame1,
01472                        CORBA::Long keyFrame2);
01473 };
01474 
01475 //
01476 // IDL:HxCorba/VxSimilaritySession:1.0
01477 //
01478 class VxSimilaritySession : virtual public ::HxCorba::VxSimilaritySession,
01479                             virtual public OBProxy_HxCorba::DatabaseSession
01480 {
01481     VxSimilaritySession(const VxSimilaritySession&);
01482     void operator=(const VxSimilaritySession&);
01483 
01484 protected:
01485 
01486     virtual OB::MarshalStubImpl_ptr _OB_createMarshalStubImpl();
01487 
01488 public:
01489 
01490     VxSimilaritySession() { }
01491     virtual ~VxSimilaritySession() { }
01492 
01493     virtual const char** _OB_ids() const;
01494 
01495     //
01496     // IDL:HxCorba/VxSimilaritySession/addSimilarities:1.0
01497     //
01498     ::HxCorba::VxSimilarityBuilder_ptr addSimilarities(const char* videoName,
01499                                                        const char* segName,
01500                                                        const char* featureName);
01501 };
01502 
01503 //
01504 // IDL:HxCorba/FullSession:1.0
01505 //
01506 class FullSession : virtual public ::HxCorba::FullSession,
01507                     virtual public OBProxy_HxCorba::UpdateSession,
01508                     virtual public OBProxy_HxCorba::XMLSession,
01509                     virtual public OBProxy_HxCorba::HistogramSession,
01510                     virtual public OBProxy_HxCorba::VxSimilaritySession
01511 {
01512     FullSession(const FullSession&);
01513     void operator=(const FullSession&);
01514 
01515 protected:
01516 
01517     virtual OB::MarshalStubImpl_ptr _OB_createMarshalStubImpl();
01518 
01519 public:
01520 
01521     FullSession() { }
01522     virtual ~FullSession() { }
01523 
01524     virtual const char** _OB_ids() const;
01525 };
01526 
01527 } // End of namespace OBProxy_HxCorba
01528 
01529 //
01530 // IDL:HxCorba:1.0
01531 //
01532 namespace OBStubImpl_HxCorba
01533 {
01534 
01535 //
01536 // IDL:HxCorba/VxSegmentBuilder:1.0
01537 //
01538 class VxSegmentBuilder : virtual public OB::StubImplBase
01539 {
01540     VxSegmentBuilder(const VxSegmentBuilder&);
01541     void operator=(const VxSegmentBuilder&);
01542 
01543 protected:
01544 
01545     VxSegmentBuilder() { }
01546 
01547 public:
01548 
01549     static inline VxSegmentBuilder_ptr
01550     _duplicate(VxSegmentBuilder_ptr p)
01551     {
01552         if(p)
01553             p -> _OB_incRef();
01554         return p;
01555     }
01556 
01557     static inline VxSegmentBuilder_ptr
01558     _nil()
01559     {
01560         return 0;
01561     }
01562 
01563     //
01564     // IDL:HxCorba/VxSegmentBuilder/addInt:1.0
01565     //
01566     virtual void addInt(const char* id,
01567                         CORBA::Long value) = 0;
01568 
01569     //
01570     // IDL:HxCorba/VxSegmentBuilder/addDouble:1.0
01571     //
01572     virtual void addDouble(const char* id,
01573                            CORBA::Double value) = 0;
01574 
01575     //
01576     // IDL:HxCorba/VxSegmentBuilder/addString:1.0
01577     //
01578     virtual void addString(const char* id,
01579                            const char* value) = 0;
01580 };
01581 
01582 //
01583 // IDL:HxCorba/VxSegmentationBuilder:1.0
01584 //
01585 class VxSegmentationBuilder : virtual public OB::StubImplBase
01586 {
01587     VxSegmentationBuilder(const VxSegmentationBuilder&);
01588     void operator=(const VxSegmentationBuilder&);
01589 
01590 protected:
01591 
01592     VxSegmentationBuilder() { }
01593 
01594 public:
01595 
01596     static inline VxSegmentationBuilder_ptr
01597     _duplicate(VxSegmentationBuilder_ptr p)
01598     {
01599         if(p)
01600             p -> _OB_incRef();
01601         return p;
01602     }
01603 
01604     static inline VxSegmentationBuilder_ptr
01605     _nil()
01606     {
01607         return 0;
01608     }
01609 
01610     //
01611     // IDL:HxCorba/VxSegmentationBuilder/setDescription:1.0
01612     //
01613     virtual void setDescription(const char* description) = 0;
01614 
01615     //
01616     // IDL:HxCorba/VxSegmentationBuilder/buildSegment:1.0
01617     //
01618     virtual ::HxCorba::VxSegmentBuilder_ptr buildSegment(CORBA::Long start,
01619                                                          CORBA::Long end) = 0;
01620 };
01621 
01622 //
01623 // IDL:HxCorba/StoreSession:1.0
01624 //
01625 class StoreSession : virtual public OBStubImpl_HxCorba::DatabaseSession
01626 {
01627     StoreSession(const StoreSession&);
01628     void operator=(const StoreSession&);
01629 
01630 protected:
01631 
01632     StoreSession() { }
01633 
01634 public:
01635 
01636     static inline StoreSession_ptr
01637     _duplicate(StoreSession_ptr p)
01638     {
01639         if(p)
01640             p -> _OB_incRef();
01641         return p;
01642     }
01643 
01644     static inline StoreSession_ptr
01645     _nil()
01646     {
01647         return 0;
01648     }
01649 
01650     //
01651     // IDL:HxCorba/StoreSession/addSegmentation:1.0
01652     //
01653     virtual void addSegmentation(::HxCorba::VxSegmentation_ptr seg,
01654                                  const char* videoName,
01655                                  const char* segName,
01656                                  const char* description) = 0;
01657 
01658     //
01659     // IDL:HxCorba/StoreSession/buildSegmentation:1.0
01660     //
01661     virtual ::HxCorba::VxSegmentationBuilder_ptr buildSegmentation(const char* videoName,
01662                                                                    const char* segName) = 0;
01663 };
01664 
01665 //
01666 // IDL:HxCorba/VxMutableSegment:1.0
01667 //
01668 class VxMutableSegment : virtual public OBStubImpl_HxCorba::VxSegmentBuilder,
01669                          virtual public OBStubImpl_HxCorba::VxSegment
01670 {
01671     VxMutableSegment(const VxMutableSegment&);
01672     void operator=(const VxMutableSegment&);
01673 
01674 protected:
01675 
01676     VxMutableSegment() { }
01677 
01678 public:
01679 
01680     static inline VxMutableSegment_ptr
01681     _duplicate(VxMutableSegment_ptr p)
01682     {
01683         if(p)
01684             p -> _OB_incRef();
01685         return p;
01686     }
01687 
01688     static inline VxMutableSegment_ptr
01689     _nil()
01690     {
01691         return 0;
01692     }
01693 
01694     //
01695     // IDL:HxCorba/VxMutableSegment/setStart:1.0
01696     //
01697     virtual void setStart(CORBA::Long start) = 0;
01698 
01699     //
01700     // IDL:HxCorba/VxMutableSegment/setEnd:1.0
01701     //
01702     virtual void setEnd(CORBA::Long end) = 0;
01703 
01704     //
01705     // IDL:HxCorba/VxMutableSegment/removeInt:1.0
01706     //
01707     virtual void removeInt(const char* id) = 0;
01708 
01709     //
01710     // IDL:HxCorba/VxMutableSegment/removeDouble:1.0
01711     //
01712     virtual void removeDouble(const char* id) = 0;
01713 
01714     //
01715     // IDL:HxCorba/VxMutableSegment/removeString:1.0
01716     //
01717     virtual void removeString(const char* id) = 0;
01718 
01719     //
01720     // IDL:HxCorba/VxMutableSegment/changeInt:1.0
01721     //
01722     virtual void changeInt(const char* id,
01723                            CORBA::Long newValue) = 0;
01724 
01725     //
01726     // IDL:HxCorba/VxMutableSegment/changeDouble:1.0
01727     //
01728     virtual void changeDouble(const char* id,
01729                               CORBA::Double newValue) = 0;
01730 
01731     //
01732     // IDL:HxCorba/VxMutableSegment/changeString:1.0
01733     //
01734     virtual void changeString(const char* id,
01735                               const char* newValue) = 0;
01736 };
01737 
01738 //
01739 // IDL:HxCorba/VxMutableSegmentation:1.0
01740 //
01741 class VxMutableSegmentation : virtual public OBStubImpl_HxCorba::VxSegmentationBuilder,
01742                               virtual public OBStubImpl_HxCorba::VxSegmentation
01743 {
01744     VxMutableSegmentation(const VxMutableSegmentation&);
01745     void operator=(const VxMutableSegmentation&);
01746 
01747 protected:
01748 
01749     VxMutableSegmentation() { }
01750 
01751 public:
01752 
01753     static inline VxMutableSegmentation_ptr
01754     _duplicate(VxMutableSegmentation_ptr p)
01755     {
01756         if(p)
01757             p -> _OB_incRef();
01758         return p;
01759     }
01760 
01761     static inline VxMutableSegmentation_ptr
01762     _nil()
01763     {
01764         return 0;
01765     }
01766 
01767     //
01768     // IDL:HxCorba/VxMutableSegmentation/removeSegment:1.0
01769     //
01770     virtual void removeSegment(CORBA::Long index) = 0;
01771 };
01772 
01773 //
01774 // IDL:HxCorba/UpdateSession:1.0
01775 //
01776 class UpdateSession : virtual public OBStubImpl_HxCorba::StoreSession
01777 {
01778     UpdateSession(const UpdateSession&);
01779     void operator=(const UpdateSession&);
01780 
01781 protected:
01782 
01783     UpdateSession() { }
01784 
01785 public:
01786 
01787     static inline UpdateSession_ptr
01788     _duplicate(UpdateSession_ptr p)
01789     {
01790         if(p)
01791             p -> _OB_incRef();
01792         return p;
01793     }
01794 
01795     static inline UpdateSession_ptr
01796     _nil()
01797     {
01798         return 0;
01799     }
01800 
01801     //
01802     // IDL:HxCorba/UpdateSession/removeVideo:1.0
01803     //
01804     virtual void removeVideo(const char* videoName) = 0;
01805 
01806     //
01807     // IDL:HxCorba/UpdateSession/removeSegmentation:1.0
01808     //
01809     virtual void removeSegmentation(::HxCorba::VxSegmentation_ptr seg) = 0;
01810 
01811     //
01812     // IDL:HxCorba/UpdateSession/removeSegment:1.0
01813     //
01814     virtual void removeSegment(::HxCorba::VxSegment_ptr segment) = 0;
01815 };
01816 
01817 //
01818 // IDL:HxCorba/XMLSession:1.0
01819 //
01820 class XMLSession : virtual public OBStubImpl_HxCorba::DatabaseSession
01821 {
01822     XMLSession(const XMLSession&);
01823     void operator=(const XMLSession&);
01824 
01825 protected:
01826 
01827     XMLSession() { }
01828 
01829 public:
01830 
01831     static inline XMLSession_ptr
01832     _duplicate(XMLSession_ptr p)
01833     {
01834         if(p)
01835             p -> _OB_incRef();
01836         return p;
01837     }
01838 
01839     static inline XMLSession_ptr
01840     _nil()
01841     {
01842         return 0;
01843     }
01844 
01845     //
01846     // IDL:HxCorba/XMLSession/queryXML:1.0
01847     //
01848     virtual char* queryXML(const char* sqlQuery) = 0;
01849 
01850     //
01851     // IDL:HxCorba/XMLSession/queryDBData:1.0
01852     //
01853     virtual ::HxCorba::DBDataRowSeq* queryDBData(const char* sqlQuery,
01854                                                  const ::HxCorba::DBDataTagSeq& resultType) = 0;
01855 };
01856 
01857 //
01858 // IDL:HxCorba/HistogramSession:1.0
01859 //
01860 class HistogramSession : virtual public OBStubImpl_HxCorba::DatabaseSession
01861 {
01862     HistogramSession(const HistogramSession&);
01863     void operator=(const HistogramSession&);
01864 
01865 protected:
01866 
01867     HistogramSession() { }
01868 
01869 public:
01870 
01871     static inline HistogramSession_ptr
01872     _duplicate(HistogramSession_ptr p)
01873     {
01874         if(p)
01875             p -> _OB_incRef();
01876         return p;
01877     }
01878 
01879     static inline HistogramSession_ptr
01880     _nil()
01881     {
01882         return 0;
01883     }
01884 
01885     //
01886     // IDL:HxCorba/HistogramSession/addHistogram:1.0
01887     //
01888     virtual void addHistogram(const char* imageName,
01889                               const char* setName,
01890                               const ::HxCorba::FloatSeq& histoData) = 0;
01891 
01892     //
01893     // IDL:HxCorba/HistogramSession/getHistogram:1.0
01894     //
01895     virtual ::HxCorba::FloatSeq* getHistogram(const char* imageName,
01896                                               const char* setName) = 0;
01897 
01898     //
01899     // IDL:HxCorba/HistogramSession/nearest:1.0
01900     //
01901     virtual ::HxCorba::StringSeq* nearest(const char* imageName,
01902                                           const char* setName,
01903                                           CORBA::Long count) = 0;
01904 
01905     //
01906     // IDL:HxCorba/HistogramSession/random:1.0
01907     //
01908     virtual ::HxCorba::StringSeq* random(const char* setName,
01909                                          CORBA::Long count) = 0;
01910 
01911     //
01912     // IDL:HxCorba/HistogramSession/search:1.0
01913     //
01914     virtual ::HxCorba::StringSeq* search(CORBA::Long count,
01915                                          const ::HxCorba::FloatSeq& sample) = 0;
01916 };
01917 
01918 //
01919 // IDL:HxCorba/VxSimilarityBuilder:1.0
01920 //
01921 class VxSimilarityBuilder : virtual public OB::StubImplBase
01922 {
01923     VxSimilarityBuilder(const VxSimilarityBuilder&);
01924     void operator=(const VxSimilarityBuilder&);
01925 
01926 protected:
01927 
01928     VxSimilarityBuilder() { }
01929 
01930 public:
01931 
01932     static inline VxSimilarityBuilder_ptr
01933     _duplicate(VxSimilarityBuilder_ptr p)
01934     {
01935         if(p)
01936             p -> _OB_incRef();
01937         return p;
01938     }
01939 
01940     static inline VxSimilarityBuilder_ptr
01941     _nil()
01942     {
01943         return 0;
01944     }
01945 
01946     //
01947     // IDL:HxCorba/VxSimilarityBuilder/addSimilarity:1.0
01948     //
01949     virtual void addSimilarity(CORBA::Long index1,
01950                                CORBA::Long index2,
01951                                CORBA::Double value,
01952                                CORBA::Long keyFrame1,
01953                                CORBA::Long keyFrame2) = 0;
01954 };
01955 
01956 //
01957 // IDL:HxCorba/VxSimilaritySession:1.0
01958 //
01959 class VxSimilaritySession : virtual public OBStubImpl_HxCorba::DatabaseSession
01960 {
01961     VxSimilaritySession(const VxSimilaritySession&);
01962     void operator=(const VxSimilaritySession&);
01963 
01964 protected:
01965 
01966     VxSimilaritySession() { }
01967 
01968 public:
01969 
01970     static inline VxSimilaritySession_ptr
01971     _duplicate(VxSimilaritySession_ptr p)
01972     {
01973         if(p)
01974             p -> _OB_incRef();
01975         return p;
01976     }
01977 
01978     static inline VxSimilaritySession_ptr
01979     _nil()
01980     {
01981         return 0;
01982     }
01983 
01984     //
01985     // IDL:HxCorba/VxSimilaritySession/addSimilarities:1.0
01986     //
01987     virtual ::HxCorba::VxSimilarityBuilder_ptr addSimilarities(const char* videoName,
01988                                                                const char* segName,
01989                                                                const char* featureName) = 0;
01990 };
01991 
01992 //
01993 // IDL:HxCorba/FullSession:1.0
01994 //
01995 class FullSession : virtual public OBStubImpl_HxCorba::UpdateSession,
01996                     virtual public OBStubImpl_HxCorba::XMLSession,
01997                     virtual public OBStubImpl_HxCorba::HistogramSession,
01998                     virtual public OBStubImpl_HxCorba::VxSimilaritySession
01999 {
02000     FullSession(const FullSession&);
02001     void operator=(const FullSession&);
02002 
02003 protected:
02004 
02005     FullSession() { }
02006 
02007 public:
02008 
02009     static inline FullSession_ptr
02010     _duplicate(FullSession_ptr p)
02011     {
02012         if(p)
02013             p -> _OB_incRef();
02014         return p;
02015     }
02016 
02017     static inline FullSession_ptr
02018     _nil()
02019     {
02020         return 0;
02021     }
02022 };
02023 
02024 } // End of namespace OBStubImpl_HxCorba
02025 
02026 //
02027 // IDL:HxCorba:1.0
02028 //
02029 namespace OBMarshalStubImpl_HxCorba
02030 {
02031 
02032 //
02033 // IDL:HxCorba/VxSegmentBuilder:1.0
02034 //
02035 class VxSegmentBuilder : virtual public OBStubImpl_HxCorba::VxSegmentBuilder,
02036                          virtual public OB::MarshalStubImpl
02037 {
02038     VxSegmentBuilder(const VxSegmentBuilder&);
02039     void operator=(const VxSegmentBuilder&);
02040 
02041 protected:
02042 
02043     VxSegmentBuilder() { }
02044     friend class OBProxy_HxCorba::VxSegmentBuilder;
02045 
02046 public:
02047 
02048     //
02049     // IDL:HxCorba/VxSegmentBuilder/addInt:1.0
02050     //
02051     virtual void addInt(const char* id,
02052                         CORBA::Long value);
02053 
02054     //
02055     // IDL:HxCorba/VxSegmentBuilder/addDouble:1.0
02056     //
02057     virtual void addDouble(const char* id,
02058                            CORBA::Double value);
02059 
02060     //
02061     // IDL:HxCorba/VxSegmentBuilder/addString:1.0
02062     //
02063     virtual void addString(const char* id,
02064                            const char* value);
02065 };
02066 
02067 //
02068 // IDL:HxCorba/VxSegmentationBuilder:1.0
02069 //
02070 class VxSegmentationBuilder : virtual public OBStubImpl_HxCorba::VxSegmentationBuilder,
02071                               virtual public OB::MarshalStubImpl
02072 {
02073     VxSegmentationBuilder(const VxSegmentationBuilder&);
02074     void operator=(const VxSegmentationBuilder&);
02075 
02076 protected:
02077 
02078     VxSegmentationBuilder() { }
02079     friend class OBProxy_HxCorba::VxSegmentationBuilder;
02080 
02081 public:
02082 
02083     //
02084     // IDL:HxCorba/VxSegmentationBuilder/setDescription:1.0
02085     //
02086     virtual void setDescription(const char* description);
02087 
02088     //
02089     // IDL:HxCorba/VxSegmentationBuilder/buildSegment:1.0
02090     //
02091     virtual ::HxCorba::VxSegmentBuilder_ptr buildSegment(CORBA::Long start,
02092                                                          CORBA::Long end);
02093 };
02094 
02095 //
02096 // IDL:HxCorba/StoreSession:1.0
02097 //
02098 class StoreSession : virtual public OBStubImpl_HxCorba::StoreSession,
02099                      virtual public OBMarshalStubImpl_HxCorba::DatabaseSession
02100 {
02101     StoreSession(const StoreSession&);
02102     void operator=(const StoreSession&);
02103 
02104 protected:
02105 
02106     StoreSession() { }
02107     friend class OBProxy_HxCorba::StoreSession;
02108 
02109 public:
02110 
02111     //
02112     // IDL:HxCorba/StoreSession/addSegmentation:1.0
02113     //
02114     virtual void addSegmentation(::HxCorba::VxSegmentation_ptr seg,
02115                                  const char* videoName,
02116                                  const char* segName,
02117                                  const char* description);
02118 
02119     //
02120     // IDL:HxCorba/StoreSession/buildSegmentation:1.0
02121     //
02122     virtual ::HxCorba::VxSegmentationBuilder_ptr buildSegmentation(const char* videoName,
02123                                                                    const char* segName);
02124 };
02125 
02126 //
02127 // IDL:HxCorba/VxMutableSegment:1.0
02128 //
02129 class VxMutableSegment : virtual public OBStubImpl_HxCorba::VxMutableSegment,
02130                          virtual public OBMarshalStubImpl_HxCorba::VxSegmentBuilder,
02131                          virtual public OBMarshalStubImpl_HxCorba::VxSegment
02132 {
02133     VxMutableSegment(const VxMutableSegment&);
02134     void operator=(const VxMutableSegment&);
02135 
02136 protected:
02137 
02138     VxMutableSegment() { }
02139     friend class OBProxy_HxCorba::VxMutableSegment;
02140 
02141 public:
02142 
02143     //
02144     // IDL:HxCorba/VxMutableSegment/setStart:1.0
02145     //
02146     virtual void setStart(CORBA::Long start);
02147 
02148     //
02149     // IDL:HxCorba/VxMutableSegment/setEnd:1.0
02150     //
02151     virtual void setEnd(CORBA::Long end);
02152 
02153     //
02154     // IDL:HxCorba/VxMutableSegment/removeInt:1.0
02155     //
02156     virtual void removeInt(const char* id);
02157 
02158     //
02159     // IDL:HxCorba/VxMutableSegment/removeDouble:1.0
02160     //
02161     virtual void removeDouble(const char* id);
02162 
02163     //
02164     // IDL:HxCorba/VxMutableSegment/removeString:1.0
02165     //
02166     virtual void removeString(const char* id);
02167 
02168     //
02169     // IDL:HxCorba/VxMutableSegment/changeInt:1.0
02170     //
02171     virtual void changeInt(const char* id,
02172                            CORBA::Long newValue);
02173 
02174     //
02175     // IDL:HxCorba/VxMutableSegment/changeDouble:1.0
02176     //
02177     virtual void changeDouble(const char* id,
02178                               CORBA::Double newValue);
02179 
02180     //
02181     // IDL:HxCorba/VxMutableSegment/changeString:1.0
02182     //
02183     virtual void changeString(const char* id,
02184                               const char* newValue);
02185 };
02186 
02187 //
02188 // IDL:HxCorba/VxMutableSegmentation:1.0
02189 //
02190 class VxMutableSegmentation : virtual public OBStubImpl_HxCorba::VxMutableSegmentation,
02191                               virtual public OBMarshalStubImpl_HxCorba::VxSegmentationBuilder,
02192                               virtual public OBMarshalStubImpl_HxCorba::VxSegmentation
02193 {
02194     VxMutableSegmentation(const VxMutableSegmentation&);
02195     void operator=(const VxMutableSegmentation&);
02196 
02197 protected:
02198 
02199     VxMutableSegmentation() { }
02200     friend class OBProxy_HxCorba::VxMutableSegmentation;
02201 
02202 public:
02203 
02204     //
02205     // IDL:HxCorba/VxMutableSegmentation/removeSegment:1.0
02206     //
02207     virtual void removeSegment(CORBA::Long index);
02208 };
02209 
02210 //
02211 // IDL:HxCorba/UpdateSession:1.0
02212 //
02213 class UpdateSession : virtual public OBStubImpl_HxCorba::UpdateSession,
02214                       virtual public OBMarshalStubImpl_HxCorba::StoreSession
02215 {
02216     UpdateSession(const UpdateSession&);
02217     void operator=(const UpdateSession&);
02218 
02219 protected:
02220 
02221     UpdateSession() { }
02222     friend class OBProxy_HxCorba::UpdateSession;
02223 
02224 public:
02225 
02226     //
02227     // IDL:HxCorba/UpdateSession/removeVideo:1.0
02228     //
02229     virtual void removeVideo(const char* videoName);
02230 
02231     //
02232     // IDL:HxCorba/UpdateSession/removeSegmentation:1.0
02233     //
02234     virtual void removeSegmentation(::HxCorba::VxSegmentation_ptr seg);
02235 
02236     //
02237     // IDL:HxCorba/UpdateSession/removeSegment:1.0
02238     //
02239     virtual void removeSegment(::HxCorba::VxSegment_ptr segment);
02240 };
02241 
02242 //
02243 // IDL:HxCorba/XMLSession:1.0
02244 //
02245 class XMLSession : virtual public OBStubImpl_HxCorba::XMLSession,
02246                    virtual public OBMarshalStubImpl_HxCorba::DatabaseSession
02247 {
02248     XMLSession(const XMLSession&);
02249     void operator=(const XMLSession&);
02250 
02251 protected:
02252 
02253     XMLSession() { }
02254     friend class OBProxy_HxCorba::XMLSession;
02255 
02256 public:
02257 
02258     //
02259     // IDL:HxCorba/XMLSession/queryXML:1.0
02260     //
02261     virtual char* queryXML(const char* sqlQuery);
02262 
02263     //
02264     // IDL:HxCorba/XMLSession/queryDBData:1.0
02265     //
02266     virtual ::HxCorba::DBDataRowSeq* queryDBData(const char* sqlQuery,
02267                                                  const ::HxCorba::DBDataTagSeq& resultType);
02268 };
02269 
02270 //
02271 // IDL:HxCorba/HistogramSession:1.0
02272 //
02273 class HistogramSession : virtual public OBStubImpl_HxCorba::HistogramSession,
02274                          virtual public OBMarshalStubImpl_HxCorba::DatabaseSession
02275 {
02276     HistogramSession(const HistogramSession&);
02277     void operator=(const HistogramSession&);
02278 
02279 protected:
02280 
02281     HistogramSession() { }
02282     friend class OBProxy_HxCorba::HistogramSession;
02283 
02284 public:
02285 
02286     //
02287     // IDL:HxCorba/HistogramSession/addHistogram:1.0
02288     //
02289     virtual void addHistogram(const char* imageName,
02290                               const char* setName,
02291                               const ::HxCorba::FloatSeq& histoData);
02292 
02293     //
02294     // IDL:HxCorba/HistogramSession/getHistogram:1.0
02295     //
02296     virtual ::HxCorba::FloatSeq* getHistogram(const char* imageName,
02297                                               const char* setName);
02298 
02299     //
02300     // IDL:HxCorba/HistogramSession/nearest:1.0
02301     //
02302     virtual ::HxCorba::StringSeq* nearest(const char* imageName,
02303                                           const char* setName,
02304                                           CORBA::Long count);
02305 
02306     //
02307     // IDL:HxCorba/HistogramSession/random:1.0
02308     //
02309     virtual ::HxCorba::StringSeq* random(const char* setName,
02310                                          CORBA::Long count);
02311 
02312     //
02313     // IDL:HxCorba/HistogramSession/search:1.0
02314     //
02315     virtual ::HxCorba::StringSeq* search(CORBA::Long count,
02316                                          const ::HxCorba::FloatSeq& sample);
02317 };
02318 
02319 //
02320 // IDL:HxCorba/VxSimilarityBuilder:1.0
02321 //
02322 class VxSimilarityBuilder : virtual public OBStubImpl_HxCorba::VxSimilarityBuilder,
02323                             virtual public OB::MarshalStubImpl
02324 {
02325     VxSimilarityBuilder(const VxSimilarityBuilder&);
02326     void operator=(const VxSimilarityBuilder&);
02327 
02328 protected:
02329 
02330     VxSimilarityBuilder() { }
02331     friend class OBProxy_HxCorba::VxSimilarityBuilder;
02332 
02333 public:
02334 
02335     //
02336     // IDL:HxCorba/VxSimilarityBuilder/addSimilarity:1.0
02337     //
02338     virtual void addSimilarity(CORBA::Long index1,
02339                                CORBA::Long index2,
02340                                CORBA::Double value,
02341                                CORBA::Long keyFrame1,
02342                                CORBA::Long keyFrame2);
02343 };
02344 
02345 //
02346 // IDL:HxCorba/VxSimilaritySession:1.0
02347 //
02348 class VxSimilaritySession : virtual public OBStubImpl_HxCorba::VxSimilaritySession,
02349                             virtual public OBMarshalStubImpl_HxCorba::DatabaseSession
02350 {
02351     VxSimilaritySession(const VxSimilaritySession&);
02352     void operator=(const VxSimilaritySession&);
02353 
02354 protected:
02355 
02356     VxSimilaritySession() { }
02357     friend class OBProxy_HxCorba::VxSimilaritySession;
02358 
02359 public:
02360 
02361     //
02362     // IDL:HxCorba/VxSimilaritySession/addSimilarities:1.0
02363     //
02364     virtual ::HxCorba::VxSimilarityBuilder_ptr addSimilarities(const char* videoName,
02365                                                                const char* segName,
02366                                                                const char* featureName);
02367 };
02368 
02369 //
02370 // IDL:HxCorba/FullSession:1.0
02371 //
02372 class FullSession : virtual public OBStubImpl_HxCorba::FullSession,
02373                     virtual public OBMarshalStubImpl_HxCorba::UpdateSession,
02374                     virtual public OBMarshalStubImpl_HxCorba::XMLSession,
02375                     virtual public OBMarshalStubImpl_HxCorba::HistogramSession,
02376                     virtual public OBMarshalStubImpl_HxCorba::VxSimilaritySession
02377 {
02378     FullSession(const FullSession&);
02379     void operator=(const FullSession&);
02380 
02381 protected:
02382 
02383     FullSession() { }
02384     friend class OBProxy_HxCorba::FullSession;
02385 
02386 public:
02387 };
02388 
02389 } // End of namespace OBMarshalStubImpl_HxCorba
02390 
02391 //
02392 // IDL:HxCorba:1.0
02393 //
02394 namespace OBV_HxCorba
02395 {
02396 
02397 } // End of namespace OBV_HxCorba
02398 
02399 //
02400 // IDL:HxCorba/VxSegmentBuilder:1.0
02401 //
02402 namespace CORBA
02403 {
02404 
02405 inline void
02406 release(::HxCorba::VxSegmentBuilder_ptr p)
02407 {
02408     if(p)
02409         p -> _remove_ref();
02410 }
02411 
02412 inline Boolean
02413 is_nil(::HxCorba::VxSegmentBuilder_ptr p)
02414 {
02415     return p == 0;
02416 }
02417 
02418 inline void
02419 release(OBStubImpl_HxCorba::VxSegmentBuilder_ptr p)
02420 {
02421     if(p)
02422         p -> _OB_decRef();
02423 }
02424 
02425 inline Boolean
02426 is_nil(OBStubImpl_HxCorba::VxSegmentBuilder_ptr p)
02427 {
02428     return p == 0;
02429 }
02430 
02431 } // End of namespace CORBA
02432 
02433 void operator<<=(CORBA::Any&, HxCorba::VxSegmentBuilder_ptr*);
02434 void operator<<=(CORBA::Any&, HxCorba::VxSegmentBuilder_ptr);
02435 CORBA::Boolean operator>>=(const CORBA::Any&, HxCorba::VxSegmentBuilder_ptr&);
02436 
02437 inline void
02438 operator<<=(CORBA::Any_var& any, HxCorba::VxSegmentBuilder_ptr* val)
02439 {
02440     any.inout() <<= val;
02441 }
02442 
02443 inline void
02444 operator<<=(CORBA::Any_var& any, HxCorba::VxSegmentBuilder_ptr val)
02445 {
02446     any.inout() <<= val;
02447 }
02448 
02449 inline CORBA::Boolean
02450 operator>>=(const CORBA::Any_var& any, HxCorba::VxSegmentBuilder_ptr& val)
02451 {
02452     return any.in() >>= val;
02453 }
02454 
02455 //
02456 // IDL:HxCorba/VxSegmentationBuilder:1.0
02457 //
02458 namespace CORBA
02459 {
02460 
02461 inline void
02462 release(::HxCorba::VxSegmentationBuilder_ptr p)
02463 {
02464     if(p)
02465         p -> _remove_ref();
02466 }
02467 
02468 inline Boolean
02469 is_nil(::HxCorba::VxSegmentationBuilder_ptr p)
02470 {
02471     return p == 0;
02472 }
02473 
02474 inline void
02475 release(OBStubImpl_HxCorba::VxSegmentationBuilder_ptr p)
02476 {
02477     if(p)
02478         p -> _OB_decRef();
02479 }
02480 
02481 inline Boolean
02482 is_nil(OBStubImpl_HxCorba::VxSegmentationBuilder_ptr p)
02483 {
02484     return p == 0;
02485 }
02486 
02487 } // End of namespace CORBA
02488 
02489 void operator<<=(CORBA::Any&, HxCorba::VxSegmentationBuilder_ptr*);
02490 void operator<<=(CORBA::Any&, HxCorba::VxSegmentationBuilder_ptr);
02491 CORBA::Boolean operator>>=(const CORBA::Any&, HxCorba::VxSegmentationBuilder_ptr&);
02492 
02493 inline void
02494 operator<<=(CORBA::Any_var& any, HxCorba::VxSegmentationBuilder_ptr* val)
02495 {
02496     any.inout() <<= val;
02497 }
02498 
02499 inline void
02500 operator<<=(CORBA::Any_var& any, HxCorba::VxSegmentationBuilder_ptr val)
02501 {
02502     any.inout() <<= val;
02503 }
02504 
02505 inline CORBA::Boolean
02506 operator>>=(const CORBA::Any_var& any, HxCorba::VxSegmentationBuilder_ptr& val)
02507 {
02508     return any.in() >>= val;
02509 }
02510 
02511 //
02512 // IDL:HxCorba/StoreSession:1.0
02513 //
02514 namespace CORBA
02515 {
02516 
02517 inline void
02518 release(::HxCorba::StoreSession_ptr p)
02519 {
02520     if(p)
02521         p -> _remove_ref();
02522 }
02523 
02524 inline Boolean
02525 is_nil(::HxCorba::StoreSession_ptr p)
02526 {
02527     return p == 0;
02528 }
02529 
02530 inline void
02531 release(OBStubImpl_HxCorba::StoreSession_ptr p)
02532 {
02533     if(p)
02534         p -> _OB_decRef();
02535 }
02536 
02537 inline Boolean
02538 is_nil(OBStubImpl_HxCorba::StoreSession_ptr p)
02539 {
02540     return p == 0;
02541 }
02542 
02543 } // End of namespace CORBA
02544 
02545 void operator<<=(CORBA::Any&, HxCorba::StoreSession_ptr*);
02546 void operator<<=(CORBA::Any&, HxCorba::StoreSession_ptr);
02547 CORBA::Boolean operator>>=(const CORBA::Any&, HxCorba::StoreSession_ptr&);
02548 
02549 inline void
02550 operator<<=(CORBA::Any_var& any, HxCorba::StoreSession_ptr* val)
02551 {
02552     any.inout() <<= val;
02553 }
02554 
02555 inline void
02556 operator<<=(CORBA::Any_var& any, HxCorba::StoreSession_ptr val)
02557 {
02558     any.inout() <<= val;
02559 }
02560 
02561 inline CORBA::Boolean
02562 operator>>=(const CORBA::Any_var& any, HxCorba::StoreSession_ptr& val)
02563 {
02564     return any.in() >>= val;
02565 }
02566 
02567 //
02568 // IDL:HxCorba/VxMutableSegment:1.0
02569 //
02570 namespace CORBA
02571 {
02572 
02573 inline void
02574 release(::HxCorba::VxMutableSegment_ptr p)
02575 {
02576     if(p)
02577         p -> _remove_ref();
02578 }
02579 
02580 inline Boolean
02581 is_nil(::HxCorba::VxMutableSegment_ptr p)
02582 {
02583     return p == 0;
02584 }
02585 
02586 inline void
02587 release(OBStubImpl_HxCorba::VxMutableSegment_ptr p)
02588 {
02589     if(p)
02590         p -> _OB_decRef();
02591 }
02592 
02593 inline Boolean
02594 is_nil(OBStubImpl_HxCorba::VxMutableSegment_ptr p)
02595 {
02596     return p == 0;
02597 }
02598 
02599 } // End of namespace CORBA
02600 
02601 void operator<<=(CORBA::Any&, HxCorba::VxMutableSegment_ptr*);
02602 void operator<<=(CORBA::Any&, HxCorba::VxMutableSegment_ptr);
02603 CORBA::Boolean operator>>=(const CORBA::Any&, HxCorba::VxMutableSegment_ptr&);
02604 
02605 inline void
02606 operator<<=(CORBA::Any_var& any, HxCorba::VxMutableSegment_ptr* val)
02607 {
02608     any.inout() <<= val;
02609 }
02610 
02611 inline void
02612 operator<<=(CORBA::Any_var& any, HxCorba::VxMutableSegment_ptr val)
02613 {
02614     any.inout() <<= val;
02615 }
02616 
02617 inline CORBA::Boolean
02618 operator>>=(const CORBA::Any_var& any, HxCorba::VxMutableSegment_ptr& val)
02619 {
02620     return any.in() >>= val;
02621 }
02622 
02623 //
02624 // IDL:HxCorba/VxMutableSegmentation:1.0
02625 //
02626 namespace CORBA
02627 {
02628 
02629 inline void
02630 release(::HxCorba::VxMutableSegmentation_ptr p)
02631 {
02632     if(p)
02633         p -> _remove_ref();
02634 }
02635 
02636 inline Boolean
02637 is_nil(::HxCorba::VxMutableSegmentation_ptr p)
02638 {
02639     return p == 0;
02640 }
02641 
02642 inline void
02643 release(OBStubImpl_HxCorba::VxMutableSegmentation_ptr p)
02644 {
02645     if(p)
02646         p -> _OB_decRef();
02647 }
02648 
02649 inline Boolean
02650 is_nil(OBStubImpl_HxCorba::VxMutableSegmentation_ptr p)
02651 {
02652     return p == 0;
02653 }
02654 
02655 } // End of namespace CORBA
02656 
02657 void operator<<=(CORBA::Any&, HxCorba::VxMutableSegmentation_ptr*);
02658 void operator<<=(CORBA::Any&, HxCorba::VxMutableSegmentation_ptr);
02659 CORBA::Boolean operator>>=(const CORBA::Any&, HxCorba::VxMutableSegmentation_ptr&);
02660 
02661 inline void
02662 operator<<=(CORBA::Any_var& any, HxCorba::VxMutableSegmentation_ptr* val)
02663 {
02664     any.inout() <<= val;
02665 }
02666 
02667 inline void
02668 operator<<=(CORBA::Any_var& any, HxCorba::VxMutableSegmentation_ptr val)
02669 {
02670     any.inout() <<= val;
02671 }
02672 
02673 inline CORBA::Boolean
02674 operator>>=(const CORBA::Any_var& any, HxCorba::VxMutableSegmentation_ptr& val)
02675 {
02676     return any.in() >>= val;
02677 }
02678 
02679 //
02680 // IDL:HxCorba/UpdateSession:1.0
02681 //
02682 namespace CORBA
02683 {
02684 
02685 inline void
02686 release(::HxCorba::UpdateSession_ptr p)
02687 {
02688     if(p)
02689         p -> _remove_ref();
02690 }
02691 
02692 inline Boolean
02693 is_nil(::HxCorba::UpdateSession_ptr p)
02694 {
02695     return p == 0;
02696 }
02697 
02698 inline void
02699 release(OBStubImpl_HxCorba::UpdateSession_ptr p)
02700 {
02701     if(p)
02702         p -> _OB_decRef();
02703 }
02704 
02705 inline Boolean
02706 is_nil(OBStubImpl_HxCorba::UpdateSession_ptr p)
02707 {
02708     return p == 0;
02709 }
02710 
02711 } // End of namespace CORBA
02712 
02713 void operator<<=(CORBA::Any&, HxCorba::UpdateSession_ptr*);
02714 void operator<<=(CORBA::Any&, HxCorba::UpdateSession_ptr);
02715 CORBA::Boolean operator>>=(const CORBA::Any&, HxCorba::UpdateSession_ptr&);
02716 
02717 inline void
02718 operator<<=(CORBA::Any_var& any, HxCorba::UpdateSession_ptr* val)
02719 {
02720     any.inout() <<= val;
02721 }
02722 
02723 inline void
02724 operator<<=(CORBA::Any_var& any, HxCorba::UpdateSession_ptr val)
02725 {
02726     any.inout() <<= val;
02727 }
02728 
02729 inline CORBA::Boolean
02730 operator>>=(const CORBA::Any_var& any, HxCorba::UpdateSession_ptr& val)
02731 {
02732     return any.in() >>= val;
02733 }
02734 
02735 //
02736 // IDL:HxCorba/DBDataTag:1.0
02737 //
02738 void operator<<=(CORBA::Any&, HxCorba::DBDataTag);
02739 CORBA::Boolean operator>>=(const CORBA::Any&, HxCorba::DBDataTag&);
02740 
02741 inline void
02742 operator<<=(CORBA::Any_var& any, HxCorba::DBDataTag val)
02743 {
02744     any.inout() <<= val;
02745 }
02746 
02747 inline CORBA::Boolean
02748 operator>>=(const CORBA::Any_var& any, HxCorba::DBDataTag& val)
02749 {
02750     return any.in() >>= val;
02751 }
02752 
02753 //
02754 // IDL:HxCorba/DBData:1.0
02755 //
02756 void operator<<=(CORBA::Any&, HxCorba::DBData*);
02757 void operator<<=(CORBA::Any&, const HxCorba::DBData&);
02758 CORBA::Boolean operator>>=(const CORBA::Any&, const HxCorba::DBData*&);
02759 
02760 inline void
02761 operator<<=(CORBA::Any_var& any, HxCorba::DBData* val)
02762 {
02763     any.inout() <<= val;
02764 }
02765 
02766 inline void
02767 operator<<=(CORBA::Any_var& any, const HxCorba::DBData& val)
02768 {
02769     any.inout() <<= val;
02770 }
02771 
02772 inline CORBA::Boolean
02773 operator>>=(const CORBA::Any_var& any, const HxCorba::DBData*& val)
02774 {
02775     return any.in() >>= val;
02776 }
02777 
02778 //
02779 // IDL:HxCorba/DBDataTagSeq:1.0
02780 //
02781 void operator<<=(CORBA::Any&, HxCorba::DBDataTagSeq*);
02782 void operator<<=(CORBA::Any&, const HxCorba::DBDataTagSeq&);
02783 CORBA::Boolean operator>>=(const CORBA::Any&, const HxCorba::DBDataTagSeq*&);
02784 
02785 inline void
02786 operator<<=(CORBA::Any_var& any, HxCorba::DBDataTagSeq* val)
02787 {
02788     any.inout() <<= val;
02789 }
02790 
02791 inline void
02792 operator<<=(CORBA::Any_var& any, const HxCorba::DBDataTagSeq& val)
02793 {
02794     any.inout() <<= val;
02795 }
02796 
02797 inline CORBA::Boolean
02798 operator>>=(const CORBA::Any_var& any, const HxCorba::DBDataTagSeq*& val)
02799 {
02800     return any.in() >>= val;
02801 }
02802 
02803 //
02804 // IDL:HxCorba/DBDataRow:1.0
02805 //
02806 void operator<<=(CORBA::Any&, HxCorba::DBDataRow*);
02807 void operator<<=(CORBA::Any&, const HxCorba::DBDataRow&);
02808 CORBA::Boolean operator>>=(const CORBA::Any&, const HxCorba::DBDataRow*&);
02809 
02810 inline void
02811 operator<<=(CORBA::Any_var& any, HxCorba::DBDataRow* val)
02812 {
02813     any.inout() <<= val;
02814 }
02815 
02816 inline void
02817 operator<<=(CORBA::Any_var& any, const HxCorba::DBDataRow& val)
02818 {
02819     any.inout() <<= val;
02820 }
02821 
02822 inline CORBA::Boolean
02823 operator>>=(const CORBA::Any_var& any, const HxCorba::DBDataRow*& val)
02824 {
02825     return any.in() >>= val;
02826 }
02827 
02828 //
02829 // IDL:HxCorba/DBDataRowSeq:1.0
02830 //
02831 void operator<<=(CORBA::Any&, HxCorba::DBDataRowSeq*);
02832 void operator<<=(CORBA::Any&, const HxCorba::DBDataRowSeq&);
02833 CORBA::Boolean operator>>=(const CORBA::Any&, const HxCorba::DBDataRowSeq*&);
02834 
02835 inline void
02836 operator<<=(CORBA::Any_var& any, HxCorba::DBDataRowSeq* val)
02837 {
02838     any.inout() <<= val;
02839 }
02840 
02841 inline void
02842 operator<<=(CORBA::Any_var& any, const HxCorba::DBDataRowSeq& val)
02843 {
02844     any.inout() <<= val;
02845 }
02846 
02847 inline CORBA::Boolean
02848 operator>>=(const CORBA::Any_var& any, const HxCorba::DBDataRowSeq*& val)
02849 {
02850     return any.in() >>= val;
02851 }
02852 
02853 //
02854 // IDL:HxCorba/XMLSession:1.0
02855 //
02856 namespace CORBA
02857 {
02858 
02859 inline void
02860 release(::HxCorba::XMLSession_ptr p)
02861 {
02862     if(p)
02863         p -> _remove_ref();
02864 }
02865 
02866 inline Boolean
02867 is_nil(::HxCorba::XMLSession_ptr p)
02868 {
02869     return p == 0;
02870 }
02871 
02872 inline void
02873 release(OBStubImpl_HxCorba::XMLSession_ptr p)
02874 {
02875     if(p)
02876         p -> _OB_decRef();
02877 }
02878 
02879 inline Boolean
02880 is_nil(OBStubImpl_HxCorba::XMLSession_ptr p)
02881 {
02882     return p == 0;
02883 }
02884 
02885 } // End of namespace CORBA
02886 
02887 void operator<<=(CORBA::Any&, HxCorba::XMLSession_ptr*);
02888 void operator<<=(CORBA::Any&, HxCorba::XMLSession_ptr);
02889 CORBA::Boolean operator>>=(const CORBA::Any&, HxCorba::XMLSession_ptr&);
02890 
02891 inline void
02892 operator<<=(CORBA::Any_var& any, HxCorba::XMLSession_ptr* val)
02893 {
02894     any.inout() <<= val;
02895 }
02896 
02897 inline void
02898 operator<<=(CORBA::Any_var& any, HxCorba::XMLSession_ptr val)
02899 {
02900     any.inout() <<= val;
02901 }
02902 
02903 inline CORBA::Boolean
02904 operator>>=(const CORBA::Any_var& any, HxCorba::XMLSession_ptr& val)
02905 {
02906     return any.in() >>= val;
02907 }
02908 
02909 //
02910 // IDL:HxCorba/HistogramSession:1.0
02911 //
02912 namespace CORBA
02913 {
02914 
02915 inline void
02916 release(::HxCorba::HistogramSession_ptr p)
02917 {
02918     if(p)
02919         p -> _remove_ref();
02920 }
02921 
02922 inline Boolean
02923 is_nil(::HxCorba::HistogramSession_ptr p)
02924 {
02925     return p == 0;
02926 }
02927 
02928 inline void
02929 release(OBStubImpl_HxCorba::HistogramSession_ptr p)
02930 {
02931     if(p)
02932         p -> _OB_decRef();
02933 }
02934 
02935 inline Boolean
02936 is_nil(OBStubImpl_HxCorba::HistogramSession_ptr p)
02937 {
02938     return p == 0;
02939 }
02940 
02941 } // End of namespace CORBA
02942 
02943 void operator<<=(CORBA::Any&, HxCorba::HistogramSession_ptr*);
02944 void operator<<=(CORBA::Any&, HxCorba::HistogramSession_ptr);
02945 CORBA::Boolean operator>>=(const CORBA::Any&, HxCorba::HistogramSession_ptr&);
02946 
02947 inline void
02948 operator<<=(CORBA::Any_var& any, HxCorba::HistogramSession_ptr* val)
02949 {
02950     any.inout() <<= val;
02951 }
02952 
02953 inline void
02954 operator<<=(CORBA::Any_var& any, HxCorba::HistogramSession_ptr val)
02955 {
02956     any.inout() <<= val;
02957 }
02958 
02959 inline CORBA::Boolean
02960 operator>>=(const CORBA::Any_var& any, HxCorba::HistogramSession_ptr& val)
02961 {
02962     return any.in() >>= val;
02963 }
02964 
02965 //
02966 // IDL:HxCorba/VxSimilarityBuilder:1.0
02967 //
02968 namespace CORBA
02969 {
02970 
02971 inline void
02972 release(::HxCorba::VxSimilarityBuilder_ptr p)
02973 {
02974     if(p)
02975         p -> _remove_ref();
02976 }
02977 
02978 inline Boolean
02979 is_nil(::HxCorba::VxSimilarityBuilder_ptr p)
02980 {
02981     return p == 0;
02982 }
02983 
02984 inline void
02985 release(OBStubImpl_HxCorba::VxSimilarityBuilder_ptr p)
02986 {
02987     if(p)
02988         p -> _OB_decRef();
02989 }
02990 
02991 inline Boolean
02992 is_nil(OBStubImpl_HxCorba::VxSimilarityBuilder_ptr p)
02993 {
02994     return p == 0;
02995 }
02996 
02997 } // End of namespace CORBA
02998 
02999 void operator<<=(CORBA::Any&, HxCorba::VxSimilarityBuilder_ptr*);
03000 void operator<<=(CORBA::Any&, HxCorba::VxSimilarityBuilder_ptr);
03001 CORBA::Boolean operator>>=(const CORBA::Any&, HxCorba::VxSimilarityBuilder_ptr&);
03002 
03003 inline void
03004 operator<<=(CORBA::Any_var& any, HxCorba::VxSimilarityBuilder_ptr* val)
03005 {
03006     any.inout() <<= val;
03007 }
03008 
03009 inline void
03010 operator<<=(CORBA::Any_var& any, HxCorba::VxSimilarityBuilder_ptr val)
03011 {
03012     any.inout() <<= val;
03013 }
03014 
03015 inline CORBA::Boolean
03016 operator>>=(const CORBA::Any_var& any, HxCorba::VxSimilarityBuilder_ptr& val)
03017 {
03018     return any.in() >>= val;
03019 }
03020 
03021 //
03022 // IDL:HxCorba/VxSimilaritySession:1.0
03023 //
03024 namespace CORBA
03025 {
03026 
03027 inline void
03028 release(::HxCorba::VxSimilaritySession_ptr p)
03029 {
03030     if(p)
03031         p -> _remove_ref();
03032 }
03033 
03034 inline Boolean
03035 is_nil(::HxCorba::VxSimilaritySession_ptr p)
03036 {
03037     return p == 0;
03038 }
03039 
03040 inline void
03041 release(OBStubImpl_HxCorba::VxSimilaritySession_ptr p)
03042 {
03043     if(p)
03044         p -> _OB_decRef();
03045 }
03046 
03047 inline Boolean
03048 is_nil(OBStubImpl_HxCorba::VxSimilaritySession_ptr p)
03049 {
03050     return p == 0;
03051 }
03052 
03053 } // End of namespace CORBA
03054 
03055 void operator<<=(CORBA::Any&, HxCorba::VxSimilaritySession_ptr*);
03056 void operator<<=(CORBA::Any&, HxCorba::VxSimilaritySession_ptr);
03057 CORBA::Boolean operator>>=(const CORBA::Any&, HxCorba::VxSimilaritySession_ptr&);
03058 
03059 inline void
03060 operator<<=(CORBA::Any_var& any, HxCorba::VxSimilaritySession_ptr* val)
03061 {
03062     any.inout() <<= val;
03063 }
03064 
03065 inline void
03066 operator<<=(CORBA::Any_var& any, HxCorba::VxSimilaritySession_ptr val)
03067 {
03068     any.inout() <<= val;
03069 }
03070 
03071 inline CORBA::Boolean
03072 operator>>=(const CORBA::Any_var& any, HxCorba::VxSimilaritySession_ptr& val)
03073 {
03074     return any.in() >>= val;
03075 }
03076 
03077 //
03078 // IDL:HxCorba/FullSession:1.0
03079 //
03080 namespace CORBA
03081 {
03082 
03083 inline void
03084 release(::HxCorba::FullSession_ptr p)
03085 {
03086     if(p)
03087         p -> _remove_ref();
03088 }
03089 
03090 inline Boolean
03091 is_nil(::HxCorba::FullSession_ptr p)
03092 {
03093     return p == 0;
03094 }
03095 
03096 inline void
03097 release(OBStubImpl_HxCorba::FullSession_ptr p)
03098 {
03099     if(p)
03100         p -> _OB_decRef();
03101 }
03102 
03103 inline Boolean
03104 is_nil(OBStubImpl_HxCorba::FullSession_ptr p)
03105 {
03106     return p == 0;
03107 }
03108 
03109 } // End of namespace CORBA
03110 
03111 void operator<<=(CORBA::Any&, HxCorba::FullSession_ptr*);
03112 void operator<<=(CORBA::Any&, HxCorba::FullSession_ptr);
03113 CORBA::Boolean operator>>=(const CORBA::Any&, HxCorba::FullSession_ptr&);
03114 
03115 inline void
03116 operator<<=(CORBA::Any_var& any, HxCorba::FullSession_ptr* val)
03117 {
03118     any.inout() <<= val;
03119 }
03120 
03121 inline void
03122 operator<<=(CORBA::Any_var& any, HxCorba::FullSession_ptr val)
03123 {
03124     any.inout() <<= val;
03125 }
03126 
03127 inline CORBA::Boolean
03128 operator>>=(const CORBA::Any_var& any, HxCorba::FullSession_ptr& val)
03129 {
03130     return any.in() >>= val;
03131 }
03132 
03133 #endif
Generated on Tue Feb 3 14:15:51 2004 for C++Binding by doxygen1.2.12 written by Dimitri van Heesch, © 1997-2001