00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015 #ifndef ___HxCorbaNJet_h__
00016 #define ___HxCorbaNJet_h__
00017
00018 #include <HxCorbaImageRep.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 NJet;
00034 typedef NJet* NJet_ptr;
00035 typedef NJet* NJetRef;
00036
00037 extern OB::TypeCodeConst _tc_NJet;
00038
00039 class NJetFactory;
00040 typedef NJetFactory* NJetFactory_ptr;
00041 typedef NJetFactory* NJetFactoryRef;
00042
00043 extern OB::TypeCodeConst _tc_NJetFactory;
00044
00045 }
00046
00047 void OBDuplicate(HxCorba::NJet_ptr);
00048 void OBRelease(HxCorba::NJet_ptr);
00049
00050 void OBMarshal(HxCorba::NJet_ptr, OB::OutputStreamImpl*);
00051 void OBUnmarshal(HxCorba::NJet_ptr&, OB::InputStreamImpl*);
00052
00053 void OBDuplicate(HxCorba::NJetFactory_ptr);
00054 void OBRelease(HxCorba::NJetFactory_ptr);
00055
00056 void OBMarshal(HxCorba::NJetFactory_ptr, OB::OutputStreamImpl*);
00057 void OBUnmarshal(HxCorba::NJetFactory_ptr&, OB::InputStreamImpl*);
00058
00059 namespace HxCorba
00060 {
00061
00062 typedef OB::ObjVar< NJet > NJet_var;
00063 typedef OB::ObjOut< NJet > NJet_out;
00064
00065 typedef OB::ObjVar< NJetFactory > NJetFactory_var;
00066 typedef OB::ObjOut< NJetFactory > NJetFactory_out;
00067
00068 }
00069
00070 namespace OBStubImpl_HxCorba
00071 {
00072
00073 class NJet;
00074 typedef NJet* NJet_ptr;
00075
00076 class NJetFactory;
00077 typedef NJetFactory* NJetFactory_ptr;
00078
00079 }
00080
00081 void OBDuplicate(OBStubImpl_HxCorba::NJet_ptr);
00082 void OBRelease(OBStubImpl_HxCorba::NJet_ptr);
00083
00084 void OBDuplicate(OBStubImpl_HxCorba::NJetFactory_ptr);
00085 void OBRelease(OBStubImpl_HxCorba::NJetFactory_ptr);
00086
00087 namespace OBStubImpl_HxCorba
00088 {
00089
00090 typedef OB::ObjVar< NJet > NJet_var;
00091
00092 typedef OB::ObjVar< NJetFactory > NJetFactory_var;
00093
00094 }
00095
00096
00097
00098
00099 namespace HxCorba
00100 {
00101
00102
00103
00104
00105 class NJet : virtual public CORBA::Object
00106 {
00107 NJet(const NJet&);
00108 void operator=(const NJet&);
00109
00110 protected:
00111
00112 static const char* ids_[];
00113
00114 public:
00115
00116 NJet() { }
00117 virtual ~NJet() { }
00118
00119 typedef NJet_ptr _ptr_type;
00120 typedef NJet_var _var_type;
00121
00122 static inline NJet_ptr
00123 _duplicate(NJet_ptr p)
00124 {
00125 if(p)
00126 p -> _add_ref();
00127 return p;
00128 }
00129
00130 static inline NJet_ptr
00131 _nil()
00132 {
00133 return 0;
00134 }
00135
00136 static NJet_ptr _narrow(CORBA::Object_ptr);
00137 static NJet_ptr _unchecked_narrow(CORBA::Object_ptr);
00138
00139 static NJet_ptr _narrow(CORBA::AbstractBase_ptr);
00140 static NJet_ptr _unchecked_narrow(CORBA::AbstractBase_ptr);
00141
00142 static const char** _OB_staticIds();
00143
00144
00145
00146
00147 virtual CORBA::Long order() = 0;
00148
00149
00150
00151
00152 virtual CORBA::Double scale() = 0;
00153
00154
00155
00156
00157 virtual CORBA::Long nrComponents() = 0;
00158
00159
00160
00161
00162 virtual CORBA::Boolean isColor() = 0;
00163
00164
00165
00166
00167 virtual ImageRep_ptr getLidx(CORBA::Long i) = 0;
00168
00169
00170
00171
00172 virtual ImageRep_ptr getJidx(CORBA::Long i) = 0;
00173
00174
00175
00176
00177 virtual ImageRep_ptr getMidx(CORBA::Long i) = 0;
00178
00179
00180
00181
00182 virtual ImageRep_ptr xy(CORBA::Long x,
00183 CORBA::Long y) = 0;
00184
00185
00186
00187
00188 virtual ImageRep_ptr xyz(CORBA::Long x,
00189 CORBA::Long y,
00190 CORBA::Long z) = 0;
00191
00192
00193
00194
00195 virtual ImageRep_ptr xyl(CORBA::Long x,
00196 CORBA::Long y,
00197 CORBA::Long l) = 0;
00198
00199
00200
00201
00202 virtual ImageRep_ptr xyzl(CORBA::Long x,
00203 CORBA::Long y,
00204 CORBA::Long z,
00205 CORBA::Long l) = 0;
00206
00207
00208
00209
00210 virtual ImageList* getLList() = 0;
00211
00212
00213
00214
00215 virtual ImageList* getJList() = 0;
00216
00217
00218
00219
00220 virtual ImageList* getMList() = 0;
00221
00222
00223
00224
00225 virtual ImageList* getList() = 0;
00226
00227
00228
00229
00230 virtual ImageRep_ptr getLw() = 0;
00231
00232
00233
00234
00235 virtual ImageRep_ptr getJw() = 0;
00236
00237
00238
00239
00240 virtual ImageRep_ptr getMw() = 0;
00241 };
00242
00243
00244
00245
00246 class NJetFactory : virtual public CORBA::Object
00247 {
00248 NJetFactory(const NJetFactory&);
00249 void operator=(const NJetFactory&);
00250
00251 protected:
00252
00253 static const char* ids_[];
00254
00255 public:
00256
00257 NJetFactory() { }
00258 virtual ~NJetFactory() { }
00259
00260 typedef NJetFactory_ptr _ptr_type;
00261 typedef NJetFactory_var _var_type;
00262
00263 static inline NJetFactory_ptr
00264 _duplicate(NJetFactory_ptr p)
00265 {
00266 if(p)
00267 p -> _add_ref();
00268 return p;
00269 }
00270
00271 static inline NJetFactory_ptr
00272 _nil()
00273 {
00274 return 0;
00275 }
00276
00277 static NJetFactory_ptr _narrow(CORBA::Object_ptr);
00278 static NJetFactory_ptr _unchecked_narrow(CORBA::Object_ptr);
00279
00280 static NJetFactory_ptr _narrow(CORBA::AbstractBase_ptr);
00281 static NJetFactory_ptr _unchecked_narrow(CORBA::AbstractBase_ptr);
00282
00283 static const char** _OB_staticIds();
00284
00285
00286
00287
00288 virtual NJet_ptr makeNJet(ImageRep_ptr im,
00289 CORBA::Long N,
00290 CORBA::Double scale,
00291 CORBA::Double precision) = 0;
00292 };
00293
00294 }
00295
00296
00297
00298
00299 namespace OBProxy_HxCorba
00300 {
00301
00302
00303
00304
00305 class NJet : virtual public ::HxCorba::NJet,
00306 virtual public OBCORBA::Object
00307 {
00308 NJet(const NJet&);
00309 void operator=(const NJet&);
00310
00311 protected:
00312
00313 virtual OB::MarshalStubImpl_ptr _OB_createMarshalStubImpl();
00314
00315 public:
00316
00317 NJet() { }
00318 virtual ~NJet() { }
00319
00320 virtual const char** _OB_ids() const;
00321
00322
00323
00324
00325 CORBA::Long order();
00326
00327
00328
00329
00330 CORBA::Double scale();
00331
00332
00333
00334
00335 CORBA::Long nrComponents();
00336
00337
00338
00339
00340 CORBA::Boolean isColor();
00341
00342
00343
00344
00345 ::HxCorba::ImageRep_ptr getLidx(CORBA::Long i);
00346
00347
00348
00349
00350 ::HxCorba::ImageRep_ptr getJidx(CORBA::Long i);
00351
00352
00353
00354
00355 ::HxCorba::ImageRep_ptr getMidx(CORBA::Long i);
00356
00357
00358
00359
00360 ::HxCorba::ImageRep_ptr xy(CORBA::Long x,
00361 CORBA::Long y);
00362
00363
00364
00365
00366 ::HxCorba::ImageRep_ptr xyz(CORBA::Long x,
00367 CORBA::Long y,
00368 CORBA::Long z);
00369
00370
00371
00372
00373 ::HxCorba::ImageRep_ptr xyl(CORBA::Long x,
00374 CORBA::Long y,
00375 CORBA::Long l);
00376
00377
00378
00379
00380 ::HxCorba::ImageRep_ptr xyzl(CORBA::Long x,
00381 CORBA::Long y,
00382 CORBA::Long z,
00383 CORBA::Long l);
00384
00385
00386
00387
00388 ::HxCorba::ImageList* getLList();
00389
00390
00391
00392
00393 ::HxCorba::ImageList* getJList();
00394
00395
00396
00397
00398 ::HxCorba::ImageList* getMList();
00399
00400
00401
00402
00403 ::HxCorba::ImageList* getList();
00404
00405
00406
00407
00408 ::HxCorba::ImageRep_ptr getLw();
00409
00410
00411
00412
00413 ::HxCorba::ImageRep_ptr getJw();
00414
00415
00416
00417
00418 ::HxCorba::ImageRep_ptr getMw();
00419 };
00420
00421
00422
00423
00424 class NJetFactory : virtual public ::HxCorba::NJetFactory,
00425 virtual public OBCORBA::Object
00426 {
00427 NJetFactory(const NJetFactory&);
00428 void operator=(const NJetFactory&);
00429
00430 protected:
00431
00432 virtual OB::MarshalStubImpl_ptr _OB_createMarshalStubImpl();
00433
00434 public:
00435
00436 NJetFactory() { }
00437 virtual ~NJetFactory() { }
00438
00439 virtual const char** _OB_ids() const;
00440
00441
00442
00443
00444 ::HxCorba::NJet_ptr makeNJet(::HxCorba::ImageRep_ptr im,
00445 CORBA::Long N,
00446 CORBA::Double scale,
00447 CORBA::Double precision);
00448 };
00449
00450 }
00451
00452
00453
00454
00455 namespace OBStubImpl_HxCorba
00456 {
00457
00458
00459
00460
00461 class NJet : virtual public OB::StubImplBase
00462 {
00463 NJet(const NJet&);
00464 void operator=(const NJet&);
00465
00466 protected:
00467
00468 NJet() { }
00469
00470 public:
00471
00472 static inline NJet_ptr
00473 _duplicate(NJet_ptr p)
00474 {
00475 if(p)
00476 p -> _OB_incRef();
00477 return p;
00478 }
00479
00480 static inline NJet_ptr
00481 _nil()
00482 {
00483 return 0;
00484 }
00485
00486
00487
00488
00489 virtual CORBA::Long order() = 0;
00490
00491
00492
00493
00494 virtual CORBA::Double scale() = 0;
00495
00496
00497
00498
00499 virtual CORBA::Long nrComponents() = 0;
00500
00501
00502
00503
00504 virtual CORBA::Boolean isColor() = 0;
00505
00506
00507
00508
00509 virtual ::HxCorba::ImageRep_ptr getLidx(CORBA::Long i) = 0;
00510
00511
00512
00513
00514 virtual ::HxCorba::ImageRep_ptr getJidx(CORBA::Long i) = 0;
00515
00516
00517
00518
00519 virtual ::HxCorba::ImageRep_ptr getMidx(CORBA::Long i) = 0;
00520
00521
00522
00523
00524 virtual ::HxCorba::ImageRep_ptr xy(CORBA::Long x,
00525 CORBA::Long y) = 0;
00526
00527
00528
00529
00530 virtual ::HxCorba::ImageRep_ptr xyz(CORBA::Long x,
00531 CORBA::Long y,
00532 CORBA::Long z) = 0;
00533
00534
00535
00536
00537 virtual ::HxCorba::ImageRep_ptr xyl(CORBA::Long x,
00538 CORBA::Long y,
00539 CORBA::Long l) = 0;
00540
00541
00542
00543
00544 virtual ::HxCorba::ImageRep_ptr xyzl(CORBA::Long x,
00545 CORBA::Long y,
00546 CORBA::Long z,
00547 CORBA::Long l) = 0;
00548
00549
00550
00551
00552 virtual ::HxCorba::ImageList* getLList() = 0;
00553
00554
00555
00556
00557 virtual ::HxCorba::ImageList* getJList() = 0;
00558
00559
00560
00561
00562 virtual ::HxCorba::ImageList* getMList() = 0;
00563
00564
00565
00566
00567 virtual ::HxCorba::ImageList* getList() = 0;
00568
00569
00570
00571
00572 virtual ::HxCorba::ImageRep_ptr getLw() = 0;
00573
00574
00575
00576
00577 virtual ::HxCorba::ImageRep_ptr getJw() = 0;
00578
00579
00580
00581
00582 virtual ::HxCorba::ImageRep_ptr getMw() = 0;
00583 };
00584
00585
00586
00587
00588 class NJetFactory : virtual public OB::StubImplBase
00589 {
00590 NJetFactory(const NJetFactory&);
00591 void operator=(const NJetFactory&);
00592
00593 protected:
00594
00595 NJetFactory() { }
00596
00597 public:
00598
00599 static inline NJetFactory_ptr
00600 _duplicate(NJetFactory_ptr p)
00601 {
00602 if(p)
00603 p -> _OB_incRef();
00604 return p;
00605 }
00606
00607 static inline NJetFactory_ptr
00608 _nil()
00609 {
00610 return 0;
00611 }
00612
00613
00614
00615
00616 virtual ::HxCorba::NJet_ptr makeNJet(::HxCorba::ImageRep_ptr im,
00617 CORBA::Long N,
00618 CORBA::Double scale,
00619 CORBA::Double precision) = 0;
00620 };
00621
00622 }
00623
00624
00625
00626
00627 namespace OBMarshalStubImpl_HxCorba
00628 {
00629
00630
00631
00632
00633 class NJet : virtual public OBStubImpl_HxCorba::NJet,
00634 virtual public OB::MarshalStubImpl
00635 {
00636 NJet(const NJet&);
00637 void operator=(const NJet&);
00638
00639 protected:
00640
00641 NJet() { }
00642 friend class OBProxy_HxCorba::NJet;
00643
00644 public:
00645
00646
00647
00648
00649 virtual CORBA::Long order();
00650
00651
00652
00653
00654 virtual CORBA::Double scale();
00655
00656
00657
00658
00659 virtual CORBA::Long nrComponents();
00660
00661
00662
00663
00664 virtual CORBA::Boolean isColor();
00665
00666
00667
00668
00669 virtual ::HxCorba::ImageRep_ptr getLidx(CORBA::Long i);
00670
00671
00672
00673
00674 virtual ::HxCorba::ImageRep_ptr getJidx(CORBA::Long i);
00675
00676
00677
00678
00679 virtual ::HxCorba::ImageRep_ptr getMidx(CORBA::Long i);
00680
00681
00682
00683
00684 virtual ::HxCorba::ImageRep_ptr xy(CORBA::Long x,
00685 CORBA::Long y);
00686
00687
00688
00689
00690 virtual ::HxCorba::ImageRep_ptr xyz(CORBA::Long x,
00691 CORBA::Long y,
00692 CORBA::Long z);
00693
00694
00695
00696
00697 virtual ::HxCorba::ImageRep_ptr xyl(CORBA::Long x,
00698 CORBA::Long y,
00699 CORBA::Long l);
00700
00701
00702
00703
00704 virtual ::HxCorba::ImageRep_ptr xyzl(CORBA::Long x,
00705 CORBA::Long y,
00706 CORBA::Long z,
00707 CORBA::Long l);
00708
00709
00710
00711
00712 virtual ::HxCorba::ImageList* getLList();
00713
00714
00715
00716
00717 virtual ::HxCorba::ImageList* getJList();
00718
00719
00720
00721
00722 virtual ::HxCorba::ImageList* getMList();
00723
00724
00725
00726
00727 virtual ::HxCorba::ImageList* getList();
00728
00729
00730
00731
00732 virtual ::HxCorba::ImageRep_ptr getLw();
00733
00734
00735
00736
00737 virtual ::HxCorba::ImageRep_ptr getJw();
00738
00739
00740
00741
00742 virtual ::HxCorba::ImageRep_ptr getMw();
00743 };
00744
00745
00746
00747
00748 class NJetFactory : virtual public OBStubImpl_HxCorba::NJetFactory,
00749 virtual public OB::MarshalStubImpl
00750 {
00751 NJetFactory(const NJetFactory&);
00752 void operator=(const NJetFactory&);
00753
00754 protected:
00755
00756 NJetFactory() { }
00757 friend class OBProxy_HxCorba::NJetFactory;
00758
00759 public:
00760
00761
00762
00763
00764 virtual ::HxCorba::NJet_ptr makeNJet(::HxCorba::ImageRep_ptr im,
00765 CORBA::Long N,
00766 CORBA::Double scale,
00767 CORBA::Double precision);
00768 };
00769
00770 }
00771
00772
00773
00774
00775 namespace OBV_HxCorba
00776 {
00777
00778 }
00779
00780
00781
00782
00783 namespace CORBA
00784 {
00785
00786 inline void
00787 release(::HxCorba::NJet_ptr p)
00788 {
00789 if(p)
00790 p -> _remove_ref();
00791 }
00792
00793 inline Boolean
00794 is_nil(::HxCorba::NJet_ptr p)
00795 {
00796 return p == 0;
00797 }
00798
00799 inline void
00800 release(OBStubImpl_HxCorba::NJet_ptr p)
00801 {
00802 if(p)
00803 p -> _OB_decRef();
00804 }
00805
00806 inline Boolean
00807 is_nil(OBStubImpl_HxCorba::NJet_ptr p)
00808 {
00809 return p == 0;
00810 }
00811
00812 }
00813
00814 void operator<<=(CORBA::Any&, HxCorba::NJet_ptr*);
00815 void operator<<=(CORBA::Any&, HxCorba::NJet_ptr);
00816 CORBA::Boolean operator>>=(const CORBA::Any&, HxCorba::NJet_ptr&);
00817
00818 inline void
00819 operator<<=(CORBA::Any_var& any, HxCorba::NJet_ptr* val)
00820 {
00821 any.inout() <<= val;
00822 }
00823
00824 inline void
00825 operator<<=(CORBA::Any_var& any, HxCorba::NJet_ptr val)
00826 {
00827 any.inout() <<= val;
00828 }
00829
00830 inline CORBA::Boolean
00831 operator>>=(const CORBA::Any_var& any, HxCorba::NJet_ptr& val)
00832 {
00833 return any.in() >>= val;
00834 }
00835
00836
00837
00838
00839 namespace CORBA
00840 {
00841
00842 inline void
00843 release(::HxCorba::NJetFactory_ptr p)
00844 {
00845 if(p)
00846 p -> _remove_ref();
00847 }
00848
00849 inline Boolean
00850 is_nil(::HxCorba::NJetFactory_ptr p)
00851 {
00852 return p == 0;
00853 }
00854
00855 inline void
00856 release(OBStubImpl_HxCorba::NJetFactory_ptr p)
00857 {
00858 if(p)
00859 p -> _OB_decRef();
00860 }
00861
00862 inline Boolean
00863 is_nil(OBStubImpl_HxCorba::NJetFactory_ptr p)
00864 {
00865 return p == 0;
00866 }
00867
00868 }
00869
00870 void operator<<=(CORBA::Any&, HxCorba::NJetFactory_ptr*);
00871 void operator<<=(CORBA::Any&, HxCorba::NJetFactory_ptr);
00872 CORBA::Boolean operator>>=(const CORBA::Any&, HxCorba::NJetFactory_ptr&);
00873
00874 inline void
00875 operator<<=(CORBA::Any_var& any, HxCorba::NJetFactory_ptr* val)
00876 {
00877 any.inout() <<= val;
00878 }
00879
00880 inline void
00881 operator<<=(CORBA::Any_var& any, HxCorba::NJetFactory_ptr val)
00882 {
00883 any.inout() <<= val;
00884 }
00885
00886 inline CORBA::Boolean
00887 operator>>=(const CORBA::Any_var& any, HxCorba::NJetFactory_ptr& val)
00888 {
00889 return any.in() >>= val;
00890 }
00891
00892 #endif