00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015 #ifndef ___HxCorbaHistogram_tie_h__
00016 #define ___HxCorbaHistogram_tie_h__
00017
00018 #include <HxCorbaHistogram_skel.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
00031
00032
00033 namespace POA_HxCorba
00034 {
00035
00036
00037
00038
00039 template<class T>
00040 class HistogramData_tie : virtual public HistogramData
00041 {
00042 T* ptr_;
00043 PortableServer::POA_ptr poa_;
00044 CORBA::Boolean rel_;
00045
00046 HistogramData_tie(const HistogramData_tie<T>&) { }
00047 void operator=(const HistogramData_tie<T>&) { }
00048
00049 public:
00050
00051 HistogramData_tie(T& t)
00052 : ptr_(&t), poa_(PortableServer::POA::_nil()), rel_(false)
00053 {
00054 }
00055
00056 HistogramData_tie(T& t, PortableServer::POA_ptr poa)
00057 : ptr_(&t), poa_(PortableServer::POA::_duplicate(poa)), rel_(false)
00058 {
00059 }
00060
00061 HistogramData_tie(T* p, CORBA::Boolean release = true)
00062 : ptr_(p), poa_(PortableServer::POA::_nil()), rel_(release)
00063 {
00064 }
00065
00066 HistogramData_tie(T* p, PortableServer::POA_ptr poa, CORBA::Boolean release = true)
00067 : ptr_(p), poa_(PortableServer::POA::_duplicate(poa)), rel_(release)
00068 {
00069 }
00070
00071 virtual
00072 ~HistogramData_tie()
00073 {
00074 if(rel_)
00075 delete ptr_;
00076
00077 CORBA::release(poa_);
00078 }
00079
00080 T*
00081 _tied_object()
00082 {
00083 return ptr_;
00084 }
00085
00086 void
00087 _tied_object(T& obj)
00088 {
00089 if(rel_)
00090 delete ptr_;
00091
00092 ptr_ = &obj;
00093 rel_ = false;
00094 }
00095
00096 void
00097 _tied_object(T* obj, CORBA::Boolean release = true)
00098 {
00099 if(rel_)
00100 delete ptr_;
00101
00102 ptr_ = obj;
00103 rel_ = release;
00104 }
00105
00106 CORBA::Boolean
00107 _is_owner()
00108 {
00109 return rel_;
00110 }
00111
00112 void
00113 _is_owner(CORBA::Boolean b)
00114 {
00115 rel_ = b;
00116 }
00117
00118 virtual CORBA::Long
00119 dimensionality()
00120 throw(CORBA::SystemException)
00121 {
00122 return ptr_ -> dimensionality();
00123 }
00124
00125 virtual CORBA::Long
00126 dimensionSize(CORBA::Long dim)
00127 throw(CORBA::SystemException)
00128 {
00129 return ptr_ -> dimensionSize(dim);
00130 }
00131
00132 virtual CORBA::Long
00133 nrOfBins()
00134 throw(CORBA::SystemException)
00135 {
00136 return ptr_ -> nrOfBins();
00137 }
00138
00139 virtual CORBA::Double
00140 lowBin(CORBA::Long dim)
00141 throw(CORBA::SystemException)
00142 {
00143 return ptr_ -> lowBin(dim);
00144 }
00145
00146 virtual CORBA::Double
00147 highBin(CORBA::Long dim)
00148 throw(CORBA::SystemException)
00149 {
00150 return ptr_ -> highBin(dim);
00151 }
00152
00153 virtual CORBA::Double
00154 binWidth(CORBA::Long dim)
00155 throw(CORBA::SystemException)
00156 {
00157 return ptr_ -> binWidth(dim);
00158 }
00159
00160 virtual CORBA::Double
00161 binToValue(CORBA::Long bin,
00162 CORBA::Long dim)
00163 throw(CORBA::SystemException)
00164 {
00165 return ptr_ -> binToValue(bin, dim);
00166 }
00167
00168 virtual CORBA::Long
00169 valueToBin(CORBA::Double value,
00170 CORBA::Long dim)
00171 throw(CORBA::SystemException)
00172 {
00173 return ptr_ -> valueToBin(value, dim);
00174 }
00175
00176 virtual CORBA::Double
00177 get1(CORBA::Long bin1)
00178 throw(CORBA::SystemException)
00179 {
00180 return ptr_ -> get1(bin1);
00181 }
00182
00183 virtual CORBA::Double
00184 get2(CORBA::Long bin1,
00185 CORBA::Long bin2)
00186 throw(CORBA::SystemException)
00187 {
00188 return ptr_ -> get2(bin1, bin2);
00189 }
00190
00191 virtual CORBA::Double
00192 get3(CORBA::Long bin1,
00193 CORBA::Long bin2,
00194 CORBA::Long bin3)
00195 throw(CORBA::SystemException)
00196 {
00197 return ptr_ -> get3(bin1, bin2, bin3);
00198 }
00199
00200 virtual CORBA::Double
00201 sum()
00202 throw(CORBA::SystemException)
00203 {
00204 return ptr_ -> sum();
00205 }
00206
00207 virtual CORBA::Double
00208 minVal()
00209 throw(CORBA::SystemException)
00210 {
00211 return ptr_ -> minVal();
00212 }
00213
00214 virtual CORBA::Double
00215 maxVal()
00216 throw(CORBA::SystemException)
00217 {
00218 return ptr_ -> maxVal();
00219 }
00220
00221 virtual CORBA::Double
00222 maxValIndex(CORBA::Long_out index)
00223 throw(CORBA::SystemException)
00224 {
00225 return ptr_ -> maxValIndex(index);
00226 }
00227
00228 virtual HxCorba::BinDataSequence*
00229 getDataDouble()
00230 throw(CORBA::SystemException)
00231 {
00232 return ptr_ -> getDataDouble();
00233 }
00234
00235 PortableServer::POA_ptr _default_POA()
00236 {
00237 if(!CORBA::is_nil(poa_))
00238 return PortableServer::POA::_duplicate(poa_);
00239 else
00240 return HistogramData::_default_POA();
00241 }
00242 };
00243
00244
00245
00246
00247 template<class T>
00248 class Histogram_tie : virtual public Histogram
00249 {
00250 T* ptr_;
00251 PortableServer::POA_ptr poa_;
00252 CORBA::Boolean rel_;
00253
00254 Histogram_tie(const Histogram_tie<T>&) { }
00255 void operator=(const Histogram_tie<T>&) { }
00256
00257 public:
00258
00259 Histogram_tie(T& t)
00260 : ptr_(&t), poa_(PortableServer::POA::_nil()), rel_(false)
00261 {
00262 }
00263
00264 Histogram_tie(T& t, PortableServer::POA_ptr poa)
00265 : ptr_(&t), poa_(PortableServer::POA::_duplicate(poa)), rel_(false)
00266 {
00267 }
00268
00269 Histogram_tie(T* p, CORBA::Boolean release = true)
00270 : ptr_(p), poa_(PortableServer::POA::_nil()), rel_(release)
00271 {
00272 }
00273
00274 Histogram_tie(T* p, PortableServer::POA_ptr poa, CORBA::Boolean release = true)
00275 : ptr_(p), poa_(PortableServer::POA::_duplicate(poa)), rel_(release)
00276 {
00277 }
00278
00279 virtual
00280 ~Histogram_tie()
00281 {
00282 if(rel_)
00283 delete ptr_;
00284
00285 CORBA::release(poa_);
00286 }
00287
00288 T*
00289 _tied_object()
00290 {
00291 return ptr_;
00292 }
00293
00294 void
00295 _tied_object(T& obj)
00296 {
00297 if(rel_)
00298 delete ptr_;
00299
00300 ptr_ = &obj;
00301 rel_ = false;
00302 }
00303
00304 void
00305 _tied_object(T* obj, CORBA::Boolean release = true)
00306 {
00307 if(rel_)
00308 delete ptr_;
00309
00310 ptr_ = obj;
00311 rel_ = release;
00312 }
00313
00314 CORBA::Boolean
00315 _is_owner()
00316 {
00317 return rel_;
00318 }
00319
00320 void
00321 _is_owner(CORBA::Boolean b)
00322 {
00323 rel_ = b;
00324 }
00325
00326 virtual HxCorba::Histogram_ptr
00327 smooth(CORBA::Double sigma)
00328 throw(CORBA::SystemException)
00329 {
00330 return ptr_ -> smooth(sigma);
00331 }
00332
00333 virtual HxCorba::HistogramModeSeq*
00334 modes()
00335 throw(CORBA::SystemException)
00336 {
00337 return ptr_ -> modes();
00338 }
00339
00340 virtual HxCorba::Histogram_ptr
00341 normalize(CORBA::Double weight)
00342 throw(CORBA::SystemException)
00343 {
00344 return ptr_ -> normalize(weight);
00345 }
00346
00347 virtual CORBA::Double
00348 intersection(HxCorba::Histogram_ptr h)
00349 throw(CORBA::SystemException)
00350 {
00351 return ptr_ -> intersection(h);
00352 }
00353
00354 virtual CORBA::Double
00355 chiSquare(HxCorba::Histogram_ptr h)
00356 throw(CORBA::SystemException)
00357 {
00358 return ptr_ -> chiSquare(h);
00359 }
00360
00361 virtual CORBA::Double
00362 chiSquareNorm(HxCorba::Histogram_ptr h)
00363 throw(CORBA::SystemException)
00364 {
00365 return ptr_ -> chiSquareNorm(h);
00366 }
00367
00368 virtual HxCorba::Histogram_ptr
00369 threshold(CORBA::Double valThreshold)
00370 throw(CORBA::SystemException)
00371 {
00372 return ptr_ -> threshold(valThreshold);
00373 }
00374
00375 virtual CORBA::Long
00376 countBins(CORBA::Double valThreshold)
00377 throw(CORBA::SystemException)
00378 {
00379 return ptr_ -> countBins(valThreshold);
00380 }
00381
00382 virtual HxCorba::Histogram_ptr
00383 reduceRange(CORBA::Long binMin1,
00384 CORBA::Long binMax1,
00385 CORBA::Long binMin2,
00386 CORBA::Long binMax2,
00387 CORBA::Long binMin3,
00388 CORBA::Long binMax3)
00389 throw(CORBA::SystemException)
00390 {
00391 return ptr_ -> reduceRange(binMin1, binMax1, binMin2, binMax2, binMin3, binMax3);
00392 }
00393
00394 virtual HxCorba::Histogram_ptr
00395 reduceRangeVal(CORBA::Double binValMin1,
00396 CORBA::Double binValMax1,
00397 CORBA::Double binValMin2,
00398 CORBA::Double binValMax2,
00399 CORBA::Double binValMin3,
00400 CORBA::Double binValMax3)
00401 throw(CORBA::SystemException)
00402 {
00403 return ptr_ -> reduceRangeVal(binValMin1, binValMax1, binValMin2, binValMax2, binValMin3, binValMax3);
00404 }
00405
00406 virtual HxCorba::Histogram_ptr
00407 to1D(CORBA::Long dim)
00408 throw(CORBA::SystemException)
00409 {
00410 return ptr_ -> to1D(dim);
00411 }
00412
00413 virtual void
00414 render3d(HxCorba::RgbBuffer_ptr buf,
00415 CORBA::Long dataWidth,
00416 CORBA::Long dataHeight,
00417 CORBA::Double elevation,
00418 CORBA::Double alpha,
00419 CORBA::Double threshold)
00420 throw(CORBA::SystemException)
00421 {
00422 ptr_ -> render3d(buf, dataWidth, dataHeight, elevation, alpha, threshold);
00423 }
00424
00425 virtual void
00426 destroy()
00427 throw(CORBA::SystemException)
00428 {
00429 ptr_ -> destroy();
00430 }
00431
00432 virtual void
00433 put()
00434 throw(CORBA::SystemException)
00435 {
00436 ptr_ -> put();
00437 }
00438
00439 virtual CORBA::Long
00440 dimensionality()
00441 throw(CORBA::SystemException)
00442 {
00443 return ptr_ -> dimensionality();
00444 }
00445
00446 virtual CORBA::Long
00447 dimensionSize(CORBA::Long dim)
00448 throw(CORBA::SystemException)
00449 {
00450 return ptr_ -> dimensionSize(dim);
00451 }
00452
00453 virtual CORBA::Long
00454 nrOfBins()
00455 throw(CORBA::SystemException)
00456 {
00457 return ptr_ -> nrOfBins();
00458 }
00459
00460 virtual CORBA::Double
00461 lowBin(CORBA::Long dim)
00462 throw(CORBA::SystemException)
00463 {
00464 return ptr_ -> lowBin(dim);
00465 }
00466
00467 virtual CORBA::Double
00468 highBin(CORBA::Long dim)
00469 throw(CORBA::SystemException)
00470 {
00471 return ptr_ -> highBin(dim);
00472 }
00473
00474 virtual CORBA::Double
00475 binWidth(CORBA::Long dim)
00476 throw(CORBA::SystemException)
00477 {
00478 return ptr_ -> binWidth(dim);
00479 }
00480
00481 virtual CORBA::Double
00482 binToValue(CORBA::Long bin,
00483 CORBA::Long dim)
00484 throw(CORBA::SystemException)
00485 {
00486 return ptr_ -> binToValue(bin, dim);
00487 }
00488
00489 virtual CORBA::Long
00490 valueToBin(CORBA::Double value,
00491 CORBA::Long dim)
00492 throw(CORBA::SystemException)
00493 {
00494 return ptr_ -> valueToBin(value, dim);
00495 }
00496
00497 virtual CORBA::Double
00498 get1(CORBA::Long bin1)
00499 throw(CORBA::SystemException)
00500 {
00501 return ptr_ -> get1(bin1);
00502 }
00503
00504 virtual CORBA::Double
00505 get2(CORBA::Long bin1,
00506 CORBA::Long bin2)
00507 throw(CORBA::SystemException)
00508 {
00509 return ptr_ -> get2(bin1, bin2);
00510 }
00511
00512 virtual CORBA::Double
00513 get3(CORBA::Long bin1,
00514 CORBA::Long bin2,
00515 CORBA::Long bin3)
00516 throw(CORBA::SystemException)
00517 {
00518 return ptr_ -> get3(bin1, bin2, bin3);
00519 }
00520
00521 virtual CORBA::Double
00522 sum()
00523 throw(CORBA::SystemException)
00524 {
00525 return ptr_ -> sum();
00526 }
00527
00528 virtual CORBA::Double
00529 minVal()
00530 throw(CORBA::SystemException)
00531 {
00532 return ptr_ -> minVal();
00533 }
00534
00535 virtual CORBA::Double
00536 maxVal()
00537 throw(CORBA::SystemException)
00538 {
00539 return ptr_ -> maxVal();
00540 }
00541
00542 virtual CORBA::Double
00543 maxValIndex(CORBA::Long_out index)
00544 throw(CORBA::SystemException)
00545 {
00546 return ptr_ -> maxValIndex(index);
00547 }
00548
00549 virtual HxCorba::BinDataSequence*
00550 getDataDouble()
00551 throw(CORBA::SystemException)
00552 {
00553 return ptr_ -> getDataDouble();
00554 }
00555
00556 PortableServer::POA_ptr _default_POA()
00557 {
00558 if(!CORBA::is_nil(poa_))
00559 return PortableServer::POA::_duplicate(poa_);
00560 else
00561 return Histogram::_default_POA();
00562 }
00563 };
00564
00565
00566
00567
00568 template<class T>
00569 class HistogramFactory_tie : virtual public HistogramFactory
00570 {
00571 T* ptr_;
00572 PortableServer::POA_ptr poa_;
00573 CORBA::Boolean rel_;
00574
00575 HistogramFactory_tie(const HistogramFactory_tie<T>&) { }
00576 void operator=(const HistogramFactory_tie<T>&) { }
00577
00578 public:
00579
00580 HistogramFactory_tie(T& t)
00581 : ptr_(&t), poa_(PortableServer::POA::_nil()), rel_(false)
00582 {
00583 }
00584
00585 HistogramFactory_tie(T& t, PortableServer::POA_ptr poa)
00586 : ptr_(&t), poa_(PortableServer::POA::_duplicate(poa)), rel_(false)
00587 {
00588 }
00589
00590 HistogramFactory_tie(T* p, CORBA::Boolean release = true)
00591 : ptr_(p), poa_(PortableServer::POA::_nil()), rel_(release)
00592 {
00593 }
00594
00595 HistogramFactory_tie(T* p, PortableServer::POA_ptr poa, CORBA::Boolean release = true)
00596 : ptr_(p), poa_(PortableServer::POA::_duplicate(poa)), rel_(release)
00597 {
00598 }
00599
00600 virtual
00601 ~HistogramFactory_tie()
00602 {
00603 if(rel_)
00604 delete ptr_;
00605
00606 CORBA::release(poa_);
00607 }
00608
00609 T*
00610 _tied_object()
00611 {
00612 return ptr_;
00613 }
00614
00615 void
00616 _tied_object(T& obj)
00617 {
00618 if(rel_)
00619 delete ptr_;
00620
00621 ptr_ = &obj;
00622 rel_ = false;
00623 }
00624
00625 void
00626 _tied_object(T* obj, CORBA::Boolean release = true)
00627 {
00628 if(rel_)
00629 delete ptr_;
00630
00631 ptr_ = obj;
00632 rel_ = release;
00633 }
00634
00635 CORBA::Boolean
00636 _is_owner()
00637 {
00638 return rel_;
00639 }
00640
00641 void
00642 _is_owner(CORBA::Boolean b)
00643 {
00644 rel_ = b;
00645 }
00646
00647 virtual HxCorba::Histogram_ptr
00648 makeHistogramFromFile(const char* filename)
00649 throw(CORBA::SystemException)
00650 {
00651 return ptr_ -> makeHistogramFromFile(filename);
00652 }
00653
00654 PortableServer::POA_ptr _default_POA()
00655 {
00656 if(!CORBA::is_nil(poa_))
00657 return PortableServer::POA::_duplicate(poa_);
00658 else
00659 return HistogramFactory::_default_POA();
00660 }
00661 };
00662
00663 }
00664
00665 #endif