|| ||   || Doxygen's  

---

HxCorbaVxSegmentation.h

Go to the documentation of this file.

// **********************************************************************
//
// Generated by the ORBacus IDL-to-C++ Translator
//
// Copyright (c) 2001
// IONA Technologies, Inc.
// Waltham, MA, USA
//
// All Rights Reserved
//
// **********************************************************************

// Version: 4.1.0

#ifndef ___HxCorbaVxSegmentation_h__
#define ___HxCorbaVxSegmentation_h__

#include <HxCorbaTypes.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

namespace HxCorba
{

class VxSegment;
typedef VxSegment* VxSegment_ptr;
typedef VxSegment* VxSegmentRef;

extern OB::TypeCodeConst _tc_VxSegment;

class VxSegmentation;
typedef VxSegmentation* VxSegmentation_ptr;
typedef VxSegmentation* VxSegmentationRef;

extern OB::TypeCodeConst _tc_VxSegmentation;

class VxSegmentationFactory;
typedef VxSegmentationFactory* VxSegmentationFactory_ptr;
typedef VxSegmentationFactory* VxSegmentationFactoryRef;

extern OB::TypeCodeConst _tc_VxSegmentationFactory;

} // End of namespace HxCorba

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

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

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

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

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

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

namespace HxCorba
{

typedef OB::ObjVar< VxSegment > VxSegment_var;
typedef OB::ObjOut< VxSegment > VxSegment_out;

typedef OB::ObjVar< VxSegmentation > VxSegmentation_var;
typedef OB::ObjOut< VxSegmentation > VxSegmentation_out;

typedef OB::ObjVar< VxSegmentationFactory > VxSegmentationFactory_var;
typedef OB::ObjOut< VxSegmentationFactory > VxSegmentationFactory_out;

} // End of namespace HxCorba

namespace OBStubImpl_HxCorba
{

class VxSegment;
typedef VxSegment* VxSegment_ptr;

class VxSegmentation;
typedef VxSegmentation* VxSegmentation_ptr;

class VxSegmentationFactory;
typedef VxSegmentationFactory* VxSegmentationFactory_ptr;

} // End of namespace OBStubImpl_HxCorba

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

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

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

namespace OBStubImpl_HxCorba
{

typedef OB::ObjVar< VxSegment > VxSegment_var;

typedef OB::ObjVar< VxSegmentation > VxSegmentation_var;

typedef OB::ObjVar< VxSegmentationFactory > VxSegmentationFactory_var;

} // End of namespace OBStubImpl_HxCorba

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

//
// IDL:HxCorba/VxTimeSpan:1.0
//
struct VxTimeSpan;
typedef OB::FixVar< VxTimeSpan > VxTimeSpan_var;
typedef VxTimeSpan& VxTimeSpan_out;

struct VxTimeSpan
{
    typedef VxTimeSpan_var _var_type;

    CORBA::Long start;
    CORBA::Long end;

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

extern OB::TypeCodeConst _tc_VxTimeSpan;

//
// IDL:HxCorba/VxTimeSpanSeq:1.0
//
class OBUnique_VxTimeSpanSeq { };

typedef OB::FixSeq< VxTimeSpan, OBUnique_VxTimeSpanSeq > VxTimeSpanSeq;
typedef OB::SeqVar< OB::FixSeq< VxTimeSpan, OBUnique_VxTimeSpanSeq > > VxTimeSpanSeq_var;
typedef OB::SeqOut< OB::FixSeq< VxTimeSpan, OBUnique_VxTimeSpanSeq > > VxTimeSpanSeq_out;
extern OB::TypeCodeConst _tc_VxTimeSpanSeq;

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

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

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

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

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

protected:

    static const char* ids_[];

public:

    VxSegment() { }
    virtual ~VxSegment() { }

    typedef VxSegment_ptr _ptr_type;
    typedef VxSegment_var _var_type;

    static inline VxSegment_ptr
    _duplicate(VxSegment_ptr p)
    {
        if(p)
            p -> _add_ref();
        return p;
    }

    static inline VxSegment_ptr
    _nil()
    {
        return 0;
    }

    static VxSegment_ptr _narrow(CORBA::Object_ptr);
    static VxSegment_ptr _unchecked_narrow(CORBA::Object_ptr);

    static VxSegment_ptr _narrow(CORBA::AbstractBase_ptr);
    static VxSegment_ptr _unchecked_narrow(CORBA::AbstractBase_ptr);

    static const char** _OB_staticIds();

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

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

    //
    // IDL:HxCorba/VxSegment/length:1.0
    //
    virtual CORBA::Long length() = 0;

    //
    // IDL:HxCorba/VxSegment/getIds:1.0
    //
    virtual StringSeq* getIds() = 0;

    //
    // IDL:HxCorba/VxSegment/getTypes:1.0
    //
    virtual StringSeq* getTypes() = 0;

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

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

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

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

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

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

//
// IDL:HxCorba/VxSegmentSeq:1.0
//
class OBUnique_VxSegmentSeq { };

typedef OB::ObjSeq< VxSegment, OBUnique_VxSegmentSeq > VxSegmentSeq;
typedef OB::SeqVar< OB::ObjSeq< VxSegment, OBUnique_VxSegmentSeq > > VxSegmentSeq_var;
typedef OB::SeqOut< OB::ObjSeq< VxSegment, OBUnique_VxSegmentSeq > > VxSegmentSeq_out;
extern OB::TypeCodeConst _tc_VxSegmentSeq;

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

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

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

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

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

protected:

    static const char* ids_[];

public:

    VxSegmentation() { }
    virtual ~VxSegmentation() { }

    typedef VxSegmentation_ptr _ptr_type;
    typedef VxSegmentation_var _var_type;

    static inline VxSegmentation_ptr
    _duplicate(VxSegmentation_ptr p)
    {
        if(p)
            p -> _add_ref();
        return p;
    }

    static inline VxSegmentation_ptr
    _nil()
    {
        return 0;
    }

    static VxSegmentation_ptr _narrow(CORBA::Object_ptr);
    static VxSegmentation_ptr _unchecked_narrow(CORBA::Object_ptr);

    static VxSegmentation_ptr _narrow(CORBA::AbstractBase_ptr);
    static VxSegmentation_ptr _unchecked_narrow(CORBA::AbstractBase_ptr);

    static const char** _OB_staticIds();

    //
    // IDL:HxCorba/VxSegmentation/size:1.0
    //
    virtual CORBA::Long size() = 0;

    //
    // IDL:HxCorba/VxSegmentation/getAll:1.0
    //
    virtual VxSegmentSeq* getAll() = 0;

    //
    // IDL:HxCorba/VxSegmentation/getTimeSpans:1.0
    //
    virtual VxTimeSpanSeq* getTimeSpans() = 0;

    //
    // IDL:HxCorba/VxSegmentation/getIds:1.0
    //
    virtual StringSeq* getIds() = 0;

    //
    // IDL:HxCorba/VxSegmentation/getTypes:1.0
    //
    virtual StringSeq* getTypes() = 0;

    //
    // IDL:HxCorba/VxSegmentation/getSegment:1.0
    //
    virtual VxSegment_ptr getSegment(CORBA::Long index) = 0;

    //
    // IDL:HxCorba/VxSegmentation/mapsToSegment:1.0
    //
    virtual VxSegment_ptr mapsToSegment(CORBA::Long timeSpan) = 0;
};

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

protected:

    static const char* ids_[];

public:

    VxSegmentationFactory() { }
    virtual ~VxSegmentationFactory() { }

    typedef VxSegmentationFactory_ptr _ptr_type;
    typedef VxSegmentationFactory_var _var_type;

    static inline VxSegmentationFactory_ptr
    _duplicate(VxSegmentationFactory_ptr p)
    {
        if(p)
            p -> _add_ref();
        return p;
    }

    static inline VxSegmentationFactory_ptr
    _nil()
    {
        return 0;
    }

    static VxSegmentationFactory_ptr _narrow(CORBA::Object_ptr);
    static VxSegmentationFactory_ptr _unchecked_narrow(CORBA::Object_ptr);

    static VxSegmentationFactory_ptr _narrow(CORBA::AbstractBase_ptr);
    static VxSegmentationFactory_ptr _unchecked_narrow(CORBA::AbstractBase_ptr);

    static const char** _OB_staticIds();

    //
    // IDL:HxCorba/VxSegmentationFactory/makeVxSegmentation:1.0
    //
    virtual VxSegmentation_ptr makeVxSegmentation(const char* filename) = 0;

    //
    // IDL:HxCorba/VxSegmentationFactory/importSegmentation:1.0
    //
    virtual VxSegmentation_ptr importSegmentation(VxSegmentation_ptr seg) = 0;
};

} // End of namespace HxCorba

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

//
// IDL:HxCorba/VxSegment:1.0
//
class VxSegment : virtual public ::HxCorba::VxSegment,
                  virtual public OBCORBA::Object
{
    VxSegment(const VxSegment&);
    void operator=(const VxSegment&);

protected:

    virtual OB::MarshalStubImpl_ptr _OB_createMarshalStubImpl();

public:

    VxSegment() { }
    virtual ~VxSegment() { }

    virtual const char** _OB_ids() const;

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

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

    //
    // IDL:HxCorba/VxSegment/length:1.0
    //
    CORBA::Long length();

    //
    // IDL:HxCorba/VxSegment/getIds:1.0
    //
    ::HxCorba::StringSeq* getIds();

    //
    // IDL:HxCorba/VxSegment/getTypes:1.0
    //
    ::HxCorba::StringSeq* getTypes();

    //
    // IDL:HxCorba/VxSegment/getInt:1.0
    //
    CORBA::Long getInt(const char* id);

    //
    // IDL:HxCorba/VxSegment/getDouble:1.0
    //
    CORBA::Double getDouble(const char* id);

    //
    // IDL:HxCorba/VxSegment/getString:1.0
    //
    char* getString(const char* id);

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

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

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

//
// IDL:HxCorba/VxSegmentation:1.0
//
class VxSegmentation : virtual public ::HxCorba::VxSegmentation,
                       virtual public OBCORBA::Object
{
    VxSegmentation(const VxSegmentation&);
    void operator=(const VxSegmentation&);

protected:

    virtual OB::MarshalStubImpl_ptr _OB_createMarshalStubImpl();

public:

    VxSegmentation() { }
    virtual ~VxSegmentation() { }

    virtual const char** _OB_ids() const;

    //
    // IDL:HxCorba/VxSegmentation/size:1.0
    //
    CORBA::Long size();

    //
    // IDL:HxCorba/VxSegmentation/getAll:1.0
    //
    ::HxCorba::VxSegmentSeq* getAll();

    //
    // IDL:HxCorba/VxSegmentation/getTimeSpans:1.0
    //
    ::HxCorba::VxTimeSpanSeq* getTimeSpans();

    //
    // IDL:HxCorba/VxSegmentation/getIds:1.0
    //
    ::HxCorba::StringSeq* getIds();

    //
    // IDL:HxCorba/VxSegmentation/getTypes:1.0
    //
    ::HxCorba::StringSeq* getTypes();

    //
    // IDL:HxCorba/VxSegmentation/getSegment:1.0
    //
    ::HxCorba::VxSegment_ptr getSegment(CORBA::Long index);

    //
    // IDL:HxCorba/VxSegmentation/mapsToSegment:1.0
    //
    ::HxCorba::VxSegment_ptr mapsToSegment(CORBA::Long timeSpan);
};

//
// IDL:HxCorba/VxSegmentationFactory:1.0
//
class VxSegmentationFactory : virtual public ::HxCorba::VxSegmentationFactory,
                              virtual public OBCORBA::Object
{
    VxSegmentationFactory(const VxSegmentationFactory&);
    void operator=(const VxSegmentationFactory&);

protected:

    virtual OB::MarshalStubImpl_ptr _OB_createMarshalStubImpl();

public:

    VxSegmentationFactory() { }
    virtual ~VxSegmentationFactory() { }

    virtual const char** _OB_ids() const;

    //
    // IDL:HxCorba/VxSegmentationFactory/makeVxSegmentation:1.0
    //
    ::HxCorba::VxSegmentation_ptr makeVxSegmentation(const char* filename);

    //
    // IDL:HxCorba/VxSegmentationFactory/importSegmentation:1.0
    //
    ::HxCorba::VxSegmentation_ptr importSegmentation(::HxCorba::VxSegmentation_ptr seg);
};

} // End of namespace OBProxy_HxCorba

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

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

protected:

    VxSegment() { }

public:

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

    static inline VxSegment_ptr
    _nil()
    {
        return 0;
    }

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

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

    //
    // IDL:HxCorba/VxSegment/length:1.0
    //
    virtual CORBA::Long length() = 0;

    //
    // IDL:HxCorba/VxSegment/getIds:1.0
    //
    virtual ::HxCorba::StringSeq* getIds() = 0;

    //
    // IDL:HxCorba/VxSegment/getTypes:1.0
    //
    virtual ::HxCorba::StringSeq* getTypes() = 0;

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

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

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

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

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

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

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

protected:

    VxSegmentation() { }

public:

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

    static inline VxSegmentation_ptr
    _nil()
    {
        return 0;
    }

    //
    // IDL:HxCorba/VxSegmentation/size:1.0
    //
    virtual CORBA::Long size() = 0;

    //
    // IDL:HxCorba/VxSegmentation/getAll:1.0
    //
    virtual ::HxCorba::VxSegmentSeq* getAll() = 0;

    //
    // IDL:HxCorba/VxSegmentation/getTimeSpans:1.0
    //
    virtual ::HxCorba::VxTimeSpanSeq* getTimeSpans() = 0;

    //
    // IDL:HxCorba/VxSegmentation/getIds:1.0
    //
    virtual ::HxCorba::StringSeq* getIds() = 0;

    //
    // IDL:HxCorba/VxSegmentation/getTypes:1.0
    //
    virtual ::HxCorba::StringSeq* getTypes() = 0;

    //
    // IDL:HxCorba/VxSegmentation/getSegment:1.0
    //
    virtual ::HxCorba::VxSegment_ptr getSegment(CORBA::Long index) = 0;

    //
    // IDL:HxCorba/VxSegmentation/mapsToSegment:1.0
    //
    virtual ::HxCorba::VxSegment_ptr mapsToSegment(CORBA::Long timeSpan) = 0;
};

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

protected:

    VxSegmentationFactory() { }

public:

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

    static inline VxSegmentationFactory_ptr
    _nil()
    {
        return 0;
    }

    //
    // IDL:HxCorba/VxSegmentationFactory/makeVxSegmentation:1.0
    //
    virtual ::HxCorba::VxSegmentation_ptr makeVxSegmentation(const char* filename) = 0;

    //
    // IDL:HxCorba/VxSegmentationFactory/importSegmentation:1.0
    //
    virtual ::HxCorba::VxSegmentation_ptr importSegmentation(::HxCorba::VxSegmentation_ptr seg) = 0;
};

} // End of namespace OBStubImpl_HxCorba

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

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

protected:

    VxSegment() { }
    friend class OBProxy_HxCorba::VxSegment;

public:

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

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

    //
    // IDL:HxCorba/VxSegment/length:1.0
    //
    virtual CORBA::Long length();

    //
    // IDL:HxCorba/VxSegment/getIds:1.0
    //
    virtual ::HxCorba::StringSeq* getIds();

    //
    // IDL:HxCorba/VxSegment/getTypes:1.0
    //
    virtual ::HxCorba::StringSeq* getTypes();

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

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

    //
    // IDL:HxCorba/VxSegment/getString:1.0
    //
    virtual char* getString(const char* id);

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

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

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

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

protected:

    VxSegmentation() { }
    friend class OBProxy_HxCorba::VxSegmentation;

public:

    //
    // IDL:HxCorba/VxSegmentation/size:1.0
    //
    virtual CORBA::Long size();

    //
    // IDL:HxCorba/VxSegmentation/getAll:1.0
    //
    virtual ::HxCorba::VxSegmentSeq* getAll();

    //
    // IDL:HxCorba/VxSegmentation/getTimeSpans:1.0
    //
    virtual ::HxCorba::VxTimeSpanSeq* getTimeSpans();

    //
    // IDL:HxCorba/VxSegmentation/getIds:1.0
    //
    virtual ::HxCorba::StringSeq* getIds();

    //
    // IDL:HxCorba/VxSegmentation/getTypes:1.0
    //
    virtual ::HxCorba::StringSeq* getTypes();

    //
    // IDL:HxCorba/VxSegmentation/getSegment:1.0
    //
    virtual ::HxCorba::VxSegment_ptr getSegment(CORBA::Long index);

    //
    // IDL:HxCorba/VxSegmentation/mapsToSegment:1.0
    //
    virtual ::HxCorba::VxSegment_ptr mapsToSegment(CORBA::Long timeSpan);
};

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

protected:

    VxSegmentationFactory() { }
    friend class OBProxy_HxCorba::VxSegmentationFactory;

public:

    //
    // IDL:HxCorba/VxSegmentationFactory/makeVxSegmentation:1.0
    //
    virtual ::HxCorba::VxSegmentation_ptr makeVxSegmentation(const char* filename);

    //
    // IDL:HxCorba/VxSegmentationFactory/importSegmentation:1.0
    //
    virtual ::HxCorba::VxSegmentation_ptr importSegmentation(::HxCorba::VxSegmentation_ptr seg);
};

} // End of namespace OBMarshalStubImpl_HxCorba

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

} // End of namespace OBV_HxCorba

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

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

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

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

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

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

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

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

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

inline void
release(::HxCorba::VxSegment_ptr p)
{
    if(p)
        p -> _remove_ref();
}

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

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

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

} // End of namespace CORBA

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

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

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

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

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

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

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

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

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

inline void
release(::HxCorba::VxSegmentation_ptr p)
{
    if(p)
        p -> _remove_ref();
}

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

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

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

} // End of namespace CORBA

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

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

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

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

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

inline void
release(::HxCorba::VxSegmentationFactory_ptr p)
{
    if(p)
        p -> _remove_ref();
}

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

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

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

} // End of namespace CORBA

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

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

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

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

#endif

---