|| ||   || Doxygen's  

---

HxCorbaMatrix_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 ___HxCorbaMatrix_tie_h__
#define ___HxCorbaMatrix_tie_h__

#include <HxCorbaMatrix_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/Matrix:1.0
//
template<class T>
class Matrix_tie : virtual public Matrix
{
    T* ptr_;
    PortableServer::POA_ptr poa_;
    CORBA::Boolean rel_;

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

public:

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

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

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

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

    virtual
    ~Matrix_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;
    }

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

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

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

public:

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

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

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

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

    virtual
    ~MatrixFactory_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::Matrix_ptr
    translate2d(CORBA::Double x,
                CORBA::Double y)
        throw(CORBA::SystemException)
    {
        return ptr_ -> translate2d(x, y);
    }

    virtual HxCorba::Matrix_ptr
    scale2d(CORBA::Double sx,
            CORBA::Double sy)
        throw(CORBA::SystemException)
    {
        return ptr_ -> scale2d(sx, sy);
    }

    virtual HxCorba::Matrix_ptr
    rotate2d(CORBA::Double alpha)
        throw(CORBA::SystemException)
    {
        return ptr_ -> rotate2d(alpha);
    }

    virtual HxCorba::Matrix_ptr
    rotate2dDeg(CORBA::Double alpha)
        throw(CORBA::SystemException)
    {
        return ptr_ -> rotate2dDeg(alpha);
    }

    virtual HxCorba::Matrix_ptr
    reflect2d(CORBA::Boolean doX,
              CORBA::Boolean doY)
        throw(CORBA::SystemException)
    {
        return ptr_ -> reflect2d(doX, doY);
    }

    virtual HxCorba::Matrix_ptr
    shear2d(CORBA::Double sx,
            CORBA::Double sy)
        throw(CORBA::SystemException)
    {
        return ptr_ -> shear2d(sx, sy);
    }

    virtual HxCorba::Matrix_ptr
    translate3d(CORBA::Double x,
                CORBA::Double y,
                CORBA::Double z)
        throw(CORBA::SystemException)
    {
        return ptr_ -> translate3d(x, y, z);
    }

    virtual HxCorba::Matrix_ptr
    scale3d(CORBA::Double sx,
            CORBA::Double sy,
            CORBA::Double sz)
        throw(CORBA::SystemException)
    {
        return ptr_ -> scale3d(sx, sy, sz);
    }

    virtual HxCorba::Matrix_ptr
    rotateX3d(CORBA::Double alpha)
        throw(CORBA::SystemException)
    {
        return ptr_ -> rotateX3d(alpha);
    }

    virtual HxCorba::Matrix_ptr
    rotateX3dDeg(CORBA::Double alpha)
        throw(CORBA::SystemException)
    {
        return ptr_ -> rotateX3dDeg(alpha);
    }

    virtual HxCorba::Matrix_ptr
    rotateY3d(CORBA::Double alpha)
        throw(CORBA::SystemException)
    {
        return ptr_ -> rotateY3d(alpha);
    }

    virtual HxCorba::Matrix_ptr
    rotateY3dDeg(CORBA::Double alpha)
        throw(CORBA::SystemException)
    {
        return ptr_ -> rotateY3dDeg(alpha);
    }

    virtual HxCorba::Matrix_ptr
    rotateZ3d(CORBA::Double alpha)
        throw(CORBA::SystemException)
    {
        return ptr_ -> rotateZ3d(alpha);
    }

    virtual HxCorba::Matrix_ptr
    rotateZ3dDeg(CORBA::Double alpha)
        throw(CORBA::SystemException)
    {
        return ptr_ -> rotateZ3dDeg(alpha);
    }

    virtual HxCorba::Matrix_ptr
    reflect3d(CORBA::Boolean doX,
              CORBA::Boolean doY,
              CORBA::Boolean doZ)
        throw(CORBA::SystemException)
    {
        return ptr_ -> reflect3d(doX, doY, doZ);
    }

    virtual HxCorba::Matrix_ptr
    projection(CORBA::Double f)
        throw(CORBA::SystemException)
    {
        return ptr_ -> projection(f);
    }

    virtual HxCorba::Matrix_ptr
    camera(CORBA::Double f)
        throw(CORBA::SystemException)
    {
        return ptr_ -> camera(f);
    }

    virtual HxCorba::Matrix_ptr
    lift2dTo3dXY()
        throw(CORBA::SystemException)
    {
        return ptr_ -> lift2dTo3dXY();
    }

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

} // End of namespace POA_HxCorba

#endif

---