// **********************************************************************
//
// 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_IFR1_h__
#define __OB_IFR1_h__

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


#include <OB/TypeCode.h>
#include <OB/Types.h>
#include <OB/IFR1_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 IRObject;
typedef IRObject* IRObject_ptr;

class IDLType;
typedef IDLType* IDLType_ptr;

} // End of namespace OBStubImpl_CORBA

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

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

namespace OBStubImpl_CORBA
{

typedef OB::ObjVar< IRObject > IRObject_var;

typedef OB::ObjVar< IDLType > IDLType_var;

} // End of namespace OBStubImpl_CORBA

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

//
// IDL:omg.org/CORBA/DefinitionKind:1.0
//
enum DefinitionKind
{
    dk_none,
    dk_all,
    dk_Attribute,
    dk_Constant,
    dk_Exception,
    dk_Interface,
    dk_Module,
    dk_Operation,
    dk_Typedef,
    dk_Alias,
    dk_Struct,
    dk_Union,
    dk_Enum,
    dk_Primitive,
    dk_String,
    dk_Sequence,
    dk_Array,
    dk_Repository,
    dk_Wstring,
    dk_Fixed,
    dk_Value,
    dk_ValueBox,
    dk_ValueMember,
    dk_Native,
    dk_AbstractInterface,
    dk_LocalInterface
};

typedef DefinitionKind& DefinitionKind_out;

OB_IMPORT extern OB::TypeCodeConst _tc_DefinitionKind;

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

protected:

    static OB_IMPORT const char* ids_[];

public:

    IRObject() { }
    virtual ~IRObject() { }

    typedef IRObject_ptr _ptr_type;
    typedef IRObject_var _var_type;

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

    static inline IRObject_ptr
    _nil()
    {
        return 0;
    }

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

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

    static const char** _OB_staticIds();

    //
    // IDL:omg.org/CORBA/IRObject/def_kind:1.0
    //
    virtual DefinitionKind def_kind() = 0;

    //
    // IDL:omg.org/CORBA/IRObject/destroy:1.0
    //
    virtual void destroy() = 0;
};

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

protected:

    static OB_IMPORT const char* ids_[];

public:

    IDLType() { }
    virtual ~IDLType() { }

    typedef IDLType_ptr _ptr_type;
    typedef IDLType_var _var_type;

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

    static inline IDLType_ptr
    _nil()
    {
        return 0;
    }

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

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

    static const char** _OB_staticIds();

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

//
// IDL:omg.org/CORBA/StructMember:1.0
//
struct StructMember;
typedef OB::VarVar< StructMember > StructMember_var;
typedef OB::VarOut< StructMember > StructMember_out;

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

    typedef StructMember_var _var_type;

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

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

OB_IMPORT extern OB::TypeCodeConst _tc_StructMember;

//
// IDL:omg.org/CORBA/StructMemberSeq:1.0
//
class OBUnique_StructMemberSeq { };

typedef OB::VarSeq< StructMember, OBUnique_StructMemberSeq > StructMemberSeq;
typedef OB::SeqVar< OB::VarSeq< StructMember, OBUnique_StructMemberSeq > > StructMemberSeq_var;
typedef OB::SeqOut< OB::VarSeq< StructMember, OBUnique_StructMemberSeq > > StructMemberSeq_out;
OB_IMPORT extern OB::TypeCodeConst _tc_StructMemberSeq;

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

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

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

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

//
// IDL:omg.org/CORBA/Initializer:1.0
//
struct Initializer;
typedef OB::VarVar< Initializer > Initializer_var;
typedef OB::VarOut< Initializer > Initializer_out;

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

    typedef Initializer_var _var_type;

    StructMemberSeq members;
    OB::StrForStruct name;

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

OB_IMPORT extern OB::TypeCodeConst _tc_Initializer;

//
// IDL:omg.org/CORBA/InitializerSeq:1.0
//
class OBUnique_InitializerSeq { };

typedef OB::VarSeq< Initializer, OBUnique_InitializerSeq > InitializerSeq;
typedef OB::SeqVar< OB::VarSeq< Initializer, OBUnique_InitializerSeq > > InitializerSeq_var;
typedef OB::SeqOut< OB::VarSeq< Initializer, OBUnique_InitializerSeq > > InitializerSeq_out;
OB_IMPORT extern OB::TypeCodeConst _tc_InitializerSeq;

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

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

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

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

//
// IDL:omg.org/CORBA/UnionMember:1.0
//
struct UnionMember;
typedef OB::VarVar< UnionMember > UnionMember_var;
typedef OB::VarOut< UnionMember > UnionMember_out;

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

    typedef UnionMember_var _var_type;

    OB::StrForStruct name;
    ::CORBA::Any label;
    ::CORBA::TypeCode_var type;
    IDLType_var type_def;

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

OB_IMPORT extern OB::TypeCodeConst _tc_UnionMember;

//
// IDL:omg.org/CORBA/UnionMemberSeq:1.0
//
class OBUnique_UnionMemberSeq { };

typedef OB::VarSeq< UnionMember, OBUnique_UnionMemberSeq > UnionMemberSeq;
typedef OB::SeqVar< OB::VarSeq< UnionMember, OBUnique_UnionMemberSeq > > UnionMemberSeq_var;
typedef OB::SeqOut< OB::VarSeq< UnionMember, OBUnique_UnionMemberSeq > > UnionMemberSeq_out;
OB_IMPORT extern OB::TypeCodeConst _tc_UnionMemberSeq;

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

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

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

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

//
// IDL:omg.org/CORBA/EnumMemberSeq:1.0
//
class OBUnique_EnumMemberSeq { };

typedef OB::StrSeq< OBUnique_EnumMemberSeq > EnumMemberSeq;
typedef OB::SeqVar< OB::StrSeq< OBUnique_EnumMemberSeq > > EnumMemberSeq_var;
typedef OB::SeqOut< OB::StrSeq< OBUnique_EnumMemberSeq > > EnumMemberSeq_out;
OB_IMPORT extern OB::TypeCodeConst _tc_EnumMemberSeq;

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

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

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

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

//
// IDL:omg.org/CORBA/ValueModifier:1.0
//
typedef ::CORBA::Short ValueModifier;
typedef ::CORBA::Short_out ValueModifier_out;
OB_IMPORT extern OB::TypeCodeConst _tc_ValueModifier;

//
// IDL:omg.org/CORBA/VM_NONE:1.0
//
const ValueModifier VM_NONE = 0;

//
// IDL:omg.org/CORBA/VM_CUSTOM:1.0
//
const ValueModifier VM_CUSTOM = 1;

//
// IDL:omg.org/CORBA/VM_ABSTRACT:1.0
//
const ValueModifier VM_ABSTRACT = 2;

//
// IDL:omg.org/CORBA/VM_TRUNCATABLE:1.0
//
const ValueModifier VM_TRUNCATABLE = 3;

//
// IDL:omg.org/CORBA/Visibility:1.0
//
typedef ::CORBA::Short Visibility;
typedef ::CORBA::Short_out Visibility_out;
OB_IMPORT extern OB::TypeCodeConst _tc_Visibility;

//
// IDL:omg.org/CORBA/PRIVATE_MEMBER:1.0
//
const Visibility PRIVATE_MEMBER = 0;

//
// IDL:omg.org/CORBA/PUBLIC_MEMBER:1.0
//
const Visibility PUBLIC_MEMBER = 1;

//
// IDL:omg.org/CORBA/ValueMember:1.0
//
struct ValueMember;
typedef OB::VarVar< ValueMember > ValueMember_var;
typedef OB::VarOut< ValueMember > ValueMember_out;

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

    typedef ValueMember_var _var_type;

    OB::StrForStruct name;
    OB::StrForStruct id;
    OB::StrForStruct defined_in;
    OB::StrForStruct version;
    ::CORBA::TypeCode_var type;
    IDLType_var type_def;
    Visibility access;

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

OB_IMPORT extern OB::TypeCodeConst _tc_ValueMember;

//
// IDL:omg.org/CORBA/ValueMemberSeq:1.0
//
class OBUnique_ValueMemberSeq { };

typedef OB::VarSeq< ValueMember, OBUnique_ValueMemberSeq > ValueMemberSeq;
typedef OB::SeqVar< OB::VarSeq< ValueMember, OBUnique_ValueMemberSeq > > ValueMemberSeq_var;
typedef OB::SeqOut< OB::VarSeq< ValueMember, OBUnique_ValueMemberSeq > > ValueMemberSeq_out;
OB_IMPORT extern OB::TypeCodeConst _tc_ValueMemberSeq;

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

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

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

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

} // End of namespace CORBA

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

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

protected:

    virtual OB::MarshalStubImpl_ptr _OB_createMarshalStubImpl();

public:

    IRObject() { }
    virtual ~IRObject() { }

    virtual const char** _OB_ids() const;

    //
    // IDL:omg.org/CORBA/IRObject/def_kind:1.0
    //
    ::CORBA::DefinitionKind def_kind();

    //
    // IDL:omg.org/CORBA/IRObject/destroy:1.0
    //
    void destroy();
};

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

protected:

    virtual OB::MarshalStubImpl_ptr _OB_createMarshalStubImpl();

public:

    IDLType() { }
    virtual ~IDLType() { }

    virtual const char** _OB_ids() const;

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

} // End of namespace OBProxy_CORBA

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

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

protected:

    IRObject() { }

public:

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

    static inline IRObject_ptr
    _nil()
    {
        return 0;
    }

    //
    // IDL:omg.org/CORBA/IRObject/def_kind:1.0
    //
    virtual ::CORBA::DefinitionKind def_kind() = 0;

    //
    // IDL:omg.org/CORBA/IRObject/destroy:1.0
    //
    virtual void destroy() = 0;
};

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

protected:

    IDLType() { }

public:

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

    static inline IDLType_ptr
    _nil()
    {
        return 0;
    }

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

} // End of namespace OBStubImpl_CORBA

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

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

protected:

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

public:

    //
    // IDL:omg.org/CORBA/IRObject/def_kind:1.0
    //
    virtual ::CORBA::DefinitionKind def_kind();

    //
    // IDL:omg.org/CORBA/IRObject/destroy:1.0
    //
    virtual void destroy();
};

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

protected:

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

public:

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

} // End of namespace OBMarshalStubImpl_CORBA

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

} // End of namespace OBV_CORBA

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

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

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

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

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

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

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

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

} // End of namespace CORBA

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

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

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

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

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

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

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

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

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

} // End of namespace CORBA

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#endif
