Horus C++ Binding

00001 // **********************************************************************
00002 //
00003 // Generated by the ORBacus IDL-to-C++ Translator
00004 //
00005 // Copyright (c) 2001
00006 // IONA Technologies, Inc.
00007 // Waltham, MA, USA
00008 //
00009 // All Rights Reserved
00010 //
00011 // **********************************************************************
00012 
00013 // Version: 4.1.0
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 // IDL:HxCorba:1.0
00032 //
00033 namespace POA_HxCorba
00034 {
00035 
00036 //
00037 // IDL:HxCorba/HistogramData:1.0
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 // IDL:HxCorba/Histogram:1.0
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 // IDL:HxCorba/HistogramFactory:1.0
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 } // End of namespace POA_HxCorba
00664 
00665 #endif
HxCorbaHistogram_skel_tie.h
