|| ||   || Doxygen's  

---

HxCorbaImageRep_skel_tie.h

Go to the documentation of this file.

// **********************************************************************
//
// Generated by the ORBacus IDL-to-C++ Translator
//
// Copyright (c) 2001
// IONA Technologies, Inc.
// Waltham, MA, USA
//
// All Rights Reserved
//
// **********************************************************************

// Version: 4.1.0

#ifndef ___HxCorbaImageRep_tie_h__
#define ___HxCorbaImageRep_tie_h__

#include <HxCorbaImageRep_skel.h>

#ifndef OB_INTEGER_VERSION
#   error No ORBacus version defined! Is <OB/CORBA.h> included?
#endif

#ifndef OB_NO_VERSION_CHECK
#   if (OB_INTEGER_VERSION != 4010000L)
#       error ORBacus version mismatch!
#   endif
#endif

//
// IDL:HxCorba:1.0
//
namespace POA_HxCorba
{

//
// IDL:HxCorba/ImageRepRgbSource:1.0
//
template<class T>
class ImageRepRgbSource_tie : virtual public ImageRepRgbSource
{
    T* ptr_;
    PortableServer::POA_ptr poa_;
    CORBA::Boolean rel_;

    ImageRepRgbSource_tie(const ImageRepRgbSource_tie<T>&) { }
    void operator=(const ImageRepRgbSource_tie<T>&) { }

public:

    ImageRepRgbSource_tie(T& t)
        : ptr_(&t), poa_(PortableServer::POA::_nil()), rel_(false)
    {
    }

    ImageRepRgbSource_tie(T& t, PortableServer::POA_ptr poa)
        : ptr_(&t), poa_(PortableServer::POA::_duplicate(poa)), rel_(false)
    {
    }

    ImageRepRgbSource_tie(T* p, CORBA::Boolean release = true)
        : ptr_(p), poa_(PortableServer::POA::_nil()), rel_(release)
    {
    }

    ImageRepRgbSource_tie(T* p, PortableServer::POA_ptr poa, CORBA::Boolean release = true)
        : ptr_(p), poa_(PortableServer::POA::_duplicate(poa)), rel_(release)
    {
    }

    virtual
    ~ImageRepRgbSource_tie()
    {
        if(rel_)
            delete ptr_;

        CORBA::release(poa_);
    }

    T*
    _tied_object()
    {
        return ptr_;
    }

    void
    _tied_object(T& obj)
    {
        if(rel_)
            delete ptr_;

        ptr_ = &obj;
        rel_ = false;
    }

    void
    _tied_object(T* obj, CORBA::Boolean release = true)
    {
        if(rel_)
            delete ptr_;

        ptr_ = obj;
        rel_ = release;
    }

    CORBA::Boolean
    _is_owner()
    {
        return rel_;
    }

    void
    _is_owner(CORBA::Boolean b)
    {
        rel_ = b;
    }

    virtual void
    setDisplayMode(const char* displayMode)
        throw(CORBA::SystemException)
    {
        ptr_ -> setDisplayMode(displayMode);
    }

    virtual char*
    getDisplayMode()
        throw(CORBA::SystemException)
    {
        return ptr_ -> getDisplayMode();
    }

    virtual void
    setSize(const HxCorba::Sizes& newSize)
        throw(CORBA::SystemException)
    {
        ptr_ -> setSize(newSize);
    }

    virtual void
    setMaxSize(const HxCorba::Sizes& maxSize)
        throw(CORBA::SystemException)
    {
        ptr_ -> setMaxSize(maxSize);
    }

    virtual void
    scale(CORBA::Float factor)
        throw(CORBA::SystemException)
    {
        ptr_ -> scale(factor);
    }

    virtual void
    setTransferSize(CORBA::Long nLines)
        throw(CORBA::SystemException)
    {
        ptr_ -> setTransferSize(nLines);
    }

    virtual CORBA::Long
    getTransferSize()
        throw(CORBA::SystemException)
    {
        return ptr_ -> getTransferSize();
    }

    virtual void
    setTransferPos(CORBA::Long line)
        throw(CORBA::SystemException)
    {
        ptr_ -> setTransferPos(line);
    }

    virtual CORBA::Long
    getTransferPos()
        throw(CORBA::SystemException)
    {
        return ptr_ -> getTransferPos();
    }

    virtual HxCorba::Sizes
    getSizes()
        throw(CORBA::SystemException)
    {
        return ptr_ -> getSizes();
    }

    virtual HxCorba::Sizes
    getOriginalSizes()
        throw(CORBA::SystemException)
    {
        return ptr_ -> getOriginalSizes();
    }

    virtual void
    close()
        throw(CORBA::SystemException)
    {
        ptr_ -> close();
    }

    virtual HxCorba::RgbSeq*
    getRgb()
        throw(CORBA::SystemException)
    {
        return ptr_ -> getRgb();
    }

    virtual void
    fillRgb(HxCorba::RgbBuffer_ptr buffer)
        throw(CORBA::SystemException)
    {
        ptr_ -> fillRgb(buffer);
    }

    PortableServer::POA_ptr _default_POA()
    {
        if(!CORBA::is_nil(poa_))
            return PortableServer::POA::_duplicate(poa_);
        else
            return ImageRepRgbSource::_default_POA();
    }
};

//
// IDL:HxCorba/ImageData:1.0
//
template<class T>
class ImageData_tie : virtual public ImageData
{
    T* ptr_;
    PortableServer::POA_ptr poa_;
    CORBA::Boolean rel_;

    ImageData_tie(const ImageData_tie<T>&) { }
    void operator=(const ImageData_tie<T>&) { }

public:

    ImageData_tie(T& t)
        : ptr_(&t), poa_(PortableServer::POA::_nil()), rel_(false)
    {
    }

    ImageData_tie(T& t, PortableServer::POA_ptr poa)
        : ptr_(&t), poa_(PortableServer::POA::_duplicate(poa)), rel_(false)
    {
    }

    ImageData_tie(T* p, CORBA::Boolean release = true)
        : ptr_(p), poa_(PortableServer::POA::_nil()), rel_(release)
    {
    }

    ImageData_tie(T* p, PortableServer::POA_ptr poa, CORBA::Boolean release = true)
        : ptr_(p), poa_(PortableServer::POA::_duplicate(poa)), rel_(release)
    {
    }

    virtual
    ~ImageData_tie()
    {
        if(rel_)
            delete ptr_;

        CORBA::release(poa_);
    }

    T*
    _tied_object()
    {
        return ptr_;
    }

    void
    _tied_object(T& obj)
    {
        if(rel_)
            delete ptr_;

        ptr_ = &obj;
        rel_ = false;
    }

    void
    _tied_object(T* obj, CORBA::Boolean release = true)
    {
        if(rel_)
            delete ptr_;

        ptr_ = obj;
        rel_ = release;
    }

    CORBA::Boolean
    _is_owner()
    {
        return rel_;
    }

    void
    _is_owner(CORBA::Boolean b)
    {
        rel_ = b;
    }

    virtual CORBA::Long
    dimensionality()
        throw(CORBA::SystemException)
    {
        return ptr_ -> dimensionality();
    }

    virtual CORBA::Long
    numberOfPixels()
        throw(CORBA::SystemException)
    {
        return ptr_ -> numberOfPixels();
    }

    virtual CORBA::Long
    pixelDimensionality()
        throw(CORBA::SystemException)
    {
        return ptr_ -> pixelDimensionality();
    }

    virtual CORBA::Long
    pixelPrecision()
        throw(CORBA::SystemException)
    {
        return ptr_ -> pixelPrecision();
    }

    virtual HxCorba::PixelT
    pixelType()
        throw(CORBA::SystemException)
    {
        return ptr_ -> pixelType();
    }

    virtual HxCorba::Sizes
    getSizes()
        throw(CORBA::SystemException)
    {
        return ptr_ -> getSizes();
    }

    virtual CORBA::Long
    dimensionSize(CORBA::Long i)
        throw(CORBA::SystemException)
    {
        return ptr_ -> dimensionSize(i);
    }

    virtual HxCorba::ImageSignature
    signature()
        throw(CORBA::SystemException)
    {
        return ptr_ -> signature();
    }

    virtual HxCorba::RgbSeq*
    getRgb2d(const char* displayMode)
        throw(CORBA::SystemException)
    {
        return ptr_ -> getRgb2d(displayMode);
    }

    virtual void
    fillRgb2d(HxCorba::RgbBuffer_ptr buf,
              const char* displayMode)
        throw(CORBA::SystemException)
    {
        ptr_ -> fillRgb2d(buf, displayMode);
    }

    virtual HxCorba::ImageRepRgbSource_ptr
    getRgbSource()
        throw(CORBA::SystemException)
    {
        return ptr_ -> getRgbSource();
    }

    PortableServer::POA_ptr _default_POA()
    {
        if(!CORBA::is_nil(poa_))
            return PortableServer::POA::_duplicate(poa_);
        else
            return ImageData::_default_POA();
    }
};

//
// IDL:HxCorba/ImageRep:1.0
//
template<class T>
class ImageRep_tie : virtual public ImageRep
{
    T* ptr_;
    PortableServer::POA_ptr poa_;
    CORBA::Boolean rel_;

    ImageRep_tie(const ImageRep_tie<T>&) { }
    void operator=(const ImageRep_tie<T>&) { }

public:

    ImageRep_tie(T& t)
        : ptr_(&t), poa_(PortableServer::POA::_nil()), rel_(false)
    {
    }

    ImageRep_tie(T& t, PortableServer::POA_ptr poa)
        : ptr_(&t), poa_(PortableServer::POA::_duplicate(poa)), rel_(false)
    {
    }

    ImageRep_tie(T* p, CORBA::Boolean release = true)
        : ptr_(p), poa_(PortableServer::POA::_nil()), rel_(release)
    {
    }

    ImageRep_tie(T* p, PortableServer::POA_ptr poa, CORBA::Boolean release = true)
        : ptr_(p), poa_(PortableServer::POA::_duplicate(poa)), rel_(release)
    {
    }

    virtual
    ~ImageRep_tie()
    {
        if(rel_)
            delete ptr_;

        CORBA::release(poa_);
    }

    T*
    _tied_object()
    {
        return ptr_;
    }

    void
    _tied_object(T& obj)
    {
        if(rel_)
            delete ptr_;

        ptr_ = &obj;
        rel_ = false;
    }

    void
    _tied_object(T* obj, CORBA::Boolean release = true)
    {
        if(rel_)
            delete ptr_;

        ptr_ = obj;
        rel_ = release;
    }

    CORBA::Boolean
    _is_owner()
    {
        return rel_;
    }

    void
    _is_owner(CORBA::Boolean b)
    {
        rel_ = b;
    }

    virtual HxCorba::ImageRep_ptr
    binaryPixOp(HxCorba::ImageRep_ptr arg,
                const char* bpoName,
                HxCorba::TagList_ptr tags)
        throw(HxCorba::ImageException,
              CORBA::SystemException)
    {
        return ptr_ -> binaryPixOp(arg, bpoName, tags);
    }

    virtual HxCorba::ImageRep_ptr
    binaryPixOpVal(const HxCorba::PixValue& arg,
                   const char* bpoName,
                   HxCorba::TagList_ptr tags)
        throw(HxCorba::ImageException,
              CORBA::SystemException)
    {
        return ptr_ -> binaryPixOpVal(arg, bpoName, tags);
    }

    virtual HxCorba::ImageRep_ptr
    unaryPixOp(const char* upoName,
               HxCorba::TagList_ptr tags)
        throw(HxCorba::ImageException,
              CORBA::SystemException)
    {
        return ptr_ -> unaryPixOp(upoName, tags);
    }

    virtual HxCorba::ImageRep_ptr
    multiPixOp(const HxCorba::ImageList& args,
               const char* mpoName,
               HxCorba::TagList_ptr tags)
        throw(HxCorba::ImageException,
              CORBA::SystemException)
    {
        return ptr_ -> multiPixOp(args, mpoName, tags);
    }

    virtual HxCorba::ImageList*
    MNPixOp(const HxCorba::ImageList& args,
            const char* mpoName,
            HxCorba::TagList_ptr tags)
        throw(HxCorba::ImageException,
              CORBA::SystemException)
    {
        return ptr_ -> MNPixOp(args, mpoName, tags);
    }

    virtual HxCorba::PixValue
    reduceOp(const char* op,
             HxCorba::TagList_ptr tags)
        throw(HxCorba::ImageException,
              CORBA::SystemException)
    {
        return ptr_ -> reduceOp(op, tags);
    }

    virtual HxCorba::ImageRep_ptr
    generalizedConvolution(HxCorba::ImageRep_ptr kernel,
                           const char* gMul,
                           const char* gAdd,
                           HxCorba::ResultPrecision resPrec,
                           HxCorba::TagList_ptr tags)
        throw(HxCorba::ImageException,
              CORBA::SystemException)
    {
        return ptr_ -> generalizedConvolution(kernel, gMul, gAdd, resPrec, tags);
    }

    virtual HxCorba::ImageRep_ptr
    genConv2dSep(HxCorba::ImageRep_ptr kernel1,
                 HxCorba::ImageRep_ptr kernel2,
                 const char* gMul,
                 const char* gAdd,
                 HxCorba::ResultPrecision resPrec,
                 HxCorba::TagList_ptr tags)
        throw(HxCorba::ImageException,
              CORBA::SystemException)
    {
        return ptr_ -> genConv2dSep(kernel1, kernel2, gMul, gAdd, resPrec, tags);
    }

    virtual HxCorba::ImageRep_ptr
    recGenConv(HxCorba::ImageRep_ptr kerImg,
               const char* gMul,
               const char* gAdd,
               HxCorba::ResultPrecision resPrec,
               HxCorba::TagList_ptr tags)
        throw(HxCorba::ImageException,
              CORBA::SystemException)
    {
        return ptr_ -> recGenConv(kerImg, gMul, gAdd, resPrec, tags);
    }

    virtual HxCorba::ImageRep_ptr
    neighbourhoodOp(const char* ngbName,
                    HxCorba::TagList_ptr tags)
        throw(HxCorba::ImageException,
              CORBA::SystemException)
    {
        return ptr_ -> neighbourhoodOp(ngbName, tags);
    }

    virtual HxCorba::ImageRep_ptr
    geometricOp2d(HxCorba::Matrix_ptr func,
                  HxCorba::GeoIntType gi,
                  HxCorba::GeoTransType gt,
                  CORBA::Boolean adjustSize,
                  const HxCorba::PixValue& background)
        throw(HxCorba::ImageException,
              CORBA::SystemException)
    {
        return ptr_ -> geometricOp2d(func, gi, gt, adjustSize, background);
    }

    virtual HxCorba::ImageRep_ptr
    scale(CORBA::Double sx,
          CORBA::Double sy,
          HxCorba::GeoIntType gi)
        throw(CORBA::SystemException)
    {
        return ptr_ -> scale(sx, sy, gi);
    }

    virtual HxCorba::PixValue
    getAt(CORBA::Long x,
          CORBA::Long y,
          CORBA::Long zz)
        throw(CORBA::SystemException)
    {
        return ptr_ -> getAt(x, y, zz);
    }

    virtual void
    destroy()
        throw(CORBA::SystemException)
    {
        ptr_ -> destroy();
    }

    virtual CORBA::Long
    dimensionality()
        throw(CORBA::SystemException)
    {
        return ptr_ -> dimensionality();
    }

    virtual CORBA::Long
    numberOfPixels()
        throw(CORBA::SystemException)
    {
        return ptr_ -> numberOfPixels();
    }

    virtual CORBA::Long
    pixelDimensionality()
        throw(CORBA::SystemException)
    {
        return ptr_ -> pixelDimensionality();
    }

    virtual CORBA::Long
    pixelPrecision()
        throw(CORBA::SystemException)
    {
        return ptr_ -> pixelPrecision();
    }

    virtual HxCorba::PixelT
    pixelType()
        throw(CORBA::SystemException)
    {
        return ptr_ -> pixelType();
    }

    virtual HxCorba::Sizes
    getSizes()
        throw(CORBA::SystemException)
    {
        return ptr_ -> getSizes();
    }

    virtual CORBA::Long
    dimensionSize(CORBA::Long i)
        throw(CORBA::SystemException)
    {
        return ptr_ -> dimensionSize(i);
    }

    virtual HxCorba::ImageSignature
    signature()
        throw(CORBA::SystemException)
    {
        return ptr_ -> signature();
    }

    virtual HxCorba::RgbSeq*
    getRgb2d(const char* displayMode)
        throw(CORBA::SystemException)
    {
        return ptr_ -> getRgb2d(displayMode);
    }

    virtual void
    fillRgb2d(HxCorba::RgbBuffer_ptr buf,
              const char* displayMode)
        throw(CORBA::SystemException)
    {
        ptr_ -> fillRgb2d(buf, displayMode);
    }

    virtual HxCorba::ImageRepRgbSource_ptr
    getRgbSource()
        throw(CORBA::SystemException)
    {
        return ptr_ -> getRgbSource();
    }

    virtual void
    addRef()
        throw(CORBA::SystemException)
    {
        ptr_ -> addRef();
    }

    virtual void
    removeRef()
        throw(CORBA::SystemException)
    {
        ptr_ -> removeRef();
    }

    PortableServer::POA_ptr _default_POA()
    {
        if(!CORBA::is_nil(poa_))
            return PortableServer::POA::_duplicate(poa_);
        else
            return ImageRep::_default_POA();
    }
};

//
// IDL:HxCorba/ImageFactory:1.0
//
template<class T>
class ImageFactory_tie : virtual public ImageFactory
{
    T* ptr_;
    PortableServer::POA_ptr poa_;
    CORBA::Boolean rel_;

    ImageFactory_tie(const ImageFactory_tie<T>&) { }
    void operator=(const ImageFactory_tie<T>&) { }

public:

    ImageFactory_tie(T& t)
        : ptr_(&t), poa_(PortableServer::POA::_nil()), rel_(false)
    {
    }

    ImageFactory_tie(T& t, PortableServer::POA_ptr poa)
        : ptr_(&t), poa_(PortableServer::POA::_duplicate(poa)), rel_(false)
    {
    }

    ImageFactory_tie(T* p, CORBA::Boolean release = true)
        : ptr_(p), poa_(PortableServer::POA::_nil()), rel_(release)
    {
    }

    ImageFactory_tie(T* p, PortableServer::POA_ptr poa, CORBA::Boolean release = true)
        : ptr_(p), poa_(PortableServer::POA::_duplicate(poa)), rel_(release)
    {
    }

    virtual
    ~ImageFactory_tie()
    {
        if(rel_)
            delete ptr_;

        CORBA::release(poa_);
    }

    T*
    _tied_object()
    {
        return ptr_;
    }

    void
    _tied_object(T& obj)
    {
        if(rel_)
            delete ptr_;

        ptr_ = &obj;
        rel_ = false;
    }

    void
    _tied_object(T* obj, CORBA::Boolean release = true)
    {
        if(rel_)
            delete ptr_;

        ptr_ = obj;
        rel_ = release;
    }

    CORBA::Boolean
    _is_owner()
    {
        return rel_;
    }

    void
    _is_owner(CORBA::Boolean b)
    {
        rel_ = b;
    }

    virtual HxCorba::ImageRep_ptr
    importImage(HxCorba::ImageData_ptr data)
        throw(CORBA::SystemException)
    {
        return ptr_ -> importImage(data);
    }

    virtual HxCorba::ImageRep_ptr
    fromSignature(HxCorba::ImageSignature sig,
                  const HxCorba::Sizes& size)
        throw(CORBA::SystemException)
    {
        return ptr_ -> fromSignature(sig, size);
    }

    virtual HxCorba::ImageRep_ptr
    fromImage(HxCorba::ImageSignature sig,
              HxCorba::ImageRep_ptr src)
        throw(CORBA::SystemException)
    {
        return ptr_ -> fromImage(sig, src);
    }

    virtual HxCorba::ImageRep_ptr
    fromValue(HxCorba::ImageSignature sig,
              const HxCorba::Sizes& size,
              const HxCorba::PixValue& val)
        throw(CORBA::SystemException)
    {
        return ptr_ -> fromValue(sig, size, val);
    }

    virtual HxCorba::ImageRep_ptr
    fromByteData(CORBA::Long pixelDimensionality,
                 CORBA::Long dimensions,
                 const HxCorba::Sizes& size,
                 const HxCorba::OctetSeq& data)
        throw(CORBA::SystemException)
    {
        return ptr_ -> fromByteData(pixelDimensionality, dimensions, size, data);
    }

    virtual HxCorba::ImageRep_ptr
    fromShortData(CORBA::Long pixelDimensionality,
                  CORBA::Long dimensions,
                  const HxCorba::Sizes& size,
                  const HxCorba::ShortSeq& data)
        throw(CORBA::SystemException)
    {
        return ptr_ -> fromShortData(pixelDimensionality, dimensions, size, data);
    }

    virtual HxCorba::ImageRep_ptr
    fromIntData(CORBA::Long pixelDimensionality,
                CORBA::Long dimensions,
                const HxCorba::Sizes& size,
                const HxCorba::LongSeq& data)
        throw(CORBA::SystemException)
    {
        return ptr_ -> fromIntData(pixelDimensionality, dimensions, size, data);
    }

    virtual HxCorba::ImageRep_ptr
    fromFloatData(CORBA::Long pixelDimensionality,
                  CORBA::Long dimensions,
                  const HxCorba::Sizes& size,
                  const HxCorba::FloatSeq& data)
        throw(CORBA::SystemException)
    {
        return ptr_ -> fromFloatData(pixelDimensionality, dimensions, size, data);
    }

    virtual HxCorba::ImageRep_ptr
    fromDoubleData(CORBA::Long pixelDimensionality,
                   CORBA::Long dimensions,
                   const HxCorba::Sizes& size,
                   const HxCorba::DoubleSeq& data)
        throw(CORBA::SystemException)
    {
        return ptr_ -> fromDoubleData(pixelDimensionality, dimensions, size, data);
    }

    virtual HxCorba::ImageRep_ptr
    fromJavaRgb(HxCorba::ImageSignature sig,
                const HxCorba::Sizes& size,
                const HxCorba::RgbSeq& pixels)
        throw(CORBA::SystemException)
    {
        return ptr_ -> fromJavaRgb(sig, size, pixels);
    }

    virtual HxCorba::ImageRep_ptr
    fromGrayValue(HxCorba::ImageSignature sig,
                  const HxCorba::Sizes& size,
                  const HxCorba::OctetSeq& pixels)
        throw(CORBA::SystemException)
    {
        return ptr_ -> fromGrayValue(sig, size, pixels);
    }

    virtual HxCorba::ImageRep_ptr
    fromMatlab(HxCorba::ImageSignature sig,
               const HxCorba::Sizes& size,
               const HxCorba::DoubleSeq& pixels)
        throw(CORBA::SystemException)
    {
        return ptr_ -> fromMatlab(sig, size, pixels);
    }

    virtual HxCorba::ImageRep_ptr
    fromNamedGenerator(HxCorba::ImageSignature sig,
                       const char* generatorName,
                       HxCorba::TagList_ptr tags)
        throw(CORBA::SystemException)
    {
        return ptr_ -> fromNamedGenerator(sig, generatorName, tags);
    }

    virtual HxCorba::ImageRep_ptr
    fromImport(HxCorba::ImageSignature sig,
               const HxCorba::Sizes& size,
               const char* importOp,
               HxCorba::TagList_ptr tags)
        throw(CORBA::SystemException)
    {
        return ptr_ -> fromImport(sig, size, importOp, tags);
    }

    virtual HxCorba::ImageRep_ptr
    from2Images(HxCorba::ImageRep_ptr i1,
                HxCorba::ImageRep_ptr i2)
        throw(CORBA::SystemException)
    {
        return ptr_ -> from2Images(i1, i2);
    }

    virtual HxCorba::ImageRep_ptr
    from3Images(HxCorba::ImageRep_ptr i1,
                HxCorba::ImageRep_ptr i2,
                HxCorba::ImageRep_ptr i3)
        throw(CORBA::SystemException)
    {
        return ptr_ -> from3Images(i1, i2, i3);
    }

    virtual HxCorba::ImageRep_ptr
    fromFile(const char* fileName)
        throw(CORBA::SystemException)
    {
        return ptr_ -> fromFile(fileName);
    }

    PortableServer::POA_ptr _default_POA()
    {
        if(!CORBA::is_nil(poa_))
            return PortableServer::POA::_duplicate(poa_);
        else
            return ImageFactory::_default_POA();
    }
};

} // End of namespace POA_HxCorba

#endif

---