00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015 #ifndef ___HxCorbaImageSeq_h__
00016 #define ___HxCorbaImageSeq_h__
00017
00018 #include <HxCorbaImageRep.h>
00019 #include <HxCorbaVxSegmentation.h>
00020
00021 #ifndef OB_INTEGER_VERSION
00022 # error No ORBacus version defined! Is <OB/CORBA.h> included?
00023 #endif
00024
00025 #ifndef OB_NO_VERSION_CHECK
00026 # if (OB_INTEGER_VERSION != 4010000L)
00027 # error ORBacus version mismatch!
00028 # endif
00029 #endif
00030
00031 namespace HxCorba
00032 {
00033
00034 class ImageSeqDisplayer;
00035 typedef ImageSeqDisplayer* ImageSeqDisplayer_ptr;
00036 typedef ImageSeqDisplayer* ImageSeqDisplayerRef;
00037
00038 extern OB::TypeCodeConst _tc_ImageSeqDisplayer;
00039
00040 class ImageSeq;
00041 typedef ImageSeq* ImageSeq_ptr;
00042 typedef ImageSeq* ImageSeqRef;
00043
00044 extern OB::TypeCodeConst _tc_ImageSeq;
00045
00046 class ImageSeqFactory;
00047 typedef ImageSeqFactory* ImageSeqFactory_ptr;
00048 typedef ImageSeqFactory* ImageSeqFactoryRef;
00049
00050 extern OB::TypeCodeConst _tc_ImageSeqFactory;
00051
00052 }
00053
00054 void OBDuplicate(HxCorba::ImageSeqDisplayer_ptr);
00055 void OBRelease(HxCorba::ImageSeqDisplayer_ptr);
00056
00057 void OBMarshal(HxCorba::ImageSeqDisplayer_ptr, OB::OutputStreamImpl*);
00058 void OBUnmarshal(HxCorba::ImageSeqDisplayer_ptr&, OB::InputStreamImpl*);
00059
00060 void OBDuplicate(HxCorba::ImageSeq_ptr);
00061 void OBRelease(HxCorba::ImageSeq_ptr);
00062
00063 void OBMarshal(HxCorba::ImageSeq_ptr, OB::OutputStreamImpl*);
00064 void OBUnmarshal(HxCorba::ImageSeq_ptr&, OB::InputStreamImpl*);
00065
00066 void OBDuplicate(HxCorba::ImageSeqFactory_ptr);
00067 void OBRelease(HxCorba::ImageSeqFactory_ptr);
00068
00069 void OBMarshal(HxCorba::ImageSeqFactory_ptr, OB::OutputStreamImpl*);
00070 void OBUnmarshal(HxCorba::ImageSeqFactory_ptr&, OB::InputStreamImpl*);
00071
00072 namespace HxCorba
00073 {
00074
00075 typedef OB::ObjVar< ImageSeqDisplayer > ImageSeqDisplayer_var;
00076 typedef OB::ObjOut< ImageSeqDisplayer > ImageSeqDisplayer_out;
00077
00078 typedef OB::ObjVar< ImageSeq > ImageSeq_var;
00079 typedef OB::ObjOut< ImageSeq > ImageSeq_out;
00080
00081 typedef OB::ObjVar< ImageSeqFactory > ImageSeqFactory_var;
00082 typedef OB::ObjOut< ImageSeqFactory > ImageSeqFactory_out;
00083
00084 }
00085
00086 namespace OBStubImpl_HxCorba
00087 {
00088
00089 class ImageSeqDisplayer;
00090 typedef ImageSeqDisplayer* ImageSeqDisplayer_ptr;
00091
00092 class ImageSeq;
00093 typedef ImageSeq* ImageSeq_ptr;
00094
00095 class ImageSeqFactory;
00096 typedef ImageSeqFactory* ImageSeqFactory_ptr;
00097
00098 }
00099
00100 void OBDuplicate(OBStubImpl_HxCorba::ImageSeqDisplayer_ptr);
00101 void OBRelease(OBStubImpl_HxCorba::ImageSeqDisplayer_ptr);
00102
00103 void OBDuplicate(OBStubImpl_HxCorba::ImageSeq_ptr);
00104 void OBRelease(OBStubImpl_HxCorba::ImageSeq_ptr);
00105
00106 void OBDuplicate(OBStubImpl_HxCorba::ImageSeqFactory_ptr);
00107 void OBRelease(OBStubImpl_HxCorba::ImageSeqFactory_ptr);
00108
00109 namespace OBStubImpl_HxCorba
00110 {
00111
00112 typedef OB::ObjVar< ImageSeqDisplayer > ImageSeqDisplayer_var;
00113
00114 typedef OB::ObjVar< ImageSeq > ImageSeq_var;
00115
00116 typedef OB::ObjVar< ImageSeqFactory > ImageSeqFactory_var;
00117
00118 }
00119
00120
00121
00122
00123 namespace HxCorba
00124 {
00125
00126
00127
00128
00129 class ImageSeqDisplayer : virtual public CORBA::Object
00130 {
00131 ImageSeqDisplayer(const ImageSeqDisplayer&);
00132 void operator=(const ImageSeqDisplayer&);
00133
00134 protected:
00135
00136 static const char* ids_[];
00137
00138 public:
00139
00140 ImageSeqDisplayer() { }
00141 virtual ~ImageSeqDisplayer() { }
00142
00143 typedef ImageSeqDisplayer_ptr _ptr_type;
00144 typedef ImageSeqDisplayer_var _var_type;
00145
00146 static inline ImageSeqDisplayer_ptr
00147 _duplicate(ImageSeqDisplayer_ptr p)
00148 {
00149 if(p)
00150 p -> _add_ref();
00151 return p;
00152 }
00153
00154 static inline ImageSeqDisplayer_ptr
00155 _nil()
00156 {
00157 return 0;
00158 }
00159
00160 static ImageSeqDisplayer_ptr _narrow(CORBA::Object_ptr);
00161 static ImageSeqDisplayer_ptr _unchecked_narrow(CORBA::Object_ptr);
00162
00163 static ImageSeqDisplayer_ptr _narrow(CORBA::AbstractBase_ptr);
00164 static ImageSeqDisplayer_ptr _unchecked_narrow(CORBA::AbstractBase_ptr);
00165
00166 static const char** _OB_staticIds();
00167
00168
00169
00170
00171 virtual RgbSeq* getRgb2d(CORBA::Long frameNr) = 0;
00172
00173
00174
00175
00176 virtual void fillRgb2d(CORBA::Long frameNr,
00177 RgbBuffer_ptr buf) = 0;
00178
00179
00180
00181
00182 virtual CORBA::Long nrFrames() = 0;
00183
00184
00185
00186
00187 virtual void setDisplayMode(const char* displayMode) = 0;
00188
00189
00190
00191
00192 virtual char* getDisplayMode() = 0;
00193
00194
00195
00196
00197 virtual void setSize(const Sizes& newSize) = 0;
00198
00199
00200
00201
00202 virtual Sizes getSizes() = 0;
00203
00204
00205
00206
00207 virtual Sizes getOriginalSizes() = 0;
00208
00209
00210
00211
00212 virtual void close() = 0;
00213 };
00214
00215
00216
00217
00218 class ImageSeq : virtual public CORBA::Object
00219 {
00220 ImageSeq(const ImageSeq&);
00221 void operator=(const ImageSeq&);
00222
00223 protected:
00224
00225 static const char* ids_[];
00226
00227 public:
00228
00229 ImageSeq() { }
00230 virtual ~ImageSeq() { }
00231
00232 typedef ImageSeq_ptr _ptr_type;
00233 typedef ImageSeq_var _var_type;
00234
00235 static inline ImageSeq_ptr
00236 _duplicate(ImageSeq_ptr p)
00237 {
00238 if(p)
00239 p -> _add_ref();
00240 return p;
00241 }
00242
00243 static inline ImageSeq_ptr
00244 _nil()
00245 {
00246 return 0;
00247 }
00248
00249 static ImageSeq_ptr _narrow(CORBA::Object_ptr);
00250 static ImageSeq_ptr _unchecked_narrow(CORBA::Object_ptr);
00251
00252 static ImageSeq_ptr _narrow(CORBA::AbstractBase_ptr);
00253 static ImageSeq_ptr _unchecked_narrow(CORBA::AbstractBase_ptr);
00254
00255 static const char** _OB_staticIds();
00256
00257
00258
00259
00260 virtual ImageRep_ptr getFrame(CORBA::Long frameNr) = 0;
00261
00262
00263
00264
00265 virtual CORBA::Long nrFrames() = 0;
00266
00267
00268
00269
00270 virtual Sizes frameSizes() = 0;
00271
00272
00273
00274
00275 virtual RgbSeq* getRgb2d(CORBA::Long frameNr,
00276 const char* displayMode) = 0;
00277
00278
00279
00280
00281 virtual void fillRgb2d(CORBA::Long frameNr,
00282 RgbBuffer_ptr buf,
00283 const char* displayMode) = 0;
00284
00285
00286
00287
00288 virtual ImageSeqDisplayer_ptr getDisplayer() = 0;
00289
00290
00291
00292
00293 virtual VxSegmentation_ptr findCuts(TagList_ptr tags) = 0;
00294
00295
00296
00297
00298 virtual void destroy() = 0;
00299 };
00300
00301
00302
00303
00304 class ImageSeqFactory : virtual public CORBA::Object
00305 {
00306 ImageSeqFactory(const ImageSeqFactory&);
00307 void operator=(const ImageSeqFactory&);
00308
00309 protected:
00310
00311 static const char* ids_[];
00312
00313 public:
00314
00315 ImageSeqFactory() { }
00316 virtual ~ImageSeqFactory() { }
00317
00318 typedef ImageSeqFactory_ptr _ptr_type;
00319 typedef ImageSeqFactory_var _var_type;
00320
00321 static inline ImageSeqFactory_ptr
00322 _duplicate(ImageSeqFactory_ptr p)
00323 {
00324 if(p)
00325 p -> _add_ref();
00326 return p;
00327 }
00328
00329 static inline ImageSeqFactory_ptr
00330 _nil()
00331 {
00332 return 0;
00333 }
00334
00335 static ImageSeqFactory_ptr _narrow(CORBA::Object_ptr);
00336 static ImageSeqFactory_ptr _unchecked_narrow(CORBA::Object_ptr);
00337
00338 static ImageSeqFactory_ptr _narrow(CORBA::AbstractBase_ptr);
00339 static ImageSeqFactory_ptr _unchecked_narrow(CORBA::AbstractBase_ptr);
00340
00341 static const char** _OB_staticIds();
00342
00343
00344
00345
00346 virtual ImageSeq_ptr constructImageSeq(const char* name) = 0;
00347
00348
00349
00350
00351 virtual ImageSeq_ptr constructBufferedImageSeq(const char* name,
00352 CORBA::Long bufSize) = 0;
00353
00354
00355
00356
00357 virtual void setUseMDC(CORBA::Long flag) = 0;
00358 };
00359
00360 }
00361
00362
00363
00364
00365 namespace OBProxy_HxCorba
00366 {
00367
00368
00369
00370
00371 class ImageSeqDisplayer : virtual public ::HxCorba::ImageSeqDisplayer,
00372 virtual public OBCORBA::Object
00373 {
00374 ImageSeqDisplayer(const ImageSeqDisplayer&);
00375 void operator=(const ImageSeqDisplayer&);
00376
00377 protected:
00378
00379 virtual OB::MarshalStubImpl_ptr _OB_createMarshalStubImpl();
00380
00381 public:
00382
00383 ImageSeqDisplayer() { }
00384 virtual ~ImageSeqDisplayer() { }
00385
00386 virtual const char** _OB_ids() const;
00387
00388
00389
00390
00391 ::HxCorba::RgbSeq* getRgb2d(CORBA::Long frameNr);
00392
00393
00394
00395
00396 void fillRgb2d(CORBA::Long frameNr,
00397 ::HxCorba::RgbBuffer_ptr buf);
00398
00399
00400
00401
00402 CORBA::Long nrFrames();
00403
00404
00405
00406
00407 void setDisplayMode(const char* displayMode);
00408
00409
00410
00411
00412 char* getDisplayMode();
00413
00414
00415
00416
00417 void setSize(const ::HxCorba::Sizes& newSize);
00418
00419
00420
00421
00422 ::HxCorba::Sizes getSizes();
00423
00424
00425
00426
00427 ::HxCorba::Sizes getOriginalSizes();
00428
00429
00430
00431
00432 void close();
00433 };
00434
00435
00436
00437
00438 class ImageSeq : virtual public ::HxCorba::ImageSeq,
00439 virtual public OBCORBA::Object
00440 {
00441 ImageSeq(const ImageSeq&);
00442 void operator=(const ImageSeq&);
00443
00444 protected:
00445
00446 virtual OB::MarshalStubImpl_ptr _OB_createMarshalStubImpl();
00447
00448 public:
00449
00450 ImageSeq() { }
00451 virtual ~ImageSeq() { }
00452
00453 virtual const char** _OB_ids() const;
00454
00455
00456
00457
00458 ::HxCorba::ImageRep_ptr getFrame(CORBA::Long frameNr);
00459
00460
00461
00462
00463 CORBA::Long nrFrames();
00464
00465
00466
00467
00468 ::HxCorba::Sizes frameSizes();
00469
00470
00471
00472
00473 ::HxCorba::RgbSeq* getRgb2d(CORBA::Long frameNr,
00474 const char* displayMode);
00475
00476
00477
00478
00479 void fillRgb2d(CORBA::Long frameNr,
00480 ::HxCorba::RgbBuffer_ptr buf,
00481 const char* displayMode);
00482
00483
00484
00485
00486 ::HxCorba::ImageSeqDisplayer_ptr getDisplayer();
00487
00488
00489
00490
00491 ::HxCorba::VxSegmentation_ptr findCuts(::HxCorba::TagList_ptr tags);
00492
00493
00494
00495
00496 void destroy();
00497 };
00498
00499
00500
00501
00502 class ImageSeqFactory : virtual public ::HxCorba::ImageSeqFactory,
00503 virtual public OBCORBA::Object
00504 {
00505 ImageSeqFactory(const ImageSeqFactory&);
00506 void operator=(const ImageSeqFactory&);
00507
00508 protected:
00509
00510 virtual OB::MarshalStubImpl_ptr _OB_createMarshalStubImpl();
00511
00512 public:
00513
00514 ImageSeqFactory() { }
00515 virtual ~ImageSeqFactory() { }
00516
00517 virtual const char** _OB_ids() const;
00518
00519
00520
00521
00522 ::HxCorba::ImageSeq_ptr constructImageSeq(const char* name);
00523
00524
00525
00526
00527 ::HxCorba::ImageSeq_ptr constructBufferedImageSeq(const char* name,
00528 CORBA::Long bufSize);
00529
00530
00531
00532
00533 void setUseMDC(CORBA::Long flag);
00534 };
00535
00536 }
00537
00538
00539
00540
00541 namespace OBStubImpl_HxCorba
00542 {
00543
00544
00545
00546
00547 class ImageSeqDisplayer : virtual public OB::StubImplBase
00548 {
00549 ImageSeqDisplayer(const ImageSeqDisplayer&);
00550 void operator=(const ImageSeqDisplayer&);
00551
00552 protected:
00553
00554 ImageSeqDisplayer() { }
00555
00556 public:
00557
00558 static inline ImageSeqDisplayer_ptr
00559 _duplicate(ImageSeqDisplayer_ptr p)
00560 {
00561 if(p)
00562 p -> _OB_incRef();
00563 return p;
00564 }
00565
00566 static inline ImageSeqDisplayer_ptr
00567 _nil()
00568 {
00569 return 0;
00570 }
00571
00572
00573
00574
00575 virtual ::HxCorba::RgbSeq* getRgb2d(CORBA::Long frameNr) = 0;
00576
00577
00578
00579
00580 virtual void fillRgb2d(CORBA::Long frameNr,
00581 ::HxCorba::RgbBuffer_ptr buf) = 0;
00582
00583
00584
00585
00586 virtual CORBA::Long nrFrames() = 0;
00587
00588
00589
00590
00591 virtual void setDisplayMode(const char* displayMode) = 0;
00592
00593
00594
00595
00596 virtual char* getDisplayMode() = 0;
00597
00598
00599
00600
00601 virtual void setSize(const ::HxCorba::Sizes& newSize) = 0;
00602
00603
00604
00605
00606 virtual ::HxCorba::Sizes getSizes() = 0;
00607
00608
00609
00610
00611 virtual ::HxCorba::Sizes getOriginalSizes() = 0;
00612
00613
00614
00615
00616 virtual void close() = 0;
00617 };
00618
00619
00620
00621
00622 class ImageSeq : virtual public OB::StubImplBase
00623 {
00624 ImageSeq(const ImageSeq&);
00625 void operator=(const ImageSeq&);
00626
00627 protected:
00628
00629 ImageSeq() { }
00630
00631 public:
00632
00633 static inline ImageSeq_ptr
00634 _duplicate(ImageSeq_ptr p)
00635 {
00636 if(p)
00637 p -> _OB_incRef();
00638 return p;
00639 }
00640
00641 static inline ImageSeq_ptr
00642 _nil()
00643 {
00644 return 0;
00645 }
00646
00647
00648
00649
00650 virtual ::HxCorba::ImageRep_ptr getFrame(CORBA::Long frameNr) = 0;
00651
00652
00653
00654
00655 virtual CORBA::Long nrFrames() = 0;
00656
00657
00658
00659
00660 virtual ::HxCorba::Sizes frameSizes() = 0;
00661
00662
00663
00664
00665 virtual ::HxCorba::RgbSeq* getRgb2d(CORBA::Long frameNr,
00666 const char* displayMode) = 0;
00667
00668
00669
00670
00671 virtual void fillRgb2d(CORBA::Long frameNr,
00672 ::HxCorba::RgbBuffer_ptr buf,
00673 const char* displayMode) = 0;
00674
00675
00676
00677
00678 virtual ::HxCorba::ImageSeqDisplayer_ptr getDisplayer() = 0;
00679
00680
00681
00682
00683 virtual ::HxCorba::VxSegmentation_ptr findCuts(::HxCorba::TagList_ptr tags) = 0;
00684
00685
00686
00687
00688 virtual void destroy() = 0;
00689 };
00690
00691
00692
00693
00694 class ImageSeqFactory : virtual public OB::StubImplBase
00695 {
00696 ImageSeqFactory(const ImageSeqFactory&);
00697 void operator=(const ImageSeqFactory&);
00698
00699 protected:
00700
00701 ImageSeqFactory() { }
00702
00703 public:
00704
00705 static inline ImageSeqFactory_ptr
00706 _duplicate(ImageSeqFactory_ptr p)
00707 {
00708 if(p)
00709 p -> _OB_incRef();
00710 return p;
00711 }
00712
00713 static inline ImageSeqFactory_ptr
00714 _nil()
00715 {
00716 return 0;
00717 }
00718
00719
00720
00721
00722 virtual ::HxCorba::ImageSeq_ptr constructImageSeq(const char* name) = 0;
00723
00724
00725
00726
00727 virtual ::HxCorba::ImageSeq_ptr constructBufferedImageSeq(const char* name,
00728 CORBA::Long bufSize) = 0;
00729
00730
00731
00732
00733 virtual void setUseMDC(CORBA::Long flag) = 0;
00734 };
00735
00736 }
00737
00738
00739
00740
00741 namespace OBMarshalStubImpl_HxCorba
00742 {
00743
00744
00745
00746
00747 class ImageSeqDisplayer : virtual public OBStubImpl_HxCorba::ImageSeqDisplayer,
00748 virtual public OB::MarshalStubImpl
00749 {
00750 ImageSeqDisplayer(const ImageSeqDisplayer&);
00751 void operator=(const ImageSeqDisplayer&);
00752
00753 protected:
00754
00755 ImageSeqDisplayer() { }
00756 friend class OBProxy_HxCorba::ImageSeqDisplayer;
00757
00758 public:
00759
00760
00761
00762
00763 virtual ::HxCorba::RgbSeq* getRgb2d(CORBA::Long frameNr);
00764
00765
00766
00767
00768 virtual void fillRgb2d(CORBA::Long frameNr,
00769 ::HxCorba::RgbBuffer_ptr buf);
00770
00771
00772
00773
00774 virtual CORBA::Long nrFrames();
00775
00776
00777
00778
00779 virtual void setDisplayMode(const char* displayMode);
00780
00781
00782
00783
00784 virtual char* getDisplayMode();
00785
00786
00787
00788
00789 virtual void setSize(const ::HxCorba::Sizes& newSize);
00790
00791
00792
00793
00794 virtual ::HxCorba::Sizes getSizes();
00795
00796
00797
00798
00799 virtual ::HxCorba::Sizes getOriginalSizes();
00800
00801
00802
00803
00804 virtual void close();
00805 };
00806
00807
00808
00809
00810 class ImageSeq : virtual public OBStubImpl_HxCorba::ImageSeq,
00811 virtual public OB::MarshalStubImpl
00812 {
00813 ImageSeq(const ImageSeq&);
00814 void operator=(const ImageSeq&);
00815
00816 protected:
00817
00818 ImageSeq() { }
00819 friend class OBProxy_HxCorba::ImageSeq;
00820
00821 public:
00822
00823
00824
00825
00826 virtual ::HxCorba::ImageRep_ptr getFrame(CORBA::Long frameNr);
00827
00828
00829
00830
00831 virtual CORBA::Long nrFrames();
00832
00833
00834
00835
00836 virtual ::HxCorba::Sizes frameSizes();
00837
00838
00839
00840
00841 virtual ::HxCorba::RgbSeq* getRgb2d(CORBA::Long frameNr,
00842 const char* displayMode);
00843
00844
00845
00846
00847 virtual void fillRgb2d(CORBA::Long frameNr,
00848 ::HxCorba::RgbBuffer_ptr buf,
00849 const char* displayMode);
00850
00851
00852
00853
00854 virtual ::HxCorba::ImageSeqDisplayer_ptr getDisplayer();
00855
00856
00857
00858
00859 virtual ::HxCorba::VxSegmentation_ptr findCuts(::HxCorba::TagList_ptr tags);
00860
00861
00862
00863
00864 virtual void destroy();
00865 };
00866
00867
00868
00869
00870 class ImageSeqFactory : virtual public OBStubImpl_HxCorba::ImageSeqFactory,
00871 virtual public OB::MarshalStubImpl
00872 {
00873 ImageSeqFactory(const ImageSeqFactory&);
00874 void operator=(const ImageSeqFactory&);
00875
00876 protected:
00877
00878 ImageSeqFactory() { }
00879 friend class OBProxy_HxCorba::ImageSeqFactory;
00880
00881 public:
00882
00883
00884
00885
00886 virtual ::HxCorba::ImageSeq_ptr constructImageSeq(const char* name);
00887
00888
00889
00890
00891 virtual ::HxCorba::ImageSeq_ptr constructBufferedImageSeq(const char* name,
00892 CORBA::Long bufSize);
00893
00894
00895
00896
00897 virtual void setUseMDC(CORBA::Long flag);
00898 };
00899
00900 }
00901
00902
00903
00904
00905 namespace OBV_HxCorba
00906 {
00907
00908 }
00909
00910
00911
00912
00913 namespace CORBA
00914 {
00915
00916 inline void
00917 release(::HxCorba::ImageSeqDisplayer_ptr p)
00918 {
00919 if(p)
00920 p -> _remove_ref();
00921 }
00922
00923 inline Boolean
00924 is_nil(::HxCorba::ImageSeqDisplayer_ptr p)
00925 {
00926 return p == 0;
00927 }
00928
00929 inline void
00930 release(OBStubImpl_HxCorba::ImageSeqDisplayer_ptr p)
00931 {
00932 if(p)
00933 p -> _OB_decRef();
00934 }
00935
00936 inline Boolean
00937 is_nil(OBStubImpl_HxCorba::ImageSeqDisplayer_ptr p)
00938 {
00939 return p == 0;
00940 }
00941
00942 }
00943
00944 void operator<<=(CORBA::Any&, HxCorba::ImageSeqDisplayer_ptr*);
00945 void operator<<=(CORBA::Any&, HxCorba::ImageSeqDisplayer_ptr);
00946 CORBA::Boolean operator>>=(const CORBA::Any&, HxCorba::ImageSeqDisplayer_ptr&);
00947
00948 inline void
00949 operator<<=(CORBA::Any_var& any, HxCorba::ImageSeqDisplayer_ptr* val)
00950 {
00951 any.inout() <<= val;
00952 }
00953
00954 inline void
00955 operator<<=(CORBA::Any_var& any, HxCorba::ImageSeqDisplayer_ptr val)
00956 {
00957 any.inout() <<= val;
00958 }
00959
00960 inline CORBA::Boolean
00961 operator>>=(const CORBA::Any_var& any, HxCorba::ImageSeqDisplayer_ptr& val)
00962 {
00963 return any.in() >>= val;
00964 }
00965
00966
00967
00968
00969 namespace CORBA
00970 {
00971
00972 inline void
00973 release(::HxCorba::ImageSeq_ptr p)
00974 {
00975 if(p)
00976 p -> _remove_ref();
00977 }
00978
00979 inline Boolean
00980 is_nil(::HxCorba::ImageSeq_ptr p)
00981 {
00982 return p == 0;
00983 }
00984
00985 inline void
00986 release(OBStubImpl_HxCorba::ImageSeq_ptr p)
00987 {
00988 if(p)
00989 p -> _OB_decRef();
00990 }
00991
00992 inline Boolean
00993 is_nil(OBStubImpl_HxCorba::ImageSeq_ptr p)
00994 {
00995 return p == 0;
00996 }
00997
00998 }
00999
01000 void operator<<=(CORBA::Any&, HxCorba::ImageSeq_ptr*);
01001 void operator<<=(CORBA::Any&, HxCorba::ImageSeq_ptr);
01002 CORBA::Boolean operator>>=(const CORBA::Any&, HxCorba::ImageSeq_ptr&);
01003
01004 inline void
01005 operator<<=(CORBA::Any_var& any, HxCorba::ImageSeq_ptr* val)
01006 {
01007 any.inout() <<= val;
01008 }
01009
01010 inline void
01011 operator<<=(CORBA::Any_var& any, HxCorba::ImageSeq_ptr val)
01012 {
01013 any.inout() <<= val;
01014 }
01015
01016 inline CORBA::Boolean
01017 operator>>=(const CORBA::Any_var& any, HxCorba::ImageSeq_ptr& val)
01018 {
01019 return any.in() >>= val;
01020 }
01021
01022
01023
01024
01025 namespace CORBA
01026 {
01027
01028 inline void
01029 release(::HxCorba::ImageSeqFactory_ptr p)
01030 {
01031 if(p)
01032 p -> _remove_ref();
01033 }
01034
01035 inline Boolean
01036 is_nil(::HxCorba::ImageSeqFactory_ptr p)
01037 {
01038 return p == 0;
01039 }
01040
01041 inline void
01042 release(OBStubImpl_HxCorba::ImageSeqFactory_ptr p)
01043 {
01044 if(p)
01045 p -> _OB_decRef();
01046 }
01047
01048 inline Boolean
01049 is_nil(OBStubImpl_HxCorba::ImageSeqFactory_ptr p)
01050 {
01051 return p == 0;
01052 }
01053
01054 }
01055
01056 void operator<<=(CORBA::Any&, HxCorba::ImageSeqFactory_ptr*);
01057 void operator<<=(CORBA::Any&, HxCorba::ImageSeqFactory_ptr);
01058 CORBA::Boolean operator>>=(const CORBA::Any&, HxCorba::ImageSeqFactory_ptr&);
01059
01060 inline void
01061 operator<<=(CORBA::Any_var& any, HxCorba::ImageSeqFactory_ptr* val)
01062 {
01063 any.inout() <<= val;
01064 }
01065
01066 inline void
01067 operator<<=(CORBA::Any_var& any, HxCorba::ImageSeqFactory_ptr val)
01068 {
01069 any.inout() <<= val;
01070 }
01071
01072 inline CORBA::Boolean
01073 operator>>=(const CORBA::Any_var& any, HxCorba::ImageSeqFactory_ptr& val)
01074 {
01075 return any.in() >>= val;
01076 }
01077
01078 #endif