---

HxCorbaDatabase.h

Go to the documentation of this file.

// **********************************************************************
//
// Generated by the ORBacus IDL-to-C++ Translator
//
// Copyright (c) 2000
// Object Oriented Concepts, Inc.
// Billerica, MA, USA
//
// All Rights Reserved
//
// **********************************************************************

// Version: 4.0.5

#ifndef ___HxCorbaDatabase_h__
#define ___HxCorbaDatabase_h__

#include <HxCorbaVxSegmentation.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 != 4000500L)
#       error ORBacus version mismatch!
#   endif
#endif

namespace HxCorba
{

class VxSegmentBuilder;
typedef VxSegmentBuilder* VxSegmentBuilder_ptr;
typedef VxSegmentBuilder* VxSegmentBuilderRef;

extern OB::TypeCodeConst _tc_VxSegmentBuilder;

class VxSegmentationBuilder;
typedef VxSegmentationBuilder* VxSegmentationBuilder_ptr;
typedef VxSegmentationBuilder* VxSegmentationBuilderRef;

extern OB::TypeCodeConst _tc_VxSegmentationBuilder;

class VxJoinedSegments;
typedef VxJoinedSegments* VxJoinedSegments_ptr;
typedef VxJoinedSegments* VxJoinedSegmentsRef;

extern OB::TypeCodeConst _tc_VxJoinedSegments;

class DatabaseSession;
typedef DatabaseSession* DatabaseSession_ptr;
typedef DatabaseSession* DatabaseSessionRef;

extern OB::TypeCodeConst _tc_DatabaseSession;

class Database;
typedef Database* Database_ptr;
typedef Database* DatabaseRef;

extern OB::TypeCodeConst _tc_Database;

} // End of namespace HxCorba

void OBDuplicate(HxCorba::VxSegmentBuilder_ptr);
void OBRelease(HxCorba::VxSegmentBuilder_ptr);

void OBMarshal(HxCorba::VxSegmentBuilder_ptr, OB::OutputStreamImpl*);
void OBUnmarshal(HxCorba::VxSegmentBuilder_ptr&, OB::InputStreamImpl*);

void OBDuplicate(HxCorba::VxSegmentationBuilder_ptr);
void OBRelease(HxCorba::VxSegmentationBuilder_ptr);

void OBMarshal(HxCorba::VxSegmentationBuilder_ptr, OB::OutputStreamImpl*);
void OBUnmarshal(HxCorba::VxSegmentationBuilder_ptr&, OB::InputStreamImpl*);

void OBDuplicate(HxCorba::VxJoinedSegments_ptr);
void OBRelease(HxCorba::VxJoinedSegments_ptr);

void OBMarshal(HxCorba::VxJoinedSegments_ptr, OB::OutputStreamImpl*);
void OBUnmarshal(HxCorba::VxJoinedSegments_ptr&, OB::InputStreamImpl*);

void OBDuplicate(HxCorba::DatabaseSession_ptr);
void OBRelease(HxCorba::DatabaseSession_ptr);

void OBMarshal(HxCorba::DatabaseSession_ptr, OB::OutputStreamImpl*);
void OBUnmarshal(HxCorba::DatabaseSession_ptr&, OB::InputStreamImpl*);

void OBDuplicate(HxCorba::Database_ptr);
void OBRelease(HxCorba::Database_ptr);

void OBMarshal(HxCorba::Database_ptr, OB::OutputStreamImpl*);
void OBUnmarshal(HxCorba::Database_ptr&, OB::InputStreamImpl*);

namespace HxCorba
{

typedef OB::ObjVar< VxSegmentBuilder > VxSegmentBuilder_var;
typedef OB::ObjOut< VxSegmentBuilder > VxSegmentBuilder_out;

typedef OB::ObjVar< VxSegmentationBuilder > VxSegmentationBuilder_var;
typedef OB::ObjOut< VxSegmentationBuilder > VxSegmentationBuilder_out;

typedef OB::ObjVar< VxJoinedSegments > VxJoinedSegments_var;
typedef OB::ObjOut< VxJoinedSegments > VxJoinedSegments_out;

typedef OB::ObjVar< DatabaseSession > DatabaseSession_var;
typedef OB::ObjOut< DatabaseSession > DatabaseSession_out;

typedef OB::ObjVar< Database > Database_var;
typedef OB::ObjOut< Database > Database_out;

} // End of namespace HxCorba

namespace OBStubImpl_HxCorba
{

class VxSegmentBuilder;
typedef VxSegmentBuilder* VxSegmentBuilder_ptr;

class VxSegmentationBuilder;
typedef VxSegmentationBuilder* VxSegmentationBuilder_ptr;

class VxJoinedSegments;
typedef VxJoinedSegments* VxJoinedSegments_ptr;

class DatabaseSession;
typedef DatabaseSession* DatabaseSession_ptr;

class Database;
typedef Database* Database_ptr;

} // End of namespace OBStubImpl_HxCorba

void OBDuplicate(OBStubImpl_HxCorba::VxSegmentBuilder_ptr);
void OBRelease(OBStubImpl_HxCorba::VxSegmentBuilder_ptr);

void OBDuplicate(OBStubImpl_HxCorba::VxSegmentationBuilder_ptr);
void OBRelease(OBStubImpl_HxCorba::VxSegmentationBuilder_ptr);

void OBDuplicate(OBStubImpl_HxCorba::VxJoinedSegments_ptr);
void OBRelease(OBStubImpl_HxCorba::VxJoinedSegments_ptr);

void OBDuplicate(OBStubImpl_HxCorba::DatabaseSession_ptr);
void OBRelease(OBStubImpl_HxCorba::DatabaseSession_ptr);

void OBDuplicate(OBStubImpl_HxCorba::Database_ptr);
void OBRelease(OBStubImpl_HxCorba::Database_ptr);

namespace OBStubImpl_HxCorba
{

typedef OB::ObjVar< VxSegmentBuilder > VxSegmentBuilder_var;

typedef OB::ObjVar< VxSegmentationBuilder > VxSegmentationBuilder_var;

typedef OB::ObjVar< VxJoinedSegments > VxJoinedSegments_var;

typedef OB::ObjVar< DatabaseSession > DatabaseSession_var;

typedef OB::ObjVar< Database > Database_var;

} // End of namespace OBStubImpl_HxCorba

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

//
// IDL:HxCorba/DatabaseException:1.0
//
struct DatabaseException : public CORBA::UserException
{
#ifdef OB_CLEAR_MEM
    DatabaseException();
#else
    DatabaseException() { }
#endif
    DatabaseException(const DatabaseException&);
    DatabaseException& operator=(const DatabaseException&);

    static DatabaseException* _downcast(CORBA::Exception*);
    static const DatabaseException* _downcast(const CORBA::Exception*);
    virtual const char* _name() const;
    virtual void _raise() const { throw *this; }
    virtual const char* _rep_id() const;
    virtual char* _to_string() const;

    virtual CORBA::Exception* _OB_clone() const;
    virtual void _OB_insertInAny(CORBA::Any&);

    CORBA::Long dbCode;
    OB::StrForStruct dbMessage;
    OB::StrForStruct message;

    DatabaseException(CORBA::Long,
                      const char*,
                      const char*);

    virtual void _OB_marshal(OB::OutputStreamImpl*) const;
    static void _OB_unmarshal(DatabaseException&, OB::InputStreamImpl*);
};

extern OB::TypeCodeConst _tc_DatabaseException;

//
// IDL:HxCorba/VxSegmentBuilder:1.0
//
class VxSegmentBuilder : virtual public CORBA::Object
{
    VxSegmentBuilder(const VxSegmentBuilder&);
    void operator=(const VxSegmentBuilder&);

    static const char* ids_[];

protected:

    virtual OB::MarshalStubImpl_ptr _OB_createMarshalStubImpl();

public:

    VxSegmentBuilder() { }
    virtual ~VxSegmentBuilder() { }

    typedef VxSegmentBuilder_ptr _ptr_type;
    typedef VxSegmentBuilder_var _var_type;

    static inline VxSegmentBuilder_ptr
    _duplicate(VxSegmentBuilder_ptr p)
    {
        if(p)
            p -> _OB_incRef();
        return p;
    }

    static inline VxSegmentBuilder_ptr
    _nil()
    {
        return 0;
    }

    static VxSegmentBuilder_ptr _narrow(CORBA::Object_ptr);
    static VxSegmentBuilder_ptr _narrow(CORBA::AbstractBase_ptr);

    virtual const char** _OB_ids() const;
    static const char** _OB_staticIds();

    //
    // IDL:HxCorba/VxSegmentBuilder/addInt:1.0
    //
    void addInt(const char* id,
                CORBA::Long value);

    //
    // IDL:HxCorba/VxSegmentBuilder/addDouble:1.0
    //
    void addDouble(const char* id,
                   CORBA::Double value);

    //
    // IDL:HxCorba/VxSegmentBuilder/addString:1.0
    //
    void addString(const char* id,
                   const char* value);

    //
    // IDL:HxCorba/VxSegmentBuilder/close:1.0
    //
    void close();
};

//
// IDL:HxCorba/VxSegmentationBuilder:1.0
//
class VxSegmentationBuilder : virtual public CORBA::Object
{
    VxSegmentationBuilder(const VxSegmentationBuilder&);
    void operator=(const VxSegmentationBuilder&);

    static const char* ids_[];

protected:

    virtual OB::MarshalStubImpl_ptr _OB_createMarshalStubImpl();

public:

    VxSegmentationBuilder() { }
    virtual ~VxSegmentationBuilder() { }

    typedef VxSegmentationBuilder_ptr _ptr_type;
    typedef VxSegmentationBuilder_var _var_type;

    static inline VxSegmentationBuilder_ptr
    _duplicate(VxSegmentationBuilder_ptr p)
    {
        if(p)
            p -> _OB_incRef();
        return p;
    }

    static inline VxSegmentationBuilder_ptr
    _nil()
    {
        return 0;
    }

    static VxSegmentationBuilder_ptr _narrow(CORBA::Object_ptr);
    static VxSegmentationBuilder_ptr _narrow(CORBA::AbstractBase_ptr);

    virtual const char** _OB_ids() const;
    static const char** _OB_staticIds();

    //
    // IDL:HxCorba/VxSegmentationBuilder/setDescription:1.0
    //
    void setDescription(const char* description);

    //
    // IDL:HxCorba/VxSegmentationBuilder/addSegment:1.0
    //
    VxSegmentBuilder_ptr addSegment(CORBA::Long start,
                                    CORBA::Long end);

    //
    // IDL:HxCorba/VxSegmentationBuilder/close:1.0
    //
    void close();
};

//
// IDL:HxCorba/FeatureCondition:1.0
//
struct FeatureCondition;
typedef OB::VarVar< FeatureCondition > FeatureCondition_var;
typedef OB::VarOut< FeatureCondition > FeatureCondition_out;

struct FeatureCondition
{
    FeatureCondition() { }
    FeatureCondition(const FeatureCondition&);
    FeatureCondition& operator=(const FeatureCondition&);

    typedef FeatureCondition_var _var_type;

    OB::StrForStruct featType;
    OB::StrForStruct feature;
    OB::StrForStruct expression;

    void _OB_marshal(OB::OutputStreamImpl*) const;
    static void _OB_unmarshal(FeatureCondition&, OB::InputStreamImpl*);
};

extern OB::TypeCodeConst _tc_FeatureCondition;

//
// IDL:HxCorba/FeatureCondSeq:1.0
//
class OBUnique_FeatureCondSeq { };

typedef OB::VarSeq< FeatureCondition, OBUnique_FeatureCondSeq > FeatureCondSeq;
typedef OB::SeqVar< OB::VarSeq< FeatureCondition, OBUnique_FeatureCondSeq > > FeatureCondSeq_var;
typedef OB::SeqOut< OB::VarSeq< FeatureCondition, OBUnique_FeatureCondSeq > > FeatureCondSeq_out;
extern OB::TypeCodeConst _tc_FeatureCondSeq;

struct OBInfo_FeatureCondSeq : public OB::ConstructedInfo
{
    OBInfo_FeatureCondSeq() { }

    virtual void free(void* p) const
    {
        delete (FeatureCondSeq*)p;
    }

    virtual void* dup(const void* p) const
    {
        return new FeatureCondSeq(*(const FeatureCondSeq*)p);
    }

    virtual void marshal(const void*, OB::OutputStreamImpl*) const;
    virtual void unmarshal(void*, OB::InputStreamImpl*) const;
};

//
// IDL:HxCorba/SegmentationCondition:1.0
//
struct SegmentationCondition;
typedef OB::VarVar< SegmentationCondition > SegmentationCondition_var;
typedef OB::VarOut< SegmentationCondition > SegmentationCondition_out;

struct SegmentationCondition
{
    SegmentationCondition() { }
    SegmentationCondition(const SegmentationCondition&);
    SegmentationCondition& operator=(const SegmentationCondition&);

    typedef SegmentationCondition_var _var_type;

    OB::StrForStruct segName;
    FeatureCondSeq featureCond;

    void _OB_marshal(OB::OutputStreamImpl*) const;
    static void _OB_unmarshal(SegmentationCondition&, OB::InputStreamImpl*);
};

extern OB::TypeCodeConst _tc_SegmentationCondition;

//
// IDL:HxCorba/SegmentationConditionSeq:1.0
//
class OBUnique_SegmentationConditionSeq { };

typedef OB::VarSeq< SegmentationCondition, OBUnique_SegmentationConditionSeq > SegmentationConditionSeq;
typedef OB::SeqVar< OB::VarSeq< SegmentationCondition, OBUnique_SegmentationConditionSeq > > SegmentationConditionSeq_var;
typedef OB::SeqOut< OB::VarSeq< SegmentationCondition, OBUnique_SegmentationConditionSeq > > SegmentationConditionSeq_out;
extern OB::TypeCodeConst _tc_SegmentationConditionSeq;

struct OBInfo_SegmentationConditionSeq : public OB::ConstructedInfo
{
    OBInfo_SegmentationConditionSeq() { }

    virtual void free(void* p) const
    {
        delete (SegmentationConditionSeq*)p;
    }

    virtual void* dup(const void* p) const
    {
        return new SegmentationConditionSeq(*(const SegmentationConditionSeq*)p);
    }

    virtual void marshal(const void*, OB::OutputStreamImpl*) const;
    virtual void unmarshal(void*, OB::InputStreamImpl*) const;
};

//
// IDL:HxCorba/OverlappingCondition:1.0
//
struct OverlappingCondition;
typedef OB::VarVar< OverlappingCondition > OverlappingCondition_var;
typedef OB::VarOut< OverlappingCondition > OverlappingCondition_out;

struct OverlappingCondition
{
#ifdef OB_CLEAR_MEM
    OverlappingCondition();
#else
    OverlappingCondition() { }
#endif
    OverlappingCondition(const OverlappingCondition&);
    OverlappingCondition& operator=(const OverlappingCondition&);

    typedef OverlappingCondition_var _var_type;

    CORBA::Boolean total;
    SegmentationCondition segCond;

    void _OB_marshal(OB::OutputStreamImpl*) const;
    static void _OB_unmarshal(OverlappingCondition&, OB::InputStreamImpl*);
};

extern OB::TypeCodeConst _tc_OverlappingCondition;

//
// IDL:HxCorba/OverlappingCondSeq:1.0
//
class OBUnique_OverlappingCondSeq { };

typedef OB::VarSeq< OverlappingCondition, OBUnique_OverlappingCondSeq > OverlappingCondSeq;
typedef OB::SeqVar< OB::VarSeq< OverlappingCondition, OBUnique_OverlappingCondSeq > > OverlappingCondSeq_var;
typedef OB::SeqOut< OB::VarSeq< OverlappingCondition, OBUnique_OverlappingCondSeq > > OverlappingCondSeq_out;
extern OB::TypeCodeConst _tc_OverlappingCondSeq;

struct OBInfo_OverlappingCondSeq : public OB::ConstructedInfo
{
    OBInfo_OverlappingCondSeq() { }

    virtual void free(void* p) const
    {
        delete (OverlappingCondSeq*)p;
    }

    virtual void* dup(const void* p) const
    {
        return new OverlappingCondSeq(*(const OverlappingCondSeq*)p);
    }

    virtual void marshal(const void*, OB::OutputStreamImpl*) const;
    virtual void unmarshal(void*, OB::InputStreamImpl*) const;
};

//
// IDL:HxCorba/VxJoinedSegments:1.0
//
class VxJoinedSegments : virtual public CORBA::Object
{
    VxJoinedSegments(const VxJoinedSegments&);
    void operator=(const VxJoinedSegments&);

    static const char* ids_[];

protected:

    virtual OB::MarshalStubImpl_ptr _OB_createMarshalStubImpl();

public:

    VxJoinedSegments() { }
    virtual ~VxJoinedSegments() { }

    typedef VxJoinedSegments_ptr _ptr_type;
    typedef VxJoinedSegments_var _var_type;

    static inline VxJoinedSegments_ptr
    _duplicate(VxJoinedSegments_ptr p)
    {
        if(p)
            p -> _OB_incRef();
        return p;
    }

    static inline VxJoinedSegments_ptr
    _nil()
    {
        return 0;
    }

    static VxJoinedSegments_ptr _narrow(CORBA::Object_ptr);
    static VxJoinedSegments_ptr _narrow(CORBA::AbstractBase_ptr);

    virtual const char** _OB_ids() const;
    static const char** _OB_staticIds();

    //
    // IDL:HxCorba/VxJoinedSegments/start:1.0
    //
    CORBA::Long start();

    //
    // IDL:HxCorba/VxJoinedSegments/end:1.0
    //
    CORBA::Long end();

    //
    // IDL:HxCorba/VxJoinedSegments/getInt:1.0
    //
    CORBA::Long getInt(const char* segmentation,
                       const char* id);

    //
    // IDL:HxCorba/VxJoinedSegments/getDouble:1.0
    //
    CORBA::Double getDouble(const char* segmentation,
                            const char* id);

    //
    // IDL:HxCorba/VxJoinedSegments/getString:1.0
    //
    char* getString(const char* segmentation,
                    const char* id);

    //
    // IDL:HxCorba/VxJoinedSegments/getIntFlag:1.0
    //
    CORBA::Long getIntFlag(const char* segmentation,
                           const char* id,
                           CORBA::Boolean_out present);

    //
    // IDL:HxCorba/VxJoinedSegments/getDoubleFlag:1.0
    //
    CORBA::Double getDoubleFlag(const char* segmentation,
                                const char* id,
                                CORBA::Boolean_out present);

    //
    // IDL:HxCorba/VxJoinedSegments/getStringFlag:1.0
    //
    char* getStringFlag(const char* segmentation,
                        const char* id,
                        CORBA::Boolean_out present);

    //
    // IDL:HxCorba/VxJoinedSegments/listSegmentations:1.0
    //
    StringSeq* listSegmentations();

    //
    // IDL:HxCorba/VxJoinedSegments/getSegment:1.0
    //
    VxSegment_ptr getSegment(const char* segmentation);
};

//
// IDL:HxCorba/VxJoinedSegmentsSeq:1.0
//
class OBUnique_VxJoinedSegmentsSeq { };

typedef OB::ObjSeq< VxJoinedSegments, OBUnique_VxJoinedSegmentsSeq > VxJoinedSegmentsSeq;
typedef OB::SeqVar< OB::ObjSeq< VxJoinedSegments, OBUnique_VxJoinedSegmentsSeq > > VxJoinedSegmentsSeq_var;
typedef OB::SeqOut< OB::ObjSeq< VxJoinedSegments, OBUnique_VxJoinedSegmentsSeq > > VxJoinedSegmentsSeq_out;
extern OB::TypeCodeConst _tc_VxJoinedSegmentsSeq;

struct OBInfo_VxJoinedSegmentsSeq : public OB::ConstructedInfo
{
    OBInfo_VxJoinedSegmentsSeq() { }

    virtual void free(void* p) const
    {
        delete (VxJoinedSegmentsSeq*)p;
    }

    virtual void* dup(const void* p) const
    {
        return new VxJoinedSegmentsSeq(*(const VxJoinedSegmentsSeq*)p);
    }

    virtual void marshal(const void*, OB::OutputStreamImpl*) const;
    virtual void unmarshal(void*, OB::InputStreamImpl*) const;
};

//
// IDL:HxCorba/DatabaseSession:1.0
//
class DatabaseSession : virtual public CORBA::Object
{
    DatabaseSession(const DatabaseSession&);
    void operator=(const DatabaseSession&);

    static const char* ids_[];

protected:

    virtual OB::MarshalStubImpl_ptr _OB_createMarshalStubImpl();

public:

    DatabaseSession() { }
    virtual ~DatabaseSession() { }

    typedef DatabaseSession_ptr _ptr_type;
    typedef DatabaseSession_var _var_type;

    static inline DatabaseSession_ptr
    _duplicate(DatabaseSession_ptr p)
    {
        if(p)
            p -> _OB_incRef();
        return p;
    }

    static inline DatabaseSession_ptr
    _nil()
    {
        return 0;
    }

    static DatabaseSession_ptr _narrow(CORBA::Object_ptr);
    static DatabaseSession_ptr _narrow(CORBA::AbstractBase_ptr);

    virtual const char** _OB_ids() const;
    static const char** _OB_staticIds();

    //
    // IDL:HxCorba/DatabaseSession/listVideos:1.0
    //
    StringSeq* listVideos();

    //
    // IDL:HxCorba/DatabaseSession/listSegmentations:1.0
    //
    StringSeq* listSegmentations(const char* videoName);

    //
    // IDL:HxCorba/DatabaseSession/getSegmentation:1.0
    //
    VxSegmentation_ptr getSegmentation(const char* videoName,
                                       const char* segName);

    //
    // IDL:HxCorba/DatabaseSession/addSegmentation:1.0
    //
    void addSegmentation(VxSegmentation_ptr seg,
                         const char* videoName,
                         const char* segName,
                         const char* description);

    //
    // IDL:HxCorba/DatabaseSession/buildSegmentation:1.0
    //
    VxSegmentationBuilder_ptr buildSegmentation(const char* videoName,
                                                const char* segName);

    //
    // IDL:HxCorba/DatabaseSession/querySegments:1.0
    //
    VxSegmentSeq* querySegments(const char* sqlQuery);

    //
    // IDL:HxCorba/DatabaseSession/querySegmentations:1.0
    //
    VxSegmentSeq* querySegmentations(const char* videoName,
                                     const SegmentationCondition& segCond,
                                     const OverlappingCondSeq& overlappings);

    //
    // IDL:HxCorba/DatabaseSession/queryIntersections:1.0
    //
    VxJoinedSegmentsSeq* queryIntersections(const char* videoName,
                                            const SegmentationConditionSeq& conds);

    //
    // IDL:HxCorba/DatabaseSession/queryXML:1.0
    //
    char* queryXML(const char* sqlQuery);

    //
    // IDL:HxCorba/DatabaseSession/close:1.0
    //
    void close();
};

//
// IDL:HxCorba/Database:1.0
//
class Database : virtual public CORBA::Object
{
    Database(const Database&);
    void operator=(const Database&);

    static const char* ids_[];

protected:

    virtual OB::MarshalStubImpl_ptr _OB_createMarshalStubImpl();

public:

    Database() { }
    virtual ~Database() { }

    typedef Database_ptr _ptr_type;
    typedef Database_var _var_type;

    static inline Database_ptr
    _duplicate(Database_ptr p)
    {
        if(p)
            p -> _OB_incRef();
        return p;
    }

    static inline Database_ptr
    _nil()
    {
        return 0;
    }

    static Database_ptr _narrow(CORBA::Object_ptr);
    static Database_ptr _narrow(CORBA::AbstractBase_ptr);

    virtual const char** _OB_ids() const;
    static const char** _OB_staticIds();

    //
    // IDL:HxCorba/Database/openSession:1.0
    //
    DatabaseSession_ptr openSession(const char* username,
                                    const char* password);
};

} // End of namespace HxCorba

//
// IDL:HxCorba:1.0
//
namespace OBStubImpl_HxCorba
{

//
// IDL:HxCorba/VxSegmentBuilder:1.0
//
class VxSegmentBuilder : virtual public OB::StubImplBase
{
    VxSegmentBuilder(const VxSegmentBuilder&);
    void operator=(const VxSegmentBuilder&);

protected:

    VxSegmentBuilder() { }

public:

    static inline VxSegmentBuilder_ptr
    _duplicate(VxSegmentBuilder_ptr p)
    {
        if(p)
            p -> _OB_incRef();
        return p;
    }

    static inline VxSegmentBuilder_ptr
    _nil()
    {
        return 0;
    }

    //
    // IDL:HxCorba/VxSegmentBuilder/addInt:1.0
    //
    virtual void addInt(const char* id,
                        CORBA::Long value) = 0;

    //
    // IDL:HxCorba/VxSegmentBuilder/addDouble:1.0
    //
    virtual void addDouble(const char* id,
                           CORBA::Double value) = 0;

    //
    // IDL:HxCorba/VxSegmentBuilder/addString:1.0
    //
    virtual void addString(const char* id,
                           const char* value) = 0;

    //
    // IDL:HxCorba/VxSegmentBuilder/close:1.0
    //
    virtual void close() = 0;
};

//
// IDL:HxCorba/VxSegmentationBuilder:1.0
//
class VxSegmentationBuilder : virtual public OB::StubImplBase
{
    VxSegmentationBuilder(const VxSegmentationBuilder&);
    void operator=(const VxSegmentationBuilder&);

protected:

    VxSegmentationBuilder() { }

public:

    static inline VxSegmentationBuilder_ptr
    _duplicate(VxSegmentationBuilder_ptr p)
    {
        if(p)
            p -> _OB_incRef();
        return p;
    }

    static inline VxSegmentationBuilder_ptr
    _nil()
    {
        return 0;
    }

    //
    // IDL:HxCorba/VxSegmentationBuilder/setDescription:1.0
    //
    virtual void setDescription(const char* description) = 0;

    //
    // IDL:HxCorba/VxSegmentationBuilder/addSegment:1.0
    //
    virtual HxCorba::VxSegmentBuilder_ptr addSegment(CORBA::Long start,
                                                     CORBA::Long end) = 0;

    //
    // IDL:HxCorba/VxSegmentationBuilder/close:1.0
    //
    virtual void close() = 0;
};

//
// IDL:HxCorba/VxJoinedSegments:1.0
//
class VxJoinedSegments : virtual public OB::StubImplBase
{
    VxJoinedSegments(const VxJoinedSegments&);
    void operator=(const VxJoinedSegments&);

protected:

    VxJoinedSegments() { }

public:

    static inline VxJoinedSegments_ptr
    _duplicate(VxJoinedSegments_ptr p)
    {
        if(p)
            p -> _OB_incRef();
        return p;
    }

    static inline VxJoinedSegments_ptr
    _nil()
    {
        return 0;
    }

    //
    // IDL:HxCorba/VxJoinedSegments/start:1.0
    //
    virtual CORBA::Long start() = 0;

    //
    // IDL:HxCorba/VxJoinedSegments/end:1.0
    //
    virtual CORBA::Long end() = 0;

    //
    // IDL:HxCorba/VxJoinedSegments/getInt:1.0
    //
    virtual CORBA::Long getInt(const char* segmentation,
                               const char* id) = 0;

    //
    // IDL:HxCorba/VxJoinedSegments/getDouble:1.0
    //
    virtual CORBA::Double getDouble(const char* segmentation,
                                    const char* id) = 0;

    //
    // IDL:HxCorba/VxJoinedSegments/getString:1.0
    //
    virtual char* getString(const char* segmentation,
                            const char* id) = 0;

    //
    // IDL:HxCorba/VxJoinedSegments/getIntFlag:1.0
    //
    virtual CORBA::Long getIntFlag(const char* segmentation,
                                   const char* id,
                                   CORBA::Boolean_out present) = 0;

    //
    // IDL:HxCorba/VxJoinedSegments/getDoubleFlag:1.0
    //
    virtual CORBA::Double getDoubleFlag(const char* segmentation,
                                        const char* id,
                                        CORBA::Boolean_out present) = 0;

    //
    // IDL:HxCorba/VxJoinedSegments/getStringFlag:1.0
    //
    virtual char* getStringFlag(const char* segmentation,
                                const char* id,
                                CORBA::Boolean_out present) = 0;

    //
    // IDL:HxCorba/VxJoinedSegments/listSegmentations:1.0
    //
    virtual HxCorba::StringSeq* listSegmentations() = 0;

    //
    // IDL:HxCorba/VxJoinedSegments/getSegment:1.0
    //
    virtual HxCorba::VxSegment_ptr getSegment(const char* segmentation) = 0;
};

//
// IDL:HxCorba/DatabaseSession:1.0
//
class DatabaseSession : virtual public OB::StubImplBase
{
    DatabaseSession(const DatabaseSession&);
    void operator=(const DatabaseSession&);

protected:

    DatabaseSession() { }

public:

    static inline DatabaseSession_ptr
    _duplicate(DatabaseSession_ptr p)
    {
        if(p)
            p -> _OB_incRef();
        return p;
    }

    static inline DatabaseSession_ptr
    _nil()
    {
        return 0;
    }

    //
    // IDL:HxCorba/DatabaseSession/listVideos:1.0
    //
    virtual HxCorba::StringSeq* listVideos() = 0;

    //
    // IDL:HxCorba/DatabaseSession/listSegmentations:1.0
    //
    virtual HxCorba::StringSeq* listSegmentations(const char* videoName) = 0;

    //
    // IDL:HxCorba/DatabaseSession/getSegmentation:1.0
    //
    virtual HxCorba::VxSegmentation_ptr getSegmentation(const char* videoName,
                                                        const char* segName) = 0;

    //
    // IDL:HxCorba/DatabaseSession/addSegmentation:1.0
    //
    virtual void addSegmentation(HxCorba::VxSegmentation_ptr seg,
                                 const char* videoName,
                                 const char* segName,
                                 const char* description) = 0;

    //
    // IDL:HxCorba/DatabaseSession/buildSegmentation:1.0
    //
    virtual HxCorba::VxSegmentationBuilder_ptr buildSegmentation(const char* videoName,
                                                                 const char* segName) = 0;

    //
    // IDL:HxCorba/DatabaseSession/querySegments:1.0
    //
    virtual HxCorba::VxSegmentSeq* querySegments(const char* sqlQuery) = 0;

    //
    // IDL:HxCorba/DatabaseSession/querySegmentations:1.0
    //
    virtual HxCorba::VxSegmentSeq* querySegmentations(const char* videoName,
                                                      const HxCorba::SegmentationCondition& segCond,
                                                      const HxCorba::OverlappingCondSeq& overlappings) = 0;

    //
    // IDL:HxCorba/DatabaseSession/queryIntersections:1.0
    //
    virtual HxCorba::VxJoinedSegmentsSeq* queryIntersections(const char* videoName,
                                                             const HxCorba::SegmentationConditionSeq& conds) = 0;

    //
    // IDL:HxCorba/DatabaseSession/queryXML:1.0
    //
    virtual char* queryXML(const char* sqlQuery) = 0;

    //
    // IDL:HxCorba/DatabaseSession/close:1.0
    //
    virtual void close() = 0;
};

//
// IDL:HxCorba/Database:1.0
//
class Database : virtual public OB::StubImplBase
{
    Database(const Database&);
    void operator=(const Database&);

protected:

    Database() { }

public:

    static inline Database_ptr
    _duplicate(Database_ptr p)
    {
        if(p)
            p -> _OB_incRef();
        return p;
    }

    static inline Database_ptr
    _nil()
    {
        return 0;
    }

    //
    // IDL:HxCorba/Database/openSession:1.0
    //
    virtual HxCorba::DatabaseSession_ptr openSession(const char* username,
                                                     const char* password) = 0;
};

} // End of namespace OBStubImpl_HxCorba

//
// IDL:HxCorba:1.0
//
namespace OBMarshalStubImpl_HxCorba
{

//
// IDL:HxCorba/VxSegmentBuilder:1.0
//
class VxSegmentBuilder : virtual public OBStubImpl_HxCorba::VxSegmentBuilder,
                         virtual public OB::MarshalStubImpl
{
    VxSegmentBuilder(const VxSegmentBuilder&);
    void operator=(const VxSegmentBuilder&);

protected:

    VxSegmentBuilder() { }
    friend class HxCorba::VxSegmentBuilder;

public:

    //
    // IDL:HxCorba/VxSegmentBuilder/addInt:1.0
    //
    virtual void addInt(const char* id,
                        CORBA::Long value);

    //
    // IDL:HxCorba/VxSegmentBuilder/addDouble:1.0
    //
    virtual void addDouble(const char* id,
                           CORBA::Double value);

    //
    // IDL:HxCorba/VxSegmentBuilder/addString:1.0
    //
    virtual void addString(const char* id,
                           const char* value);

    //
    // IDL:HxCorba/VxSegmentBuilder/close:1.0
    //
    virtual void close();
};

//
// IDL:HxCorba/VxSegmentationBuilder:1.0
//
class VxSegmentationBuilder : virtual public OBStubImpl_HxCorba::VxSegmentationBuilder,
                              virtual public OB::MarshalStubImpl
{
    VxSegmentationBuilder(const VxSegmentationBuilder&);
    void operator=(const VxSegmentationBuilder&);

protected:

    VxSegmentationBuilder() { }
    friend class HxCorba::VxSegmentationBuilder;

public:

    //
    // IDL:HxCorba/VxSegmentationBuilder/setDescription:1.0
    //
    virtual void setDescription(const char* description);

    //
    // IDL:HxCorba/VxSegmentationBuilder/addSegment:1.0
    //
    virtual HxCorba::VxSegmentBuilder_ptr addSegment(CORBA::Long start,
                                                     CORBA::Long end);

    //
    // IDL:HxCorba/VxSegmentationBuilder/close:1.0
    //
    virtual void close();
};

//
// IDL:HxCorba/VxJoinedSegments:1.0
//
class VxJoinedSegments : virtual public OBStubImpl_HxCorba::VxJoinedSegments,
                         virtual public OB::MarshalStubImpl
{
    VxJoinedSegments(const VxJoinedSegments&);
    void operator=(const VxJoinedSegments&);

protected:

    VxJoinedSegments() { }
    friend class HxCorba::VxJoinedSegments;

public:

    //
    // IDL:HxCorba/VxJoinedSegments/start:1.0
    //
    virtual CORBA::Long start();

    //
    // IDL:HxCorba/VxJoinedSegments/end:1.0
    //
    virtual CORBA::Long end();

    //
    // IDL:HxCorba/VxJoinedSegments/getInt:1.0
    //
    virtual CORBA::Long getInt(const char* segmentation,
                               const char* id);

    //
    // IDL:HxCorba/VxJoinedSegments/getDouble:1.0
    //
    virtual CORBA::Double getDouble(const char* segmentation,
                                    const char* id);

    //
    // IDL:HxCorba/VxJoinedSegments/getString:1.0
    //
    virtual char* getString(const char* segmentation,
                            const char* id);

    //
    // IDL:HxCorba/VxJoinedSegments/getIntFlag:1.0
    //
    virtual CORBA::Long getIntFlag(const char* segmentation,
                                   const char* id,
                                   CORBA::Boolean_out present);

    //
    // IDL:HxCorba/VxJoinedSegments/getDoubleFlag:1.0
    //
    virtual CORBA::Double getDoubleFlag(const char* segmentation,
                                        const char* id,
                                        CORBA::Boolean_out present);

    //
    // IDL:HxCorba/VxJoinedSegments/getStringFlag:1.0
    //
    virtual char* getStringFlag(const char* segmentation,
                                const char* id,
                                CORBA::Boolean_out present);

    //
    // IDL:HxCorba/VxJoinedSegments/listSegmentations:1.0
    //
    virtual HxCorba::StringSeq* listSegmentations();

    //
    // IDL:HxCorba/VxJoinedSegments/getSegment:1.0
    //
    virtual HxCorba::VxSegment_ptr getSegment(const char* segmentation);
};

//
// IDL:HxCorba/DatabaseSession:1.0
//
class DatabaseSession : virtual public OBStubImpl_HxCorba::DatabaseSession,
                        virtual public OB::MarshalStubImpl
{
    DatabaseSession(const DatabaseSession&);
    void operator=(const DatabaseSession&);

protected:

    DatabaseSession() { }
    friend class HxCorba::DatabaseSession;

public:

    //
    // IDL:HxCorba/DatabaseSession/listVideos:1.0
    //
    virtual HxCorba::StringSeq* listVideos();

    //
    // IDL:HxCorba/DatabaseSession/listSegmentations:1.0
    //
    virtual HxCorba::StringSeq* listSegmentations(const char* videoName);

    //
    // IDL:HxCorba/DatabaseSession/getSegmentation:1.0
    //
    virtual HxCorba::VxSegmentation_ptr getSegmentation(const char* videoName,
                                                        const char* segName);

    //
    // IDL:HxCorba/DatabaseSession/addSegmentation:1.0
    //
    virtual void addSegmentation(HxCorba::VxSegmentation_ptr seg,
                                 const char* videoName,
                                 const char* segName,
                                 const char* description);

    //
    // IDL:HxCorba/DatabaseSession/buildSegmentation:1.0
    //
    virtual HxCorba::VxSegmentationBuilder_ptr buildSegmentation(const char* videoName,
                                                                 const char* segName);

    //
    // IDL:HxCorba/DatabaseSession/querySegments:1.0
    //
    virtual HxCorba::VxSegmentSeq* querySegments(const char* sqlQuery);

    //
    // IDL:HxCorba/DatabaseSession/querySegmentations:1.0
    //
    virtual HxCorba::VxSegmentSeq* querySegmentations(const char* videoName,
                                                      const HxCorba::SegmentationCondition& segCond,
                                                      const HxCorba::OverlappingCondSeq& overlappings);

    //
    // IDL:HxCorba/DatabaseSession/queryIntersections:1.0
    //
    virtual HxCorba::VxJoinedSegmentsSeq* queryIntersections(const char* videoName,
                                                             const HxCorba::SegmentationConditionSeq& conds);

    //
    // IDL:HxCorba/DatabaseSession/queryXML:1.0
    //
    virtual char* queryXML(const char* sqlQuery);

    //
    // IDL:HxCorba/DatabaseSession/close:1.0
    //
    virtual void close();
};

//
// IDL:HxCorba/Database:1.0
//
class Database : virtual public OBStubImpl_HxCorba::Database,
                 virtual public OB::MarshalStubImpl
{
    Database(const Database&);
    void operator=(const Database&);

protected:

    Database() { }
    friend class HxCorba::Database;

public:

    //
    // IDL:HxCorba/Database/openSession:1.0
    //
    virtual HxCorba::DatabaseSession_ptr openSession(const char* username,
                                                     const char* password);
};

} // End of namespace OBMarshalStubImpl_HxCorba

//
// IDL:HxCorba:1.0
//
namespace OBV_HxCorba
{

} // End of namespace OBV_HxCorba

//
// IDL:HxCorba/DatabaseException:1.0
//
void operator<<=(CORBA::Any&, HxCorba::DatabaseException*);
void operator<<=(CORBA::Any&, const HxCorba::DatabaseException&);
CORBA::Boolean operator>>=(const CORBA::Any&, const HxCorba::DatabaseException*&);

inline void
operator<<=(CORBA::Any_var& any, HxCorba::DatabaseException* val)
{
    any.inout() <<= val;
}

inline void
operator<<=(CORBA::Any_var& any, const HxCorba::DatabaseException& val)
{
    any.inout() <<= val;
}

inline CORBA::Boolean
operator>>=(const CORBA::Any_var& any, const HxCorba::DatabaseException*& val)
{
    return any.in() >>= val;
}

//
// IDL:HxCorba/VxSegmentBuilder:1.0
//
namespace CORBA
{

inline void
release(HxCorba::VxSegmentBuilder_ptr p)
{
    if(p)
        p -> _OB_decRef();
}

inline Boolean
is_nil(HxCorba::VxSegmentBuilder_ptr p)
{
    return p == 0;
}

inline void
release(OBStubImpl_HxCorba::VxSegmentBuilder_ptr p)
{
    if(p)
        p -> _OB_decRef();
}

inline Boolean
is_nil(OBStubImpl_HxCorba::VxSegmentBuilder_ptr p)
{
    return p == 0;
}

} // End of namespace CORBA

void operator<<=(CORBA::Any&, HxCorba::VxSegmentBuilder_ptr*);
void operator<<=(CORBA::Any&, HxCorba::VxSegmentBuilder_ptr);
CORBA::Boolean operator>>=(const CORBA::Any&, HxCorba::VxSegmentBuilder_ptr&);

inline void
operator<<=(CORBA::Any_var& any, HxCorba::VxSegmentBuilder_ptr* val)
{
    any.inout() <<= val;
}

inline void
operator<<=(CORBA::Any_var& any, HxCorba::VxSegmentBuilder_ptr val)
{
    any.inout() <<= val;
}

inline CORBA::Boolean
operator>>=(const CORBA::Any_var& any, HxCorba::VxSegmentBuilder_ptr& val)
{
    return any.in() >>= val;
}

//
// IDL:HxCorba/VxSegmentationBuilder:1.0
//
namespace CORBA
{

inline void
release(HxCorba::VxSegmentationBuilder_ptr p)
{
    if(p)
        p -> _OB_decRef();
}

inline Boolean
is_nil(HxCorba::VxSegmentationBuilder_ptr p)
{
    return p == 0;
}

inline void
release(OBStubImpl_HxCorba::VxSegmentationBuilder_ptr p)
{
    if(p)
        p -> _OB_decRef();
}

inline Boolean
is_nil(OBStubImpl_HxCorba::VxSegmentationBuilder_ptr p)
{
    return p == 0;
}

} // End of namespace CORBA

void operator<<=(CORBA::Any&, HxCorba::VxSegmentationBuilder_ptr*);
void operator<<=(CORBA::Any&, HxCorba::VxSegmentationBuilder_ptr);
CORBA::Boolean operator>>=(const CORBA::Any&, HxCorba::VxSegmentationBuilder_ptr&);

inline void
operator<<=(CORBA::Any_var& any, HxCorba::VxSegmentationBuilder_ptr* val)
{
    any.inout() <<= val;
}

inline void
operator<<=(CORBA::Any_var& any, HxCorba::VxSegmentationBuilder_ptr val)
{
    any.inout() <<= val;
}

inline CORBA::Boolean
operator>>=(const CORBA::Any_var& any, HxCorba::VxSegmentationBuilder_ptr& val)
{
    return any.in() >>= val;
}

//
// IDL:HxCorba/FeatureCondition:1.0
//
void operator<<=(CORBA::Any&, HxCorba::FeatureCondition*);
void operator<<=(CORBA::Any&, const HxCorba::FeatureCondition&);
CORBA::Boolean operator>>=(const CORBA::Any&, const HxCorba::FeatureCondition*&);

inline void
operator<<=(CORBA::Any_var& any, HxCorba::FeatureCondition* val)
{
    any.inout() <<= val;
}

inline void
operator<<=(CORBA::Any_var& any, const HxCorba::FeatureCondition& val)
{
    any.inout() <<= val;
}

inline CORBA::Boolean
operator>>=(const CORBA::Any_var& any, const HxCorba::FeatureCondition*& val)
{
    return any.in() >>= val;
}

//
// IDL:HxCorba/FeatureCondSeq:1.0
//
void operator<<=(CORBA::Any&, HxCorba::FeatureCondSeq*);
void operator<<=(CORBA::Any&, const HxCorba::FeatureCondSeq&);
CORBA::Boolean operator>>=(const CORBA::Any&, const HxCorba::FeatureCondSeq*&);

inline void
operator<<=(CORBA::Any_var& any, HxCorba::FeatureCondSeq* val)
{
    any.inout() <<= val;
}

inline void
operator<<=(CORBA::Any_var& any, const HxCorba::FeatureCondSeq& val)
{
    any.inout() <<= val;
}

inline CORBA::Boolean
operator>>=(const CORBA::Any_var& any, const HxCorba::FeatureCondSeq*& val)
{
    return any.in() >>= val;
}

//
// IDL:HxCorba/SegmentationCondition:1.0
//
void operator<<=(CORBA::Any&, HxCorba::SegmentationCondition*);
void operator<<=(CORBA::Any&, const HxCorba::SegmentationCondition&);
CORBA::Boolean operator>>=(const CORBA::Any&, const HxCorba::SegmentationCondition*&);

inline void
operator<<=(CORBA::Any_var& any, HxCorba::SegmentationCondition* val)
{
    any.inout() <<= val;
}

inline void
operator<<=(CORBA::Any_var& any, const HxCorba::SegmentationCondition& val)
{
    any.inout() <<= val;
}

inline CORBA::Boolean
operator>>=(const CORBA::Any_var& any, const HxCorba::SegmentationCondition*& val)
{
    return any.in() >>= val;
}

//
// IDL:HxCorba/SegmentationConditionSeq:1.0
//
void operator<<=(CORBA::Any&, HxCorba::SegmentationConditionSeq*);
void operator<<=(CORBA::Any&, const HxCorba::SegmentationConditionSeq&);
CORBA::Boolean operator>>=(const CORBA::Any&, const HxCorba::SegmentationConditionSeq*&);

inline void
operator<<=(CORBA::Any_var& any, HxCorba::SegmentationConditionSeq* val)
{
    any.inout() <<= val;
}

inline void
operator<<=(CORBA::Any_var& any, const HxCorba::SegmentationConditionSeq& val)
{
    any.inout() <<= val;
}

inline CORBA::Boolean
operator>>=(const CORBA::Any_var& any, const HxCorba::SegmentationConditionSeq*& val)
{
    return any.in() >>= val;
}

//
// IDL:HxCorba/OverlappingCondition:1.0
//
void operator<<=(CORBA::Any&, HxCorba::OverlappingCondition*);
void operator<<=(CORBA::Any&, const HxCorba::OverlappingCondition&);
CORBA::Boolean operator>>=(const CORBA::Any&, const HxCorba::OverlappingCondition*&);

inline void
operator<<=(CORBA::Any_var& any, HxCorba::OverlappingCondition* val)
{
    any.inout() <<= val;
}

inline void
operator<<=(CORBA::Any_var& any, const HxCorba::OverlappingCondition& val)
{
    any.inout() <<= val;
}

inline CORBA::Boolean
operator>>=(const CORBA::Any_var& any, const HxCorba::OverlappingCondition*& val)
{
    return any.in() >>= val;
}

//
// IDL:HxCorba/OverlappingCondSeq:1.0
//
void operator<<=(CORBA::Any&, HxCorba::OverlappingCondSeq*);
void operator<<=(CORBA::Any&, const HxCorba::OverlappingCondSeq&);
CORBA::Boolean operator>>=(const CORBA::Any&, const HxCorba::OverlappingCondSeq*&);

inline void
operator<<=(CORBA::Any_var& any, HxCorba::OverlappingCondSeq* val)
{
    any.inout() <<= val;
}

inline void
operator<<=(CORBA::Any_var& any, const HxCorba::OverlappingCondSeq& val)
{
    any.inout() <<= val;
}

inline CORBA::Boolean
operator>>=(const CORBA::Any_var& any, const HxCorba::OverlappingCondSeq*& val)
{
    return any.in() >>= val;
}

//
// IDL:HxCorba/VxJoinedSegments:1.0
//
namespace CORBA
{

inline void
release(HxCorba::VxJoinedSegments_ptr p)
{
    if(p)
        p -> _OB_decRef();
}

inline Boolean
is_nil(HxCorba::VxJoinedSegments_ptr p)
{
    return p == 0;
}

inline void
release(OBStubImpl_HxCorba::VxJoinedSegments_ptr p)
{
    if(p)
        p -> _OB_decRef();
}

inline Boolean
is_nil(OBStubImpl_HxCorba::VxJoinedSegments_ptr p)
{
    return p == 0;
}

} // End of namespace CORBA

void operator<<=(CORBA::Any&, HxCorba::VxJoinedSegments_ptr*);
void operator<<=(CORBA::Any&, HxCorba::VxJoinedSegments_ptr);
CORBA::Boolean operator>>=(const CORBA::Any&, HxCorba::VxJoinedSegments_ptr&);

inline void
operator<<=(CORBA::Any_var& any, HxCorba::VxJoinedSegments_ptr* val)
{
    any.inout() <<= val;
}

inline void
operator<<=(CORBA::Any_var& any, HxCorba::VxJoinedSegments_ptr val)
{
    any.inout() <<= val;
}

inline CORBA::Boolean
operator>>=(const CORBA::Any_var& any, HxCorba::VxJoinedSegments_ptr& val)
{
    return any.in() >>= val;
}

//
// IDL:HxCorba/VxJoinedSegmentsSeq:1.0
//
void operator<<=(CORBA::Any&, HxCorba::VxJoinedSegmentsSeq*);
void operator<<=(CORBA::Any&, const HxCorba::VxJoinedSegmentsSeq&);
CORBA::Boolean operator>>=(const CORBA::Any&, const HxCorba::VxJoinedSegmentsSeq*&);

inline void
operator<<=(CORBA::Any_var& any, HxCorba::VxJoinedSegmentsSeq* val)
{
    any.inout() <<= val;
}

inline void
operator<<=(CORBA::Any_var& any, const HxCorba::VxJoinedSegmentsSeq& val)
{
    any.inout() <<= val;
}

inline CORBA::Boolean
operator>>=(const CORBA::Any_var& any, const HxCorba::VxJoinedSegmentsSeq*& val)
{
    return any.in() >>= val;
}

//
// IDL:HxCorba/DatabaseSession:1.0
//
namespace CORBA
{

inline void
release(HxCorba::DatabaseSession_ptr p)
{
    if(p)
        p -> _OB_decRef();
}

inline Boolean
is_nil(HxCorba::DatabaseSession_ptr p)
{
    return p == 0;
}

inline void
release(OBStubImpl_HxCorba::DatabaseSession_ptr p)
{
    if(p)
        p -> _OB_decRef();
}

inline Boolean
is_nil(OBStubImpl_HxCorba::DatabaseSession_ptr p)
{
    return p == 0;
}

} // End of namespace CORBA

void operator<<=(CORBA::Any&, HxCorba::DatabaseSession_ptr*);
void operator<<=(CORBA::Any&, HxCorba::DatabaseSession_ptr);
CORBA::Boolean operator>>=(const CORBA::Any&, HxCorba::DatabaseSession_ptr&);

inline void
operator<<=(CORBA::Any_var& any, HxCorba::DatabaseSession_ptr* val)
{
    any.inout() <<= val;
}

inline void
operator<<=(CORBA::Any_var& any, HxCorba::DatabaseSession_ptr val)
{
    any.inout() <<= val;
}

inline CORBA::Boolean
operator>>=(const CORBA::Any_var& any, HxCorba::DatabaseSession_ptr& val)
{
    return any.in() >>= val;
}

//
// IDL:HxCorba/Database:1.0
//
namespace CORBA
{

inline void
release(HxCorba::Database_ptr p)
{
    if(p)
        p -> _OB_decRef();
}

inline Boolean
is_nil(HxCorba::Database_ptr p)
{
    return p == 0;
}

inline void
release(OBStubImpl_HxCorba::Database_ptr p)
{
    if(p)
        p -> _OB_decRef();
}

inline Boolean
is_nil(OBStubImpl_HxCorba::Database_ptr p)
{
    return p == 0;
}

} // End of namespace CORBA

void operator<<=(CORBA::Any&, HxCorba::Database_ptr*);
void operator<<=(CORBA::Any&, HxCorba::Database_ptr);
CORBA::Boolean operator>>=(const CORBA::Any&, HxCorba::Database_ptr&);

inline void
operator<<=(CORBA::Any_var& any, HxCorba::Database_ptr* val)
{
    any.inout() <<= val;
}

inline void
operator<<=(CORBA::Any_var& any, HxCorba::Database_ptr val)
{
    any.inout() <<= val;
}

inline CORBA::Boolean
operator>>=(const CORBA::Any_var& any, HxCorba::Database_ptr& val)
{
    return any.in() >>= val;
}

#endif

---