|| ||   || Doxygen's  

---

HxCorbaVxStructure_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 ___HxCorbaVxStructure_tie_h__
#define ___HxCorbaVxStructure_tie_h__

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

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

public:

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

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

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

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

    virtual
    ~VxStructure_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::StringSeq*
    getLevelNames()
        throw(CORBA::SystemException)
    {
        return ptr_ -> getLevelNames();
    }

    virtual CORBA::Boolean
    exist(const char* levelId)
        throw(CORBA::SystemException)
    {
        return ptr_ -> exist(levelId);
    }

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

    virtual CORBA::Boolean
    push(const char* level,
         HxCorba::VxSegmentation_ptr seg)
        throw(CORBA::SystemException)
    {
        return ptr_ -> push(level, seg);
    }

    virtual CORBA::Boolean
    pushFromFile(const char* level,
                 const char* filename)
        throw(CORBA::SystemException)
    {
        return ptr_ -> pushFromFile(level, filename);
    }

    virtual HxCorba::VxSegmentation_ptr
    get(const char* levelId)
        throw(CORBA::SystemException)
    {
        return ptr_ -> get(levelId);
    }

    virtual HxCorba::VxSegment_ptr
    getSegment(const char* levelId,
               CORBA::Long index)
        throw(CORBA::SystemException)
    {
        return ptr_ -> getSegment(levelId, index);
    }

    virtual HxCorba::VxSegment_ptr
    mapsToSegment(const char* levelId,
                  CORBA::Long timeSpan)
        throw(CORBA::SystemException)
    {
        return ptr_ -> mapsToSegment(levelId, timeSpan);
    }

    virtual HxCorba::VxSegmentation_ptr
    getFromInterval(const char* levelId,
                    const HxCorba::VxTimeSpan& timeSpan,
                    CORBA::Boolean complete)
        throw(CORBA::SystemException)
    {
        return ptr_ -> getFromInterval(levelId, timeSpan, complete);
    }

    virtual HxCorba::VxSegmentation_ptr
    getWhereInt(const char* levelId,
                const char* strType,
                CORBA::Long val)
        throw(CORBA::SystemException)
    {
        return ptr_ -> getWhereInt(levelId, strType, val);
    }

    virtual HxCorba::VxSegmentation_ptr
    getWhereString(const char* levelId,
                   const char* strType,
                   const char* val)
        throw(CORBA::SystemException)
    {
        return ptr_ -> getWhereString(levelId, strType, val);
    }

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

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

    virtual CORBA::Long
    mapsToIndex(const char* levelId,
                const HxCorba::VxTimeSpan& timeSpan)
        throw(CORBA::SystemException)
    {
        return ptr_ -> mapsToIndex(levelId, timeSpan);
    }

    virtual CORBA::Long
    mapsToIndexInt(const char* levelId,
                   CORBA::Long timeSpan)
        throw(CORBA::SystemException)
    {
        return ptr_ -> mapsToIndexInt(levelId, timeSpan);
    }

    virtual HxCorba::LongSeq*
    getSegmentBoundaries(const char* levelId,
                         const HxCorba::VxTimeSpan& timeSpan)
        throw(CORBA::SystemException)
    {
        return ptr_ -> getSegmentBoundaries(levelId, timeSpan);
    }

    virtual CORBA::Boolean
    isContinuous(const char* levelId)
        throw(CORBA::SystemException)
    {
        return ptr_ -> isContinuous(levelId);
    }

    virtual CORBA::Boolean
    isSequential(const char* levelId)
        throw(CORBA::SystemException)
    {
        return ptr_ -> isSequential(levelId);
    }

    virtual CORBA::Boolean
    isParentOf(const char* levelId1,
               const char* levelId2)
        throw(CORBA::SystemException)
    {
        return ptr_ -> isParentOf(levelId1, levelId2);
    }

    virtual CORBA::Boolean
    isChildOf(const char* levelId1,
              const char* levelId2)
        throw(CORBA::SystemException)
    {
        return ptr_ -> isChildOf(levelId1, levelId2);
    }

    virtual HxCorba::VxStructureEval
    compare(const char* levelId,
            HxCorba::VxSegmentation_ptr foundTruth)
        throw(CORBA::SystemException)
    {
        return ptr_ -> compare(levelId, foundTruth);
    }

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

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

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

public:

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

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

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

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

    virtual
    ~VxStructureFactory_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::VxStructure_ptr
    makeVxStructure(const char* base,
                    const HxCorba::StringSeq& extLevels)
        throw(CORBA::SystemException)
    {
        return ptr_ -> makeVxStructure(base, extLevels);
    }

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

} // End of namespace POA_HxCorba

#endif

---