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

// Version: 4.1.3

#ifndef __OB_IFR2_h__
#define __OB_IFR2_h__

#ifndef OB_IMPORT
#   ifdef OB_DLL
#      define OB_IMPORT __declspec(dllimport)
#   else
#      define OB_IMPORT /**/
#   endif
#endif


#include <OB/IFR1.h>
#include <OB/IFR2_fwd.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 != 4010300L)
#       error ORBacus version mismatch!
#   endif
#endif

namespace OBStubImpl_CORBA
{

class Repository;
typedef Repository* Repository_ptr;

class Contained;
typedef Contained* Contained_ptr;

class ModuleDef;
typedef ModuleDef* ModuleDef_ptr;

class ConstantDef;
typedef ConstantDef* ConstantDef_ptr;

class StructDef;
typedef StructDef* StructDef_ptr;

class UnionDef;
typedef UnionDef* UnionDef_ptr;

class EnumDef;
typedef EnumDef* EnumDef_ptr;

class AliasDef;
typedef AliasDef* AliasDef_ptr;

class AbstractInterfaceDef;
typedef AbstractInterfaceDef* AbstractInterfaceDef_ptr;

class LocalInterfaceDef;
typedef LocalInterfaceDef* LocalInterfaceDef_ptr;

class NativeDef;
typedef NativeDef* NativeDef_ptr;

class ValueDef;
typedef ValueDef* ValueDef_ptr;

class ValueBoxDef;
typedef ValueBoxDef* ValueBoxDef_ptr;

class Container;
typedef Container* Container_ptr;

class AttributeDef;
typedef AttributeDef* AttributeDef_ptr;

class ExceptionDef;
typedef ExceptionDef* ExceptionDef_ptr;

class OperationDef;
typedef OperationDef* OperationDef_ptr;

class InterfaceDef;
typedef InterfaceDef* InterfaceDef_ptr;

} // End of namespace OBStubImpl_CORBA

void OBDuplicate(OBStubImpl_CORBA::Repository_ptr);
void OBRelease(OBStubImpl_CORBA::Repository_ptr);

void OBDuplicate(OBStubImpl_CORBA::Contained_ptr);
void OBRelease(OBStubImpl_CORBA::Contained_ptr);

void OBDuplicate(OBStubImpl_CORBA::ModuleDef_ptr);
void OBRelease(OBStubImpl_CORBA::ModuleDef_ptr);

void OBDuplicate(OBStubImpl_CORBA::ConstantDef_ptr);
void OBRelease(OBStubImpl_CORBA::ConstantDef_ptr);

void OBDuplicate(OBStubImpl_CORBA::StructDef_ptr);
void OBRelease(OBStubImpl_CORBA::StructDef_ptr);

void OBDuplicate(OBStubImpl_CORBA::UnionDef_ptr);
void OBRelease(OBStubImpl_CORBA::UnionDef_ptr);

void OBDuplicate(OBStubImpl_CORBA::EnumDef_ptr);
void OBRelease(OBStubImpl_CORBA::EnumDef_ptr);

void OBDuplicate(OBStubImpl_CORBA::AliasDef_ptr);
void OBRelease(OBStubImpl_CORBA::AliasDef_ptr);

void OBDuplicate(OBStubImpl_CORBA::AbstractInterfaceDef_ptr);
void OBRelease(OBStubImpl_CORBA::AbstractInterfaceDef_ptr);

void OBDuplicate(OBStubImpl_CORBA::LocalInterfaceDef_ptr);
void OBRelease(OBStubImpl_CORBA::LocalInterfaceDef_ptr);

void OBDuplicate(OBStubImpl_CORBA::NativeDef_ptr);
void OBRelease(OBStubImpl_CORBA::NativeDef_ptr);

void OBDuplicate(OBStubImpl_CORBA::ValueDef_ptr);
void OBRelease(OBStubImpl_CORBA::ValueDef_ptr);

void OBDuplicate(OBStubImpl_CORBA::ValueBoxDef_ptr);
void OBRelease(OBStubImpl_CORBA::ValueBoxDef_ptr);

void OBDuplicate(OBStubImpl_CORBA::Container_ptr);
void OBRelease(OBStubImpl_CORBA::Container_ptr);

void OBDuplicate(OBStubImpl_CORBA::AttributeDef_ptr);
void OBRelease(OBStubImpl_CORBA::AttributeDef_ptr);

void OBDuplicate(OBStubImpl_CORBA::ExceptionDef_ptr);
void OBRelease(OBStubImpl_CORBA::ExceptionDef_ptr);

void OBDuplicate(OBStubImpl_CORBA::OperationDef_ptr);
void OBRelease(OBStubImpl_CORBA::OperationDef_ptr);

void OBDuplicate(OBStubImpl_CORBA::InterfaceDef_ptr);
void OBRelease(OBStubImpl_CORBA::InterfaceDef_ptr);

namespace OBStubImpl_CORBA
{

typedef OB::ObjVar< Repository > Repository_var;

typedef OB::ObjVar< Contained > Contained_var;

typedef OB::ObjVar< ModuleDef > ModuleDef_var;

typedef OB::ObjVar< ConstantDef > ConstantDef_var;

typedef OB::ObjVar< StructDef > StructDef_var;

typedef OB::ObjVar< UnionDef > UnionDef_var;

typedef OB::ObjVar< EnumDef > EnumDef_var;

typedef OB::ObjVar< AliasDef > AliasDef_var;

typedef OB::ObjVar< AbstractInterfaceDef > AbstractInterfaceDef_var;

typedef OB::ObjVar< LocalInterfaceDef > LocalInterfaceDef_var;

typedef OB::ObjVar< NativeDef > NativeDef_var;

typedef OB::ObjVar< ValueDef > ValueDef_var;

typedef OB::ObjVar< ValueBoxDef > ValueBoxDef_var;

typedef OB::ObjVar< Container > Container_var;

typedef OB::ObjVar< AttributeDef > AttributeDef_var;

typedef OB::ObjVar< ExceptionDef > ExceptionDef_var;

typedef OB::ObjVar< OperationDef > OperationDef_var;

typedef OB::ObjVar< InterfaceDef > InterfaceDef_var;

} // End of namespace OBStubImpl_CORBA

//
// IDL:omg.org/CORBA:1.0
//
namespace CORBA
{

//
// IDL:omg.org/CORBA/Contained:1.0
//
class Contained : virtual public ::CORBA::IRObject
{
    Contained(const Contained&);
    void operator=(const Contained&);

protected:

    static OB_IMPORT const char* ids_[];

public:

    Contained() { }
    virtual ~Contained() { }

    typedef Contained_ptr _ptr_type;
    typedef Contained_var _var_type;

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

    static inline Contained_ptr
    _nil()
    {
        return 0;
    }

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

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

    static const char** _OB_staticIds();

    //
    // IDL:omg.org/CORBA/Contained/id:1.0
    //
    virtual RepositoryId id() = 0;
    virtual void id(const char*) = 0;

    //
    // IDL:omg.org/CORBA/Contained/name:1.0
    //
    virtual Identifier name() = 0;
    virtual void name(const char*) = 0;

    //
    // IDL:omg.org/CORBA/Contained/version:1.0
    //
    virtual VersionSpec version() = 0;
    virtual void version(const char*) = 0;

    //
    // IDL:omg.org/CORBA/Contained/defined_in:1.0
    //
    virtual Container_ptr defined_in() = 0;

    //
    // IDL:omg.org/CORBA/Contained/absolute_name:1.0
    //
    virtual ScopedName absolute_name() = 0;

    //
    // IDL:omg.org/CORBA/Contained/containing_repository:1.0
    //
    virtual Repository_ptr containing_repository() = 0;

    //
    // IDL:omg.org/CORBA/Contained/Description:1.0
    //
    struct Description;
    typedef OB::VarVar< Description > Description_var;
    typedef OB::VarOut< Description > Description_out;

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

        typedef Description_var _var_type;

        DefinitionKind kind;
        ::CORBA::Any value;

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

    OB_IMPORT static OB::TypeCodeConst _tc_Description;

    //
    // IDL:omg.org/CORBA/Contained/describe:1.0
    //
    virtual Description* describe() = 0;

    //
    // IDL:omg.org/CORBA/Contained/move:1.0
    //
    virtual void move(Container_ptr new_container,
                      const char* new_name,
                      const char* new_version) = 0;
};

//
// IDL:omg.org/CORBA/InterfaceDefSeq:1.0
//
class OBUnique_InterfaceDefSeq { };

typedef OB::ObjSeq< InterfaceDef, OBUnique_InterfaceDefSeq > InterfaceDefSeq;
typedef OB::SeqVar< OB::ObjSeq< InterfaceDef, OBUnique_InterfaceDefSeq > > InterfaceDefSeq_var;
typedef OB::SeqOut< OB::ObjSeq< InterfaceDef, OBUnique_InterfaceDefSeq > > InterfaceDefSeq_out;
OB_IMPORT extern OB::TypeCodeConst _tc_InterfaceDefSeq;

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

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

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

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

//
// IDL:omg.org/CORBA/AbstractInterfaceDefSeq:1.0
//
class OBUnique_AbstractInterfaceDefSeq { };

typedef OB::ObjSeq< AbstractInterfaceDef, OBUnique_AbstractInterfaceDefSeq > AbstractInterfaceDefSeq;
typedef OB::SeqVar< OB::ObjSeq< AbstractInterfaceDef, OBUnique_AbstractInterfaceDefSeq > > AbstractInterfaceDefSeq_var;
typedef OB::SeqOut< OB::ObjSeq< AbstractInterfaceDef, OBUnique_AbstractInterfaceDefSeq > > AbstractInterfaceDefSeq_out;
OB_IMPORT extern OB::TypeCodeConst _tc_AbstractInterfaceDefSeq;

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

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

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

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

//
// IDL:omg.org/CORBA/LocalInterfaceDefSeq:1.0
//
class OBUnique_LocalInterfaceDefSeq { };

typedef OB::ObjSeq< LocalInterfaceDef, OBUnique_LocalInterfaceDefSeq > LocalInterfaceDefSeq;
typedef OB::SeqVar< OB::ObjSeq< LocalInterfaceDef, OBUnique_LocalInterfaceDefSeq > > LocalInterfaceDefSeq_var;
typedef OB::SeqOut< OB::ObjSeq< LocalInterfaceDef, OBUnique_LocalInterfaceDefSeq > > LocalInterfaceDefSeq_out;
OB_IMPORT extern OB::TypeCodeConst _tc_LocalInterfaceDefSeq;

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

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

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

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

//
// IDL:omg.org/CORBA/ValueDefSeq:1.0
//
class OBUnique_ValueDefSeq { };

typedef OB::ObjSeq< ValueDef, OBUnique_ValueDefSeq > ValueDefSeq;
typedef OB::SeqVar< OB::ObjSeq< ValueDef, OBUnique_ValueDefSeq > > ValueDefSeq_var;
typedef OB::SeqOut< OB::ObjSeq< ValueDef, OBUnique_ValueDefSeq > > ValueDefSeq_out;
OB_IMPORT extern OB::TypeCodeConst _tc_ValueDefSeq;

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

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

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

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

//
// IDL:omg.org/CORBA/ContainedSeq:1.0
//
class OBUnique_ContainedSeq { };

typedef OB::ObjSeq< Contained, OBUnique_ContainedSeq > ContainedSeq;
typedef OB::SeqVar< OB::ObjSeq< Contained, OBUnique_ContainedSeq > > ContainedSeq_var;
typedef OB::SeqOut< OB::ObjSeq< Contained, OBUnique_ContainedSeq > > ContainedSeq_out;
OB_IMPORT extern OB::TypeCodeConst _tc_ContainedSeq;

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

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

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

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

//
// IDL:omg.org/CORBA/Container:1.0
//
class Container : virtual public ::CORBA::IRObject
{
    Container(const Container&);
    void operator=(const Container&);

protected:

    static OB_IMPORT const char* ids_[];

public:

    Container() { }
    virtual ~Container() { }

    typedef Container_ptr _ptr_type;
    typedef Container_var _var_type;

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

    static inline Container_ptr
    _nil()
    {
        return 0;
    }

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

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

    static const char** _OB_staticIds();

    //
    // IDL:omg.org/CORBA/Container/lookup:1.0
    //
    virtual Contained_ptr lookup(const char* search_name) = 0;

    //
    // IDL:omg.org/CORBA/Container/contents:1.0
    //
    virtual ContainedSeq* contents(DefinitionKind limit_type,
                                   ::CORBA::Boolean exclude_inherited) = 0;

    //
    // IDL:omg.org/CORBA/Container/lookup_name:1.0
    //
    virtual ContainedSeq* lookup_name(const char* search_name,
                                      ::CORBA::Long levels_to_search,
                                      DefinitionKind limit_type,
                                      ::CORBA::Boolean exclude_inherited) = 0;

    //
    // IDL:omg.org/CORBA/Container/Description:1.0
    //
    struct Description;
    typedef OB::VarVar< Description > Description_var;
    typedef OB::VarOut< Description > Description_out;

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

        typedef Description_var _var_type;

        Contained_var contained_object;
        DefinitionKind kind;
        ::CORBA::Any value;

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

    OB_IMPORT static OB::TypeCodeConst _tc_Description;

    //
    // IDL:omg.org/CORBA/Container/DescriptionSeq:1.0
    //
    class OBUnique_DescriptionSeq { };

    typedef OB::VarSeq< Description, OBUnique_DescriptionSeq > DescriptionSeq;
    typedef OB::SeqVar< OB::VarSeq< Description, OBUnique_DescriptionSeq > > DescriptionSeq_var;
    typedef OB::SeqOut< OB::VarSeq< Description, OBUnique_DescriptionSeq > > DescriptionSeq_out;
    OB_IMPORT static OB::TypeCodeConst _tc_DescriptionSeq;

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

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

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

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

    //
    // IDL:omg.org/CORBA/Container/describe_contents:1.0
    //
    virtual DescriptionSeq* describe_contents(DefinitionKind limit_type,
                                              ::CORBA::Boolean exclude_inherited,
                                              ::CORBA::Long max_returned_objs) = 0;

    //
    // IDL:omg.org/CORBA/Container/create_module:1.0
    //
    virtual ModuleDef_ptr create_module(const char* id,
                                        const char* name,
                                        const char* version) = 0;

    //
    // IDL:omg.org/CORBA/Container/create_constant:1.0
    //
    virtual ConstantDef_ptr create_constant(const char* id,
                                            const char* name,
                                            const char* version,
                                            IDLType_ptr type,
                                            const ::CORBA::Any& value) = 0;

    //
    // IDL:omg.org/CORBA/Container/create_struct:1.0
    //
    virtual StructDef_ptr create_struct(const char* id,
                                        const char* name,
                                        const char* version,
                                        const StructMemberSeq& members) = 0;

    //
    // IDL:omg.org/CORBA/Container/create_union:1.0
    //
    virtual UnionDef_ptr create_union(const char* id,
                                      const char* name,
                                      const char* version,
                                      IDLType_ptr discriminator_type,
                                      const UnionMemberSeq& members) = 0;

    //
    // IDL:omg.org/CORBA/Container/create_enum:1.0
    //
    virtual EnumDef_ptr create_enum(const char* id,
                                    const char* name,
                                    const char* version,
                                    const EnumMemberSeq& members) = 0;

    //
    // IDL:omg.org/CORBA/Container/create_alias:1.0
    //
    virtual AliasDef_ptr create_alias(const char* id,
                                      const char* name,
                                      const char* version,
                                      IDLType_ptr original_type) = 0;

    //
    // IDL:omg.org/CORBA/Container/create_interface:1.0
    //
    virtual InterfaceDef_ptr create_interface(const char* id,
                                              const char* name,
                                              const char* version,
                                              const InterfaceDefSeq& base_interfaces) = 0;

    //
    // IDL:omg.org/CORBA/Container/create_abstract_interface:1.0
    //
    virtual AbstractInterfaceDef_ptr create_abstract_interface(const char* id,
                                                               const char* name,
                                                               const char* version,
                                                               const AbstractInterfaceDefSeq& base_interfaces) = 0;

    //
    // IDL:omg.org/CORBA/Container/create_local_interface:1.0
    //
    virtual LocalInterfaceDef_ptr create_local_interface(const char* id,
                                                         const char* name,
                                                         const char* version,
                                                         const InterfaceDefSeq& base_interfaces) = 0;

    //
    // IDL:omg.org/CORBA/Container/create_exception:1.0
    //
    virtual ExceptionDef_ptr create_exception(const char* id,
                                              const char* name,
                                              const char* version,
                                              const StructMemberSeq& members) = 0;

    //
    // IDL:omg.org/CORBA/Container/create_value:1.0
    //
    virtual ValueDef_ptr create_value(const char* id,
                                      const char* name,
                                      const char* version,
                                      ::CORBA::Boolean is_custom,
                                      ::CORBA::Boolean is_abstract,
                                      ValueDef_ptr base_value,
                                      ::CORBA::Boolean is_truncatable,
                                      const ValueDefSeq& abstract_base_values,
                                      const InterfaceDefSeq& supported_interfaces,
                                      const InitializerSeq& initializers) = 0;

    //
    // IDL:omg.org/CORBA/Container/create_value_box:1.0
    //
    virtual ValueBoxDef_ptr create_value_box(const char* id,
                                             const char* name,
                                             const char* version,
                                             IDLType_ptr original_type_def) = 0;

    //
    // IDL:omg.org/CORBA/Container/create_native:1.0
    //
    virtual NativeDef_ptr create_native(const char* id,
                                        const char* name,
                                        const char* version) = 0;
};

//
// IDL:omg.org/CORBA/AttributeMode:1.0
//
enum AttributeMode
{
    ATTR_NORMAL,
    ATTR_READONLY
};

typedef AttributeMode& AttributeMode_out;

OB_IMPORT extern OB::TypeCodeConst _tc_AttributeMode;

//
// IDL:omg.org/CORBA/AttributeDef:1.0
//
class AttributeDef : virtual public ::CORBA::Contained
{
    AttributeDef(const AttributeDef&);
    void operator=(const AttributeDef&);

protected:

    static OB_IMPORT const char* ids_[];

public:

    AttributeDef() { }
    virtual ~AttributeDef() { }

    typedef AttributeDef_ptr _ptr_type;
    typedef AttributeDef_var _var_type;

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

    static inline AttributeDef_ptr
    _nil()
    {
        return 0;
    }

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

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

    static const char** _OB_staticIds();

    //
    // IDL:omg.org/CORBA/AttributeDef/type:1.0
    //
    virtual ::CORBA::TypeCode_ptr type() = 0;

    //
    // IDL:omg.org/CORBA/AttributeDef/type_def:1.0
    //
    virtual IDLType_ptr type_def() = 0;
    virtual void type_def(IDLType_ptr) = 0;

    //
    // IDL:omg.org/CORBA/AttributeDef/mode:1.0
    //
    virtual AttributeMode mode() = 0;
    virtual void mode(AttributeMode) = 0;
};

//
// IDL:omg.org/CORBA/AttributeDescription:1.0
//
struct AttributeDescription;
typedef OB::VarVar< AttributeDescription > AttributeDescription_var;
typedef OB::VarOut< AttributeDescription > AttributeDescription_out;

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

    typedef AttributeDescription_var _var_type;

    OB::StrForStruct name;
    OB::StrForStruct id;
    OB::StrForStruct defined_in;
    OB::StrForStruct version;
    ::CORBA::TypeCode_var type;
    AttributeMode mode;

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

OB_IMPORT extern OB::TypeCodeConst _tc_AttributeDescription;

//
// IDL:omg.org/CORBA/OperationMode:1.0
//
enum OperationMode
{
    OP_NORMAL,
    OP_ONEWAY
};

typedef OperationMode& OperationMode_out;

OB_IMPORT extern OB::TypeCodeConst _tc_OperationMode;

//
// IDL:omg.org/CORBA/ParameterDescription:1.0
//
struct ParameterDescription;
typedef OB::VarVar< ParameterDescription > ParameterDescription_var;
typedef OB::VarOut< ParameterDescription > ParameterDescription_out;

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

    typedef ParameterDescription_var _var_type;

    OB::StrForStruct name;
    ::CORBA::TypeCode_var type;
    IDLType_var type_def;
    ParameterMode mode;

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

OB_IMPORT extern OB::TypeCodeConst _tc_ParameterDescription;

//
// IDL:omg.org/CORBA/ParDescriptionSeq:1.0
//
class OBUnique_ParDescriptionSeq { };

typedef OB::VarSeq< ParameterDescription, OBUnique_ParDescriptionSeq > ParDescriptionSeq;
typedef OB::SeqVar< OB::VarSeq< ParameterDescription, OBUnique_ParDescriptionSeq > > ParDescriptionSeq_var;
typedef OB::SeqOut< OB::VarSeq< ParameterDescription, OBUnique_ParDescriptionSeq > > ParDescriptionSeq_out;
OB_IMPORT extern OB::TypeCodeConst _tc_ParDescriptionSeq;

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

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

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

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

//
// IDL:omg.org/CORBA/ContextIdentifier:1.0
//
typedef char* ContextIdentifier;
typedef ::CORBA::String_var ContextIdentifier_var;
typedef ::CORBA::String_out ContextIdentifier_out;
OB_IMPORT extern OB::TypeCodeConst _tc_ContextIdentifier;

//
// IDL:omg.org/CORBA/ContextIdSeq:1.0
//
class OBUnique_ContextIdSeq { };

typedef OB::StrSeq< OBUnique_ContextIdSeq > ContextIdSeq;
typedef OB::SeqVar< OB::StrSeq< OBUnique_ContextIdSeq > > ContextIdSeq_var;
typedef OB::SeqOut< OB::StrSeq< OBUnique_ContextIdSeq > > ContextIdSeq_out;
OB_IMPORT extern OB::TypeCodeConst _tc_ContextIdSeq;

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

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

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

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

//
// IDL:omg.org/CORBA/ExceptionDef:1.0
//
class ExceptionDef : virtual public ::CORBA::Contained,
                     virtual public ::CORBA::Container
{
    ExceptionDef(const ExceptionDef&);
    void operator=(const ExceptionDef&);

protected:

    static OB_IMPORT const char* ids_[];

public:

    ExceptionDef() { }
    virtual ~ExceptionDef() { }

    typedef ExceptionDef_ptr _ptr_type;
    typedef ExceptionDef_var _var_type;

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

    static inline ExceptionDef_ptr
    _nil()
    {
        return 0;
    }

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

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

    static const char** _OB_staticIds();

    //
    // IDL:omg.org/CORBA/ExceptionDef/type:1.0
    //
    virtual ::CORBA::TypeCode_ptr type() = 0;

    //
    // IDL:omg.org/CORBA/ExceptionDef/members:1.0
    //
    virtual StructMemberSeq* members() = 0;
    virtual void members(const StructMemberSeq&) = 0;
};

//
// IDL:omg.org/CORBA/ExceptionDescription:1.0
//
struct ExceptionDescription;
typedef OB::VarVar< ExceptionDescription > ExceptionDescription_var;
typedef OB::VarOut< ExceptionDescription > ExceptionDescription_out;

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

    typedef ExceptionDescription_var _var_type;

    OB::StrForStruct name;
    OB::StrForStruct id;
    OB::StrForStruct defined_in;
    OB::StrForStruct version;
    ::CORBA::TypeCode_var type;

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

OB_IMPORT extern OB::TypeCodeConst _tc_ExceptionDescription;

//
// IDL:omg.org/CORBA/ExceptionDefSeq:1.0
//
class OBUnique_ExceptionDefSeq { };

typedef OB::ObjSeq< ExceptionDef, OBUnique_ExceptionDefSeq > ExceptionDefSeq;
typedef OB::SeqVar< OB::ObjSeq< ExceptionDef, OBUnique_ExceptionDefSeq > > ExceptionDefSeq_var;
typedef OB::SeqOut< OB::ObjSeq< ExceptionDef, OBUnique_ExceptionDefSeq > > ExceptionDefSeq_out;
OB_IMPORT extern OB::TypeCodeConst _tc_ExceptionDefSeq;

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

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

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

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

//
// IDL:omg.org/CORBA/ExcDescriptionSeq:1.0
//
class OBUnique_ExcDescriptionSeq { };

typedef OB::VarSeq< ExceptionDescription, OBUnique_ExcDescriptionSeq > ExcDescriptionSeq;
typedef OB::SeqVar< OB::VarSeq< ExceptionDescription, OBUnique_ExcDescriptionSeq > > ExcDescriptionSeq_var;
typedef OB::SeqOut< OB::VarSeq< ExceptionDescription, OBUnique_ExcDescriptionSeq > > ExcDescriptionSeq_out;
OB_IMPORT extern OB::TypeCodeConst _tc_ExcDescriptionSeq;

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

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

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

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

//
// IDL:omg.org/CORBA/OperationDef:1.0
//
class OperationDef : virtual public ::CORBA::Contained
{
    OperationDef(const OperationDef&);
    void operator=(const OperationDef&);

protected:

    static OB_IMPORT const char* ids_[];

public:

    OperationDef() { }
    virtual ~OperationDef() { }

    typedef OperationDef_ptr _ptr_type;
    typedef OperationDef_var _var_type;

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

    static inline OperationDef_ptr
    _nil()
    {
        return 0;
    }

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

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

    static const char** _OB_staticIds();

    //
    // IDL:omg.org/CORBA/OperationDef/result:1.0
    //
    virtual ::CORBA::TypeCode_ptr result() = 0;

    //
    // IDL:omg.org/CORBA/OperationDef/result_def:1.0
    //
    virtual IDLType_ptr result_def() = 0;
    virtual void result_def(IDLType_ptr) = 0;

    //
    // IDL:omg.org/CORBA/OperationDef/params:1.0
    //
    virtual ParDescriptionSeq* params() = 0;
    virtual void params(const ParDescriptionSeq&) = 0;

    //
    // IDL:omg.org/CORBA/OperationDef/mode:1.0
    //
    virtual OperationMode mode() = 0;
    virtual void mode(OperationMode) = 0;

    //
    // IDL:omg.org/CORBA/OperationDef/contexts:1.0
    //
    virtual ContextIdSeq* contexts() = 0;
    virtual void contexts(const ContextIdSeq&) = 0;

    //
    // IDL:omg.org/CORBA/OperationDef/exceptions:1.0
    //
    virtual ExceptionDefSeq* exceptions() = 0;
    virtual void exceptions(const ExceptionDefSeq&) = 0;
};

//
// IDL:omg.org/CORBA/OperationDescription:1.0
//
struct OperationDescription;
typedef OB::VarVar< OperationDescription > OperationDescription_var;
typedef OB::VarOut< OperationDescription > OperationDescription_out;

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

    typedef OperationDescription_var _var_type;

    OB::StrForStruct name;
    OB::StrForStruct id;
    OB::StrForStruct defined_in;
    OB::StrForStruct version;
    ::CORBA::TypeCode_var result;
    OperationMode mode;
    ContextIdSeq contexts;
    ParDescriptionSeq parameters;
    ExcDescriptionSeq exceptions;

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

OB_IMPORT extern OB::TypeCodeConst _tc_OperationDescription;

//
// IDL:omg.org/CORBA/RepositoryIdSeq:1.0
//
class OBUnique_RepositoryIdSeq { };

typedef OB::StrSeq< OBUnique_RepositoryIdSeq > RepositoryIdSeq;
typedef OB::SeqVar< OB::StrSeq< OBUnique_RepositoryIdSeq > > RepositoryIdSeq_var;
typedef OB::SeqOut< OB::StrSeq< OBUnique_RepositoryIdSeq > > RepositoryIdSeq_out;
OB_IMPORT extern OB::TypeCodeConst _tc_RepositoryIdSeq;

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

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

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

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

//
// IDL:omg.org/CORBA/OpDescriptionSeq:1.0
//
class OBUnique_OpDescriptionSeq { };

typedef OB::VarSeq< OperationDescription, OBUnique_OpDescriptionSeq > OpDescriptionSeq;
typedef OB::SeqVar< OB::VarSeq< OperationDescription, OBUnique_OpDescriptionSeq > > OpDescriptionSeq_var;
typedef OB::SeqOut< OB::VarSeq< OperationDescription, OBUnique_OpDescriptionSeq > > OpDescriptionSeq_out;
OB_IMPORT extern OB::TypeCodeConst _tc_OpDescriptionSeq;

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

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

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

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

//
// IDL:omg.org/CORBA/AttrDescriptionSeq:1.0
//
class OBUnique_AttrDescriptionSeq { };

typedef OB::VarSeq< AttributeDescription, OBUnique_AttrDescriptionSeq > AttrDescriptionSeq;
typedef OB::SeqVar< OB::VarSeq< AttributeDescription, OBUnique_AttrDescriptionSeq > > AttrDescriptionSeq_var;
typedef OB::SeqOut< OB::VarSeq< AttributeDescription, OBUnique_AttrDescriptionSeq > > AttrDescriptionSeq_out;
OB_IMPORT extern OB::TypeCodeConst _tc_AttrDescriptionSeq;

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

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

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

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

//
// IDL:omg.org/CORBA/InterfaceDef:1.0
//
class InterfaceDef : virtual public ::CORBA::Container,
                     virtual public ::CORBA::Contained,
                     virtual public ::CORBA::IDLType
{
    InterfaceDef(const InterfaceDef&);
    void operator=(const InterfaceDef&);

protected:

    static OB_IMPORT const char* ids_[];

public:

    InterfaceDef() { }
    virtual ~InterfaceDef() { }

    typedef InterfaceDef_ptr _ptr_type;
    typedef InterfaceDef_var _var_type;

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

    static inline InterfaceDef_ptr
    _nil()
    {
        return 0;
    }

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

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

    static const char** _OB_staticIds();

    //
    // IDL:omg.org/CORBA/InterfaceDef/base_interfaces:1.0
    //
    virtual InterfaceDefSeq* base_interfaces() = 0;
    virtual void base_interfaces(const InterfaceDefSeq&) = 0;

    //
    // IDL:omg.org/CORBA/InterfaceDef/is_a:1.0
    //
    virtual ::CORBA::Boolean is_a(const char* interface_id) = 0;

    //
    // IDL:omg.org/CORBA/InterfaceDef/FullInterfaceDescription:1.0
    //
    struct FullInterfaceDescription;
    typedef OB::VarVar< FullInterfaceDescription > FullInterfaceDescription_var;
    typedef OB::VarOut< FullInterfaceDescription > FullInterfaceDescription_out;

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

        typedef FullInterfaceDescription_var _var_type;

        OB::StrForStruct name;
        OB::StrForStruct id;
        OB::StrForStruct defined_in;
        OB::StrForStruct version;
        OpDescriptionSeq operations;
        AttrDescriptionSeq attributes;
        RepositoryIdSeq base_interfaces;
        ::CORBA::TypeCode_var type;

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

    OB_IMPORT static OB::TypeCodeConst _tc_FullInterfaceDescription;

    //
    // IDL:omg.org/CORBA/InterfaceDef/describe_interface:1.0
    //
    virtual FullInterfaceDescription* describe_interface() = 0;

    //
    // IDL:omg.org/CORBA/InterfaceDef/create_attribute:1.0
    //
    virtual AttributeDef_ptr create_attribute(const char* id,
                                              const char* name,
                                              const char* version,
                                              IDLType_ptr type,
                                              AttributeMode mode) = 0;

    //
    // IDL:omg.org/CORBA/InterfaceDef/create_operation:1.0
    //
    virtual OperationDef_ptr create_operation(const char* id,
                                              const char* name,
                                              const char* version,
                                              IDLType_ptr result,
                                              OperationMode mode,
                                              const ParDescriptionSeq& params,
                                              const ExceptionDefSeq& exceptions,
                                              const ContextIdSeq& contexts) = 0;
};

//
// IDL:omg.org/CORBA/InterfaceDescription:1.0
//
struct InterfaceDescription;
typedef OB::VarVar< InterfaceDescription > InterfaceDescription_var;
typedef OB::VarOut< InterfaceDescription > InterfaceDescription_out;

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

    typedef InterfaceDescription_var _var_type;

    OB::StrForStruct name;
    OB::StrForStruct id;
    OB::StrForStruct defined_in;
    OB::StrForStruct version;
    RepositoryIdSeq base_interfaces;

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

OB_IMPORT extern OB::TypeCodeConst _tc_InterfaceDescription;

} // End of namespace CORBA

//
// IDL:omg.org/CORBA:1.0
//
namespace OBProxy_CORBA
{

//
// IDL:omg.org/CORBA/Contained:1.0
//
class Contained : virtual public ::CORBA::Contained,
                  virtual public OBProxy_CORBA::IRObject
{
    Contained(const Contained&);
    void operator=(const Contained&);

protected:

    virtual OB::MarshalStubImpl_ptr _OB_createMarshalStubImpl();

public:

    Contained() { }
    virtual ~Contained() { }

    virtual const char** _OB_ids() const;

    //
    // IDL:omg.org/CORBA/Contained/id:1.0
    //
    ::CORBA::RepositoryId id();
    void id(const char*);

    //
    // IDL:omg.org/CORBA/Contained/name:1.0
    //
    ::CORBA::Identifier name();
    void name(const char*);

    //
    // IDL:omg.org/CORBA/Contained/version:1.0
    //
    ::CORBA::VersionSpec version();
    void version(const char*);

    //
    // IDL:omg.org/CORBA/Contained/defined_in:1.0
    //
    ::CORBA::Container_ptr defined_in();

    //
    // IDL:omg.org/CORBA/Contained/absolute_name:1.0
    //
    ::CORBA::ScopedName absolute_name();

    //
    // IDL:omg.org/CORBA/Contained/containing_repository:1.0
    //
    ::CORBA::Repository_ptr containing_repository();

    //
    // IDL:omg.org/CORBA/Contained/describe:1.0
    //
    ::CORBA::Contained::Description* describe();

    //
    // IDL:omg.org/CORBA/Contained/move:1.0
    //
    void move(::CORBA::Container_ptr new_container,
              const char* new_name,
              const char* new_version);
};

//
// IDL:omg.org/CORBA/Container:1.0
//
class Container : virtual public ::CORBA::Container,
                  virtual public OBProxy_CORBA::IRObject
{
    Container(const Container&);
    void operator=(const Container&);

protected:

    virtual OB::MarshalStubImpl_ptr _OB_createMarshalStubImpl();

public:

    Container() { }
    virtual ~Container() { }

    virtual const char** _OB_ids() const;

    //
    // IDL:omg.org/CORBA/Container/lookup:1.0
    //
    ::CORBA::Contained_ptr lookup(const char* search_name);

    //
    // IDL:omg.org/CORBA/Container/contents:1.0
    //
    ::CORBA::ContainedSeq* contents(::CORBA::DefinitionKind limit_type,
                                    ::CORBA::Boolean exclude_inherited);

    //
    // IDL:omg.org/CORBA/Container/lookup_name:1.0
    //
    ::CORBA::ContainedSeq* lookup_name(const char* search_name,
                                       ::CORBA::Long levels_to_search,
                                       ::CORBA::DefinitionKind limit_type,
                                       ::CORBA::Boolean exclude_inherited);

    //
    // IDL:omg.org/CORBA/Container/describe_contents:1.0
    //
    ::CORBA::Container::DescriptionSeq* describe_contents(::CORBA::DefinitionKind limit_type,
                                                          ::CORBA::Boolean exclude_inherited,
                                                          ::CORBA::Long max_returned_objs);

    //
    // IDL:omg.org/CORBA/Container/create_module:1.0
    //
    ::CORBA::ModuleDef_ptr create_module(const char* id,
                                         const char* name,
                                         const char* version);

    //
    // IDL:omg.org/CORBA/Container/create_constant:1.0
    //
    ::CORBA::ConstantDef_ptr create_constant(const char* id,
                                             const char* name,
                                             const char* version,
                                             ::CORBA::IDLType_ptr type,
                                             const ::CORBA::Any& value);

    //
    // IDL:omg.org/CORBA/Container/create_struct:1.0
    //
    ::CORBA::StructDef_ptr create_struct(const char* id,
                                         const char* name,
                                         const char* version,
                                         const ::CORBA::StructMemberSeq& members);

    //
    // IDL:omg.org/CORBA/Container/create_union:1.0
    //
    ::CORBA::UnionDef_ptr create_union(const char* id,
                                       const char* name,
                                       const char* version,
                                       ::CORBA::IDLType_ptr discriminator_type,
                                       const ::CORBA::UnionMemberSeq& members);

    //
    // IDL:omg.org/CORBA/Container/create_enum:1.0
    //
    ::CORBA::EnumDef_ptr create_enum(const char* id,
                                     const char* name,
                                     const char* version,
                                     const ::CORBA::EnumMemberSeq& members);

    //
    // IDL:omg.org/CORBA/Container/create_alias:1.0
    //
    ::CORBA::AliasDef_ptr create_alias(const char* id,
                                       const char* name,
                                       const char* version,
                                       ::CORBA::IDLType_ptr original_type);

    //
    // IDL:omg.org/CORBA/Container/create_interface:1.0
    //
    ::CORBA::InterfaceDef_ptr create_interface(const char* id,
                                               const char* name,
                                               const char* version,
                                               const ::CORBA::InterfaceDefSeq& base_interfaces);

    //
    // IDL:omg.org/CORBA/Container/create_abstract_interface:1.0
    //
    ::CORBA::AbstractInterfaceDef_ptr create_abstract_interface(const char* id,
                                                                const char* name,
                                                                const char* version,
                                                                const ::CORBA::AbstractInterfaceDefSeq& base_interfaces);

    //
    // IDL:omg.org/CORBA/Container/create_local_interface:1.0
    //
    ::CORBA::LocalInterfaceDef_ptr create_local_interface(const char* id,
                                                          const char* name,
                                                          const char* version,
                                                          const ::CORBA::InterfaceDefSeq& base_interfaces);

    //
    // IDL:omg.org/CORBA/Container/create_exception:1.0
    //
    ::CORBA::ExceptionDef_ptr create_exception(const char* id,
                                               const char* name,
                                               const char* version,
                                               const ::CORBA::StructMemberSeq& members);

    //
    // IDL:omg.org/CORBA/Container/create_value:1.0
    //
    ::CORBA::ValueDef_ptr create_value(const char* id,
                                       const char* name,
                                       const char* version,
                                       ::CORBA::Boolean is_custom,
                                       ::CORBA::Boolean is_abstract,
                                       ::CORBA::ValueDef_ptr base_value,
                                       ::CORBA::Boolean is_truncatable,
                                       const ::CORBA::ValueDefSeq& abstract_base_values,
                                       const ::CORBA::InterfaceDefSeq& supported_interfaces,
                                       const ::CORBA::InitializerSeq& initializers);

    //
    // IDL:omg.org/CORBA/Container/create_value_box:1.0
    //
    ::CORBA::ValueBoxDef_ptr create_value_box(const char* id,
                                              const char* name,
                                              const char* version,
                                              ::CORBA::IDLType_ptr original_type_def);

    //
    // IDL:omg.org/CORBA/Container/create_native:1.0
    //
    ::CORBA::NativeDef_ptr create_native(const char* id,
                                         const char* name,
                                         const char* version);
};

//
// IDL:omg.org/CORBA/AttributeDef:1.0
//
class AttributeDef : virtual public ::CORBA::AttributeDef,
                     virtual public OBProxy_CORBA::Contained
{
    AttributeDef(const AttributeDef&);
    void operator=(const AttributeDef&);

protected:

    virtual OB::MarshalStubImpl_ptr _OB_createMarshalStubImpl();

public:

    AttributeDef() { }
    virtual ~AttributeDef() { }

    virtual const char** _OB_ids() const;

    //
    // IDL:omg.org/CORBA/AttributeDef/type:1.0
    //
    ::CORBA::TypeCode_ptr type();

    //
    // IDL:omg.org/CORBA/AttributeDef/type_def:1.0
    //
    ::CORBA::IDLType_ptr type_def();
    void type_def(::CORBA::IDLType_ptr);

    //
    // IDL:omg.org/CORBA/AttributeDef/mode:1.0
    //
    ::CORBA::AttributeMode mode();
    void mode(::CORBA::AttributeMode);
};

//
// IDL:omg.org/CORBA/ExceptionDef:1.0
//
class ExceptionDef : virtual public ::CORBA::ExceptionDef,
                     virtual public OBProxy_CORBA::Contained,
                     virtual public OBProxy_CORBA::Container
{
    ExceptionDef(const ExceptionDef&);
    void operator=(const ExceptionDef&);

protected:

    virtual OB::MarshalStubImpl_ptr _OB_createMarshalStubImpl();

public:

    ExceptionDef() { }
    virtual ~ExceptionDef() { }

    virtual const char** _OB_ids() const;

    //
    // IDL:omg.org/CORBA/ExceptionDef/type:1.0
    //
    ::CORBA::TypeCode_ptr type();

    //
    // IDL:omg.org/CORBA/ExceptionDef/members:1.0
    //
    ::CORBA::StructMemberSeq* members();
    void members(const ::CORBA::StructMemberSeq&);
};

//
// IDL:omg.org/CORBA/OperationDef:1.0
//
class OperationDef : virtual public ::CORBA::OperationDef,
                     virtual public OBProxy_CORBA::Contained
{
    OperationDef(const OperationDef&);
    void operator=(const OperationDef&);

protected:

    virtual OB::MarshalStubImpl_ptr _OB_createMarshalStubImpl();

public:

    OperationDef() { }
    virtual ~OperationDef() { }

    virtual const char** _OB_ids() const;

    //
    // IDL:omg.org/CORBA/OperationDef/result:1.0
    //
    ::CORBA::TypeCode_ptr result();

    //
    // IDL:omg.org/CORBA/OperationDef/result_def:1.0
    //
    ::CORBA::IDLType_ptr result_def();
    void result_def(::CORBA::IDLType_ptr);

    //
    // IDL:omg.org/CORBA/OperationDef/params:1.0
    //
    ::CORBA::ParDescriptionSeq* params();
    void params(const ::CORBA::ParDescriptionSeq&);

    //
    // IDL:omg.org/CORBA/OperationDef/mode:1.0
    //
    ::CORBA::OperationMode mode();
    void mode(::CORBA::OperationMode);

    //
    // IDL:omg.org/CORBA/OperationDef/contexts:1.0
    //
    ::CORBA::ContextIdSeq* contexts();
    void contexts(const ::CORBA::ContextIdSeq&);

    //
    // IDL:omg.org/CORBA/OperationDef/exceptions:1.0
    //
    ::CORBA::ExceptionDefSeq* exceptions();
    void exceptions(const ::CORBA::ExceptionDefSeq&);
};

//
// IDL:omg.org/CORBA/InterfaceDef:1.0
//
class InterfaceDef : virtual public ::CORBA::InterfaceDef,
                     virtual public OBProxy_CORBA::Container,
                     virtual public OBProxy_CORBA::Contained,
                     virtual public OBProxy_CORBA::IDLType
{
    InterfaceDef(const InterfaceDef&);
    void operator=(const InterfaceDef&);

protected:

    virtual OB::MarshalStubImpl_ptr _OB_createMarshalStubImpl();

public:

    InterfaceDef() { }
    virtual ~InterfaceDef() { }

    virtual const char** _OB_ids() const;

    //
    // IDL:omg.org/CORBA/InterfaceDef/base_interfaces:1.0
    //
    ::CORBA::InterfaceDefSeq* base_interfaces();
    void base_interfaces(const ::CORBA::InterfaceDefSeq&);

    //
    // IDL:omg.org/CORBA/InterfaceDef/is_a:1.0
    //
    ::CORBA::Boolean is_a(const char* interface_id);

    //
    // IDL:omg.org/CORBA/InterfaceDef/describe_interface:1.0
    //
    ::CORBA::InterfaceDef::FullInterfaceDescription* describe_interface();

    //
    // IDL:omg.org/CORBA/InterfaceDef/create_attribute:1.0
    //
    ::CORBA::AttributeDef_ptr create_attribute(const char* id,
                                               const char* name,
                                               const char* version,
                                               ::CORBA::IDLType_ptr type,
                                               ::CORBA::AttributeMode mode);

    //
    // IDL:omg.org/CORBA/InterfaceDef/create_operation:1.0
    //
    ::CORBA::OperationDef_ptr create_operation(const char* id,
                                               const char* name,
                                               const char* version,
                                               ::CORBA::IDLType_ptr result,
                                               ::CORBA::OperationMode mode,
                                               const ::CORBA::ParDescriptionSeq& params,
                                               const ::CORBA::ExceptionDefSeq& exceptions,
                                               const ::CORBA::ContextIdSeq& contexts);
};

} // End of namespace OBProxy_CORBA

//
// IDL:omg.org/CORBA:1.0
//
namespace OBStubImpl_CORBA
{

//
// IDL:omg.org/CORBA/Contained:1.0
//
class Contained : virtual public OBStubImpl_CORBA::IRObject
{
    Contained(const Contained&);
    void operator=(const Contained&);

protected:

    Contained() { }

public:

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

    static inline Contained_ptr
    _nil()
    {
        return 0;
    }

    //
    // IDL:omg.org/CORBA/Contained/id:1.0
    //
    virtual ::CORBA::RepositoryId id() = 0;
    virtual void id(const char*) = 0;

    //
    // IDL:omg.org/CORBA/Contained/name:1.0
    //
    virtual ::CORBA::Identifier name() = 0;
    virtual void name(const char*) = 0;

    //
    // IDL:omg.org/CORBA/Contained/version:1.0
    //
    virtual ::CORBA::VersionSpec version() = 0;
    virtual void version(const char*) = 0;

    //
    // IDL:omg.org/CORBA/Contained/defined_in:1.0
    //
    virtual ::CORBA::Container_ptr defined_in() = 0;

    //
    // IDL:omg.org/CORBA/Contained/absolute_name:1.0
    //
    virtual ::CORBA::ScopedName absolute_name() = 0;

    //
    // IDL:omg.org/CORBA/Contained/containing_repository:1.0
    //
    virtual ::CORBA::Repository_ptr containing_repository() = 0;

    //
    // IDL:omg.org/CORBA/Contained/describe:1.0
    //
    virtual ::CORBA::Contained::Description* describe() = 0;

    //
    // IDL:omg.org/CORBA/Contained/move:1.0
    //
    virtual void move(::CORBA::Container_ptr new_container,
                      const char* new_name,
                      const char* new_version) = 0;
};

//
// IDL:omg.org/CORBA/Container:1.0
//
class Container : virtual public OBStubImpl_CORBA::IRObject
{
    Container(const Container&);
    void operator=(const Container&);

protected:

    Container() { }

public:

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

    static inline Container_ptr
    _nil()
    {
        return 0;
    }

    //
    // IDL:omg.org/CORBA/Container/lookup:1.0
    //
    virtual ::CORBA::Contained_ptr lookup(const char* search_name) = 0;

    //
    // IDL:omg.org/CORBA/Container/contents:1.0
    //
    virtual ::CORBA::ContainedSeq* contents(::CORBA::DefinitionKind limit_type,
                                            ::CORBA::Boolean exclude_inherited) = 0;

    //
    // IDL:omg.org/CORBA/Container/lookup_name:1.0
    //
    virtual ::CORBA::ContainedSeq* lookup_name(const char* search_name,
                                               ::CORBA::Long levels_to_search,
                                               ::CORBA::DefinitionKind limit_type,
                                               ::CORBA::Boolean exclude_inherited) = 0;

    //
    // IDL:omg.org/CORBA/Container/describe_contents:1.0
    //
    virtual ::CORBA::Container::DescriptionSeq* describe_contents(::CORBA::DefinitionKind limit_type,
                                                                  ::CORBA::Boolean exclude_inherited,
                                                                  ::CORBA::Long max_returned_objs) = 0;

    //
    // IDL:omg.org/CORBA/Container/create_module:1.0
    //
    virtual ::CORBA::ModuleDef_ptr create_module(const char* id,
                                                 const char* name,
                                                 const char* version) = 0;

    //
    // IDL:omg.org/CORBA/Container/create_constant:1.0
    //
    virtual ::CORBA::ConstantDef_ptr create_constant(const char* id,
                                                     const char* name,
                                                     const char* version,
                                                     ::CORBA::IDLType_ptr type,
                                                     const ::CORBA::Any& value) = 0;

    //
    // IDL:omg.org/CORBA/Container/create_struct:1.0
    //
    virtual ::CORBA::StructDef_ptr create_struct(const char* id,
                                                 const char* name,
                                                 const char* version,
                                                 const ::CORBA::StructMemberSeq& members) = 0;

    //
    // IDL:omg.org/CORBA/Container/create_union:1.0
    //
    virtual ::CORBA::UnionDef_ptr create_union(const char* id,
                                               const char* name,
                                               const char* version,
                                               ::CORBA::IDLType_ptr discriminator_type,
                                               const ::CORBA::UnionMemberSeq& members) = 0;

    //
    // IDL:omg.org/CORBA/Container/create_enum:1.0
    //
    virtual ::CORBA::EnumDef_ptr create_enum(const char* id,
                                             const char* name,
                                             const char* version,
                                             const ::CORBA::EnumMemberSeq& members) = 0;

    //
    // IDL:omg.org/CORBA/Container/create_alias:1.0
    //
    virtual ::CORBA::AliasDef_ptr create_alias(const char* id,
                                               const char* name,
                                               const char* version,
                                               ::CORBA::IDLType_ptr original_type) = 0;

    //
    // IDL:omg.org/CORBA/Container/create_interface:1.0
    //
    virtual ::CORBA::InterfaceDef_ptr create_interface(const char* id,
                                                       const char* name,
                                                       const char* version,
                                                       const ::CORBA::InterfaceDefSeq& base_interfaces) = 0;

    //
    // IDL:omg.org/CORBA/Container/create_abstract_interface:1.0
    //
    virtual ::CORBA::AbstractInterfaceDef_ptr create_abstract_interface(const char* id,
                                                                        const char* name,
                                                                        const char* version,
                                                                        const ::CORBA::AbstractInterfaceDefSeq& base_interfaces) = 0;

    //
    // IDL:omg.org/CORBA/Container/create_local_interface:1.0
    //
    virtual ::CORBA::LocalInterfaceDef_ptr create_local_interface(const char* id,
                                                                  const char* name,
                                                                  const char* version,
                                                                  const ::CORBA::InterfaceDefSeq& base_interfaces) = 0;

    //
    // IDL:omg.org/CORBA/Container/create_exception:1.0
    //
    virtual ::CORBA::ExceptionDef_ptr create_exception(const char* id,
                                                       const char* name,
                                                       const char* version,
                                                       const ::CORBA::StructMemberSeq& members) = 0;

    //
    // IDL:omg.org/CORBA/Container/create_value:1.0
    //
    virtual ::CORBA::ValueDef_ptr create_value(const char* id,
                                               const char* name,
                                               const char* version,
                                               ::CORBA::Boolean is_custom,
                                               ::CORBA::Boolean is_abstract,
                                               ::CORBA::ValueDef_ptr base_value,
                                               ::CORBA::Boolean is_truncatable,
                                               const ::CORBA::ValueDefSeq& abstract_base_values,
                                               const ::CORBA::InterfaceDefSeq& supported_interfaces,
                                               const ::CORBA::InitializerSeq& initializers) = 0;

    //
    // IDL:omg.org/CORBA/Container/create_value_box:1.0
    //
    virtual ::CORBA::ValueBoxDef_ptr create_value_box(const char* id,
                                                      const char* name,
                                                      const char* version,
                                                      ::CORBA::IDLType_ptr original_type_def) = 0;

    //
    // IDL:omg.org/CORBA/Container/create_native:1.0
    //
    virtual ::CORBA::NativeDef_ptr create_native(const char* id,
                                                 const char* name,
                                                 const char* version) = 0;
};

//
// IDL:omg.org/CORBA/AttributeDef:1.0
//
class AttributeDef : virtual public OBStubImpl_CORBA::Contained
{
    AttributeDef(const AttributeDef&);
    void operator=(const AttributeDef&);

protected:

    AttributeDef() { }

public:

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

    static inline AttributeDef_ptr
    _nil()
    {
        return 0;
    }

    //
    // IDL:omg.org/CORBA/AttributeDef/type:1.0
    //
    virtual ::CORBA::TypeCode_ptr type() = 0;

    //
    // IDL:omg.org/CORBA/AttributeDef/type_def:1.0
    //
    virtual ::CORBA::IDLType_ptr type_def() = 0;
    virtual void type_def(::CORBA::IDLType_ptr) = 0;

    //
    // IDL:omg.org/CORBA/AttributeDef/mode:1.0
    //
    virtual ::CORBA::AttributeMode mode() = 0;
    virtual void mode(::CORBA::AttributeMode) = 0;
};

//
// IDL:omg.org/CORBA/ExceptionDef:1.0
//
class ExceptionDef : virtual public OBStubImpl_CORBA::Contained,
                     virtual public OBStubImpl_CORBA::Container
{
    ExceptionDef(const ExceptionDef&);
    void operator=(const ExceptionDef&);

protected:

    ExceptionDef() { }

public:

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

    static inline ExceptionDef_ptr
    _nil()
    {
        return 0;
    }

    //
    // IDL:omg.org/CORBA/ExceptionDef/type:1.0
    //
    virtual ::CORBA::TypeCode_ptr type() = 0;

    //
    // IDL:omg.org/CORBA/ExceptionDef/members:1.0
    //
    virtual ::CORBA::StructMemberSeq* members() = 0;
    virtual void members(const ::CORBA::StructMemberSeq&) = 0;
};

//
// IDL:omg.org/CORBA/OperationDef:1.0
//
class OperationDef : virtual public OBStubImpl_CORBA::Contained
{
    OperationDef(const OperationDef&);
    void operator=(const OperationDef&);

protected:

    OperationDef() { }

public:

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

    static inline OperationDef_ptr
    _nil()
    {
        return 0;
    }

    //
    // IDL:omg.org/CORBA/OperationDef/result:1.0
    //
    virtual ::CORBA::TypeCode_ptr result() = 0;

    //
    // IDL:omg.org/CORBA/OperationDef/result_def:1.0
    //
    virtual ::CORBA::IDLType_ptr result_def() = 0;
    virtual void result_def(::CORBA::IDLType_ptr) = 0;

    //
    // IDL:omg.org/CORBA/OperationDef/params:1.0
    //
    virtual ::CORBA::ParDescriptionSeq* params() = 0;
    virtual void params(const ::CORBA::ParDescriptionSeq&) = 0;

    //
    // IDL:omg.org/CORBA/OperationDef/mode:1.0
    //
    virtual ::CORBA::OperationMode mode() = 0;
    virtual void mode(::CORBA::OperationMode) = 0;

    //
    // IDL:omg.org/CORBA/OperationDef/contexts:1.0
    //
    virtual ::CORBA::ContextIdSeq* contexts() = 0;
    virtual void contexts(const ::CORBA::ContextIdSeq&) = 0;

    //
    // IDL:omg.org/CORBA/OperationDef/exceptions:1.0
    //
    virtual ::CORBA::ExceptionDefSeq* exceptions() = 0;
    virtual void exceptions(const ::CORBA::ExceptionDefSeq&) = 0;
};

//
// IDL:omg.org/CORBA/InterfaceDef:1.0
//
class InterfaceDef : virtual public OBStubImpl_CORBA::Container,
                     virtual public OBStubImpl_CORBA::Contained,
                     virtual public OBStubImpl_CORBA::IDLType
{
    InterfaceDef(const InterfaceDef&);
    void operator=(const InterfaceDef&);

protected:

    InterfaceDef() { }

public:

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

    static inline InterfaceDef_ptr
    _nil()
    {
        return 0;
    }

    //
    // IDL:omg.org/CORBA/InterfaceDef/base_interfaces:1.0
    //
    virtual ::CORBA::InterfaceDefSeq* base_interfaces() = 0;
    virtual void base_interfaces(const ::CORBA::InterfaceDefSeq&) = 0;

    //
    // IDL:omg.org/CORBA/InterfaceDef/is_a:1.0
    //
    virtual ::CORBA::Boolean is_a(const char* interface_id) = 0;

    //
    // IDL:omg.org/CORBA/InterfaceDef/describe_interface:1.0
    //
    virtual ::CORBA::InterfaceDef::FullInterfaceDescription* describe_interface() = 0;

    //
    // IDL:omg.org/CORBA/InterfaceDef/create_attribute:1.0
    //
    virtual ::CORBA::AttributeDef_ptr create_attribute(const char* id,
                                                       const char* name,
                                                       const char* version,
                                                       ::CORBA::IDLType_ptr type,
                                                       ::CORBA::AttributeMode mode) = 0;

    //
    // IDL:omg.org/CORBA/InterfaceDef/create_operation:1.0
    //
    virtual ::CORBA::OperationDef_ptr create_operation(const char* id,
                                                       const char* name,
                                                       const char* version,
                                                       ::CORBA::IDLType_ptr result,
                                                       ::CORBA::OperationMode mode,
                                                       const ::CORBA::ParDescriptionSeq& params,
                                                       const ::CORBA::ExceptionDefSeq& exceptions,
                                                       const ::CORBA::ContextIdSeq& contexts) = 0;
};

} // End of namespace OBStubImpl_CORBA

//
// IDL:omg.org/CORBA:1.0
//
namespace OBMarshalStubImpl_CORBA
{

//
// IDL:omg.org/CORBA/Contained:1.0
//
class Contained : virtual public OBStubImpl_CORBA::Contained,
                  virtual public OBMarshalStubImpl_CORBA::IRObject
{
    Contained(const Contained&);
    void operator=(const Contained&);

protected:

    Contained() { }
    friend class OBProxy_CORBA::Contained;

public:

    //
    // IDL:omg.org/CORBA/Contained/id:1.0
    //
    virtual ::CORBA::RepositoryId id();
    virtual void id(const char*);

    //
    // IDL:omg.org/CORBA/Contained/name:1.0
    //
    virtual ::CORBA::Identifier name();
    virtual void name(const char*);

    //
    // IDL:omg.org/CORBA/Contained/version:1.0
    //
    virtual ::CORBA::VersionSpec version();
    virtual void version(const char*);

    //
    // IDL:omg.org/CORBA/Contained/defined_in:1.0
    //
    virtual ::CORBA::Container_ptr defined_in();

    //
    // IDL:omg.org/CORBA/Contained/absolute_name:1.0
    //
    virtual ::CORBA::ScopedName absolute_name();

    //
    // IDL:omg.org/CORBA/Contained/containing_repository:1.0
    //
    virtual ::CORBA::Repository_ptr containing_repository();

    //
    // IDL:omg.org/CORBA/Contained/describe:1.0
    //
    virtual ::CORBA::Contained::Description* describe();

    //
    // IDL:omg.org/CORBA/Contained/move:1.0
    //
    virtual void move(::CORBA::Container_ptr new_container,
                      const char* new_name,
                      const char* new_version);
};

//
// IDL:omg.org/CORBA/Container:1.0
//
class Container : virtual public OBStubImpl_CORBA::Container,
                  virtual public OBMarshalStubImpl_CORBA::IRObject
{
    Container(const Container&);
    void operator=(const Container&);

protected:

    Container() { }
    friend class OBProxy_CORBA::Container;

public:

    //
    // IDL:omg.org/CORBA/Container/lookup:1.0
    //
    virtual ::CORBA::Contained_ptr lookup(const char* search_name);

    //
    // IDL:omg.org/CORBA/Container/contents:1.0
    //
    virtual ::CORBA::ContainedSeq* contents(::CORBA::DefinitionKind limit_type,
                                            ::CORBA::Boolean exclude_inherited);

    //
    // IDL:omg.org/CORBA/Container/lookup_name:1.0
    //
    virtual ::CORBA::ContainedSeq* lookup_name(const char* search_name,
                                               ::CORBA::Long levels_to_search,
                                               ::CORBA::DefinitionKind limit_type,
                                               ::CORBA::Boolean exclude_inherited);

    //
    // IDL:omg.org/CORBA/Container/describe_contents:1.0
    //
    virtual ::CORBA::Container::DescriptionSeq* describe_contents(::CORBA::DefinitionKind limit_type,
                                                                  ::CORBA::Boolean exclude_inherited,
                                                                  ::CORBA::Long max_returned_objs);

    //
    // IDL:omg.org/CORBA/Container/create_module:1.0
    //
    virtual ::CORBA::ModuleDef_ptr create_module(const char* id,
                                                 const char* name,
                                                 const char* version);

    //
    // IDL:omg.org/CORBA/Container/create_constant:1.0
    //
    virtual ::CORBA::ConstantDef_ptr create_constant(const char* id,
                                                     const char* name,
                                                     const char* version,
                                                     ::CORBA::IDLType_ptr type,
                                                     const ::CORBA::Any& value);

    //
    // IDL:omg.org/CORBA/Container/create_struct:1.0
    //
    virtual ::CORBA::StructDef_ptr create_struct(const char* id,
                                                 const char* name,
                                                 const char* version,
                                                 const ::CORBA::StructMemberSeq& members);

    //
    // IDL:omg.org/CORBA/Container/create_union:1.0
    //
    virtual ::CORBA::UnionDef_ptr create_union(const char* id,
                                               const char* name,
                                               const char* version,
                                               ::CORBA::IDLType_ptr discriminator_type,
                                               const ::CORBA::UnionMemberSeq& members);

    //
    // IDL:omg.org/CORBA/Container/create_enum:1.0
    //
    virtual ::CORBA::EnumDef_ptr create_enum(const char* id,
                                             const char* name,
                                             const char* version,
                                             const ::CORBA::EnumMemberSeq& members);

    //
    // IDL:omg.org/CORBA/Container/create_alias:1.0
    //
    virtual ::CORBA::AliasDef_ptr create_alias(const char* id,
                                               const char* name,
                                               const char* version,
                                               ::CORBA::IDLType_ptr original_type);

    //
    // IDL:omg.org/CORBA/Container/create_interface:1.0
    //
    virtual ::CORBA::InterfaceDef_ptr create_interface(const char* id,
                                                       const char* name,
                                                       const char* version,
                                                       const ::CORBA::InterfaceDefSeq& base_interfaces);

    //
    // IDL:omg.org/CORBA/Container/create_abstract_interface:1.0
    //
    virtual ::CORBA::AbstractInterfaceDef_ptr create_abstract_interface(const char* id,
                                                                        const char* name,
                                                                        const char* version,
                                                                        const ::CORBA::AbstractInterfaceDefSeq& base_interfaces);

    //
    // IDL:omg.org/CORBA/Container/create_local_interface:1.0
    //
    virtual ::CORBA::LocalInterfaceDef_ptr create_local_interface(const char* id,
                                                                  const char* name,
                                                                  const char* version,
                                                                  const ::CORBA::InterfaceDefSeq& base_interfaces);

    //
    // IDL:omg.org/CORBA/Container/create_exception:1.0
    //
    virtual ::CORBA::ExceptionDef_ptr create_exception(const char* id,
                                                       const char* name,
                                                       const char* version,
                                                       const ::CORBA::StructMemberSeq& members);

    //
    // IDL:omg.org/CORBA/Container/create_value:1.0
    //
    virtual ::CORBA::ValueDef_ptr create_value(const char* id,
                                               const char* name,
                                               const char* version,
                                               ::CORBA::Boolean is_custom,
                                               ::CORBA::Boolean is_abstract,
                                               ::CORBA::ValueDef_ptr base_value,
                                               ::CORBA::Boolean is_truncatable,
                                               const ::CORBA::ValueDefSeq& abstract_base_values,
                                               const ::CORBA::InterfaceDefSeq& supported_interfaces,
                                               const ::CORBA::InitializerSeq& initializers);

    //
    // IDL:omg.org/CORBA/Container/create_value_box:1.0
    //
    virtual ::CORBA::ValueBoxDef_ptr create_value_box(const char* id,
                                                      const char* name,
                                                      const char* version,
                                                      ::CORBA::IDLType_ptr original_type_def);

    //
    // IDL:omg.org/CORBA/Container/create_native:1.0
    //
    virtual ::CORBA::NativeDef_ptr create_native(const char* id,
                                                 const char* name,
                                                 const char* version);
};

//
// IDL:omg.org/CORBA/AttributeDef:1.0
//
class AttributeDef : virtual public OBStubImpl_CORBA::AttributeDef,
                     virtual public OBMarshalStubImpl_CORBA::Contained
{
    AttributeDef(const AttributeDef&);
    void operator=(const AttributeDef&);

protected:

    AttributeDef() { }
    friend class OBProxy_CORBA::AttributeDef;

public:

    //
    // IDL:omg.org/CORBA/AttributeDef/type:1.0
    //
    virtual ::CORBA::TypeCode_ptr type();

    //
    // IDL:omg.org/CORBA/AttributeDef/type_def:1.0
    //
    virtual ::CORBA::IDLType_ptr type_def();
    virtual void type_def(::CORBA::IDLType_ptr);

    //
    // IDL:omg.org/CORBA/AttributeDef/mode:1.0
    //
    virtual ::CORBA::AttributeMode mode();
    virtual void mode(::CORBA::AttributeMode);
};

//
// IDL:omg.org/CORBA/ExceptionDef:1.0
//
class ExceptionDef : virtual public OBStubImpl_CORBA::ExceptionDef,
                     virtual public OBMarshalStubImpl_CORBA::Contained,
                     virtual public OBMarshalStubImpl_CORBA::Container
{
    ExceptionDef(const ExceptionDef&);
    void operator=(const ExceptionDef&);

protected:

    ExceptionDef() { }
    friend class OBProxy_CORBA::ExceptionDef;

public:

    //
    // IDL:omg.org/CORBA/ExceptionDef/type:1.0
    //
    virtual ::CORBA::TypeCode_ptr type();

    //
    // IDL:omg.org/CORBA/ExceptionDef/members:1.0
    //
    virtual ::CORBA::StructMemberSeq* members();
    virtual void members(const ::CORBA::StructMemberSeq&);
};

//
// IDL:omg.org/CORBA/OperationDef:1.0
//
class OperationDef : virtual public OBStubImpl_CORBA::OperationDef,
                     virtual public OBMarshalStubImpl_CORBA::Contained
{
    OperationDef(const OperationDef&);
    void operator=(const OperationDef&);

protected:

    OperationDef() { }
    friend class OBProxy_CORBA::OperationDef;

public:

    //
    // IDL:omg.org/CORBA/OperationDef/result:1.0
    //
    virtual ::CORBA::TypeCode_ptr result();

    //
    // IDL:omg.org/CORBA/OperationDef/result_def:1.0
    //
    virtual ::CORBA::IDLType_ptr result_def();
    virtual void result_def(::CORBA::IDLType_ptr);

    //
    // IDL:omg.org/CORBA/OperationDef/params:1.0
    //
    virtual ::CORBA::ParDescriptionSeq* params();
    virtual void params(const ::CORBA::ParDescriptionSeq&);

    //
    // IDL:omg.org/CORBA/OperationDef/mode:1.0
    //
    virtual ::CORBA::OperationMode mode();
    virtual void mode(::CORBA::OperationMode);

    //
    // IDL:omg.org/CORBA/OperationDef/contexts:1.0
    //
    virtual ::CORBA::ContextIdSeq* contexts();
    virtual void contexts(const ::CORBA::ContextIdSeq&);

    //
    // IDL:omg.org/CORBA/OperationDef/exceptions:1.0
    //
    virtual ::CORBA::ExceptionDefSeq* exceptions();
    virtual void exceptions(const ::CORBA::ExceptionDefSeq&);
};

//
// IDL:omg.org/CORBA/InterfaceDef:1.0
//
class InterfaceDef : virtual public OBStubImpl_CORBA::InterfaceDef,
                     virtual public OBMarshalStubImpl_CORBA::Container,
                     virtual public OBMarshalStubImpl_CORBA::Contained,
                     virtual public OBMarshalStubImpl_CORBA::IDLType
{
    InterfaceDef(const InterfaceDef&);
    void operator=(const InterfaceDef&);

protected:

    InterfaceDef() { }
    friend class OBProxy_CORBA::InterfaceDef;

public:

    //
    // IDL:omg.org/CORBA/InterfaceDef/base_interfaces:1.0
    //
    virtual ::CORBA::InterfaceDefSeq* base_interfaces();
    virtual void base_interfaces(const ::CORBA::InterfaceDefSeq&);

    //
    // IDL:omg.org/CORBA/InterfaceDef/is_a:1.0
    //
    virtual ::CORBA::Boolean is_a(const char* interface_id);

    //
    // IDL:omg.org/CORBA/InterfaceDef/describe_interface:1.0
    //
    virtual ::CORBA::InterfaceDef::FullInterfaceDescription* describe_interface();

    //
    // IDL:omg.org/CORBA/InterfaceDef/create_attribute:1.0
    //
    virtual ::CORBA::AttributeDef_ptr create_attribute(const char* id,
                                                       const char* name,
                                                       const char* version,
                                                       ::CORBA::IDLType_ptr type,
                                                       ::CORBA::AttributeMode mode);

    //
    // IDL:omg.org/CORBA/InterfaceDef/create_operation:1.0
    //
    virtual ::CORBA::OperationDef_ptr create_operation(const char* id,
                                                       const char* name,
                                                       const char* version,
                                                       ::CORBA::IDLType_ptr result,
                                                       ::CORBA::OperationMode mode,
                                                       const ::CORBA::ParDescriptionSeq& params,
                                                       const ::CORBA::ExceptionDefSeq& exceptions,
                                                       const ::CORBA::ContextIdSeq& contexts);
};

} // End of namespace OBMarshalStubImpl_CORBA

//
// IDL:omg.org/CORBA:1.0
//
namespace OBV_CORBA
{

} // End of namespace OBV_CORBA

//
// IDL:omg.org/CORBA/Contained:1.0
//
namespace CORBA
{

inline void
release(::CORBA::Contained_ptr p)
{
    if(p)
        p -> _remove_ref();
}

inline Boolean
is_nil(::CORBA::Contained_ptr p)
{
    return p == 0;
}

inline void
release(OBStubImpl_CORBA::Contained_ptr p)
{
    if(p)
        p -> _OB_decRef();
}

inline Boolean
is_nil(OBStubImpl_CORBA::Contained_ptr p)
{
    return p == 0;
}

} // End of namespace CORBA

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

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

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

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

//
// IDL:omg.org/CORBA/Contained/Description:1.0
//
void operator<<=(::CORBA::Any&, CORBA::Contained::Description*);
void operator<<=(::CORBA::Any&, const CORBA::Contained::Description&);
CORBA::Boolean operator>>=(const ::CORBA::Any&, const CORBA::Contained::Description*&);

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

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

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

//
// IDL:omg.org/CORBA/InterfaceDefSeq:1.0
//
void operator<<=(::CORBA::Any&, CORBA::InterfaceDefSeq*);
void operator<<=(::CORBA::Any&, const CORBA::InterfaceDefSeq&);
CORBA::Boolean operator>>=(const ::CORBA::Any&, const CORBA::InterfaceDefSeq*&);

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

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

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

//
// IDL:omg.org/CORBA/AbstractInterfaceDefSeq:1.0
//
void operator<<=(::CORBA::Any&, CORBA::AbstractInterfaceDefSeq*);
void operator<<=(::CORBA::Any&, const CORBA::AbstractInterfaceDefSeq&);
CORBA::Boolean operator>>=(const ::CORBA::Any&, const CORBA::AbstractInterfaceDefSeq*&);

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

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

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

//
// IDL:omg.org/CORBA/LocalInterfaceDefSeq:1.0
//
void operator<<=(::CORBA::Any&, CORBA::LocalInterfaceDefSeq*);
void operator<<=(::CORBA::Any&, const CORBA::LocalInterfaceDefSeq&);
CORBA::Boolean operator>>=(const ::CORBA::Any&, const CORBA::LocalInterfaceDefSeq*&);

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

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

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

//
// IDL:omg.org/CORBA/ValueDefSeq:1.0
//
void operator<<=(::CORBA::Any&, CORBA::ValueDefSeq*);
void operator<<=(::CORBA::Any&, const CORBA::ValueDefSeq&);
CORBA::Boolean operator>>=(const ::CORBA::Any&, const CORBA::ValueDefSeq*&);

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

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

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

//
// IDL:omg.org/CORBA/ContainedSeq:1.0
//
void operator<<=(::CORBA::Any&, CORBA::ContainedSeq*);
void operator<<=(::CORBA::Any&, const CORBA::ContainedSeq&);
CORBA::Boolean operator>>=(const ::CORBA::Any&, const CORBA::ContainedSeq*&);

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

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

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

//
// IDL:omg.org/CORBA/Container:1.0
//
namespace CORBA
{

inline void
release(::CORBA::Container_ptr p)
{
    if(p)
        p -> _remove_ref();
}

inline Boolean
is_nil(::CORBA::Container_ptr p)
{
    return p == 0;
}

inline void
release(OBStubImpl_CORBA::Container_ptr p)
{
    if(p)
        p -> _OB_decRef();
}

inline Boolean
is_nil(OBStubImpl_CORBA::Container_ptr p)
{
    return p == 0;
}

} // End of namespace CORBA

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

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

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

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

//
// IDL:omg.org/CORBA/Container/Description:1.0
//
void operator<<=(::CORBA::Any&, CORBA::Container::Description*);
void operator<<=(::CORBA::Any&, const CORBA::Container::Description&);
CORBA::Boolean operator>>=(const ::CORBA::Any&, const CORBA::Container::Description*&);

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

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

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

//
// IDL:omg.org/CORBA/Container/DescriptionSeq:1.0
//
void operator<<=(::CORBA::Any&, CORBA::Container::DescriptionSeq*);
void operator<<=(::CORBA::Any&, const CORBA::Container::DescriptionSeq&);
CORBA::Boolean operator>>=(const ::CORBA::Any&, const CORBA::Container::DescriptionSeq*&);

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

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

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

//
// IDL:omg.org/CORBA/AttributeMode:1.0
//
void operator<<=(::CORBA::Any&, CORBA::AttributeMode);
CORBA::Boolean operator>>=(const ::CORBA::Any&, CORBA::AttributeMode&);

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

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

//
// IDL:omg.org/CORBA/AttributeDef:1.0
//
namespace CORBA
{

inline void
release(::CORBA::AttributeDef_ptr p)
{
    if(p)
        p -> _remove_ref();
}

inline Boolean
is_nil(::CORBA::AttributeDef_ptr p)
{
    return p == 0;
}

inline void
release(OBStubImpl_CORBA::AttributeDef_ptr p)
{
    if(p)
        p -> _OB_decRef();
}

inline Boolean
is_nil(OBStubImpl_CORBA::AttributeDef_ptr p)
{
    return p == 0;
}

} // End of namespace CORBA

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

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

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

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

//
// IDL:omg.org/CORBA/AttributeDescription:1.0
//
void operator<<=(::CORBA::Any&, CORBA::AttributeDescription*);
void operator<<=(::CORBA::Any&, const CORBA::AttributeDescription&);
CORBA::Boolean operator>>=(const ::CORBA::Any&, const CORBA::AttributeDescription*&);

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

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

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

//
// IDL:omg.org/CORBA/OperationMode:1.0
//
void operator<<=(::CORBA::Any&, CORBA::OperationMode);
CORBA::Boolean operator>>=(const ::CORBA::Any&, CORBA::OperationMode&);

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

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

//
// IDL:omg.org/CORBA/ParameterDescription:1.0
//
void operator<<=(::CORBA::Any&, CORBA::ParameterDescription*);
void operator<<=(::CORBA::Any&, const CORBA::ParameterDescription&);
CORBA::Boolean operator>>=(const ::CORBA::Any&, const CORBA::ParameterDescription*&);

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

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

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

//
// IDL:omg.org/CORBA/ParDescriptionSeq:1.0
//
void operator<<=(::CORBA::Any&, CORBA::ParDescriptionSeq*);
void operator<<=(::CORBA::Any&, const CORBA::ParDescriptionSeq&);
CORBA::Boolean operator>>=(const ::CORBA::Any&, const CORBA::ParDescriptionSeq*&);

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

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

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

//
// IDL:omg.org/CORBA/ContextIdSeq:1.0
//
void operator<<=(::CORBA::Any&, CORBA::ContextIdSeq*);
void operator<<=(::CORBA::Any&, const CORBA::ContextIdSeq&);
CORBA::Boolean operator>>=(const ::CORBA::Any&, const CORBA::ContextIdSeq*&);

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

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

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

//
// IDL:omg.org/CORBA/ExceptionDef:1.0
//
namespace CORBA
{

inline void
release(::CORBA::ExceptionDef_ptr p)
{
    if(p)
        p -> _remove_ref();
}

inline Boolean
is_nil(::CORBA::ExceptionDef_ptr p)
{
    return p == 0;
}

inline void
release(OBStubImpl_CORBA::ExceptionDef_ptr p)
{
    if(p)
        p -> _OB_decRef();
}

inline Boolean
is_nil(OBStubImpl_CORBA::ExceptionDef_ptr p)
{
    return p == 0;
}

} // End of namespace CORBA

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

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

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

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

//
// IDL:omg.org/CORBA/ExceptionDescription:1.0
//
void operator<<=(::CORBA::Any&, CORBA::ExceptionDescription*);
void operator<<=(::CORBA::Any&, const CORBA::ExceptionDescription&);
CORBA::Boolean operator>>=(const ::CORBA::Any&, const CORBA::ExceptionDescription*&);

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

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

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

//
// IDL:omg.org/CORBA/ExceptionDefSeq:1.0
//
void operator<<=(::CORBA::Any&, CORBA::ExceptionDefSeq*);
void operator<<=(::CORBA::Any&, const CORBA::ExceptionDefSeq&);
CORBA::Boolean operator>>=(const ::CORBA::Any&, const CORBA::ExceptionDefSeq*&);

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

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

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

//
// IDL:omg.org/CORBA/ExcDescriptionSeq:1.0
//
void operator<<=(::CORBA::Any&, CORBA::ExcDescriptionSeq*);
void operator<<=(::CORBA::Any&, const CORBA::ExcDescriptionSeq&);
CORBA::Boolean operator>>=(const ::CORBA::Any&, const CORBA::ExcDescriptionSeq*&);

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

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

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

//
// IDL:omg.org/CORBA/OperationDef:1.0
//
namespace CORBA
{

inline void
release(::CORBA::OperationDef_ptr p)
{
    if(p)
        p -> _remove_ref();
}

inline Boolean
is_nil(::CORBA::OperationDef_ptr p)
{
    return p == 0;
}

inline void
release(OBStubImpl_CORBA::OperationDef_ptr p)
{
    if(p)
        p -> _OB_decRef();
}

inline Boolean
is_nil(OBStubImpl_CORBA::OperationDef_ptr p)
{
    return p == 0;
}

} // End of namespace CORBA

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

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

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

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

//
// IDL:omg.org/CORBA/OperationDescription:1.0
//
void operator<<=(::CORBA::Any&, CORBA::OperationDescription*);
void operator<<=(::CORBA::Any&, const CORBA::OperationDescription&);
CORBA::Boolean operator>>=(const ::CORBA::Any&, const CORBA::OperationDescription*&);

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

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

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

//
// IDL:omg.org/CORBA/RepositoryIdSeq:1.0
//
void operator<<=(::CORBA::Any&, CORBA::RepositoryIdSeq*);
void operator<<=(::CORBA::Any&, const CORBA::RepositoryIdSeq&);
CORBA::Boolean operator>>=(const ::CORBA::Any&, const CORBA::RepositoryIdSeq*&);

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

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

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

//
// IDL:omg.org/CORBA/OpDescriptionSeq:1.0
//
void operator<<=(::CORBA::Any&, CORBA::OpDescriptionSeq*);
void operator<<=(::CORBA::Any&, const CORBA::OpDescriptionSeq&);
CORBA::Boolean operator>>=(const ::CORBA::Any&, const CORBA::OpDescriptionSeq*&);

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

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

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

//
// IDL:omg.org/CORBA/AttrDescriptionSeq:1.0
//
void operator<<=(::CORBA::Any&, CORBA::AttrDescriptionSeq*);
void operator<<=(::CORBA::Any&, const CORBA::AttrDescriptionSeq&);
CORBA::Boolean operator>>=(const ::CORBA::Any&, const CORBA::AttrDescriptionSeq*&);

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

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

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

//
// IDL:omg.org/CORBA/InterfaceDef:1.0
//
namespace CORBA
{

inline void
release(::CORBA::InterfaceDef_ptr p)
{
    if(p)
        p -> _remove_ref();
}

inline Boolean
is_nil(::CORBA::InterfaceDef_ptr p)
{
    return p == 0;
}

inline void
release(OBStubImpl_CORBA::InterfaceDef_ptr p)
{
    if(p)
        p -> _OB_decRef();
}

inline Boolean
is_nil(OBStubImpl_CORBA::InterfaceDef_ptr p)
{
    return p == 0;
}

} // End of namespace CORBA

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

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

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

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

//
// IDL:omg.org/CORBA/InterfaceDef/FullInterfaceDescription:1.0
//
void operator<<=(::CORBA::Any&, CORBA::InterfaceDef::FullInterfaceDescription*);
void operator<<=(::CORBA::Any&, const CORBA::InterfaceDef::FullInterfaceDescription&);
CORBA::Boolean operator>>=(const ::CORBA::Any&, const CORBA::InterfaceDef::FullInterfaceDescription*&);

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

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

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

//
// IDL:omg.org/CORBA/InterfaceDescription:1.0
//
void operator<<=(::CORBA::Any&, CORBA::InterfaceDescription*);
void operator<<=(::CORBA::Any&, const CORBA::InterfaceDescription&);
CORBA::Boolean operator>>=(const ::CORBA::Any&, const CORBA::InterfaceDescription*&);

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

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

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

#endif
