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