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 != 4000500L)
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 static const char* ids_[];
00111
00112 protected:
00113
00114 virtual OB::MarshalStubImpl_ptr _OB_createMarshalStubImpl();
00115
00116 public:
00117
00118 NJet() { }
00119 virtual ~NJet() { }
00120
00121 typedef NJet_ptr _ptr_type;
00122 typedef NJet_var _var_type;
00123
00124 static inline NJet_ptr
00125 _duplicate(NJet_ptr p)
00126 {
00127 if(p)
00128 p -> _OB_incRef();
00129 return p;
00130 }
00131
00132 static inline NJet_ptr
00133 _nil()
00134 {
00135 return 0;
00136 }
00137
00138 static NJet_ptr _narrow(CORBA::Object_ptr);
00139 static NJet_ptr _narrow(CORBA::AbstractBase_ptr);
00140
00141 virtual const char** _OB_ids() const;
00142 static const char** _OB_staticIds();
00143
00144
00145
00146
00147 CORBA::Long order();
00148
00149
00150
00151
00152 CORBA::Double scale();
00153
00154
00155
00156
00157 CORBA::Long nrComponents();
00158
00159
00160
00161
00162 CORBA::Boolean isColor();
00163
00164
00165
00166
00167 ImageRep_ptr getLidx(CORBA::Long i);
00168
00169
00170
00171
00172 ImageRep_ptr getJidx(CORBA::Long i);
00173
00174
00175
00176
00177 ImageRep_ptr getMidx(CORBA::Long i);
00178
00179
00180
00181
00182 ImageRep_ptr xy(CORBA::Long x,
00183 CORBA::Long y);
00184
00185
00186
00187
00188 ImageRep_ptr xyz(CORBA::Long x,
00189 CORBA::Long y,
00190 CORBA::Long z);
00191
00192
00193
00194
00195 ImageRep_ptr xyl(CORBA::Long x,
00196 CORBA::Long y,
00197 CORBA::Long l);
00198
00199
00200
00201
00202 ImageRep_ptr xyzl(CORBA::Long x,
00203 CORBA::Long y,
00204 CORBA::Long z,
00205 CORBA::Long l);
00206
00207
00208
00209
00210 ImageList* getLList();
00211
00212
00213
00214
00215 ImageList* getJList();
00216
00217
00218
00219
00220 ImageList* getMList();
00221
00222
00223
00224
00225 ImageList* getList();
00226
00227
00228
00229
00230 ImageRep_ptr getLw();
00231
00232
00233
00234
00235 ImageRep_ptr getJw();
00236
00237
00238
00239
00240 ImageRep_ptr getMw();
00241 };
00242
00243
00244
00245
00246 class NJetFactory : virtual public CORBA::Object
00247 {
00248 NJetFactory(const NJetFactory&);
00249 void operator=(const NJetFactory&);
00250
00251 static const char* ids_[];
00252
00253 protected:
00254
00255 virtual OB::MarshalStubImpl_ptr _OB_createMarshalStubImpl();
00256
00257 public:
00258
00259 NJetFactory() { }
00260 virtual ~NJetFactory() { }
00261
00262 typedef NJetFactory_ptr _ptr_type;
00263 typedef NJetFactory_var _var_type;
00264
00265 static inline NJetFactory_ptr
00266 _duplicate(NJetFactory_ptr p)
00267 {
00268 if(p)
00269 p -> _OB_incRef();
00270 return p;
00271 }
00272
00273 static inline NJetFactory_ptr
00274 _nil()
00275 {
00276 return 0;
00277 }
00278
00279 static NJetFactory_ptr _narrow(CORBA::Object_ptr);
00280 static NJetFactory_ptr _narrow(CORBA::AbstractBase_ptr);
00281
00282 virtual const char** _OB_ids() const;
00283 static const char** _OB_staticIds();
00284
00285
00286
00287
00288 NJet_ptr makeNJet(ImageRep_ptr im,
00289 CORBA::Long N,
00290 CORBA::Double scale,
00291 CORBA::Double precision);
00292 };
00293
00294 }
00295
00296
00297
00298
00299 namespace OBStubImpl_HxCorba
00300 {
00301
00302
00303
00304
00305 class NJet : virtual public OB::StubImplBase
00306 {
00307 NJet(const NJet&);
00308 void operator=(const NJet&);
00309
00310 protected:
00311
00312 NJet() { }
00313
00314 public:
00315
00316 static inline NJet_ptr
00317 _duplicate(NJet_ptr p)
00318 {
00319 if(p)
00320 p -> _OB_incRef();
00321 return p;
00322 }
00323
00324 static inline NJet_ptr
00325 _nil()
00326 {
00327 return 0;
00328 }
00329
00330
00331
00332
00333 virtual CORBA::Long order() = 0;
00334
00335
00336
00337
00338 virtual CORBA::Double scale() = 0;
00339
00340
00341
00342
00343 virtual CORBA::Long nrComponents() = 0;
00344
00345
00346
00347
00348 virtual CORBA::Boolean isColor() = 0;
00349
00350
00351
00352
00353 virtual HxCorba::ImageRep_ptr getLidx(CORBA::Long i) = 0;
00354
00355
00356
00357
00358 virtual HxCorba::ImageRep_ptr getJidx(CORBA::Long i) = 0;
00359
00360
00361
00362
00363 virtual HxCorba::ImageRep_ptr getMidx(CORBA::Long i) = 0;
00364
00365
00366
00367
00368 virtual HxCorba::ImageRep_ptr xy(CORBA::Long x,
00369 CORBA::Long y) = 0;
00370
00371
00372
00373
00374 virtual HxCorba::ImageRep_ptr xyz(CORBA::Long x,
00375 CORBA::Long y,
00376 CORBA::Long z) = 0;
00377
00378
00379
00380
00381 virtual HxCorba::ImageRep_ptr xyl(CORBA::Long x,
00382 CORBA::Long y,
00383 CORBA::Long l) = 0;
00384
00385
00386
00387
00388 virtual HxCorba::ImageRep_ptr xyzl(CORBA::Long x,
00389 CORBA::Long y,
00390 CORBA::Long z,
00391 CORBA::Long l) = 0;
00392
00393
00394
00395
00396 virtual HxCorba::ImageList* getLList() = 0;
00397
00398
00399
00400
00401 virtual HxCorba::ImageList* getJList() = 0;
00402
00403
00404
00405
00406 virtual HxCorba::ImageList* getMList() = 0;
00407
00408
00409
00410
00411 virtual HxCorba::ImageList* getList() = 0;
00412
00413
00414
00415
00416 virtual HxCorba::ImageRep_ptr getLw() = 0;
00417
00418
00419
00420
00421 virtual HxCorba::ImageRep_ptr getJw() = 0;
00422
00423
00424
00425
00426 virtual HxCorba::ImageRep_ptr getMw() = 0;
00427 };
00428
00429
00430
00431
00432 class NJetFactory : virtual public OB::StubImplBase
00433 {
00434 NJetFactory(const NJetFactory&);
00435 void operator=(const NJetFactory&);
00436
00437 protected:
00438
00439 NJetFactory() { }
00440
00441 public:
00442
00443 static inline NJetFactory_ptr
00444 _duplicate(NJetFactory_ptr p)
00445 {
00446 if(p)
00447 p -> _OB_incRef();
00448 return p;
00449 }
00450
00451 static inline NJetFactory_ptr
00452 _nil()
00453 {
00454 return 0;
00455 }
00456
00457
00458
00459
00460 virtual HxCorba::NJet_ptr makeNJet(HxCorba::ImageRep_ptr im,
00461 CORBA::Long N,
00462 CORBA::Double scale,
00463 CORBA::Double precision) = 0;
00464 };
00465
00466 }
00467
00468
00469
00470
00471 namespace OBMarshalStubImpl_HxCorba
00472 {
00473
00474
00475
00476
00477 class NJet : virtual public OBStubImpl_HxCorba::NJet,
00478 virtual public OB::MarshalStubImpl
00479 {
00480 NJet(const NJet&);
00481 void operator=(const NJet&);
00482
00483 protected:
00484
00485 NJet() { }
00486 friend class HxCorba::NJet;
00487
00488 public:
00489
00490
00491
00492
00493 virtual CORBA::Long order();
00494
00495
00496
00497
00498 virtual CORBA::Double scale();
00499
00500
00501
00502
00503 virtual CORBA::Long nrComponents();
00504
00505
00506
00507
00508 virtual CORBA::Boolean isColor();
00509
00510
00511
00512
00513 virtual HxCorba::ImageRep_ptr getLidx(CORBA::Long i);
00514
00515
00516
00517
00518 virtual HxCorba::ImageRep_ptr getJidx(CORBA::Long i);
00519
00520
00521
00522
00523 virtual HxCorba::ImageRep_ptr getMidx(CORBA::Long i);
00524
00525
00526
00527
00528 virtual HxCorba::ImageRep_ptr xy(CORBA::Long x,
00529 CORBA::Long y);
00530
00531
00532
00533
00534 virtual HxCorba::ImageRep_ptr xyz(CORBA::Long x,
00535 CORBA::Long y,
00536 CORBA::Long z);
00537
00538
00539
00540
00541 virtual HxCorba::ImageRep_ptr xyl(CORBA::Long x,
00542 CORBA::Long y,
00543 CORBA::Long l);
00544
00545
00546
00547
00548 virtual HxCorba::ImageRep_ptr xyzl(CORBA::Long x,
00549 CORBA::Long y,
00550 CORBA::Long z,
00551 CORBA::Long l);
00552
00553
00554
00555
00556 virtual HxCorba::ImageList* getLList();
00557
00558
00559
00560
00561 virtual HxCorba::ImageList* getJList();
00562
00563
00564
00565
00566 virtual HxCorba::ImageList* getMList();
00567
00568
00569
00570
00571 virtual HxCorba::ImageList* getList();
00572
00573
00574
00575
00576 virtual HxCorba::ImageRep_ptr getLw();
00577
00578
00579
00580
00581 virtual HxCorba::ImageRep_ptr getJw();
00582
00583
00584
00585
00586 virtual HxCorba::ImageRep_ptr getMw();
00587 };
00588
00589
00590
00591
00592 class NJetFactory : virtual public OBStubImpl_HxCorba::NJetFactory,
00593 virtual public OB::MarshalStubImpl
00594 {
00595 NJetFactory(const NJetFactory&);
00596 void operator=(const NJetFactory&);
00597
00598 protected:
00599
00600 NJetFactory() { }
00601 friend class HxCorba::NJetFactory;
00602
00603 public:
00604
00605
00606
00607
00608 virtual HxCorba::NJet_ptr makeNJet(HxCorba::ImageRep_ptr im,
00609 CORBA::Long N,
00610 CORBA::Double scale,
00611 CORBA::Double precision);
00612 };
00613
00614 }
00615
00616
00617
00618
00619 namespace OBV_HxCorba
00620 {
00621
00622 }
00623
00624
00625
00626
00627 namespace CORBA
00628 {
00629
00630 inline void
00631 release(HxCorba::NJet_ptr p)
00632 {
00633 if(p)
00634 p -> _OB_decRef();
00635 }
00636
00637 inline Boolean
00638 is_nil(HxCorba::NJet_ptr p)
00639 {
00640 return p == 0;
00641 }
00642
00643 inline void
00644 release(OBStubImpl_HxCorba::NJet_ptr p)
00645 {
00646 if(p)
00647 p -> _OB_decRef();
00648 }
00649
00650 inline Boolean
00651 is_nil(OBStubImpl_HxCorba::NJet_ptr p)
00652 {
00653 return p == 0;
00654 }
00655
00656 }
00657
00658 void operator<<=(CORBA::Any&, HxCorba::NJet_ptr*);
00659 void operator<<=(CORBA::Any&, HxCorba::NJet_ptr);
00660 CORBA::Boolean operator>>=(const CORBA::Any&, HxCorba::NJet_ptr&);
00661
00662 inline void
00663 operator<<=(CORBA::Any_var& any, HxCorba::NJet_ptr* val)
00664 {
00665 any.inout() <<= val;
00666 }
00667
00668 inline void
00669 operator<<=(CORBA::Any_var& any, HxCorba::NJet_ptr val)
00670 {
00671 any.inout() <<= val;
00672 }
00673
00674 inline CORBA::Boolean
00675 operator>>=(const CORBA::Any_var& any, HxCorba::NJet_ptr& val)
00676 {
00677 return any.in() >>= val;
00678 }
00679
00680
00681
00682
00683 namespace CORBA
00684 {
00685
00686 inline void
00687 release(HxCorba::NJetFactory_ptr p)
00688 {
00689 if(p)
00690 p -> _OB_decRef();
00691 }
00692
00693 inline Boolean
00694 is_nil(HxCorba::NJetFactory_ptr p)
00695 {
00696 return p == 0;
00697 }
00698
00699 inline void
00700 release(OBStubImpl_HxCorba::NJetFactory_ptr p)
00701 {
00702 if(p)
00703 p -> _OB_decRef();
00704 }
00705
00706 inline Boolean
00707 is_nil(OBStubImpl_HxCorba::NJetFactory_ptr p)
00708 {
00709 return p == 0;
00710 }
00711
00712 }
00713
00714 void operator<<=(CORBA::Any&, HxCorba::NJetFactory_ptr*);
00715 void operator<<=(CORBA::Any&, HxCorba::NJetFactory_ptr);
00716 CORBA::Boolean operator>>=(const CORBA::Any&, HxCorba::NJetFactory_ptr&);
00717
00718 inline void
00719 operator<<=(CORBA::Any_var& any, HxCorba::NJetFactory_ptr* val)
00720 {
00721 any.inout() <<= val;
00722 }
00723
00724 inline void
00725 operator<<=(CORBA::Any_var& any, HxCorba::NJetFactory_ptr val)
00726 {
00727 any.inout() <<= val;
00728 }
00729
00730 inline CORBA::Boolean
00731 operator>>=(const CORBA::Any_var& any, HxCorba::NJetFactory_ptr& val)
00732 {
00733 return any.in() >>= val;
00734 }
00735
00736 #endif