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

// Version: 3.2.1
// License: non-commercial

#ifndef __IntRep_h__
#define __IntRep_h__

#include <OB/IntRepMember.h>

#ifndef OB_INTEGER_VERSION
#   error No ORBacus version defined!
#endif

#ifndef OB_NO_VERSION_CHECK
#   if (OB_INTEGER_VERSION != 3020100L)
#       error ORBacus version mismatch!
#   endif
#endif

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

//
// IDL:omg.org/CORBA/IRObject:1.0
//
class CORBA_IRObject;
typedef CORBA_IRObject* CORBA_IRObject_ptr;
typedef CORBA_IRObject* CORBA_IRObjectRef;
void OBDuplicate(CORBA_IRObject_ptr);
void OBRelease(CORBA_IRObject_ptr);
typedef OBObjVar< CORBA_IRObject > CORBA_IRObject_var;

//
// IDL:omg.org/CORBA/IDLType:1.0
//
class CORBA_IDLType;
typedef CORBA_IDLType* CORBA_IDLType_ptr;
typedef CORBA_IDLType* CORBA_IDLTypeRef;
void OBDuplicate(CORBA_IDLType_ptr);
void OBRelease(CORBA_IDLType_ptr);
typedef OBObjVar< CORBA_IDLType > CORBA_IDLType_var;

//
// IDL:omg.org/CORBA/Contained:1.0
//
class CORBA_Contained;
typedef CORBA_Contained* CORBA_Contained_ptr;
typedef CORBA_Contained* CORBA_ContainedRef;
void OBDuplicate(CORBA_Contained_ptr);
void OBRelease(CORBA_Contained_ptr);
typedef OBObjVar< CORBA_Contained > CORBA_Contained_var;

//
// IDL:omg.org/CORBA/Container:1.0
//
class CORBA_Container;
typedef CORBA_Container* CORBA_Container_ptr;
typedef CORBA_Container* CORBA_ContainerRef;
void OBDuplicate(CORBA_Container_ptr);
void OBRelease(CORBA_Container_ptr);
typedef OBObjVar< CORBA_Container > CORBA_Container_var;

//
// IDL:omg.org/CORBA/Repository:1.0
//
class CORBA_Repository;
typedef CORBA_Repository* CORBA_Repository_ptr;
typedef CORBA_Repository* CORBA_RepositoryRef;
void OBDuplicate(CORBA_Repository_ptr);
void OBRelease(CORBA_Repository_ptr);
typedef OBObjVar< CORBA_Repository > CORBA_Repository_var;

//
// IDL:omg.org/CORBA/ModuleDef:1.0
//
class CORBA_ModuleDef;
typedef CORBA_ModuleDef* CORBA_ModuleDef_ptr;
typedef CORBA_ModuleDef* CORBA_ModuleDefRef;
void OBDuplicate(CORBA_ModuleDef_ptr);
void OBRelease(CORBA_ModuleDef_ptr);
typedef OBObjVar< CORBA_ModuleDef > CORBA_ModuleDef_var;

//
// IDL:omg.org/CORBA/ConstantDef:1.0
//
class CORBA_ConstantDef;
typedef CORBA_ConstantDef* CORBA_ConstantDef_ptr;
typedef CORBA_ConstantDef* CORBA_ConstantDefRef;
void OBDuplicate(CORBA_ConstantDef_ptr);
void OBRelease(CORBA_ConstantDef_ptr);
typedef OBObjVar< CORBA_ConstantDef > CORBA_ConstantDef_var;

//
// IDL:omg.org/CORBA/TypedefDef:1.0
//
class CORBA_TypedefDef;
typedef CORBA_TypedefDef* CORBA_TypedefDef_ptr;
typedef CORBA_TypedefDef* CORBA_TypedefDefRef;
void OBDuplicate(CORBA_TypedefDef_ptr);
void OBRelease(CORBA_TypedefDef_ptr);
typedef OBObjVar< CORBA_TypedefDef > CORBA_TypedefDef_var;

//
// IDL:omg.org/CORBA/StructDef:1.0
//
class CORBA_StructDef;
typedef CORBA_StructDef* CORBA_StructDef_ptr;
typedef CORBA_StructDef* CORBA_StructDefRef;
void OBDuplicate(CORBA_StructDef_ptr);
void OBRelease(CORBA_StructDef_ptr);
typedef OBObjVar< CORBA_StructDef > CORBA_StructDef_var;

//
// IDL:omg.org/CORBA/UnionDef:1.0
//
class CORBA_UnionDef;
typedef CORBA_UnionDef* CORBA_UnionDef_ptr;
typedef CORBA_UnionDef* CORBA_UnionDefRef;
void OBDuplicate(CORBA_UnionDef_ptr);
void OBRelease(CORBA_UnionDef_ptr);
typedef OBObjVar< CORBA_UnionDef > CORBA_UnionDef_var;

//
// IDL:omg.org/CORBA/EnumDef:1.0
//
class CORBA_EnumDef;
typedef CORBA_EnumDef* CORBA_EnumDef_ptr;
typedef CORBA_EnumDef* CORBA_EnumDefRef;
void OBDuplicate(CORBA_EnumDef_ptr);
void OBRelease(CORBA_EnumDef_ptr);
typedef OBObjVar< CORBA_EnumDef > CORBA_EnumDef_var;

//
// IDL:omg.org/CORBA/AliasDef:1.0
//
class CORBA_AliasDef;
typedef CORBA_AliasDef* CORBA_AliasDef_ptr;
typedef CORBA_AliasDef* CORBA_AliasDefRef;
void OBDuplicate(CORBA_AliasDef_ptr);
void OBRelease(CORBA_AliasDef_ptr);
typedef OBObjVar< CORBA_AliasDef > CORBA_AliasDef_var;

//
// IDL:omg.org/CORBA/PrimitiveDef:1.0
//
class CORBA_PrimitiveDef;
typedef CORBA_PrimitiveDef* CORBA_PrimitiveDef_ptr;
typedef CORBA_PrimitiveDef* CORBA_PrimitiveDefRef;
void OBDuplicate(CORBA_PrimitiveDef_ptr);
void OBRelease(CORBA_PrimitiveDef_ptr);
typedef OBObjVar< CORBA_PrimitiveDef > CORBA_PrimitiveDef_var;

//
// IDL:omg.org/CORBA/StringDef:1.0
//
class CORBA_StringDef;
typedef CORBA_StringDef* CORBA_StringDef_ptr;
typedef CORBA_StringDef* CORBA_StringDefRef;
void OBDuplicate(CORBA_StringDef_ptr);
void OBRelease(CORBA_StringDef_ptr);
typedef OBObjVar< CORBA_StringDef > CORBA_StringDef_var;

//
// IDL:omg.org/CORBA/SequenceDef:1.0
//
class CORBA_SequenceDef;
typedef CORBA_SequenceDef* CORBA_SequenceDef_ptr;
typedef CORBA_SequenceDef* CORBA_SequenceDefRef;
void OBDuplicate(CORBA_SequenceDef_ptr);
void OBRelease(CORBA_SequenceDef_ptr);
typedef OBObjVar< CORBA_SequenceDef > CORBA_SequenceDef_var;

//
// IDL:omg.org/CORBA/ArrayDef:1.0
//
class CORBA_ArrayDef;
typedef CORBA_ArrayDef* CORBA_ArrayDef_ptr;
typedef CORBA_ArrayDef* CORBA_ArrayDefRef;
void OBDuplicate(CORBA_ArrayDef_ptr);
void OBRelease(CORBA_ArrayDef_ptr);
typedef OBObjVar< CORBA_ArrayDef > CORBA_ArrayDef_var;

//
// IDL:omg.org/CORBA/ExceptionDef:1.0
//
class CORBA_ExceptionDef;
typedef CORBA_ExceptionDef* CORBA_ExceptionDef_ptr;
typedef CORBA_ExceptionDef* CORBA_ExceptionDefRef;
void OBDuplicate(CORBA_ExceptionDef_ptr);
void OBRelease(CORBA_ExceptionDef_ptr);
typedef OBObjVar< CORBA_ExceptionDef > CORBA_ExceptionDef_var;

//
// IDL:omg.org/CORBA/AttributeDef:1.0
//
class CORBA_AttributeDef;
typedef CORBA_AttributeDef* CORBA_AttributeDef_ptr;
typedef CORBA_AttributeDef* CORBA_AttributeDefRef;
void OBDuplicate(CORBA_AttributeDef_ptr);
void OBRelease(CORBA_AttributeDef_ptr);
typedef OBObjVar< CORBA_AttributeDef > CORBA_AttributeDef_var;

//
// IDL:omg.org/CORBA/OperationDef:1.0
//
class CORBA_OperationDef;
typedef CORBA_OperationDef* CORBA_OperationDef_ptr;
typedef CORBA_OperationDef* CORBA_OperationDefRef;
void OBDuplicate(CORBA_OperationDef_ptr);
void OBRelease(CORBA_OperationDef_ptr);
typedef OBObjVar< CORBA_OperationDef > CORBA_OperationDef_var;

//
// IDL:omg.org/CORBA/InterfaceDef:1.0
//
class CORBA_InterfaceDef;
typedef CORBA_InterfaceDef* CORBA_InterfaceDef_ptr;
typedef CORBA_InterfaceDef* CORBA_InterfaceDefRef;
void OBDuplicate(CORBA_InterfaceDef_ptr);
void OBRelease(CORBA_InterfaceDef_ptr);
typedef OBObjVar< CORBA_InterfaceDef > CORBA_InterfaceDef_var;

//
// IDL:omg.org/CORBA/VersionSpec:1.0
//
typedef char* CORBA_VersionSpec;
typedef CORBA_String_var CORBA_VersionSpec_var;
OB_IMPORT extern OBTypeCodeConst CORBA__tc_VersionSpec;

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

protected:

    CORBA_Contained() { }

public:

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

    static inline CORBA_Contained_ptr
    _nil()
    {
        return 0;
    }

    static CORBA_Contained_ptr _narrow(CORBA_Object_ptr);
    virtual void* _OB_narrowHelp(const char*) const;
    virtual const char* _OB_typeId() const;

    friend void OBUnmarshal(CORBA_Contained_ptr&, const CORBA_Octet*&, bool);

    friend CORBA_Boolean operator>>=(const CORBA_Any&, CORBA_Contained_ptr&);

    //
    // 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/Description:1.0
    //
    struct Description
    {
#ifdef OB_CLEAR_MEM
        Description();
#else
        Description() { }
#endif
        Description(const Description&);
        ~Description() { }
        Description& operator=(const Description&);

        CORBA_DefinitionKind kind;
        CORBA_Any value;
    };

    typedef OBVarVar< Description > Description_var;

    OB_IMPORT static OBTypeCodeConst _tc_Description;

    //
    // IDL:omg.org/CORBA/Contained/describe:1.0
    //
    virtual 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);
};

OB_IMPORT extern OBTypeCodeConst CORBA__tc_Contained;

//
// IDL:omg.org/CORBA/InterfaceDefSeq:1.0
//
typedef OBObjSeq< CORBA_InterfaceDef > CORBA_InterfaceDefSeq;
typedef OBSeqVar< OBObjSeq< CORBA_InterfaceDef > > CORBA_InterfaceDefSeq_var;
OB_IMPORT extern OBTypeCodeConst CORBA__tc_InterfaceDefSeq;

//
// IDL:omg.org/CORBA/ContainedSeq:1.0
//
typedef OBObjSeq< CORBA_Contained > CORBA_ContainedSeq;
typedef OBSeqVar< OBObjSeq< CORBA_Contained > > CORBA_ContainedSeq_var;
OB_IMPORT extern OBTypeCodeConst CORBA__tc_ContainedSeq;

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

protected:

    CORBA_Container() { }

public:

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

    static inline CORBA_Container_ptr
    _nil()
    {
        return 0;
    }

    static CORBA_Container_ptr _narrow(CORBA_Object_ptr);
    virtual void* _OB_narrowHelp(const char*) const;
    virtual const char* _OB_typeId() const;

    friend void OBUnmarshal(CORBA_Container_ptr&, const CORBA_Octet*&, bool);

    friend CORBA_Boolean operator>>=(const CORBA_Any&, CORBA_Container_ptr&);

    //
    // 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/Description:1.0
    //
    struct Description
    {
#ifdef OB_CLEAR_MEM
        Description();
#else
        Description() { }
#endif
        Description(const Description&);
        ~Description() { }
        Description& operator=(const Description&);

        CORBA_Contained_var contained_object;
        CORBA_DefinitionKind kind;
        CORBA_Any value;
    };

    typedef OBVarVar< Description > Description_var;

    OB_IMPORT static OBTypeCodeConst _tc_Description;

    //
    // IDL:omg.org/CORBA/Container/DescriptionSeq:1.0
    //
    typedef OBVarSeq< Description > DescriptionSeq;
    typedef OBSeqVar< OBVarSeq< Description > > DescriptionSeq_var;
    OB_IMPORT static OBTypeCodeConst _tc_DescriptionSeq;

    //
    // IDL:omg.org/CORBA/Container/describe_contents:1.0
    //
    virtual 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_exception:1.0
    //
    virtual CORBA_ExceptionDef_ptr create_exception(const char* id,
                                                    const char* name,
                                                    const char* version,
                                                    const CORBA_StructMemberSeq& members);
};

OB_IMPORT extern OBTypeCodeConst CORBA__tc_Container;

//
// IDL:omg.org/CORBA/PrimitiveKind:1.0
//
enum CORBA_PrimitiveKind
{
    CORBA_pk_null,
    CORBA_pk_void,
    CORBA_pk_short,
    CORBA_pk_long,
    CORBA_pk_ushort,
    CORBA_pk_ulong,
    CORBA_pk_float,
    CORBA_pk_double,
    CORBA_pk_boolean,
    CORBA_pk_char,
    CORBA_pk_octet,
    CORBA_pk_any,
    CORBA_pk_TypeCode,
    CORBA_pk_Principal,
    CORBA_pk_string,
    CORBA_pk_objref
};

OB_IMPORT extern OBTypeCodeConst CORBA__tc_PrimitiveKind;

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

protected:

    CORBA_Repository() { }

public:

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

    static inline CORBA_Repository_ptr
    _nil()
    {
        return 0;
    }

    static CORBA_Repository_ptr _narrow(CORBA_Object_ptr);
    virtual void* _OB_narrowHelp(const char*) const;
    virtual const char* _OB_typeId() const;

    friend void OBUnmarshal(CORBA_Repository_ptr&, const CORBA_Octet*&, bool);

    friend CORBA_Boolean operator>>=(const CORBA_Any&, CORBA_Repository_ptr&);

    //
    // 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_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_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);
};

OB_IMPORT extern OBTypeCodeConst CORBA__tc_Repository;

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

protected:

    CORBA_ModuleDef() { }

public:

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

    static inline CORBA_ModuleDef_ptr
    _nil()
    {
        return 0;
    }

    static CORBA_ModuleDef_ptr _narrow(CORBA_Object_ptr);
    virtual void* _OB_narrowHelp(const char*) const;
    virtual const char* _OB_typeId() const;

    friend void OBUnmarshal(CORBA_ModuleDef_ptr&, const CORBA_Octet*&, bool);

    friend CORBA_Boolean operator>>=(const CORBA_Any&, CORBA_ModuleDef_ptr&);
};

OB_IMPORT extern OBTypeCodeConst CORBA__tc_ModuleDef;

//
// IDL:omg.org/CORBA/ModuleDescription:1.0
//
struct CORBA_ModuleDescription
{
    CORBA_ModuleDescription() { }
    CORBA_ModuleDescription(const CORBA_ModuleDescription&);
    ~CORBA_ModuleDescription() { }
    CORBA_ModuleDescription& operator=(const CORBA_ModuleDescription&);

    CORBA_Identifier_var name;
    CORBA_RepositoryId_var id;
    CORBA_RepositoryId_var defined_in;
    CORBA_VersionSpec_var version;
};

typedef OBVarVar< CORBA_ModuleDescription > CORBA_ModuleDescription_var;

OB_IMPORT extern OBTypeCodeConst CORBA__tc_ModuleDescription;

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

protected:

    CORBA_ConstantDef() { }

public:

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

    static inline CORBA_ConstantDef_ptr
    _nil()
    {
        return 0;
    }

    static CORBA_ConstantDef_ptr _narrow(CORBA_Object_ptr);
    virtual void* _OB_narrowHelp(const char*) const;
    virtual const char* _OB_typeId() const;

    friend void OBUnmarshal(CORBA_ConstantDef_ptr&, const CORBA_Octet*&, bool);

    friend CORBA_Boolean operator>>=(const CORBA_Any&, CORBA_ConstantDef_ptr&);

    //
    // 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&);
};

OB_IMPORT extern OBTypeCodeConst CORBA__tc_ConstantDef;

//
// IDL:omg.org/CORBA/ConstantDescription:1.0
//
struct CORBA_ConstantDescription
{
    CORBA_ConstantDescription() { }
    CORBA_ConstantDescription(const CORBA_ConstantDescription&);
    ~CORBA_ConstantDescription() { }
    CORBA_ConstantDescription& operator=(const CORBA_ConstantDescription&);

    CORBA_Identifier_var name;
    CORBA_RepositoryId_var id;
    CORBA_RepositoryId_var defined_in;
    CORBA_VersionSpec_var version;
    CORBA_TypeCode_var type;
    CORBA_Any value;
};

typedef OBVarVar< CORBA_ConstantDescription > CORBA_ConstantDescription_var;

OB_IMPORT extern OBTypeCodeConst CORBA__tc_ConstantDescription;

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

protected:

    CORBA_TypedefDef() { }

public:

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

    static inline CORBA_TypedefDef_ptr
    _nil()
    {
        return 0;
    }

    static CORBA_TypedefDef_ptr _narrow(CORBA_Object_ptr);
    virtual void* _OB_narrowHelp(const char*) const;
    virtual const char* _OB_typeId() const;

    friend void OBUnmarshal(CORBA_TypedefDef_ptr&, const CORBA_Octet*&, bool);

    friend CORBA_Boolean operator>>=(const CORBA_Any&, CORBA_TypedefDef_ptr&);
};

OB_IMPORT extern OBTypeCodeConst CORBA__tc_TypedefDef;

//
// IDL:omg.org/CORBA/TypeDescription:1.0
//
struct CORBA_TypeDescription
{
    CORBA_TypeDescription() { }
    CORBA_TypeDescription(const CORBA_TypeDescription&);
    ~CORBA_TypeDescription() { }
    CORBA_TypeDescription& operator=(const CORBA_TypeDescription&);

    CORBA_Identifier_var name;
    CORBA_RepositoryId_var id;
    CORBA_RepositoryId_var defined_in;
    CORBA_VersionSpec_var version;
    CORBA_TypeCode_var type;
};

typedef OBVarVar< CORBA_TypeDescription > CORBA_TypeDescription_var;

OB_IMPORT extern OBTypeCodeConst CORBA__tc_TypeDescription;

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

protected:

    CORBA_StructDef() { }

public:

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

    static inline CORBA_StructDef_ptr
    _nil()
    {
        return 0;
    }

    static CORBA_StructDef_ptr _narrow(CORBA_Object_ptr);
    virtual void* _OB_narrowHelp(const char*) const;
    virtual const char* _OB_typeId() const;

    friend void OBUnmarshal(CORBA_StructDef_ptr&, const CORBA_Octet*&, bool);

    friend CORBA_Boolean operator>>=(const CORBA_Any&, CORBA_StructDef_ptr&);

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

OB_IMPORT extern OBTypeCodeConst CORBA__tc_StructDef;

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

protected:

    CORBA_UnionDef() { }

public:

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

    static inline CORBA_UnionDef_ptr
    _nil()
    {
        return 0;
    }

    static CORBA_UnionDef_ptr _narrow(CORBA_Object_ptr);
    virtual void* _OB_narrowHelp(const char*) const;
    virtual const char* _OB_typeId() const;

    friend void OBUnmarshal(CORBA_UnionDef_ptr&, const CORBA_Octet*&, bool);

    friend CORBA_Boolean operator>>=(const CORBA_Any&, CORBA_UnionDef_ptr&);

    //
    // 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&);
};

OB_IMPORT extern OBTypeCodeConst CORBA__tc_UnionDef;

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

protected:

    CORBA_EnumDef() { }

public:

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

    static inline CORBA_EnumDef_ptr
    _nil()
    {
        return 0;
    }

    static CORBA_EnumDef_ptr _narrow(CORBA_Object_ptr);
    virtual void* _OB_narrowHelp(const char*) const;
    virtual const char* _OB_typeId() const;

    friend void OBUnmarshal(CORBA_EnumDef_ptr&, const CORBA_Octet*&, bool);

    friend CORBA_Boolean operator>>=(const CORBA_Any&, CORBA_EnumDef_ptr&);

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

OB_IMPORT extern OBTypeCodeConst CORBA__tc_EnumDef;

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

protected:

    CORBA_AliasDef() { }

public:

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

    static inline CORBA_AliasDef_ptr
    _nil()
    {
        return 0;
    }

    static CORBA_AliasDef_ptr _narrow(CORBA_Object_ptr);
    virtual void* _OB_narrowHelp(const char*) const;
    virtual const char* _OB_typeId() const;

    friend void OBUnmarshal(CORBA_AliasDef_ptr&, const CORBA_Octet*&, bool);

    friend CORBA_Boolean operator>>=(const CORBA_Any&, CORBA_AliasDef_ptr&);

    //
    // 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);
};

OB_IMPORT extern OBTypeCodeConst CORBA__tc_AliasDef;

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

protected:

    CORBA_PrimitiveDef() { }

public:

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

    static inline CORBA_PrimitiveDef_ptr
    _nil()
    {
        return 0;
    }

    static CORBA_PrimitiveDef_ptr _narrow(CORBA_Object_ptr);
    virtual void* _OB_narrowHelp(const char*) const;
    virtual const char* _OB_typeId() const;

    friend void OBUnmarshal(CORBA_PrimitiveDef_ptr&, const CORBA_Octet*&, bool);

    friend CORBA_Boolean operator>>=(const CORBA_Any&, CORBA_PrimitiveDef_ptr&);

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

OB_IMPORT extern OBTypeCodeConst CORBA__tc_PrimitiveDef;

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

protected:

    CORBA_StringDef() { }

public:

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

    static inline CORBA_StringDef_ptr
    _nil()
    {
        return 0;
    }

    static CORBA_StringDef_ptr _narrow(CORBA_Object_ptr);
    virtual void* _OB_narrowHelp(const char*) const;
    virtual const char* _OB_typeId() const;

    friend void OBUnmarshal(CORBA_StringDef_ptr&, const CORBA_Octet*&, bool);

    friend CORBA_Boolean operator>>=(const CORBA_Any&, CORBA_StringDef_ptr&);

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

OB_IMPORT extern OBTypeCodeConst CORBA__tc_StringDef;

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

protected:

    CORBA_SequenceDef() { }

public:

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

    static inline CORBA_SequenceDef_ptr
    _nil()
    {
        return 0;
    }

    static CORBA_SequenceDef_ptr _narrow(CORBA_Object_ptr);
    virtual void* _OB_narrowHelp(const char*) const;
    virtual const char* _OB_typeId() const;

    friend void OBUnmarshal(CORBA_SequenceDef_ptr&, const CORBA_Octet*&, bool);

    friend CORBA_Boolean operator>>=(const CORBA_Any&, CORBA_SequenceDef_ptr&);

    //
    // 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);
};

OB_IMPORT extern OBTypeCodeConst CORBA__tc_SequenceDef;

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

protected:

    CORBA_ArrayDef() { }

public:

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

    static inline CORBA_ArrayDef_ptr
    _nil()
    {
        return 0;
    }

    static CORBA_ArrayDef_ptr _narrow(CORBA_Object_ptr);
    virtual void* _OB_narrowHelp(const char*) const;
    virtual const char* _OB_typeId() const;

    friend void OBUnmarshal(CORBA_ArrayDef_ptr&, const CORBA_Octet*&, bool);

    friend CORBA_Boolean operator>>=(const CORBA_Any&, CORBA_ArrayDef_ptr&);

    //
    // 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);
};

OB_IMPORT extern OBTypeCodeConst CORBA__tc_ArrayDef;

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

protected:

    CORBA_ExceptionDef() { }

public:

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

    static inline CORBA_ExceptionDef_ptr
    _nil()
    {
        return 0;
    }

    static CORBA_ExceptionDef_ptr _narrow(CORBA_Object_ptr);
    virtual void* _OB_narrowHelp(const char*) const;
    virtual const char* _OB_typeId() const;

    friend void OBUnmarshal(CORBA_ExceptionDef_ptr&, const CORBA_Octet*&, bool);

    friend CORBA_Boolean operator>>=(const CORBA_Any&, CORBA_ExceptionDef_ptr&);

    //
    // 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&);
};

OB_IMPORT extern OBTypeCodeConst CORBA__tc_ExceptionDef;

//
// IDL:omg.org/CORBA/ExceptionDescription:1.0
//
struct CORBA_ExceptionDescription
{
    CORBA_ExceptionDescription() { }
    CORBA_ExceptionDescription(const CORBA_ExceptionDescription&);
    ~CORBA_ExceptionDescription() { }
    CORBA_ExceptionDescription& operator=(const CORBA_ExceptionDescription&);

    CORBA_Identifier_var name;
    CORBA_RepositoryId_var id;
    CORBA_RepositoryId_var defined_in;
    CORBA_VersionSpec_var version;
    CORBA_TypeCode_var type;
};

typedef OBVarVar< CORBA_ExceptionDescription > CORBA_ExceptionDescription_var;

OB_IMPORT extern OBTypeCodeConst CORBA__tc_ExceptionDescription;

//
// IDL:omg.org/CORBA/AttributeMode:1.0
//
enum CORBA_AttributeMode
{
    CORBA_ATTR_NORMAL,
    CORBA_ATTR_READONLY
};

OB_IMPORT extern OBTypeCodeConst CORBA__tc_AttributeMode;

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

protected:

    CORBA_AttributeDef() { }

public:

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

    static inline CORBA_AttributeDef_ptr
    _nil()
    {
        return 0;
    }

    static CORBA_AttributeDef_ptr _narrow(CORBA_Object_ptr);
    virtual void* _OB_narrowHelp(const char*) const;
    virtual const char* _OB_typeId() const;

    friend void OBUnmarshal(CORBA_AttributeDef_ptr&, const CORBA_Octet*&, bool);

    friend CORBA_Boolean operator>>=(const CORBA_Any&, CORBA_AttributeDef_ptr&);

    //
    // 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);
};

OB_IMPORT extern OBTypeCodeConst CORBA__tc_AttributeDef;

//
// IDL:omg.org/CORBA/AttributeDescription:1.0
//
struct CORBA_AttributeDescription
{
#ifdef OB_CLEAR_MEM
    CORBA_AttributeDescription();
#else
    CORBA_AttributeDescription() { }
#endif
    CORBA_AttributeDescription(const CORBA_AttributeDescription&);
    ~CORBA_AttributeDescription() { }
    CORBA_AttributeDescription& operator=(const CORBA_AttributeDescription&);

    CORBA_Identifier_var name;
    CORBA_RepositoryId_var id;
    CORBA_RepositoryId_var defined_in;
    CORBA_VersionSpec_var version;
    CORBA_TypeCode_var type;
    CORBA_AttributeMode mode;
};

typedef OBVarVar< CORBA_AttributeDescription > CORBA_AttributeDescription_var;

OB_IMPORT extern OBTypeCodeConst CORBA__tc_AttributeDescription;

//
// IDL:omg.org/CORBA/OperationMode:1.0
//
enum CORBA_OperationMode
{
    CORBA_OP_NORMAL,
    CORBA_OP_ONEWAY
};

OB_IMPORT extern OBTypeCodeConst CORBA__tc_OperationMode;

//
// IDL:omg.org/CORBA/ParameterMode:1.0
//
enum CORBA_ParameterMode
{
    CORBA_PARAM_IN,
    CORBA_PARAM_OUT,
    CORBA_PARAM_INOUT
};

OB_IMPORT extern OBTypeCodeConst CORBA__tc_ParameterMode;

//
// IDL:omg.org/CORBA/ParameterDescription:1.0
//
struct CORBA_ParameterDescription
{
#ifdef OB_CLEAR_MEM
    CORBA_ParameterDescription();
#else
    CORBA_ParameterDescription() { }
#endif
    CORBA_ParameterDescription(const CORBA_ParameterDescription&);
    ~CORBA_ParameterDescription() { }
    CORBA_ParameterDescription& operator=(const CORBA_ParameterDescription&);

    CORBA_Identifier_var name;
    CORBA_TypeCode_var type;
    CORBA_IDLType_var type_def;
    CORBA_ParameterMode mode;
};

typedef OBVarVar< CORBA_ParameterDescription > CORBA_ParameterDescription_var;

OB_IMPORT extern OBTypeCodeConst CORBA__tc_ParameterDescription;

//
// IDL:omg.org/CORBA/ParDescriptionSeq:1.0
//
typedef OBVarSeq< CORBA_ParameterDescription > CORBA_ParDescriptionSeq;
typedef OBSeqVar< OBVarSeq< CORBA_ParameterDescription > > CORBA_ParDescriptionSeq_var;
OB_IMPORT extern OBTypeCodeConst CORBA__tc_ParDescriptionSeq;

//
// IDL:omg.org/CORBA/ContextIdentifier:1.0
//
typedef CORBA_Identifier CORBA_ContextIdentifier;
typedef CORBA_Identifier_var CORBA_ContextIdentifier_var;
OB_IMPORT extern OBTypeCodeConst CORBA__tc_ContextIdentifier;

//
// IDL:omg.org/CORBA/ContextIdSeq:1.0
//
typedef OBStrSeq CORBA_ContextIdSeq;
typedef OBSeqVar< OBStrSeq > CORBA_ContextIdSeq_var;
OB_IMPORT extern OBTypeCodeConst CORBA__tc_ContextIdSeq;

//
// IDL:omg.org/CORBA/ExceptionDefSeq:1.0
//
typedef OBObjSeq< CORBA_ExceptionDef > CORBA_ExceptionDefSeq;
typedef OBSeqVar< OBObjSeq< CORBA_ExceptionDef > > CORBA_ExceptionDefSeq_var;
OB_IMPORT extern OBTypeCodeConst CORBA__tc_ExceptionDefSeq;

//
// IDL:omg.org/CORBA/ExcDescriptionSeq:1.0
//
typedef OBVarSeq< CORBA_ExceptionDescription > CORBA_ExcDescriptionSeq;
typedef OBSeqVar< OBVarSeq< CORBA_ExceptionDescription > > CORBA_ExcDescriptionSeq_var;
OB_IMPORT extern OBTypeCodeConst CORBA__tc_ExcDescriptionSeq;

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

protected:

    CORBA_OperationDef() { }

public:

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

    static inline CORBA_OperationDef_ptr
    _nil()
    {
        return 0;
    }

    static CORBA_OperationDef_ptr _narrow(CORBA_Object_ptr);
    virtual void* _OB_narrowHelp(const char*) const;
    virtual const char* _OB_typeId() const;

    friend void OBUnmarshal(CORBA_OperationDef_ptr&, const CORBA_Octet*&, bool);

    friend CORBA_Boolean operator>>=(const CORBA_Any&, CORBA_OperationDef_ptr&);

    //
    // 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&);
};

OB_IMPORT extern OBTypeCodeConst CORBA__tc_OperationDef;

//
// IDL:omg.org/CORBA/OperationDescription:1.0
//
struct CORBA_OperationDescription
{
#ifdef OB_CLEAR_MEM
    CORBA_OperationDescription();
#else
    CORBA_OperationDescription() { }
#endif
    CORBA_OperationDescription(const CORBA_OperationDescription&);
    ~CORBA_OperationDescription() { }
    CORBA_OperationDescription& operator=(const CORBA_OperationDescription&);

    CORBA_Identifier_var name;
    CORBA_RepositoryId_var id;
    CORBA_RepositoryId_var defined_in;
    CORBA_VersionSpec_var version;
    CORBA_TypeCode_var result;
    CORBA_OperationMode mode;
    CORBA_ContextIdSeq contexts;
    CORBA_ParDescriptionSeq parameters;
    CORBA_ExcDescriptionSeq exceptions;
};

typedef OBVarVar< CORBA_OperationDescription > CORBA_OperationDescription_var;

OB_IMPORT extern OBTypeCodeConst CORBA__tc_OperationDescription;

//
// IDL:omg.org/CORBA/RepositoryIdSeq:1.0
//
typedef OBStrSeq CORBA_RepositoryIdSeq;
typedef OBSeqVar< OBStrSeq > CORBA_RepositoryIdSeq_var;
OB_IMPORT extern OBTypeCodeConst CORBA__tc_RepositoryIdSeq;

//
// IDL:omg.org/CORBA/OpDescriptionSeq:1.0
//
typedef OBVarSeq< CORBA_OperationDescription > CORBA_OpDescriptionSeq;
typedef OBSeqVar< OBVarSeq< CORBA_OperationDescription > > CORBA_OpDescriptionSeq_var;
OB_IMPORT extern OBTypeCodeConst CORBA__tc_OpDescriptionSeq;

//
// IDL:omg.org/CORBA/AttrDescriptionSeq:1.0
//
typedef OBVarSeq< CORBA_AttributeDescription > CORBA_AttrDescriptionSeq;
typedef OBSeqVar< OBVarSeq< CORBA_AttributeDescription > > CORBA_AttrDescriptionSeq_var;
OB_IMPORT extern OBTypeCodeConst CORBA__tc_AttrDescriptionSeq;

//
// IDL:omg.org/CORBA/InterfaceDef:1.0
//
class CORBA_InterfaceDef : virtual public CORBA_Container,
                           virtual public CORBA_Contained,
                           virtual public CORBA_IDLType
{
    CORBA_InterfaceDef(const CORBA_InterfaceDef&);
    void operator=(const CORBA_InterfaceDef&);

protected:

    CORBA_InterfaceDef() { }

public:

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

    static inline CORBA_InterfaceDef_ptr
    _nil()
    {
        return 0;
    }

    static CORBA_InterfaceDef_ptr _narrow(CORBA_Object_ptr);
    virtual void* _OB_narrowHelp(const char*) const;
    virtual const char* _OB_typeId() const;

    friend void OBUnmarshal(CORBA_InterfaceDef_ptr&, const CORBA_Octet*&, bool);

    friend CORBA_Boolean operator>>=(const CORBA_Any&, CORBA_InterfaceDef_ptr&);

    //
    // 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/FullInterfaceDescription:1.0
    //
    struct FullInterfaceDescription
    {
        FullInterfaceDescription() { }
        FullInterfaceDescription(const FullInterfaceDescription&);
        ~FullInterfaceDescription() { }
        FullInterfaceDescription& operator=(const FullInterfaceDescription&);

        CORBA_Identifier_var name;
        CORBA_RepositoryId_var id;
        CORBA_RepositoryId_var defined_in;
        CORBA_VersionSpec_var version;
        CORBA_OpDescriptionSeq operations;
        CORBA_AttrDescriptionSeq attributes;
        CORBA_RepositoryIdSeq base_interfaces;
        CORBA_TypeCode_var type;
    };

    typedef OBVarVar< FullInterfaceDescription > FullInterfaceDescription_var;

    OB_IMPORT static OBTypeCodeConst _tc_FullInterfaceDescription;

    //
    // IDL:omg.org/CORBA/InterfaceDef/describe_interface:1.0
    //
    virtual 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);
};

OB_IMPORT extern OBTypeCodeConst CORBA__tc_InterfaceDef;

//
// IDL:omg.org/CORBA/InterfaceDescription:1.0
//
struct CORBA_InterfaceDescription
{
    CORBA_InterfaceDescription() { }
    CORBA_InterfaceDescription(const CORBA_InterfaceDescription&);
    ~CORBA_InterfaceDescription() { }
    CORBA_InterfaceDescription& operator=(const CORBA_InterfaceDescription&);

    CORBA_Identifier_var name;
    CORBA_RepositoryId_var id;
    CORBA_RepositoryId_var defined_in;
    CORBA_VersionSpec_var version;
    CORBA_RepositoryIdSeq base_interfaces;
};

typedef OBVarVar< CORBA_InterfaceDescription > CORBA_InterfaceDescription_var;

OB_IMPORT extern OBTypeCodeConst CORBA__tc_InterfaceDescription;

//
// IDL:omg.org/CORBA/Contained:1.0
//
inline void
CORBA_release(CORBA_Contained_ptr p)
{
    if(p)
        p -> _OB_decRef();
}

inline CORBA_Boolean
CORBA_is_nil(CORBA_Contained_ptr p)
{
    return p == 0;
}

inline void
OBMarshal(CORBA_Contained_ptr p, CORBA_Octet*& oct)
{
    OBMarshal((CORBA_Object_ptr)p, oct);
}

inline void
OBMarshalCount(CORBA_Contained_ptr p, CORBA_ULong& count)
{
    OBMarshalCount((CORBA_Object_ptr)p, count);
}

void OBUnmarshal(CORBA_Contained_ptr&, const CORBA_Octet*&, bool);

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 OBMarshal(const CORBA_Contained::Description&, CORBA_Octet*&);
void OBMarshalCount(const CORBA_Contained::Description&, CORBA_ULong&);
void OBUnmarshal(CORBA_Contained::Description&, const CORBA_Octet*&, bool);

void operator<<=(CORBA_Any&, CORBA_Contained::Description*);
void operator<<=(CORBA_Any&, const CORBA_Contained::Description&);
CORBA_Boolean operator>>=(const CORBA_Any&, 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, CORBA_Contained::Description*& val)
{
    return any.in() >>= val;
}

//
// IDL:omg.org/CORBA/Container:1.0
//
inline void
CORBA_release(CORBA_Container_ptr p)
{
    if(p)
        p -> _OB_decRef();
}

inline CORBA_Boolean
CORBA_is_nil(CORBA_Container_ptr p)
{
    return p == 0;
}

inline void
OBMarshal(CORBA_Container_ptr p, CORBA_Octet*& oct)
{
    OBMarshal((CORBA_Object_ptr)p, oct);
}

inline void
OBMarshalCount(CORBA_Container_ptr p, CORBA_ULong& count)
{
    OBMarshalCount((CORBA_Object_ptr)p, count);
}

void OBUnmarshal(CORBA_Container_ptr&, const CORBA_Octet*&, bool);

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 OBMarshal(const CORBA_Container::Description&, CORBA_Octet*&);
void OBMarshalCount(const CORBA_Container::Description&, CORBA_ULong&);
void OBUnmarshal(CORBA_Container::Description&, const CORBA_Octet*&, bool);

void operator<<=(CORBA_Any&, CORBA_Container::Description*);
void operator<<=(CORBA_Any&, const CORBA_Container::Description&);
CORBA_Boolean operator>>=(const CORBA_Any&, 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, CORBA_Container::Description*& val)
{
    return any.in() >>= val;
}

//
// IDL:omg.org/CORBA/PrimitiveKind:1.0
//
inline void
OBMarshal(CORBA_PrimitiveKind val, CORBA_Octet*& oct)
{
    OBMarshal((CORBA_ULong)val, oct);
}

inline void
OBMarshalCount(CORBA_PrimitiveKind, CORBA_ULong& count)
{
    OBMarshalCount((CORBA_ULong)0, count);
}

inline void
OBUnmarshal(CORBA_PrimitiveKind& val, const CORBA_Octet*& coct, bool swap)
{
    CORBA_ULong v;
    OBUnmarshal(v, coct, swap);
    val = (CORBA_PrimitiveKind)v;
}

void operator<<=(CORBA_Any&, CORBA_PrimitiveKind);
CORBA_Boolean operator>>=(const CORBA_Any&, CORBA_PrimitiveKind&);

//
// IDL:omg.org/CORBA/Repository:1.0
//
inline void
CORBA_release(CORBA_Repository_ptr p)
{
    if(p)
        p -> _OB_decRef();
}

inline CORBA_Boolean
CORBA_is_nil(CORBA_Repository_ptr p)
{
    return p == 0;
}

inline void
OBMarshal(CORBA_Repository_ptr p, CORBA_Octet*& oct)
{
    OBMarshal((CORBA_Object_ptr)p, oct);
}

inline void
OBMarshalCount(CORBA_Repository_ptr p, CORBA_ULong& count)
{
    OBMarshalCount((CORBA_Object_ptr)p, count);
}

void OBUnmarshal(CORBA_Repository_ptr&, const CORBA_Octet*&, bool);

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
//
inline void
CORBA_release(CORBA_ModuleDef_ptr p)
{
    if(p)
        p -> _OB_decRef();
}

inline CORBA_Boolean
CORBA_is_nil(CORBA_ModuleDef_ptr p)
{
    return p == 0;
}

inline void
OBMarshal(CORBA_ModuleDef_ptr p, CORBA_Octet*& oct)
{
    OBMarshal((CORBA_Object_ptr)p, oct);
}

inline void
OBMarshalCount(CORBA_ModuleDef_ptr p, CORBA_ULong& count)
{
    OBMarshalCount((CORBA_Object_ptr)p, count);
}

void OBUnmarshal(CORBA_ModuleDef_ptr&, const CORBA_Octet*&, bool);

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 OBMarshal(const CORBA_ModuleDescription&, CORBA_Octet*&);
void OBMarshalCount(const CORBA_ModuleDescription&, CORBA_ULong&);
void OBUnmarshal(CORBA_ModuleDescription&, const CORBA_Octet*&, bool);

void operator<<=(CORBA_Any&, CORBA_ModuleDescription*);
void operator<<=(CORBA_Any&, const CORBA_ModuleDescription&);
CORBA_Boolean operator>>=(const CORBA_Any&, 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, CORBA_ModuleDescription*& val)
{
    return any.in() >>= val;
}

//
// IDL:omg.org/CORBA/ConstantDef:1.0
//
inline void
CORBA_release(CORBA_ConstantDef_ptr p)
{
    if(p)
        p -> _OB_decRef();
}

inline CORBA_Boolean
CORBA_is_nil(CORBA_ConstantDef_ptr p)
{
    return p == 0;
}

inline void
OBMarshal(CORBA_ConstantDef_ptr p, CORBA_Octet*& oct)
{
    OBMarshal((CORBA_Object_ptr)p, oct);
}

inline void
OBMarshalCount(CORBA_ConstantDef_ptr p, CORBA_ULong& count)
{
    OBMarshalCount((CORBA_Object_ptr)p, count);
}

void OBUnmarshal(CORBA_ConstantDef_ptr&, const CORBA_Octet*&, bool);

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 OBMarshal(const CORBA_ConstantDescription&, CORBA_Octet*&);
void OBMarshalCount(const CORBA_ConstantDescription&, CORBA_ULong&);
void OBUnmarshal(CORBA_ConstantDescription&, const CORBA_Octet*&, bool);

void operator<<=(CORBA_Any&, CORBA_ConstantDescription*);
void operator<<=(CORBA_Any&, const CORBA_ConstantDescription&);
CORBA_Boolean operator>>=(const CORBA_Any&, 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, CORBA_ConstantDescription*& val)
{
    return any.in() >>= val;
}

//
// IDL:omg.org/CORBA/TypedefDef:1.0
//
inline void
CORBA_release(CORBA_TypedefDef_ptr p)
{
    if(p)
        p -> _OB_decRef();
}

inline CORBA_Boolean
CORBA_is_nil(CORBA_TypedefDef_ptr p)
{
    return p == 0;
}

inline void
OBMarshal(CORBA_TypedefDef_ptr p, CORBA_Octet*& oct)
{
    OBMarshal((CORBA_Object_ptr)p, oct);
}

inline void
OBMarshalCount(CORBA_TypedefDef_ptr p, CORBA_ULong& count)
{
    OBMarshalCount((CORBA_Object_ptr)p, count);
}

void OBUnmarshal(CORBA_TypedefDef_ptr&, const CORBA_Octet*&, bool);

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 OBMarshal(const CORBA_TypeDescription&, CORBA_Octet*&);
void OBMarshalCount(const CORBA_TypeDescription&, CORBA_ULong&);
void OBUnmarshal(CORBA_TypeDescription&, const CORBA_Octet*&, bool);

void operator<<=(CORBA_Any&, CORBA_TypeDescription*);
void operator<<=(CORBA_Any&, const CORBA_TypeDescription&);
CORBA_Boolean operator>>=(const CORBA_Any&, 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, CORBA_TypeDescription*& val)
{
    return any.in() >>= val;
}

//
// IDL:omg.org/CORBA/StructDef:1.0
//
inline void
CORBA_release(CORBA_StructDef_ptr p)
{
    if(p)
        p -> _OB_decRef();
}

inline CORBA_Boolean
CORBA_is_nil(CORBA_StructDef_ptr p)
{
    return p == 0;
}

inline void
OBMarshal(CORBA_StructDef_ptr p, CORBA_Octet*& oct)
{
    OBMarshal((CORBA_Object_ptr)p, oct);
}

inline void
OBMarshalCount(CORBA_StructDef_ptr p, CORBA_ULong& count)
{
    OBMarshalCount((CORBA_Object_ptr)p, count);
}

void OBUnmarshal(CORBA_StructDef_ptr&, const CORBA_Octet*&, bool);

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
//
inline void
CORBA_release(CORBA_UnionDef_ptr p)
{
    if(p)
        p -> _OB_decRef();
}

inline CORBA_Boolean
CORBA_is_nil(CORBA_UnionDef_ptr p)
{
    return p == 0;
}

inline void
OBMarshal(CORBA_UnionDef_ptr p, CORBA_Octet*& oct)
{
    OBMarshal((CORBA_Object_ptr)p, oct);
}

inline void
OBMarshalCount(CORBA_UnionDef_ptr p, CORBA_ULong& count)
{
    OBMarshalCount((CORBA_Object_ptr)p, count);
}

void OBUnmarshal(CORBA_UnionDef_ptr&, const CORBA_Octet*&, bool);

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
//
inline void
CORBA_release(CORBA_EnumDef_ptr p)
{
    if(p)
        p -> _OB_decRef();
}

inline CORBA_Boolean
CORBA_is_nil(CORBA_EnumDef_ptr p)
{
    return p == 0;
}

inline void
OBMarshal(CORBA_EnumDef_ptr p, CORBA_Octet*& oct)
{
    OBMarshal((CORBA_Object_ptr)p, oct);
}

inline void
OBMarshalCount(CORBA_EnumDef_ptr p, CORBA_ULong& count)
{
    OBMarshalCount((CORBA_Object_ptr)p, count);
}

void OBUnmarshal(CORBA_EnumDef_ptr&, const CORBA_Octet*&, bool);

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
//
inline void
CORBA_release(CORBA_AliasDef_ptr p)
{
    if(p)
        p -> _OB_decRef();
}

inline CORBA_Boolean
CORBA_is_nil(CORBA_AliasDef_ptr p)
{
    return p == 0;
}

inline void
OBMarshal(CORBA_AliasDef_ptr p, CORBA_Octet*& oct)
{
    OBMarshal((CORBA_Object_ptr)p, oct);
}

inline void
OBMarshalCount(CORBA_AliasDef_ptr p, CORBA_ULong& count)
{
    OBMarshalCount((CORBA_Object_ptr)p, count);
}

void OBUnmarshal(CORBA_AliasDef_ptr&, const CORBA_Octet*&, bool);

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/PrimitiveDef:1.0
//
inline void
CORBA_release(CORBA_PrimitiveDef_ptr p)
{
    if(p)
        p -> _OB_decRef();
}

inline CORBA_Boolean
CORBA_is_nil(CORBA_PrimitiveDef_ptr p)
{
    return p == 0;
}

inline void
OBMarshal(CORBA_PrimitiveDef_ptr p, CORBA_Octet*& oct)
{
    OBMarshal((CORBA_Object_ptr)p, oct);
}

inline void
OBMarshalCount(CORBA_PrimitiveDef_ptr p, CORBA_ULong& count)
{
    OBMarshalCount((CORBA_Object_ptr)p, count);
}

void OBUnmarshal(CORBA_PrimitiveDef_ptr&, const CORBA_Octet*&, bool);

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
//
inline void
CORBA_release(CORBA_StringDef_ptr p)
{
    if(p)
        p -> _OB_decRef();
}

inline CORBA_Boolean
CORBA_is_nil(CORBA_StringDef_ptr p)
{
    return p == 0;
}

inline void
OBMarshal(CORBA_StringDef_ptr p, CORBA_Octet*& oct)
{
    OBMarshal((CORBA_Object_ptr)p, oct);
}

inline void
OBMarshalCount(CORBA_StringDef_ptr p, CORBA_ULong& count)
{
    OBMarshalCount((CORBA_Object_ptr)p, count);
}

void OBUnmarshal(CORBA_StringDef_ptr&, const CORBA_Octet*&, bool);

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/SequenceDef:1.0
//
inline void
CORBA_release(CORBA_SequenceDef_ptr p)
{
    if(p)
        p -> _OB_decRef();
}

inline CORBA_Boolean
CORBA_is_nil(CORBA_SequenceDef_ptr p)
{
    return p == 0;
}

inline void
OBMarshal(CORBA_SequenceDef_ptr p, CORBA_Octet*& oct)
{
    OBMarshal((CORBA_Object_ptr)p, oct);
}

inline void
OBMarshalCount(CORBA_SequenceDef_ptr p, CORBA_ULong& count)
{
    OBMarshalCount((CORBA_Object_ptr)p, count);
}

void OBUnmarshal(CORBA_SequenceDef_ptr&, const CORBA_Octet*&, bool);

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
//
inline void
CORBA_release(CORBA_ArrayDef_ptr p)
{
    if(p)
        p -> _OB_decRef();
}

inline CORBA_Boolean
CORBA_is_nil(CORBA_ArrayDef_ptr p)
{
    return p == 0;
}

inline void
OBMarshal(CORBA_ArrayDef_ptr p, CORBA_Octet*& oct)
{
    OBMarshal((CORBA_Object_ptr)p, oct);
}

inline void
OBMarshalCount(CORBA_ArrayDef_ptr p, CORBA_ULong& count)
{
    OBMarshalCount((CORBA_Object_ptr)p, count);
}

void OBUnmarshal(CORBA_ArrayDef_ptr&, const CORBA_Octet*&, bool);

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;
}

//
// IDL:omg.org/CORBA/ExceptionDef:1.0
//
inline void
CORBA_release(CORBA_ExceptionDef_ptr p)
{
    if(p)
        p -> _OB_decRef();
}

inline CORBA_Boolean
CORBA_is_nil(CORBA_ExceptionDef_ptr p)
{
    return p == 0;
}

inline void
OBMarshal(CORBA_ExceptionDef_ptr p, CORBA_Octet*& oct)
{
    OBMarshal((CORBA_Object_ptr)p, oct);
}

inline void
OBMarshalCount(CORBA_ExceptionDef_ptr p, CORBA_ULong& count)
{
    OBMarshalCount((CORBA_Object_ptr)p, count);
}

void OBUnmarshal(CORBA_ExceptionDef_ptr&, const CORBA_Octet*&, bool);

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 OBMarshal(const CORBA_ExceptionDescription&, CORBA_Octet*&);
void OBMarshalCount(const CORBA_ExceptionDescription&, CORBA_ULong&);
void OBUnmarshal(CORBA_ExceptionDescription&, const CORBA_Octet*&, bool);

void operator<<=(CORBA_Any&, CORBA_ExceptionDescription*);
void operator<<=(CORBA_Any&, const CORBA_ExceptionDescription&);
CORBA_Boolean operator>>=(const CORBA_Any&, 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, CORBA_ExceptionDescription*& val)
{
    return any.in() >>= val;
}

//
// IDL:omg.org/CORBA/AttributeMode:1.0
//
inline void
OBMarshal(CORBA_AttributeMode val, CORBA_Octet*& oct)
{
    OBMarshal((CORBA_ULong)val, oct);
}

inline void
OBMarshalCount(CORBA_AttributeMode, CORBA_ULong& count)
{
    OBMarshalCount((CORBA_ULong)0, count);
}

inline void
OBUnmarshal(CORBA_AttributeMode& val, const CORBA_Octet*& coct, bool swap)
{
    CORBA_ULong v;
    OBUnmarshal(v, coct, swap);
    val = (CORBA_AttributeMode)v;
}

void operator<<=(CORBA_Any&, CORBA_AttributeMode);
CORBA_Boolean operator>>=(const CORBA_Any&, CORBA_AttributeMode&);

//
// IDL:omg.org/CORBA/AttributeDef:1.0
//
inline void
CORBA_release(CORBA_AttributeDef_ptr p)
{
    if(p)
        p -> _OB_decRef();
}

inline CORBA_Boolean
CORBA_is_nil(CORBA_AttributeDef_ptr p)
{
    return p == 0;
}

inline void
OBMarshal(CORBA_AttributeDef_ptr p, CORBA_Octet*& oct)
{
    OBMarshal((CORBA_Object_ptr)p, oct);
}

inline void
OBMarshalCount(CORBA_AttributeDef_ptr p, CORBA_ULong& count)
{
    OBMarshalCount((CORBA_Object_ptr)p, count);
}

void OBUnmarshal(CORBA_AttributeDef_ptr&, const CORBA_Octet*&, bool);

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 OBMarshal(const CORBA_AttributeDescription&, CORBA_Octet*&);
void OBMarshalCount(const CORBA_AttributeDescription&, CORBA_ULong&);
void OBUnmarshal(CORBA_AttributeDescription&, const CORBA_Octet*&, bool);

void operator<<=(CORBA_Any&, CORBA_AttributeDescription*);
void operator<<=(CORBA_Any&, const CORBA_AttributeDescription&);
CORBA_Boolean operator>>=(const CORBA_Any&, 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, CORBA_AttributeDescription*& val)
{
    return any.in() >>= val;
}

//
// IDL:omg.org/CORBA/OperationMode:1.0
//
inline void
OBMarshal(CORBA_OperationMode val, CORBA_Octet*& oct)
{
    OBMarshal((CORBA_ULong)val, oct);
}

inline void
OBMarshalCount(CORBA_OperationMode, CORBA_ULong& count)
{
    OBMarshalCount((CORBA_ULong)0, count);
}

inline void
OBUnmarshal(CORBA_OperationMode& val, const CORBA_Octet*& coct, bool swap)
{
    CORBA_ULong v;
    OBUnmarshal(v, coct, swap);
    val = (CORBA_OperationMode)v;
}

void operator<<=(CORBA_Any&, CORBA_OperationMode);
CORBA_Boolean operator>>=(const CORBA_Any&, CORBA_OperationMode&);

//
// IDL:omg.org/CORBA/ParameterMode:1.0
//
inline void
OBMarshal(CORBA_ParameterMode val, CORBA_Octet*& oct)
{
    OBMarshal((CORBA_ULong)val, oct);
}

inline void
OBMarshalCount(CORBA_ParameterMode, CORBA_ULong& count)
{
    OBMarshalCount((CORBA_ULong)0, count);
}

inline void
OBUnmarshal(CORBA_ParameterMode& val, const CORBA_Octet*& coct, bool swap)
{
    CORBA_ULong v;
    OBUnmarshal(v, coct, swap);
    val = (CORBA_ParameterMode)v;
}

void operator<<=(CORBA_Any&, CORBA_ParameterMode);
CORBA_Boolean operator>>=(const CORBA_Any&, CORBA_ParameterMode&);

//
// IDL:omg.org/CORBA/ParameterDescription:1.0
//
void OBMarshal(const CORBA_ParameterDescription&, CORBA_Octet*&);
void OBMarshalCount(const CORBA_ParameterDescription&, CORBA_ULong&);
void OBUnmarshal(CORBA_ParameterDescription&, const CORBA_Octet*&, bool);

void operator<<=(CORBA_Any&, CORBA_ParameterDescription*);
void operator<<=(CORBA_Any&, const CORBA_ParameterDescription&);
CORBA_Boolean operator>>=(const CORBA_Any&, 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, CORBA_ParameterDescription*& val)
{
    return any.in() >>= val;
}

//
// IDL:omg.org/CORBA/OperationDef:1.0
//
inline void
CORBA_release(CORBA_OperationDef_ptr p)
{
    if(p)
        p -> _OB_decRef();
}

inline CORBA_Boolean
CORBA_is_nil(CORBA_OperationDef_ptr p)
{
    return p == 0;
}

inline void
OBMarshal(CORBA_OperationDef_ptr p, CORBA_Octet*& oct)
{
    OBMarshal((CORBA_Object_ptr)p, oct);
}

inline void
OBMarshalCount(CORBA_OperationDef_ptr p, CORBA_ULong& count)
{
    OBMarshalCount((CORBA_Object_ptr)p, count);
}

void OBUnmarshal(CORBA_OperationDef_ptr&, const CORBA_Octet*&, bool);

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 OBMarshal(const CORBA_OperationDescription&, CORBA_Octet*&);
void OBMarshalCount(const CORBA_OperationDescription&, CORBA_ULong&);
void OBUnmarshal(CORBA_OperationDescription&, const CORBA_Octet*&, bool);

void operator<<=(CORBA_Any&, CORBA_OperationDescription*);
void operator<<=(CORBA_Any&, const CORBA_OperationDescription&);
CORBA_Boolean operator>>=(const CORBA_Any&, 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, CORBA_OperationDescription*& val)
{
    return any.in() >>= val;
}

//
// IDL:omg.org/CORBA/InterfaceDef:1.0
//
inline void
CORBA_release(CORBA_InterfaceDef_ptr p)
{
    if(p)
        p -> _OB_decRef();
}

inline CORBA_Boolean
CORBA_is_nil(CORBA_InterfaceDef_ptr p)
{
    return p == 0;
}

inline void
OBMarshal(CORBA_InterfaceDef_ptr p, CORBA_Octet*& oct)
{
    OBMarshal((CORBA_Object_ptr)p, oct);
}

inline void
OBMarshalCount(CORBA_InterfaceDef_ptr p, CORBA_ULong& count)
{
    OBMarshalCount((CORBA_Object_ptr)p, count);
}

void OBUnmarshal(CORBA_InterfaceDef_ptr&, const CORBA_Octet*&, bool);

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 OBMarshal(const CORBA_InterfaceDef::FullInterfaceDescription&, CORBA_Octet*&);
void OBMarshalCount(const CORBA_InterfaceDef::FullInterfaceDescription&, CORBA_ULong&);
void OBUnmarshal(CORBA_InterfaceDef::FullInterfaceDescription&, const CORBA_Octet*&, bool);

void operator<<=(CORBA_Any&, CORBA_InterfaceDef::FullInterfaceDescription*);
void operator<<=(CORBA_Any&, const CORBA_InterfaceDef::FullInterfaceDescription&);
CORBA_Boolean operator>>=(const CORBA_Any&, 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, CORBA_InterfaceDef::FullInterfaceDescription*& val)
{
    return any.in() >>= val;
}

//
// IDL:omg.org/CORBA/InterfaceDescription:1.0
//
void OBMarshal(const CORBA_InterfaceDescription&, CORBA_Octet*&);
void OBMarshalCount(const CORBA_InterfaceDescription&, CORBA_ULong&);
void OBUnmarshal(CORBA_InterfaceDescription&, const CORBA_Octet*&, bool);

void operator<<=(CORBA_Any&, CORBA_InterfaceDescription*);
void operator<<=(CORBA_Any&, const CORBA_InterfaceDescription&);
CORBA_Boolean operator>>=(const CORBA_Any&, 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, CORBA_InterfaceDescription*& val)
{
    return any.in() >>= val;
}

//
// OBObjSeq< CORBA_InterfaceDef >
//
#ifndef OB_use_OBObjSeq_CORBA__InterfaceDef
#define OB_use_OBObjSeq_CORBA__InterfaceDef
#define OB_use_OBObjSeq_CORBA__InterfaceDef_from_IntRep_h

void OBMarshal(const OBObjSeq< CORBA_InterfaceDef >&, CORBA_Octet*&);
void OBMarshalCount(const OBObjSeq< CORBA_InterfaceDef >&, CORBA_ULong&);
void OBUnmarshal(OBObjSeq< CORBA_InterfaceDef >&, const CORBA_Octet*&, bool);

void operator<<=(CORBA_Any&, OBObjSeq< CORBA_InterfaceDef >*);
void operator<<=(CORBA_Any&, const OBObjSeq< CORBA_InterfaceDef >&);
CORBA_Boolean operator>>=(const CORBA_Any&, OBObjSeq< CORBA_InterfaceDef >*&);

inline void
operator<<=(CORBA_Any_var& any, OBObjSeq< CORBA_InterfaceDef >* val)
{
    any.inout() <<= val;
}

inline void
operator<<=(CORBA_Any_var& any, const OBObjSeq< CORBA_InterfaceDef >& val)
{
    any.inout() <<= val;
}

inline CORBA_Boolean
operator>>=(const CORBA_Any_var& any, OBObjSeq< CORBA_InterfaceDef >*& val)
{
    return any.in() >>= val;
}

#endif

//
// OBObjSeq< CORBA_Contained >
//
#ifndef OB_use_OBObjSeq_CORBA__Contained
#define OB_use_OBObjSeq_CORBA__Contained
#define OB_use_OBObjSeq_CORBA__Contained_from_IntRep_h

void OBMarshal(const OBObjSeq< CORBA_Contained >&, CORBA_Octet*&);
void OBMarshalCount(const OBObjSeq< CORBA_Contained >&, CORBA_ULong&);
void OBUnmarshal(OBObjSeq< CORBA_Contained >&, const CORBA_Octet*&, bool);

void operator<<=(CORBA_Any&, OBObjSeq< CORBA_Contained >*);
void operator<<=(CORBA_Any&, const OBObjSeq< CORBA_Contained >&);
CORBA_Boolean operator>>=(const CORBA_Any&, OBObjSeq< CORBA_Contained >*&);

inline void
operator<<=(CORBA_Any_var& any, OBObjSeq< CORBA_Contained >* val)
{
    any.inout() <<= val;
}

inline void
operator<<=(CORBA_Any_var& any, const OBObjSeq< CORBA_Contained >& val)
{
    any.inout() <<= val;
}

inline CORBA_Boolean
operator>>=(const CORBA_Any_var& any, OBObjSeq< CORBA_Contained >*& val)
{
    return any.in() >>= val;
}

#endif

//
// OBVarSeq< CORBA_Container::Description >
//
#ifndef OB_use_OBVarSeq_CORBA__Container_Description
#define OB_use_OBVarSeq_CORBA__Container_Description
#define OB_use_OBVarSeq_CORBA__Container_Description_from_IntRep_h

void OBMarshal(const OBVarSeq< CORBA_Container::Description >&, CORBA_Octet*&);
void OBMarshalCount(const OBVarSeq< CORBA_Container::Description >&, CORBA_ULong&);
void OBUnmarshal(OBVarSeq< CORBA_Container::Description >&, const CORBA_Octet*&, bool);

void operator<<=(CORBA_Any&, OBVarSeq< CORBA_Container::Description >*);
void operator<<=(CORBA_Any&, const OBVarSeq< CORBA_Container::Description >&);
CORBA_Boolean operator>>=(const CORBA_Any&, OBVarSeq< CORBA_Container::Description >*&);

inline void
operator<<=(CORBA_Any_var& any, OBVarSeq< CORBA_Container::Description >* val)
{
    any.inout() <<= val;
}

inline void
operator<<=(CORBA_Any_var& any, const OBVarSeq< CORBA_Container::Description >& val)
{
    any.inout() <<= val;
}

inline CORBA_Boolean
operator>>=(const CORBA_Any_var& any, OBVarSeq< CORBA_Container::Description >*& val)
{
    return any.in() >>= val;
}

#endif

//
// OBVarSeq< CORBA_StructMember >
//
#ifndef OB_use_OBVarSeq_CORBA__StructMember
#define OB_use_OBVarSeq_CORBA__StructMember
#define OB_use_OBVarSeq_CORBA__StructMember_from_IntRep_h

void OBMarshal(const OBVarSeq< CORBA_StructMember >&, CORBA_Octet*&);
void OBMarshalCount(const OBVarSeq< CORBA_StructMember >&, CORBA_ULong&);
void OBUnmarshal(OBVarSeq< CORBA_StructMember >&, const CORBA_Octet*&, bool);

void operator<<=(CORBA_Any&, OBVarSeq< CORBA_StructMember >*);
void operator<<=(CORBA_Any&, const OBVarSeq< CORBA_StructMember >&);
CORBA_Boolean operator>>=(const CORBA_Any&, OBVarSeq< CORBA_StructMember >*&);

inline void
operator<<=(CORBA_Any_var& any, OBVarSeq< CORBA_StructMember >* val)
{
    any.inout() <<= val;
}

inline void
operator<<=(CORBA_Any_var& any, const OBVarSeq< CORBA_StructMember >& val)
{
    any.inout() <<= val;
}

inline CORBA_Boolean
operator>>=(const CORBA_Any_var& any, OBVarSeq< CORBA_StructMember >*& val)
{
    return any.in() >>= val;
}

#endif

//
// OBVarSeq< CORBA_UnionMember >
//
#ifndef OB_use_OBVarSeq_CORBA__UnionMember
#define OB_use_OBVarSeq_CORBA__UnionMember
#define OB_use_OBVarSeq_CORBA__UnionMember_from_IntRep_h

void OBMarshal(const OBVarSeq< CORBA_UnionMember >&, CORBA_Octet*&);
void OBMarshalCount(const OBVarSeq< CORBA_UnionMember >&, CORBA_ULong&);
void OBUnmarshal(OBVarSeq< CORBA_UnionMember >&, const CORBA_Octet*&, bool);

void operator<<=(CORBA_Any&, OBVarSeq< CORBA_UnionMember >*);
void operator<<=(CORBA_Any&, const OBVarSeq< CORBA_UnionMember >&);
CORBA_Boolean operator>>=(const CORBA_Any&, OBVarSeq< CORBA_UnionMember >*&);

inline void
operator<<=(CORBA_Any_var& any, OBVarSeq< CORBA_UnionMember >* val)
{
    any.inout() <<= val;
}

inline void
operator<<=(CORBA_Any_var& any, const OBVarSeq< CORBA_UnionMember >& val)
{
    any.inout() <<= val;
}

inline CORBA_Boolean
operator>>=(const CORBA_Any_var& any, OBVarSeq< CORBA_UnionMember >*& val)
{
    return any.in() >>= val;
}

#endif

//
// OBStrSeq
//
#ifndef OB_use_OBStrSeq
#define OB_use_OBStrSeq
#define OB_use_OBStrSeq_from_IntRep_h

void operator<<=(CORBA_Any&, OBStrSeq*);
void operator<<=(CORBA_Any&, const OBStrSeq&);
CORBA_Boolean operator>>=(const CORBA_Any&, OBStrSeq*&);

inline void
operator<<=(CORBA_Any_var& any, OBStrSeq* val)
{
    any.inout() <<= val;
}

inline void
operator<<=(CORBA_Any_var& any, const OBStrSeq& val)
{
    any.inout() <<= val;
}

inline CORBA_Boolean
operator>>=(const CORBA_Any_var& any, OBStrSeq*& val)
{
    return any.in() >>= val;
}

#endif

//
// OBVarSeq< CORBA_ParameterDescription >
//
#ifndef OB_use_OBVarSeq_CORBA__ParameterDescription
#define OB_use_OBVarSeq_CORBA__ParameterDescription
#define OB_use_OBVarSeq_CORBA__ParameterDescription_from_IntRep_h

void OBMarshal(const OBVarSeq< CORBA_ParameterDescription >&, CORBA_Octet*&);
void OBMarshalCount(const OBVarSeq< CORBA_ParameterDescription >&, CORBA_ULong&);
void OBUnmarshal(OBVarSeq< CORBA_ParameterDescription >&, const CORBA_Octet*&, bool);

void operator<<=(CORBA_Any&, OBVarSeq< CORBA_ParameterDescription >*);
void operator<<=(CORBA_Any&, const OBVarSeq< CORBA_ParameterDescription >&);
CORBA_Boolean operator>>=(const CORBA_Any&, OBVarSeq< CORBA_ParameterDescription >*&);

inline void
operator<<=(CORBA_Any_var& any, OBVarSeq< CORBA_ParameterDescription >* val)
{
    any.inout() <<= val;
}

inline void
operator<<=(CORBA_Any_var& any, const OBVarSeq< CORBA_ParameterDescription >& val)
{
    any.inout() <<= val;
}

inline CORBA_Boolean
operator>>=(const CORBA_Any_var& any, OBVarSeq< CORBA_ParameterDescription >*& val)
{
    return any.in() >>= val;
}

#endif

//
// OBObjSeq< CORBA_ExceptionDef >
//
#ifndef OB_use_OBObjSeq_CORBA__ExceptionDef
#define OB_use_OBObjSeq_CORBA__ExceptionDef
#define OB_use_OBObjSeq_CORBA__ExceptionDef_from_IntRep_h

void OBMarshal(const OBObjSeq< CORBA_ExceptionDef >&, CORBA_Octet*&);
void OBMarshalCount(const OBObjSeq< CORBA_ExceptionDef >&, CORBA_ULong&);
void OBUnmarshal(OBObjSeq< CORBA_ExceptionDef >&, const CORBA_Octet*&, bool);

void operator<<=(CORBA_Any&, OBObjSeq< CORBA_ExceptionDef >*);
void operator<<=(CORBA_Any&, const OBObjSeq< CORBA_ExceptionDef >&);
CORBA_Boolean operator>>=(const CORBA_Any&, OBObjSeq< CORBA_ExceptionDef >*&);

inline void
operator<<=(CORBA_Any_var& any, OBObjSeq< CORBA_ExceptionDef >* val)
{
    any.inout() <<= val;
}

inline void
operator<<=(CORBA_Any_var& any, const OBObjSeq< CORBA_ExceptionDef >& val)
{
    any.inout() <<= val;
}

inline CORBA_Boolean
operator>>=(const CORBA_Any_var& any, OBObjSeq< CORBA_ExceptionDef >*& val)
{
    return any.in() >>= val;
}

#endif

//
// OBVarSeq< CORBA_ExceptionDescription >
//
#ifndef OB_use_OBVarSeq_CORBA__ExceptionDescription
#define OB_use_OBVarSeq_CORBA__ExceptionDescription
#define OB_use_OBVarSeq_CORBA__ExceptionDescription_from_IntRep_h

void OBMarshal(const OBVarSeq< CORBA_ExceptionDescription >&, CORBA_Octet*&);
void OBMarshalCount(const OBVarSeq< CORBA_ExceptionDescription >&, CORBA_ULong&);
void OBUnmarshal(OBVarSeq< CORBA_ExceptionDescription >&, const CORBA_Octet*&, bool);

void operator<<=(CORBA_Any&, OBVarSeq< CORBA_ExceptionDescription >*);
void operator<<=(CORBA_Any&, const OBVarSeq< CORBA_ExceptionDescription >&);
CORBA_Boolean operator>>=(const CORBA_Any&, OBVarSeq< CORBA_ExceptionDescription >*&);

inline void
operator<<=(CORBA_Any_var& any, OBVarSeq< CORBA_ExceptionDescription >* val)
{
    any.inout() <<= val;
}

inline void
operator<<=(CORBA_Any_var& any, const OBVarSeq< CORBA_ExceptionDescription >& val)
{
    any.inout() <<= val;
}

inline CORBA_Boolean
operator>>=(const CORBA_Any_var& any, OBVarSeq< CORBA_ExceptionDescription >*& val)
{
    return any.in() >>= val;
}

#endif

//
// OBVarSeq< CORBA_OperationDescription >
//
#ifndef OB_use_OBVarSeq_CORBA__OperationDescription
#define OB_use_OBVarSeq_CORBA__OperationDescription
#define OB_use_OBVarSeq_CORBA__OperationDescription_from_IntRep_h

void OBMarshal(const OBVarSeq< CORBA_OperationDescription >&, CORBA_Octet*&);
void OBMarshalCount(const OBVarSeq< CORBA_OperationDescription >&, CORBA_ULong&);
void OBUnmarshal(OBVarSeq< CORBA_OperationDescription >&, const CORBA_Octet*&, bool);

void operator<<=(CORBA_Any&, OBVarSeq< CORBA_OperationDescription >*);
void operator<<=(CORBA_Any&, const OBVarSeq< CORBA_OperationDescription >&);
CORBA_Boolean operator>>=(const CORBA_Any&, OBVarSeq< CORBA_OperationDescription >*&);

inline void
operator<<=(CORBA_Any_var& any, OBVarSeq< CORBA_OperationDescription >* val)
{
    any.inout() <<= val;
}

inline void
operator<<=(CORBA_Any_var& any, const OBVarSeq< CORBA_OperationDescription >& val)
{
    any.inout() <<= val;
}

inline CORBA_Boolean
operator>>=(const CORBA_Any_var& any, OBVarSeq< CORBA_OperationDescription >*& val)
{
    return any.in() >>= val;
}

#endif

//
// OBVarSeq< CORBA_AttributeDescription >
//
#ifndef OB_use_OBVarSeq_CORBA__AttributeDescription
#define OB_use_OBVarSeq_CORBA__AttributeDescription
#define OB_use_OBVarSeq_CORBA__AttributeDescription_from_IntRep_h

void OBMarshal(const OBVarSeq< CORBA_AttributeDescription >&, CORBA_Octet*&);
void OBMarshalCount(const OBVarSeq< CORBA_AttributeDescription >&, CORBA_ULong&);
void OBUnmarshal(OBVarSeq< CORBA_AttributeDescription >&, const CORBA_Octet*&, bool);

void operator<<=(CORBA_Any&, OBVarSeq< CORBA_AttributeDescription >*);
void operator<<=(CORBA_Any&, const OBVarSeq< CORBA_AttributeDescription >&);
CORBA_Boolean operator>>=(const CORBA_Any&, OBVarSeq< CORBA_AttributeDescription >*&);

inline void
operator<<=(CORBA_Any_var& any, OBVarSeq< CORBA_AttributeDescription >* val)
{
    any.inout() <<= val;
}

inline void
operator<<=(CORBA_Any_var& any, const OBVarSeq< CORBA_AttributeDescription >& val)
{
    any.inout() <<= val;
}

inline CORBA_Boolean
operator>>=(const CORBA_Any_var& any, OBVarSeq< CORBA_AttributeDescription >*& val)
{
    return any.in() >>= val;
}

#endif

#endif
