// **********************************************************************
//
// 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_IFR3_h__
#define __OB_IFR3_h__

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


#include <OB/IFR2.h>
#include <OB/IFR3_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 ModuleDef;
typedef ModuleDef* ModuleDef_ptr;

class ConstantDef;
typedef ConstantDef* ConstantDef_ptr;

class TypedefDef;
typedef TypedefDef* TypedefDef_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 NativeDef;
typedef NativeDef* NativeDef_ptr;

class PrimitiveDef;
typedef PrimitiveDef* PrimitiveDef_ptr;

class StringDef;
typedef StringDef* StringDef_ptr;

class WstringDef;
typedef WstringDef* WstringDef_ptr;

class FixedDef;
typedef FixedDef* FixedDef_ptr;

class SequenceDef;
typedef SequenceDef* SequenceDef_ptr;

class ArrayDef;
typedef ArrayDef* ArrayDef_ptr;

} // End of namespace OBStubImpl_CORBA

void OBDuplicate(OBStubImpl_CORBA::Repository_ptr);
void OBRelease(OBStubImpl_CORBA::Repository_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::TypedefDef_ptr);
void OBRelease(OBStubImpl_CORBA::TypedefDef_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::NativeDef_ptr);
void OBRelease(OBStubImpl_CORBA::NativeDef_ptr);

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

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

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

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

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

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

namespace OBStubImpl_CORBA
{

typedef OB::ObjVar< Repository > Repository_var;

typedef OB::ObjVar< ModuleDef > ModuleDef_var;

typedef OB::ObjVar< ConstantDef > ConstantDef_var;

typedef OB::ObjVar< TypedefDef > TypedefDef_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< NativeDef > NativeDef_var;

typedef OB::ObjVar< PrimitiveDef > PrimitiveDef_var;

typedef OB::ObjVar< StringDef > StringDef_var;

typedef OB::ObjVar< WstringDef > WstringDef_var;

typedef OB::ObjVar< FixedDef > FixedDef_var;

typedef OB::ObjVar< SequenceDef > SequenceDef_var;

typedef OB::ObjVar< ArrayDef > ArrayDef_var;

} // End of namespace OBStubImpl_CORBA

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

//
// IDL:omg.org/CORBA/PrimitiveKind:1.0
//
enum PrimitiveKind
{
    pk_null,
    pk_void,
    pk_short,
    pk_long,
    pk_ushort,
    pk_ulong,
    pk_float,
    pk_double,
    pk_boolean,
    pk_char,
    pk_octet,
    pk_any,
    pk_TypeCode,
    pk_Principal,
    pk_string,
    pk_objref,
    pk_longlong,
    pk_ulonglong,
    pk_longdouble,
    pk_wchar,
    pk_wstring,
    pk_value_base
};

typedef PrimitiveKind& PrimitiveKind_out;

OB_IMPORT extern OB::TypeCodeConst _tc_PrimitiveKind;

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

protected:

    static OB_IMPORT const char* ids_[];

public:

    Repository() { }
    virtual ~Repository() { }

    typedef Repository_ptr _ptr_type;
    typedef Repository_var _var_type;

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

    static inline Repository_ptr
    _nil()
    {
        return 0;
    }

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

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

    static const char** _OB_staticIds();

    //
    // IDL:omg.org/CORBA/Repository/lookup_id:1.0
    //
    virtual Contained_ptr lookup_id(const char* search_id) = 0;

    //
    // IDL:omg.org/CORBA/Repository/get_canonical_typecode:1.0
    //
    virtual ::CORBA::TypeCode_ptr get_canonical_typecode(::CORBA::TypeCode_ptr tc) = 0;

    //
    // IDL:omg.org/CORBA/Repository/get_primitive:1.0
    //
    virtual PrimitiveDef_ptr get_primitive(PrimitiveKind kind) = 0;

    //
    // IDL:omg.org/CORBA/Repository/create_string:1.0
    //
    virtual StringDef_ptr create_string(::CORBA::ULong bound) = 0;

    //
    // IDL:omg.org/CORBA/Repository/create_wstring:1.0
    //
    virtual WstringDef_ptr create_wstring(::CORBA::ULong bound) = 0;

    //
    // IDL:omg.org/CORBA/Repository/create_sequence:1.0
    //
    virtual SequenceDef_ptr create_sequence(::CORBA::ULong bound,
                                            IDLType_ptr element_type) = 0;

    //
    // IDL:omg.org/CORBA/Repository/create_array:1.0
    //
    virtual ArrayDef_ptr create_array(::CORBA::ULong length,
                                      IDLType_ptr element_type) = 0;

    //
    // IDL:omg.org/CORBA/Repository/create_fixed:1.0
    //
    virtual FixedDef_ptr create_fixed(::CORBA::UShort digits,
                                      ::CORBA::Short scale) = 0;
};

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

protected:

    static OB_IMPORT const char* ids_[];

public:

    ModuleDef() { }
    virtual ~ModuleDef() { }

    typedef ModuleDef_ptr _ptr_type;
    typedef ModuleDef_var _var_type;

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

    static inline ModuleDef_ptr
    _nil()
    {
        return 0;
    }

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

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

    static const char** _OB_staticIds();
};

//
// IDL:omg.org/CORBA/ModuleDescription:1.0
//
struct ModuleDescription;
typedef OB::VarVar< ModuleDescription > ModuleDescription_var;
typedef OB::VarOut< ModuleDescription > ModuleDescription_out;

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

    typedef ModuleDescription_var _var_type;

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

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

OB_IMPORT extern OB::TypeCodeConst _tc_ModuleDescription;

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

protected:

    static OB_IMPORT const char* ids_[];

public:

    ConstantDef() { }
    virtual ~ConstantDef() { }

    typedef ConstantDef_ptr _ptr_type;
    typedef ConstantDef_var _var_type;

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

    static inline ConstantDef_ptr
    _nil()
    {
        return 0;
    }

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

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

    static const char** _OB_staticIds();

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

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

    //
    // IDL:omg.org/CORBA/ConstantDef/value:1.0
    //
    virtual ::CORBA::Any* value() = 0;
    virtual void value(const ::CORBA::Any&) = 0;
};

//
// IDL:omg.org/CORBA/ConstantDescription:1.0
//
struct ConstantDescription;
typedef OB::VarVar< ConstantDescription > ConstantDescription_var;
typedef OB::VarOut< ConstantDescription > ConstantDescription_out;

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

    typedef ConstantDescription_var _var_type;

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

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

OB_IMPORT extern OB::TypeCodeConst _tc_ConstantDescription;

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

protected:

    static OB_IMPORT const char* ids_[];

public:

    TypedefDef() { }
    virtual ~TypedefDef() { }

    typedef TypedefDef_ptr _ptr_type;
    typedef TypedefDef_var _var_type;

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

    static inline TypedefDef_ptr
    _nil()
    {
        return 0;
    }

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

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

    static const char** _OB_staticIds();
};

//
// IDL:omg.org/CORBA/TypeDescription:1.0
//
struct TypeDescription;
typedef OB::VarVar< TypeDescription > TypeDescription_var;
typedef OB::VarOut< TypeDescription > TypeDescription_out;

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

    typedef TypeDescription_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(TypeDescription&, OB::InputStreamImpl*);
};

OB_IMPORT extern OB::TypeCodeConst _tc_TypeDescription;

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

protected:

    static OB_IMPORT const char* ids_[];

public:

    StructDef() { }
    virtual ~StructDef() { }

    typedef StructDef_ptr _ptr_type;
    typedef StructDef_var _var_type;

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

    static inline StructDef_ptr
    _nil()
    {
        return 0;
    }

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

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

    static const char** _OB_staticIds();

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

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

protected:

    static OB_IMPORT const char* ids_[];

public:

    UnionDef() { }
    virtual ~UnionDef() { }

    typedef UnionDef_ptr _ptr_type;
    typedef UnionDef_var _var_type;

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

    static inline UnionDef_ptr
    _nil()
    {
        return 0;
    }

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

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

    static const char** _OB_staticIds();

    //
    // IDL:omg.org/CORBA/UnionDef/discriminator_type:1.0
    //
    virtual ::CORBA::TypeCode_ptr discriminator_type() = 0;

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

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

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

protected:

    static OB_IMPORT const char* ids_[];

public:

    EnumDef() { }
    virtual ~EnumDef() { }

    typedef EnumDef_ptr _ptr_type;
    typedef EnumDef_var _var_type;

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

    static inline EnumDef_ptr
    _nil()
    {
        return 0;
    }

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

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

    static const char** _OB_staticIds();

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

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

protected:

    static OB_IMPORT const char* ids_[];

public:

    AliasDef() { }
    virtual ~AliasDef() { }

    typedef AliasDef_ptr _ptr_type;
    typedef AliasDef_var _var_type;

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

    static inline AliasDef_ptr
    _nil()
    {
        return 0;
    }

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

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

    static const char** _OB_staticIds();

    //
    // IDL:omg.org/CORBA/AliasDef/original_type_def:1.0
    //
    virtual IDLType_ptr original_type_def() = 0;
    virtual void original_type_def(IDLType_ptr) = 0;
};

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

protected:

    static OB_IMPORT const char* ids_[];

public:

    NativeDef() { }
    virtual ~NativeDef() { }

    typedef NativeDef_ptr _ptr_type;
    typedef NativeDef_var _var_type;

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

    static inline NativeDef_ptr
    _nil()
    {
        return 0;
    }

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

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

    static const char** _OB_staticIds();
};

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

protected:

    static OB_IMPORT const char* ids_[];

public:

    PrimitiveDef() { }
    virtual ~PrimitiveDef() { }

    typedef PrimitiveDef_ptr _ptr_type;
    typedef PrimitiveDef_var _var_type;

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

    static inline PrimitiveDef_ptr
    _nil()
    {
        return 0;
    }

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

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

    static const char** _OB_staticIds();

    //
    // IDL:omg.org/CORBA/PrimitiveDef/kind:1.0
    //
    virtual PrimitiveKind kind() = 0;
};

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

protected:

    static OB_IMPORT const char* ids_[];

public:

    StringDef() { }
    virtual ~StringDef() { }

    typedef StringDef_ptr _ptr_type;
    typedef StringDef_var _var_type;

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

    static inline StringDef_ptr
    _nil()
    {
        return 0;
    }

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

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

    static const char** _OB_staticIds();

    //
    // IDL:omg.org/CORBA/StringDef/bound:1.0
    //
    virtual ::CORBA::ULong bound() = 0;
    virtual void bound(::CORBA::ULong) = 0;
};

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

protected:

    static OB_IMPORT const char* ids_[];

public:

    WstringDef() { }
    virtual ~WstringDef() { }

    typedef WstringDef_ptr _ptr_type;
    typedef WstringDef_var _var_type;

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

    static inline WstringDef_ptr
    _nil()
    {
        return 0;
    }

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

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

    static const char** _OB_staticIds();

    //
    // IDL:omg.org/CORBA/WstringDef/bound:1.0
    //
    virtual ::CORBA::ULong bound() = 0;
    virtual void bound(::CORBA::ULong) = 0;
};

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

protected:

    static OB_IMPORT const char* ids_[];

public:

    FixedDef() { }
    virtual ~FixedDef() { }

    typedef FixedDef_ptr _ptr_type;
    typedef FixedDef_var _var_type;

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

    static inline FixedDef_ptr
    _nil()
    {
        return 0;
    }

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

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

    static const char** _OB_staticIds();

    //
    // IDL:omg.org/CORBA/FixedDef/digits:1.0
    //
    virtual ::CORBA::UShort digits() = 0;
    virtual void digits(::CORBA::UShort) = 0;

    //
    // IDL:omg.org/CORBA/FixedDef/scale:1.0
    //
    virtual ::CORBA::Short scale() = 0;
    virtual void scale(::CORBA::Short) = 0;
};

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

protected:

    static OB_IMPORT const char* ids_[];

public:

    SequenceDef() { }
    virtual ~SequenceDef() { }

    typedef SequenceDef_ptr _ptr_type;
    typedef SequenceDef_var _var_type;

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

    static inline SequenceDef_ptr
    _nil()
    {
        return 0;
    }

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

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

    static const char** _OB_staticIds();

    //
    // IDL:omg.org/CORBA/SequenceDef/bound:1.0
    //
    virtual ::CORBA::ULong bound() = 0;
    virtual void bound(::CORBA::ULong) = 0;

    //
    // IDL:omg.org/CORBA/SequenceDef/element_type:1.0
    //
    virtual ::CORBA::TypeCode_ptr element_type() = 0;

    //
    // IDL:omg.org/CORBA/SequenceDef/element_type_def:1.0
    //
    virtual IDLType_ptr element_type_def() = 0;
    virtual void element_type_def(IDLType_ptr) = 0;
};

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

protected:

    static OB_IMPORT const char* ids_[];

public:

    ArrayDef() { }
    virtual ~ArrayDef() { }

    typedef ArrayDef_ptr _ptr_type;
    typedef ArrayDef_var _var_type;

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

    static inline ArrayDef_ptr
    _nil()
    {
        return 0;
    }

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

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

    static const char** _OB_staticIds();

    //
    // IDL:omg.org/CORBA/ArrayDef/length:1.0
    //
    virtual ::CORBA::ULong length() = 0;
    virtual void length(::CORBA::ULong) = 0;

    //
    // IDL:omg.org/CORBA/ArrayDef/element_type:1.0
    //
    virtual ::CORBA::TypeCode_ptr element_type() = 0;

    //
    // IDL:omg.org/CORBA/ArrayDef/element_type_def:1.0
    //
    virtual IDLType_ptr element_type_def() = 0;
    virtual void element_type_def(IDLType_ptr) = 0;
};

} // End of namespace CORBA

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

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

protected:

    virtual OB::MarshalStubImpl_ptr _OB_createMarshalStubImpl();

public:

    Repository() { }
    virtual ~Repository() { }

    virtual const char** _OB_ids() const;

    //
    // IDL:omg.org/CORBA/Repository/lookup_id:1.0
    //
    ::CORBA::Contained_ptr lookup_id(const char* search_id);

    //
    // IDL:omg.org/CORBA/Repository/get_canonical_typecode:1.0
    //
    ::CORBA::TypeCode_ptr get_canonical_typecode(::CORBA::TypeCode_ptr tc);

    //
    // IDL:omg.org/CORBA/Repository/get_primitive:1.0
    //
    ::CORBA::PrimitiveDef_ptr get_primitive(::CORBA::PrimitiveKind kind);

    //
    // IDL:omg.org/CORBA/Repository/create_string:1.0
    //
    ::CORBA::StringDef_ptr create_string(::CORBA::ULong bound);

    //
    // IDL:omg.org/CORBA/Repository/create_wstring:1.0
    //
    ::CORBA::WstringDef_ptr create_wstring(::CORBA::ULong bound);

    //
    // IDL:omg.org/CORBA/Repository/create_sequence:1.0
    //
    ::CORBA::SequenceDef_ptr create_sequence(::CORBA::ULong bound,
                                             ::CORBA::IDLType_ptr element_type);

    //
    // IDL:omg.org/CORBA/Repository/create_array:1.0
    //
    ::CORBA::ArrayDef_ptr create_array(::CORBA::ULong length,
                                       ::CORBA::IDLType_ptr element_type);

    //
    // IDL:omg.org/CORBA/Repository/create_fixed:1.0
    //
    ::CORBA::FixedDef_ptr create_fixed(::CORBA::UShort digits,
                                       ::CORBA::Short scale);
};

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

protected:

    virtual OB::MarshalStubImpl_ptr _OB_createMarshalStubImpl();

public:

    ModuleDef() { }
    virtual ~ModuleDef() { }

    virtual const char** _OB_ids() const;
};

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

protected:

    virtual OB::MarshalStubImpl_ptr _OB_createMarshalStubImpl();

public:

    ConstantDef() { }
    virtual ~ConstantDef() { }

    virtual const char** _OB_ids() const;

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

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

    //
    // IDL:omg.org/CORBA/ConstantDef/value:1.0
    //
    ::CORBA::Any* value();
    void value(const ::CORBA::Any&);
};

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

protected:

    virtual OB::MarshalStubImpl_ptr _OB_createMarshalStubImpl();

public:

    TypedefDef() { }
    virtual ~TypedefDef() { }

    virtual const char** _OB_ids() const;
};

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

protected:

    virtual OB::MarshalStubImpl_ptr _OB_createMarshalStubImpl();

public:

    StructDef() { }
    virtual ~StructDef() { }

    virtual const char** _OB_ids() const;

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

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

protected:

    virtual OB::MarshalStubImpl_ptr _OB_createMarshalStubImpl();

public:

    UnionDef() { }
    virtual ~UnionDef() { }

    virtual const char** _OB_ids() const;

    //
    // IDL:omg.org/CORBA/UnionDef/discriminator_type:1.0
    //
    ::CORBA::TypeCode_ptr discriminator_type();

    //
    // IDL:omg.org/CORBA/UnionDef/discriminator_type_def:1.0
    //
    ::CORBA::IDLType_ptr discriminator_type_def();
    void discriminator_type_def(::CORBA::IDLType_ptr);

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

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

protected:

    virtual OB::MarshalStubImpl_ptr _OB_createMarshalStubImpl();

public:

    EnumDef() { }
    virtual ~EnumDef() { }

    virtual const char** _OB_ids() const;

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

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

protected:

    virtual OB::MarshalStubImpl_ptr _OB_createMarshalStubImpl();

public:

    AliasDef() { }
    virtual ~AliasDef() { }

    virtual const char** _OB_ids() const;

    //
    // IDL:omg.org/CORBA/AliasDef/original_type_def:1.0
    //
    ::CORBA::IDLType_ptr original_type_def();
    void original_type_def(::CORBA::IDLType_ptr);
};

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

protected:

    virtual OB::MarshalStubImpl_ptr _OB_createMarshalStubImpl();

public:

    NativeDef() { }
    virtual ~NativeDef() { }

    virtual const char** _OB_ids() const;
};

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

protected:

    virtual OB::MarshalStubImpl_ptr _OB_createMarshalStubImpl();

public:

    PrimitiveDef() { }
    virtual ~PrimitiveDef() { }

    virtual const char** _OB_ids() const;

    //
    // IDL:omg.org/CORBA/PrimitiveDef/kind:1.0
    //
    ::CORBA::PrimitiveKind kind();
};

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

protected:

    virtual OB::MarshalStubImpl_ptr _OB_createMarshalStubImpl();

public:

    StringDef() { }
    virtual ~StringDef() { }

    virtual const char** _OB_ids() const;

    //
    // IDL:omg.org/CORBA/StringDef/bound:1.0
    //
    ::CORBA::ULong bound();
    void bound(::CORBA::ULong);
};

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

protected:

    virtual OB::MarshalStubImpl_ptr _OB_createMarshalStubImpl();

public:

    WstringDef() { }
    virtual ~WstringDef() { }

    virtual const char** _OB_ids() const;

    //
    // IDL:omg.org/CORBA/WstringDef/bound:1.0
    //
    ::CORBA::ULong bound();
    void bound(::CORBA::ULong);
};

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

protected:

    virtual OB::MarshalStubImpl_ptr _OB_createMarshalStubImpl();

public:

    FixedDef() { }
    virtual ~FixedDef() { }

    virtual const char** _OB_ids() const;

    //
    // IDL:omg.org/CORBA/FixedDef/digits:1.0
    //
    ::CORBA::UShort digits();
    void digits(::CORBA::UShort);

    //
    // IDL:omg.org/CORBA/FixedDef/scale:1.0
    //
    ::CORBA::Short scale();
    void scale(::CORBA::Short);
};

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

protected:

    virtual OB::MarshalStubImpl_ptr _OB_createMarshalStubImpl();

public:

    SequenceDef() { }
    virtual ~SequenceDef() { }

    virtual const char** _OB_ids() const;

    //
    // IDL:omg.org/CORBA/SequenceDef/bound:1.0
    //
    ::CORBA::ULong bound();
    void bound(::CORBA::ULong);

    //
    // IDL:omg.org/CORBA/SequenceDef/element_type:1.0
    //
    ::CORBA::TypeCode_ptr element_type();

    //
    // IDL:omg.org/CORBA/SequenceDef/element_type_def:1.0
    //
    ::CORBA::IDLType_ptr element_type_def();
    void element_type_def(::CORBA::IDLType_ptr);
};

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

protected:

    virtual OB::MarshalStubImpl_ptr _OB_createMarshalStubImpl();

public:

    ArrayDef() { }
    virtual ~ArrayDef() { }

    virtual const char** _OB_ids() const;

    //
    // IDL:omg.org/CORBA/ArrayDef/length:1.0
    //
    ::CORBA::ULong length();
    void length(::CORBA::ULong);

    //
    // IDL:omg.org/CORBA/ArrayDef/element_type:1.0
    //
    ::CORBA::TypeCode_ptr element_type();

    //
    // IDL:omg.org/CORBA/ArrayDef/element_type_def:1.0
    //
    ::CORBA::IDLType_ptr element_type_def();
    void element_type_def(::CORBA::IDLType_ptr);
};

} // End of namespace OBProxy_CORBA

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

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

protected:

    Repository() { }

public:

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

    static inline Repository_ptr
    _nil()
    {
        return 0;
    }

    //
    // IDL:omg.org/CORBA/Repository/lookup_id:1.0
    //
    virtual ::CORBA::Contained_ptr lookup_id(const char* search_id) = 0;

    //
    // IDL:omg.org/CORBA/Repository/get_canonical_typecode:1.0
    //
    virtual ::CORBA::TypeCode_ptr get_canonical_typecode(::CORBA::TypeCode_ptr tc) = 0;

    //
    // IDL:omg.org/CORBA/Repository/get_primitive:1.0
    //
    virtual ::CORBA::PrimitiveDef_ptr get_primitive(::CORBA::PrimitiveKind kind) = 0;

    //
    // IDL:omg.org/CORBA/Repository/create_string:1.0
    //
    virtual ::CORBA::StringDef_ptr create_string(::CORBA::ULong bound) = 0;

    //
    // IDL:omg.org/CORBA/Repository/create_wstring:1.0
    //
    virtual ::CORBA::WstringDef_ptr create_wstring(::CORBA::ULong bound) = 0;

    //
    // IDL:omg.org/CORBA/Repository/create_sequence:1.0
    //
    virtual ::CORBA::SequenceDef_ptr create_sequence(::CORBA::ULong bound,
                                                     ::CORBA::IDLType_ptr element_type) = 0;

    //
    // IDL:omg.org/CORBA/Repository/create_array:1.0
    //
    virtual ::CORBA::ArrayDef_ptr create_array(::CORBA::ULong length,
                                               ::CORBA::IDLType_ptr element_type) = 0;

    //
    // IDL:omg.org/CORBA/Repository/create_fixed:1.0
    //
    virtual ::CORBA::FixedDef_ptr create_fixed(::CORBA::UShort digits,
                                               ::CORBA::Short scale) = 0;
};

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

protected:

    ModuleDef() { }

public:

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

    static inline ModuleDef_ptr
    _nil()
    {
        return 0;
    }
};

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

protected:

    ConstantDef() { }

public:

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

    static inline ConstantDef_ptr
    _nil()
    {
        return 0;
    }

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

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

    //
    // IDL:omg.org/CORBA/ConstantDef/value:1.0
    //
    virtual ::CORBA::Any* value() = 0;
    virtual void value(const ::CORBA::Any&) = 0;
};

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

protected:

    TypedefDef() { }

public:

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

    static inline TypedefDef_ptr
    _nil()
    {
        return 0;
    }
};

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

protected:

    StructDef() { }

public:

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

    static inline StructDef_ptr
    _nil()
    {
        return 0;
    }

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

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

protected:

    UnionDef() { }

public:

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

    static inline UnionDef_ptr
    _nil()
    {
        return 0;
    }

    //
    // IDL:omg.org/CORBA/UnionDef/discriminator_type:1.0
    //
    virtual ::CORBA::TypeCode_ptr discriminator_type() = 0;

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

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

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

protected:

    EnumDef() { }

public:

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

    static inline EnumDef_ptr
    _nil()
    {
        return 0;
    }

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

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

protected:

    AliasDef() { }

public:

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

    static inline AliasDef_ptr
    _nil()
    {
        return 0;
    }

    //
    // IDL:omg.org/CORBA/AliasDef/original_type_def:1.0
    //
    virtual ::CORBA::IDLType_ptr original_type_def() = 0;
    virtual void original_type_def(::CORBA::IDLType_ptr) = 0;
};

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

protected:

    NativeDef() { }

public:

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

    static inline NativeDef_ptr
    _nil()
    {
        return 0;
    }
};

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

protected:

    PrimitiveDef() { }

public:

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

    static inline PrimitiveDef_ptr
    _nil()
    {
        return 0;
    }

    //
    // IDL:omg.org/CORBA/PrimitiveDef/kind:1.0
    //
    virtual ::CORBA::PrimitiveKind kind() = 0;
};

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

protected:

    StringDef() { }

public:

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

    static inline StringDef_ptr
    _nil()
    {
        return 0;
    }

    //
    // IDL:omg.org/CORBA/StringDef/bound:1.0
    //
    virtual ::CORBA::ULong bound() = 0;
    virtual void bound(::CORBA::ULong) = 0;
};

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

protected:

    WstringDef() { }

public:

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

    static inline WstringDef_ptr
    _nil()
    {
        return 0;
    }

    //
    // IDL:omg.org/CORBA/WstringDef/bound:1.0
    //
    virtual ::CORBA::ULong bound() = 0;
    virtual void bound(::CORBA::ULong) = 0;
};

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

protected:

    FixedDef() { }

public:

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

    static inline FixedDef_ptr
    _nil()
    {
        return 0;
    }

    //
    // IDL:omg.org/CORBA/FixedDef/digits:1.0
    //
    virtual ::CORBA::UShort digits() = 0;
    virtual void digits(::CORBA::UShort) = 0;

    //
    // IDL:omg.org/CORBA/FixedDef/scale:1.0
    //
    virtual ::CORBA::Short scale() = 0;
    virtual void scale(::CORBA::Short) = 0;
};

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

protected:

    SequenceDef() { }

public:

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

    static inline SequenceDef_ptr
    _nil()
    {
        return 0;
    }

    //
    // IDL:omg.org/CORBA/SequenceDef/bound:1.0
    //
    virtual ::CORBA::ULong bound() = 0;
    virtual void bound(::CORBA::ULong) = 0;

    //
    // IDL:omg.org/CORBA/SequenceDef/element_type:1.0
    //
    virtual ::CORBA::TypeCode_ptr element_type() = 0;

    //
    // IDL:omg.org/CORBA/SequenceDef/element_type_def:1.0
    //
    virtual ::CORBA::IDLType_ptr element_type_def() = 0;
    virtual void element_type_def(::CORBA::IDLType_ptr) = 0;
};

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

protected:

    ArrayDef() { }

public:

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

    static inline ArrayDef_ptr
    _nil()
    {
        return 0;
    }

    //
    // IDL:omg.org/CORBA/ArrayDef/length:1.0
    //
    virtual ::CORBA::ULong length() = 0;
    virtual void length(::CORBA::ULong) = 0;

    //
    // IDL:omg.org/CORBA/ArrayDef/element_type:1.0
    //
    virtual ::CORBA::TypeCode_ptr element_type() = 0;

    //
    // IDL:omg.org/CORBA/ArrayDef/element_type_def:1.0
    //
    virtual ::CORBA::IDLType_ptr element_type_def() = 0;
    virtual void element_type_def(::CORBA::IDLType_ptr) = 0;
};

} // End of namespace OBStubImpl_CORBA

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

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

protected:

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

public:

    //
    // IDL:omg.org/CORBA/Repository/lookup_id:1.0
    //
    virtual ::CORBA::Contained_ptr lookup_id(const char* search_id);

    //
    // IDL:omg.org/CORBA/Repository/get_canonical_typecode:1.0
    //
    virtual ::CORBA::TypeCode_ptr get_canonical_typecode(::CORBA::TypeCode_ptr tc);

    //
    // IDL:omg.org/CORBA/Repository/get_primitive:1.0
    //
    virtual ::CORBA::PrimitiveDef_ptr get_primitive(::CORBA::PrimitiveKind kind);

    //
    // IDL:omg.org/CORBA/Repository/create_string:1.0
    //
    virtual ::CORBA::StringDef_ptr create_string(::CORBA::ULong bound);

    //
    // IDL:omg.org/CORBA/Repository/create_wstring:1.0
    //
    virtual ::CORBA::WstringDef_ptr create_wstring(::CORBA::ULong bound);

    //
    // IDL:omg.org/CORBA/Repository/create_sequence:1.0
    //
    virtual ::CORBA::SequenceDef_ptr create_sequence(::CORBA::ULong bound,
                                                     ::CORBA::IDLType_ptr element_type);

    //
    // IDL:omg.org/CORBA/Repository/create_array:1.0
    //
    virtual ::CORBA::ArrayDef_ptr create_array(::CORBA::ULong length,
                                               ::CORBA::IDLType_ptr element_type);

    //
    // IDL:omg.org/CORBA/Repository/create_fixed:1.0
    //
    virtual ::CORBA::FixedDef_ptr create_fixed(::CORBA::UShort digits,
                                               ::CORBA::Short scale);
};

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

protected:

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

public:
};

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

protected:

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

public:

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

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

    //
    // IDL:omg.org/CORBA/ConstantDef/value:1.0
    //
    virtual ::CORBA::Any* value();
    virtual void value(const ::CORBA::Any&);
};

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

protected:

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

public:
};

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

protected:

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

public:

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

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

protected:

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

public:

    //
    // IDL:omg.org/CORBA/UnionDef/discriminator_type:1.0
    //
    virtual ::CORBA::TypeCode_ptr discriminator_type();

    //
    // IDL:omg.org/CORBA/UnionDef/discriminator_type_def:1.0
    //
    virtual ::CORBA::IDLType_ptr discriminator_type_def();
    virtual void discriminator_type_def(::CORBA::IDLType_ptr);

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

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

protected:

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

public:

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

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

protected:

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

public:

    //
    // IDL:omg.org/CORBA/AliasDef/original_type_def:1.0
    //
    virtual ::CORBA::IDLType_ptr original_type_def();
    virtual void original_type_def(::CORBA::IDLType_ptr);
};

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

protected:

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

public:
};

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

protected:

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

public:

    //
    // IDL:omg.org/CORBA/PrimitiveDef/kind:1.0
    //
    virtual ::CORBA::PrimitiveKind kind();
};

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

protected:

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

public:

    //
    // IDL:omg.org/CORBA/StringDef/bound:1.0
    //
    virtual ::CORBA::ULong bound();
    virtual void bound(::CORBA::ULong);
};

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

protected:

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

public:

    //
    // IDL:omg.org/CORBA/WstringDef/bound:1.0
    //
    virtual ::CORBA::ULong bound();
    virtual void bound(::CORBA::ULong);
};

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

protected:

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

public:

    //
    // IDL:omg.org/CORBA/FixedDef/digits:1.0
    //
    virtual ::CORBA::UShort digits();
    virtual void digits(::CORBA::UShort);

    //
    // IDL:omg.org/CORBA/FixedDef/scale:1.0
    //
    virtual ::CORBA::Short scale();
    virtual void scale(::CORBA::Short);
};

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

protected:

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

public:

    //
    // IDL:omg.org/CORBA/SequenceDef/bound:1.0
    //
    virtual ::CORBA::ULong bound();
    virtual void bound(::CORBA::ULong);

    //
    // IDL:omg.org/CORBA/SequenceDef/element_type:1.0
    //
    virtual ::CORBA::TypeCode_ptr element_type();

    //
    // IDL:omg.org/CORBA/SequenceDef/element_type_def:1.0
    //
    virtual ::CORBA::IDLType_ptr element_type_def();
    virtual void element_type_def(::CORBA::IDLType_ptr);
};

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

protected:

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

public:

    //
    // IDL:omg.org/CORBA/ArrayDef/length:1.0
    //
    virtual ::CORBA::ULong length();
    virtual void length(::CORBA::ULong);

    //
    // IDL:omg.org/CORBA/ArrayDef/element_type:1.0
    //
    virtual ::CORBA::TypeCode_ptr element_type();

    //
    // IDL:omg.org/CORBA/ArrayDef/element_type_def:1.0
    //
    virtual ::CORBA::IDLType_ptr element_type_def();
    virtual void element_type_def(::CORBA::IDLType_ptr);
};

} // End of namespace OBMarshalStubImpl_CORBA

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

} // End of namespace OBV_CORBA

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

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

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

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

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

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

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

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

} // End of namespace CORBA

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

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

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

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

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

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

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

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

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

} // End of namespace CORBA

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

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

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

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

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

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

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

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

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

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

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

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

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

} // End of namespace CORBA

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

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

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

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

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

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

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

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

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

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

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

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

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

} // End of namespace CORBA

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

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

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

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

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

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

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

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

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

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

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

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

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

} // End of namespace CORBA

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

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

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

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

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

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

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

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

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

} // End of namespace CORBA

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

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

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

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

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

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

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

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

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

} // End of namespace CORBA

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

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

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

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

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

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

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

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

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

} // End of namespace CORBA

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

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

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

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

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

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

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

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

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

} // End of namespace CORBA

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

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

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

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

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

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

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

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

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

} // End of namespace CORBA

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

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

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

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

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

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

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

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

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

} // End of namespace CORBA

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

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

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

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

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

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

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

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

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

} // End of namespace CORBA

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

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

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

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

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

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

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

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

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

} // End of namespace CORBA

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

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

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

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

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

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

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

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

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

} // End of namespace CORBA

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

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

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

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

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

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

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

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

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

} // End of namespace CORBA

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

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

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

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

#endif
