00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015 #ifndef ___HxCorbaTagList_h__
00016 #define ___HxCorbaTagList_h__
00017
00018 #include <HxCorbaPixValue.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 TagList;
00034 typedef TagList* TagList_ptr;
00035 typedef TagList* TagListRef;
00036
00037 extern OB::TypeCodeConst _tc_TagList;
00038
00039 class TagListFactory;
00040 typedef TagListFactory* TagListFactory_ptr;
00041 typedef TagListFactory* TagListFactoryRef;
00042
00043 extern OB::TypeCodeConst _tc_TagListFactory;
00044
00045 }
00046
00047 void OBDuplicate(HxCorba::TagList_ptr);
00048 void OBRelease(HxCorba::TagList_ptr);
00049
00050 void OBMarshal(HxCorba::TagList_ptr, OB::OutputStreamImpl*);
00051 void OBUnmarshal(HxCorba::TagList_ptr&, OB::InputStreamImpl*);
00052
00053 void OBDuplicate(HxCorba::TagListFactory_ptr);
00054 void OBRelease(HxCorba::TagListFactory_ptr);
00055
00056 void OBMarshal(HxCorba::TagListFactory_ptr, OB::OutputStreamImpl*);
00057 void OBUnmarshal(HxCorba::TagListFactory_ptr&, OB::InputStreamImpl*);
00058
00059 namespace HxCorba
00060 {
00061
00062 typedef OB::ObjVar< TagList > TagList_var;
00063 typedef OB::ObjOut< TagList > TagList_out;
00064
00065 typedef OB::ObjVar< TagListFactory > TagListFactory_var;
00066 typedef OB::ObjOut< TagListFactory > TagListFactory_out;
00067
00068 }
00069
00070 namespace OBStubImpl_HxCorba
00071 {
00072
00073 class TagList;
00074 typedef TagList* TagList_ptr;
00075
00076 class TagListFactory;
00077 typedef TagListFactory* TagListFactory_ptr;
00078
00079 }
00080
00081 void OBDuplicate(OBStubImpl_HxCorba::TagList_ptr);
00082 void OBRelease(OBStubImpl_HxCorba::TagList_ptr);
00083
00084 void OBDuplicate(OBStubImpl_HxCorba::TagListFactory_ptr);
00085 void OBRelease(OBStubImpl_HxCorba::TagListFactory_ptr);
00086
00087 namespace OBStubImpl_HxCorba
00088 {
00089
00090 typedef OB::ObjVar< TagList > TagList_var;
00091
00092 typedef OB::ObjVar< TagListFactory > TagListFactory_var;
00093
00094 }
00095
00096
00097
00098
00099 namespace HxCorba
00100 {
00101
00102
00103
00104
00105 class TagList : virtual public CORBA::Object
00106 {
00107 TagList(const TagList&);
00108 void operator=(const TagList&);
00109
00110 protected:
00111
00112 static const char* ids_[];
00113
00114 public:
00115
00116 TagList() { }
00117 virtual ~TagList() { }
00118
00119 typedef TagList_ptr _ptr_type;
00120 typedef TagList_var _var_type;
00121
00122 static inline TagList_ptr
00123 _duplicate(TagList_ptr p)
00124 {
00125 if(p)
00126 p -> _add_ref();
00127 return p;
00128 }
00129
00130 static inline TagList_ptr
00131 _nil()
00132 {
00133 return 0;
00134 }
00135
00136 static TagList_ptr _narrow(CORBA::Object_ptr);
00137 static TagList_ptr _unchecked_narrow(CORBA::Object_ptr);
00138
00139 static TagList_ptr _narrow(CORBA::AbstractBase_ptr);
00140 static TagList_ptr _unchecked_narrow(CORBA::AbstractBase_ptr);
00141
00142 static const char** _OB_staticIds();
00143
00144
00145
00146
00147 virtual void addInt(const char* name,
00148 CORBA::Long val) = 0;
00149
00150
00151
00152
00153 virtual CORBA::Long getInt(const char* name) = 0;
00154
00155
00156
00157
00158 virtual void addFloat(const char* name,
00159 CORBA::Double val) = 0;
00160
00161
00162
00163
00164 virtual CORBA::Double getFloat(const char* name) = 0;
00165
00166
00167
00168
00169 virtual void addValue(const char* name,
00170 const PixValue& val) = 0;
00171
00172
00173
00174
00175 virtual PixValue getValue(const char* name) = 0;
00176 };
00177
00178
00179
00180
00181 class TagListFactory : virtual public CORBA::Object
00182 {
00183 TagListFactory(const TagListFactory&);
00184 void operator=(const TagListFactory&);
00185
00186 protected:
00187
00188 static const char* ids_[];
00189
00190 public:
00191
00192 TagListFactory() { }
00193 virtual ~TagListFactory() { }
00194
00195 typedef TagListFactory_ptr _ptr_type;
00196 typedef TagListFactory_var _var_type;
00197
00198 static inline TagListFactory_ptr
00199 _duplicate(TagListFactory_ptr p)
00200 {
00201 if(p)
00202 p -> _add_ref();
00203 return p;
00204 }
00205
00206 static inline TagListFactory_ptr
00207 _nil()
00208 {
00209 return 0;
00210 }
00211
00212 static TagListFactory_ptr _narrow(CORBA::Object_ptr);
00213 static TagListFactory_ptr _unchecked_narrow(CORBA::Object_ptr);
00214
00215 static TagListFactory_ptr _narrow(CORBA::AbstractBase_ptr);
00216 static TagListFactory_ptr _unchecked_narrow(CORBA::AbstractBase_ptr);
00217
00218 static const char** _OB_staticIds();
00219
00220
00221
00222
00223 virtual TagList_ptr emptyTagList() = 0;
00224
00225
00226
00227
00228 virtual TagList_ptr simpleIntTag(const char* name,
00229 CORBA::Long val) = 0;
00230
00231
00232
00233
00234 virtual TagList_ptr simpleFloatTag(const char* name,
00235 CORBA::Double val) = 0;
00236 };
00237
00238 }
00239
00240
00241
00242
00243 namespace OBProxy_HxCorba
00244 {
00245
00246
00247
00248
00249 class TagList : virtual public ::HxCorba::TagList,
00250 virtual public OBCORBA::Object
00251 {
00252 TagList(const TagList&);
00253 void operator=(const TagList&);
00254
00255 protected:
00256
00257 virtual OB::MarshalStubImpl_ptr _OB_createMarshalStubImpl();
00258
00259 public:
00260
00261 TagList() { }
00262 virtual ~TagList() { }
00263
00264 virtual const char** _OB_ids() const;
00265
00266
00267
00268
00269 void addInt(const char* name,
00270 CORBA::Long val);
00271
00272
00273
00274
00275 CORBA::Long getInt(const char* name);
00276
00277
00278
00279
00280 void addFloat(const char* name,
00281 CORBA::Double val);
00282
00283
00284
00285
00286 CORBA::Double getFloat(const char* name);
00287
00288
00289
00290
00291 void addValue(const char* name,
00292 const ::HxCorba::PixValue& val);
00293
00294
00295
00296
00297 ::HxCorba::PixValue getValue(const char* name);
00298 };
00299
00300
00301
00302
00303 class TagListFactory : virtual public ::HxCorba::TagListFactory,
00304 virtual public OBCORBA::Object
00305 {
00306 TagListFactory(const TagListFactory&);
00307 void operator=(const TagListFactory&);
00308
00309 protected:
00310
00311 virtual OB::MarshalStubImpl_ptr _OB_createMarshalStubImpl();
00312
00313 public:
00314
00315 TagListFactory() { }
00316 virtual ~TagListFactory() { }
00317
00318 virtual const char** _OB_ids() const;
00319
00320
00321
00322
00323 ::HxCorba::TagList_ptr emptyTagList();
00324
00325
00326
00327
00328 ::HxCorba::TagList_ptr simpleIntTag(const char* name,
00329 CORBA::Long val);
00330
00331
00332
00333
00334 ::HxCorba::TagList_ptr simpleFloatTag(const char* name,
00335 CORBA::Double val);
00336 };
00337
00338 }
00339
00340
00341
00342
00343 namespace OBStubImpl_HxCorba
00344 {
00345
00346
00347
00348
00349 class TagList : virtual public OB::StubImplBase
00350 {
00351 TagList(const TagList&);
00352 void operator=(const TagList&);
00353
00354 protected:
00355
00356 TagList() { }
00357
00358 public:
00359
00360 static inline TagList_ptr
00361 _duplicate(TagList_ptr p)
00362 {
00363 if(p)
00364 p -> _OB_incRef();
00365 return p;
00366 }
00367
00368 static inline TagList_ptr
00369 _nil()
00370 {
00371 return 0;
00372 }
00373
00374
00375
00376
00377 virtual void addInt(const char* name,
00378 CORBA::Long val) = 0;
00379
00380
00381
00382
00383 virtual CORBA::Long getInt(const char* name) = 0;
00384
00385
00386
00387
00388 virtual void addFloat(const char* name,
00389 CORBA::Double val) = 0;
00390
00391
00392
00393
00394 virtual CORBA::Double getFloat(const char* name) = 0;
00395
00396
00397
00398
00399 virtual void addValue(const char* name,
00400 const ::HxCorba::PixValue& val) = 0;
00401
00402
00403
00404
00405 virtual ::HxCorba::PixValue getValue(const char* name) = 0;
00406 };
00407
00408
00409
00410
00411 class TagListFactory : virtual public OB::StubImplBase
00412 {
00413 TagListFactory(const TagListFactory&);
00414 void operator=(const TagListFactory&);
00415
00416 protected:
00417
00418 TagListFactory() { }
00419
00420 public:
00421
00422 static inline TagListFactory_ptr
00423 _duplicate(TagListFactory_ptr p)
00424 {
00425 if(p)
00426 p -> _OB_incRef();
00427 return p;
00428 }
00429
00430 static inline TagListFactory_ptr
00431 _nil()
00432 {
00433 return 0;
00434 }
00435
00436
00437
00438
00439 virtual ::HxCorba::TagList_ptr emptyTagList() = 0;
00440
00441
00442
00443
00444 virtual ::HxCorba::TagList_ptr simpleIntTag(const char* name,
00445 CORBA::Long val) = 0;
00446
00447
00448
00449
00450 virtual ::HxCorba::TagList_ptr simpleFloatTag(const char* name,
00451 CORBA::Double val) = 0;
00452 };
00453
00454 }
00455
00456
00457
00458
00459 namespace OBMarshalStubImpl_HxCorba
00460 {
00461
00462
00463
00464
00465 class TagList : virtual public OBStubImpl_HxCorba::TagList,
00466 virtual public OB::MarshalStubImpl
00467 {
00468 TagList(const TagList&);
00469 void operator=(const TagList&);
00470
00471 protected:
00472
00473 TagList() { }
00474 friend class OBProxy_HxCorba::TagList;
00475
00476 public:
00477
00478
00479
00480
00481 virtual void addInt(const char* name,
00482 CORBA::Long val);
00483
00484
00485
00486
00487 virtual CORBA::Long getInt(const char* name);
00488
00489
00490
00491
00492 virtual void addFloat(const char* name,
00493 CORBA::Double val);
00494
00495
00496
00497
00498 virtual CORBA::Double getFloat(const char* name);
00499
00500
00501
00502
00503 virtual void addValue(const char* name,
00504 const ::HxCorba::PixValue& val);
00505
00506
00507
00508
00509 virtual ::HxCorba::PixValue getValue(const char* name);
00510 };
00511
00512
00513
00514
00515 class TagListFactory : virtual public OBStubImpl_HxCorba::TagListFactory,
00516 virtual public OB::MarshalStubImpl
00517 {
00518 TagListFactory(const TagListFactory&);
00519 void operator=(const TagListFactory&);
00520
00521 protected:
00522
00523 TagListFactory() { }
00524 friend class OBProxy_HxCorba::TagListFactory;
00525
00526 public:
00527
00528
00529
00530
00531 virtual ::HxCorba::TagList_ptr emptyTagList();
00532
00533
00534
00535
00536 virtual ::HxCorba::TagList_ptr simpleIntTag(const char* name,
00537 CORBA::Long val);
00538
00539
00540
00541
00542 virtual ::HxCorba::TagList_ptr simpleFloatTag(const char* name,
00543 CORBA::Double val);
00544 };
00545
00546 }
00547
00548
00549
00550
00551 namespace OBV_HxCorba
00552 {
00553
00554 }
00555
00556
00557
00558
00559 namespace CORBA
00560 {
00561
00562 inline void
00563 release(::HxCorba::TagList_ptr p)
00564 {
00565 if(p)
00566 p -> _remove_ref();
00567 }
00568
00569 inline Boolean
00570 is_nil(::HxCorba::TagList_ptr p)
00571 {
00572 return p == 0;
00573 }
00574
00575 inline void
00576 release(OBStubImpl_HxCorba::TagList_ptr p)
00577 {
00578 if(p)
00579 p -> _OB_decRef();
00580 }
00581
00582 inline Boolean
00583 is_nil(OBStubImpl_HxCorba::TagList_ptr p)
00584 {
00585 return p == 0;
00586 }
00587
00588 }
00589
00590 void operator<<=(CORBA::Any&, HxCorba::TagList_ptr*);
00591 void operator<<=(CORBA::Any&, HxCorba::TagList_ptr);
00592 CORBA::Boolean operator>>=(const CORBA::Any&, HxCorba::TagList_ptr&);
00593
00594 inline void
00595 operator<<=(CORBA::Any_var& any, HxCorba::TagList_ptr* val)
00596 {
00597 any.inout() <<= val;
00598 }
00599
00600 inline void
00601 operator<<=(CORBA::Any_var& any, HxCorba::TagList_ptr val)
00602 {
00603 any.inout() <<= val;
00604 }
00605
00606 inline CORBA::Boolean
00607 operator>>=(const CORBA::Any_var& any, HxCorba::TagList_ptr& val)
00608 {
00609 return any.in() >>= val;
00610 }
00611
00612
00613
00614
00615 namespace CORBA
00616 {
00617
00618 inline void
00619 release(::HxCorba::TagListFactory_ptr p)
00620 {
00621 if(p)
00622 p -> _remove_ref();
00623 }
00624
00625 inline Boolean
00626 is_nil(::HxCorba::TagListFactory_ptr p)
00627 {
00628 return p == 0;
00629 }
00630
00631 inline void
00632 release(OBStubImpl_HxCorba::TagListFactory_ptr p)
00633 {
00634 if(p)
00635 p -> _OB_decRef();
00636 }
00637
00638 inline Boolean
00639 is_nil(OBStubImpl_HxCorba::TagListFactory_ptr p)
00640 {
00641 return p == 0;
00642 }
00643
00644 }
00645
00646 void operator<<=(CORBA::Any&, HxCorba::TagListFactory_ptr*);
00647 void operator<<=(CORBA::Any&, HxCorba::TagListFactory_ptr);
00648 CORBA::Boolean operator>>=(const CORBA::Any&, HxCorba::TagListFactory_ptr&);
00649
00650 inline void
00651 operator<<=(CORBA::Any_var& any, HxCorba::TagListFactory_ptr* val)
00652 {
00653 any.inout() <<= val;
00654 }
00655
00656 inline void
00657 operator<<=(CORBA::Any_var& any, HxCorba::TagListFactory_ptr val)
00658 {
00659 any.inout() <<= val;
00660 }
00661
00662 inline CORBA::Boolean
00663 operator>>=(const CORBA::Any_var& any, HxCorba::TagListFactory_ptr& val)
00664 {
00665 return any.in() >>= val;
00666 }
00667
00668 #endif