|| ||   || Doxygen's  

---

HxCorbaVxSegmentation_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 ___HxCorbaVxSegmentation_tie_h__
#define ___HxCorbaVxSegmentation_tie_h__

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

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

public:

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

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

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

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

    virtual
    ~VxSegment_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
    start()
        throw(CORBA::SystemException)
    {
        return ptr_ -> start();
    }

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

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

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

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

    virtual CORBA::Long
    getInt(const char* id)
        throw(CORBA::SystemException)
    {
        return ptr_ -> getInt(id);
    }

    virtual CORBA::Double
    getDouble(const char* id)
        throw(CORBA::SystemException)
    {
        return ptr_ -> getDouble(id);
    }

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

    virtual CORBA::Long
    getIntFlag(const char* id,
               CORBA::Boolean_out present)
        throw(CORBA::SystemException)
    {
        return ptr_ -> getIntFlag(id, present);
    }

    virtual CORBA::Double
    getDoubleFlag(const char* id,
                  CORBA::Boolean_out present)
        throw(CORBA::SystemException)
    {
        return ptr_ -> getDoubleFlag(id, present);
    }

    virtual char*
    getStringFlag(const char* id,
                  CORBA::Boolean_out present)
        throw(CORBA::SystemException)
    {
        return ptr_ -> getStringFlag(id, present);
    }

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

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

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

public:

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

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

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

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

    virtual
    ~VxSegmentation_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
    size()
        throw(CORBA::SystemException)
    {
        return ptr_ -> size();
    }

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

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

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

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

    virtual HxCorba::VxSegment_ptr
    getSegment(CORBA::Long index)
        throw(CORBA::SystemException)
    {
        return ptr_ -> getSegment(index);
    }

    virtual HxCorba::VxSegment_ptr
    mapsToSegment(CORBA::Long timeSpan)
        throw(CORBA::SystemException)
    {
        return ptr_ -> mapsToSegment(timeSpan);
    }

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

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

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

public:

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

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

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

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

    virtual
    ~VxSegmentationFactory_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::VxSegmentation_ptr
    makeVxSegmentation(const char* filename)
        throw(CORBA::SystemException)
    {
        return ptr_ -> makeVxSegmentation(filename);
    }

    virtual HxCorba::VxSegmentation_ptr
    importSegmentation(HxCorba::VxSegmentation_ptr seg)
        throw(CORBA::SystemException)
    {
        return ptr_ -> importSegmentation(seg);
    }

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

} // End of namespace POA_HxCorba

#endif

---