|| ||   || Doxygen's  

---

HxCorbaDatabaseSessions_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 ___HxCorbaDatabaseSessions_tie_h__
#define ___HxCorbaDatabaseSessions_tie_h__

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

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

public:

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

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

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

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

    virtual
    ~VxSegmentBuilder_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
    addInt(const char* id,
           CORBA::Long value)
        throw(HxCorba::DatabaseException,
              CORBA::SystemException)
    {
        ptr_ -> addInt(id, value);
    }

    virtual void
    addDouble(const char* id,
              CORBA::Double value)
        throw(HxCorba::DatabaseException,
              CORBA::SystemException)
    {
        ptr_ -> addDouble(id, value);
    }

    virtual void
    addString(const char* id,
              const char* value)
        throw(HxCorba::DatabaseException,
              CORBA::SystemException)
    {
        ptr_ -> addString(id, value);
    }

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

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

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

public:

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

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

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

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

    virtual
    ~VxSegmentationBuilder_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
    setDescription(const char* description)
        throw(CORBA::SystemException)
    {
        ptr_ -> setDescription(description);
    }

    virtual HxCorba::VxSegmentBuilder_ptr
    buildSegment(CORBA::Long start,
                 CORBA::Long end)
        throw(HxCorba::DatabaseException,
              CORBA::SystemException)
    {
        return ptr_ -> buildSegment(start, end);
    }

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

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

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

public:

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

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

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

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

    virtual
    ~StoreSession_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
    addSegmentation(HxCorba::VxSegmentation_ptr seg,
                    const char* videoName,
                    const char* segName,
                    const char* description)
        throw(HxCorba::DatabaseException,
              CORBA::SystemException)
    {
        ptr_ -> addSegmentation(seg, videoName, segName, description);
    }

    virtual HxCorba::VxSegmentationBuilder_ptr
    buildSegmentation(const char* videoName,
                      const char* segName)
        throw(HxCorba::DatabaseException,
              CORBA::SystemException)
    {
        return ptr_ -> buildSegmentation(videoName, segName);
    }

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

    virtual HxCorba::StringSeq*
    listSegmentations(const char* videoName)
        throw(CORBA::SystemException)
    {
        return ptr_ -> listSegmentations(videoName);
    }

    virtual HxCorba::VxSegmentation_ptr
    getSegmentation(const char* videoName,
                    const char* segName)
        throw(CORBA::SystemException)
    {
        return ptr_ -> getSegmentation(videoName, segName);
    }

    virtual HxCorba::VxSegmentSeq*
    querySegments(const char* sqlQuery)
        throw(HxCorba::DatabaseException,
              CORBA::SystemException)
    {
        return ptr_ -> querySegments(sqlQuery);
    }

    virtual HxCorba::StringSeq*
    queryStrings(const char* sqlQuery)
        throw(HxCorba::DatabaseException,
              CORBA::SystemException)
    {
        return ptr_ -> queryStrings(sqlQuery);
    }

    virtual HxCorba::SegmentQueryResultSeq*
    queryMultipleSegments(const char* sqlQuery)
        throw(HxCorba::DatabaseException,
              CORBA::SystemException)
    {
        return ptr_ -> queryMultipleSegments(sqlQuery);
    }

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

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

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

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

public:

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

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

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

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

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

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

    virtual void
    removeInt(const char* id)
        throw(HxCorba::DatabaseException,
              CORBA::SystemException)
    {
        ptr_ -> removeInt(id);
    }

    virtual void
    removeDouble(const char* id)
        throw(HxCorba::DatabaseException,
              CORBA::SystemException)
    {
        ptr_ -> removeDouble(id);
    }

    virtual void
    removeString(const char* id)
        throw(HxCorba::DatabaseException,
              CORBA::SystemException)
    {
        ptr_ -> removeString(id);
    }

    virtual void
    changeInt(const char* id,
              CORBA::Long newValue)
        throw(HxCorba::DatabaseException,
              CORBA::SystemException)
    {
        ptr_ -> changeInt(id, newValue);
    }

    virtual void
    changeDouble(const char* id,
                 CORBA::Double newValue)
        throw(HxCorba::DatabaseException,
              CORBA::SystemException)
    {
        ptr_ -> changeDouble(id, newValue);
    }

    virtual void
    changeString(const char* id,
                 const char* newValue)
        throw(HxCorba::DatabaseException,
              CORBA::SystemException)
    {
        ptr_ -> changeString(id, newValue);
    }

    virtual void
    addInt(const char* id,
           CORBA::Long value)
        throw(HxCorba::DatabaseException,
              CORBA::SystemException)
    {
        ptr_ -> addInt(id, value);
    }

    virtual void
    addDouble(const char* id,
              CORBA::Double value)
        throw(HxCorba::DatabaseException,
              CORBA::SystemException)
    {
        ptr_ -> addDouble(id, value);
    }

    virtual void
    addString(const char* id,
              const char* value)
        throw(HxCorba::DatabaseException,
              CORBA::SystemException)
    {
        ptr_ -> addString(id, value);
    }

    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 VxMutableSegment::_default_POA();
    }
};

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

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

public:

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

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

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

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

    virtual
    ~VxMutableSegmentation_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
    removeSegment(CORBA::Long index)
        throw(HxCorba::DatabaseException,
              CORBA::SystemException)
    {
        ptr_ -> removeSegment(index);
    }

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

    virtual HxCorba::VxSegmentBuilder_ptr
    buildSegment(CORBA::Long start,
                 CORBA::Long end)
        throw(HxCorba::DatabaseException,
              CORBA::SystemException)
    {
        return ptr_ -> buildSegment(start, end);
    }

    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 VxMutableSegmentation::_default_POA();
    }
};

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

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

public:

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

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

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

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

    virtual
    ~UpdateSession_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
    removeVideo(const char* videoName)
        throw(HxCorba::DatabaseException,
              CORBA::SystemException)
    {
        ptr_ -> removeVideo(videoName);
    }

    virtual void
    removeSegmentation(HxCorba::VxSegmentation_ptr seg)
        throw(HxCorba::DatabaseException,
              CORBA::SystemException)
    {
        ptr_ -> removeSegmentation(seg);
    }

    virtual void
    removeSegment(HxCorba::VxSegment_ptr segment)
        throw(HxCorba::DatabaseException,
              CORBA::SystemException)
    {
        ptr_ -> removeSegment(segment);
    }

    virtual void
    addSegmentation(HxCorba::VxSegmentation_ptr seg,
                    const char* videoName,
                    const char* segName,
                    const char* description)
        throw(HxCorba::DatabaseException,
              CORBA::SystemException)
    {
        ptr_ -> addSegmentation(seg, videoName, segName, description);
    }

    virtual HxCorba::VxSegmentationBuilder_ptr
    buildSegmentation(const char* videoName,
                      const char* segName)
        throw(HxCorba::DatabaseException,
              CORBA::SystemException)
    {
        return ptr_ -> buildSegmentation(videoName, segName);
    }

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

    virtual HxCorba::StringSeq*
    listSegmentations(const char* videoName)
        throw(CORBA::SystemException)
    {
        return ptr_ -> listSegmentations(videoName);
    }

    virtual HxCorba::VxSegmentation_ptr
    getSegmentation(const char* videoName,
                    const char* segName)
        throw(CORBA::SystemException)
    {
        return ptr_ -> getSegmentation(videoName, segName);
    }

    virtual HxCorba::VxSegmentSeq*
    querySegments(const char* sqlQuery)
        throw(HxCorba::DatabaseException,
              CORBA::SystemException)
    {
        return ptr_ -> querySegments(sqlQuery);
    }

    virtual HxCorba::StringSeq*
    queryStrings(const char* sqlQuery)
        throw(HxCorba::DatabaseException,
              CORBA::SystemException)
    {
        return ptr_ -> queryStrings(sqlQuery);
    }

    virtual HxCorba::SegmentQueryResultSeq*
    queryMultipleSegments(const char* sqlQuery)
        throw(HxCorba::DatabaseException,
              CORBA::SystemException)
    {
        return ptr_ -> queryMultipleSegments(sqlQuery);
    }

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

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

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

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

public:

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

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

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

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

    virtual
    ~XMLSession_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 char*
    queryXML(const char* sqlQuery)
        throw(HxCorba::DatabaseException,
              CORBA::SystemException)
    {
        return ptr_ -> queryXML(sqlQuery);
    }

    virtual HxCorba::DBDataRowSeq*
    queryDBData(const char* sqlQuery,
                const HxCorba::DBDataTagSeq& resultType)
        throw(HxCorba::DatabaseException,
              CORBA::SystemException)
    {
        return ptr_ -> queryDBData(sqlQuery, resultType);
    }

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

    virtual HxCorba::StringSeq*
    listSegmentations(const char* videoName)
        throw(CORBA::SystemException)
    {
        return ptr_ -> listSegmentations(videoName);
    }

    virtual HxCorba::VxSegmentation_ptr
    getSegmentation(const char* videoName,
                    const char* segName)
        throw(CORBA::SystemException)
    {
        return ptr_ -> getSegmentation(videoName, segName);
    }

    virtual HxCorba::VxSegmentSeq*
    querySegments(const char* sqlQuery)
        throw(HxCorba::DatabaseException,
              CORBA::SystemException)
    {
        return ptr_ -> querySegments(sqlQuery);
    }

    virtual HxCorba::StringSeq*
    queryStrings(const char* sqlQuery)
        throw(HxCorba::DatabaseException,
              CORBA::SystemException)
    {
        return ptr_ -> queryStrings(sqlQuery);
    }

    virtual HxCorba::SegmentQueryResultSeq*
    queryMultipleSegments(const char* sqlQuery)
        throw(HxCorba::DatabaseException,
              CORBA::SystemException)
    {
        return ptr_ -> queryMultipleSegments(sqlQuery);
    }

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

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

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

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

public:

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

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

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

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

    virtual
    ~HistogramSession_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
    addHistogram(const char* imageName,
                 const char* setName,
                 const HxCorba::FloatSeq& histoData)
        throw(HxCorba::DatabaseException,
              CORBA::SystemException)
    {
        ptr_ -> addHistogram(imageName, setName, histoData);
    }

    virtual HxCorba::FloatSeq*
    getHistogram(const char* imageName,
                 const char* setName)
        throw(HxCorba::DatabaseException,
              CORBA::SystemException)
    {
        return ptr_ -> getHistogram(imageName, setName);
    }

    virtual HxCorba::StringSeq*
    nearest(const char* imageName,
            const char* setName,
            CORBA::Long count)
        throw(HxCorba::DatabaseException,
              CORBA::SystemException)
    {
        return ptr_ -> nearest(imageName, setName, count);
    }

    virtual HxCorba::StringSeq*
    random(const char* setName,
           CORBA::Long count)
        throw(HxCorba::DatabaseException,
              CORBA::SystemException)
    {
        return ptr_ -> random(setName, count);
    }

    virtual HxCorba::StringSeq*
    search(CORBA::Long count,
           const HxCorba::FloatSeq& sample)
        throw(HxCorba::DatabaseException,
              CORBA::SystemException)
    {
        return ptr_ -> search(count, sample);
    }

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

    virtual HxCorba::StringSeq*
    listSegmentations(const char* videoName)
        throw(CORBA::SystemException)
    {
        return ptr_ -> listSegmentations(videoName);
    }

    virtual HxCorba::VxSegmentation_ptr
    getSegmentation(const char* videoName,
                    const char* segName)
        throw(CORBA::SystemException)
    {
        return ptr_ -> getSegmentation(videoName, segName);
    }

    virtual HxCorba::VxSegmentSeq*
    querySegments(const char* sqlQuery)
        throw(HxCorba::DatabaseException,
              CORBA::SystemException)
    {
        return ptr_ -> querySegments(sqlQuery);
    }

    virtual HxCorba::StringSeq*
    queryStrings(const char* sqlQuery)
        throw(HxCorba::DatabaseException,
              CORBA::SystemException)
    {
        return ptr_ -> queryStrings(sqlQuery);
    }

    virtual HxCorba::SegmentQueryResultSeq*
    queryMultipleSegments(const char* sqlQuery)
        throw(HxCorba::DatabaseException,
              CORBA::SystemException)
    {
        return ptr_ -> queryMultipleSegments(sqlQuery);
    }

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

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

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

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

public:

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

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

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

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

    virtual
    ~VxSimilarityBuilder_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
    addSimilarity(CORBA::Long index1,
                  CORBA::Long index2,
                  CORBA::Double value,
                  CORBA::Long keyFrame1,
                  CORBA::Long keyFrame2)
        throw(HxCorba::DatabaseException,
              CORBA::SystemException)
    {
        ptr_ -> addSimilarity(index1, index2, value, keyFrame1, keyFrame2);
    }

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

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

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

public:

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

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

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

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

    virtual
    ~VxSimilaritySession_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::VxSimilarityBuilder_ptr
    addSimilarities(const char* videoName,
                    const char* segName,
                    const char* featureName)
        throw(HxCorba::DatabaseException,
              CORBA::SystemException)
    {
        return ptr_ -> addSimilarities(videoName, segName, featureName);
    }

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

    virtual HxCorba::StringSeq*
    listSegmentations(const char* videoName)
        throw(CORBA::SystemException)
    {
        return ptr_ -> listSegmentations(videoName);
    }

    virtual HxCorba::VxSegmentation_ptr
    getSegmentation(const char* videoName,
                    const char* segName)
        throw(CORBA::SystemException)
    {
        return ptr_ -> getSegmentation(videoName, segName);
    }

    virtual HxCorba::VxSegmentSeq*
    querySegments(const char* sqlQuery)
        throw(HxCorba::DatabaseException,
              CORBA::SystemException)
    {
        return ptr_ -> querySegments(sqlQuery);
    }

    virtual HxCorba::StringSeq*
    queryStrings(const char* sqlQuery)
        throw(HxCorba::DatabaseException,
              CORBA::SystemException)
    {
        return ptr_ -> queryStrings(sqlQuery);
    }

    virtual HxCorba::SegmentQueryResultSeq*
    queryMultipleSegments(const char* sqlQuery)
        throw(HxCorba::DatabaseException,
              CORBA::SystemException)
    {
        return ptr_ -> queryMultipleSegments(sqlQuery);
    }

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

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

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

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

public:

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

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

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

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

    virtual
    ~FullSession_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
    removeVideo(const char* videoName)
        throw(HxCorba::DatabaseException,
              CORBA::SystemException)
    {
        ptr_ -> removeVideo(videoName);
    }

    virtual void
    removeSegmentation(HxCorba::VxSegmentation_ptr seg)
        throw(HxCorba::DatabaseException,
              CORBA::SystemException)
    {
        ptr_ -> removeSegmentation(seg);
    }

    virtual void
    removeSegment(HxCorba::VxSegment_ptr segment)
        throw(HxCorba::DatabaseException,
              CORBA::SystemException)
    {
        ptr_ -> removeSegment(segment);
    }

    virtual void
    addSegmentation(HxCorba::VxSegmentation_ptr seg,
                    const char* videoName,
                    const char* segName,
                    const char* description)
        throw(HxCorba::DatabaseException,
              CORBA::SystemException)
    {
        ptr_ -> addSegmentation(seg, videoName, segName, description);
    }

    virtual HxCorba::VxSegmentationBuilder_ptr
    buildSegmentation(const char* videoName,
                      const char* segName)
        throw(HxCorba::DatabaseException,
              CORBA::SystemException)
    {
        return ptr_ -> buildSegmentation(videoName, segName);
    }

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

    virtual HxCorba::StringSeq*
    listSegmentations(const char* videoName)
        throw(CORBA::SystemException)
    {
        return ptr_ -> listSegmentations(videoName);
    }

    virtual HxCorba::VxSegmentation_ptr
    getSegmentation(const char* videoName,
                    const char* segName)
        throw(CORBA::SystemException)
    {
        return ptr_ -> getSegmentation(videoName, segName);
    }

    virtual HxCorba::VxSegmentSeq*
    querySegments(const char* sqlQuery)
        throw(HxCorba::DatabaseException,
              CORBA::SystemException)
    {
        return ptr_ -> querySegments(sqlQuery);
    }

    virtual HxCorba::StringSeq*
    queryStrings(const char* sqlQuery)
        throw(HxCorba::DatabaseException,
              CORBA::SystemException)
    {
        return ptr_ -> queryStrings(sqlQuery);
    }

    virtual HxCorba::SegmentQueryResultSeq*
    queryMultipleSegments(const char* sqlQuery)
        throw(HxCorba::DatabaseException,
              CORBA::SystemException)
    {
        return ptr_ -> queryMultipleSegments(sqlQuery);
    }

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

    virtual char*
    queryXML(const char* sqlQuery)
        throw(HxCorba::DatabaseException,
              CORBA::SystemException)
    {
        return ptr_ -> queryXML(sqlQuery);
    }

    virtual HxCorba::DBDataRowSeq*
    queryDBData(const char* sqlQuery,
                const HxCorba::DBDataTagSeq& resultType)
        throw(HxCorba::DatabaseException,
              CORBA::SystemException)
    {
        return ptr_ -> queryDBData(sqlQuery, resultType);
    }

    virtual void
    addHistogram(const char* imageName,
                 const char* setName,
                 const HxCorba::FloatSeq& histoData)
        throw(HxCorba::DatabaseException,
              CORBA::SystemException)
    {
        ptr_ -> addHistogram(imageName, setName, histoData);
    }

    virtual HxCorba::FloatSeq*
    getHistogram(const char* imageName,
                 const char* setName)
        throw(HxCorba::DatabaseException,
              CORBA::SystemException)
    {
        return ptr_ -> getHistogram(imageName, setName);
    }

    virtual HxCorba::StringSeq*
    nearest(const char* imageName,
            const char* setName,
            CORBA::Long count)
        throw(HxCorba::DatabaseException,
              CORBA::SystemException)
    {
        return ptr_ -> nearest(imageName, setName, count);
    }

    virtual HxCorba::StringSeq*
    random(const char* setName,
           CORBA::Long count)
        throw(HxCorba::DatabaseException,
              CORBA::SystemException)
    {
        return ptr_ -> random(setName, count);
    }

    virtual HxCorba::StringSeq*
    search(CORBA::Long count,
           const HxCorba::FloatSeq& sample)
        throw(HxCorba::DatabaseException,
              CORBA::SystemException)
    {
        return ptr_ -> search(count, sample);
    }

    virtual HxCorba::VxSimilarityBuilder_ptr
    addSimilarities(const char* videoName,
                    const char* segName,
                    const char* featureName)
        throw(HxCorba::DatabaseException,
              CORBA::SystemException)
    {
        return ptr_ -> addSimilarities(videoName, segName, featureName);
    }

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

} // End of namespace POA_HxCorba

#endif

---