// **********************************************************************
//
// 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 __IntRepMember_h__
#define __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/RepositoryId:1.0
//
typedef char* CORBA_RepositoryId;
typedef CORBA_String_var CORBA_RepositoryId_var;
OB_IMPORT extern OBTypeCodeConst CORBA__tc_RepositoryId;

//
// IDL:omg.org/CORBA/ScopedName:1.0
//
typedef char* CORBA_ScopedName;
typedef CORBA_String_var CORBA_ScopedName_var;
OB_IMPORT extern OBTypeCodeConst CORBA__tc_ScopedName;

//
// IDL:omg.org/CORBA/Identifier:1.0
//
typedef char* CORBA_Identifier;
typedef CORBA_String_var CORBA_Identifier_var;
OB_IMPORT extern OBTypeCodeConst CORBA__tc_Identifier;

//
// IDL:omg.org/CORBA/DefinitionKind:1.0
//
enum CORBA_DefinitionKind
{
    CORBA_dk_none,
    CORBA_dk_all,
    CORBA_dk_Attribute,
    CORBA_dk_Constant,
    CORBA_dk_Exception,
    CORBA_dk_Interface,
    CORBA_dk_Module,
    CORBA_dk_Operation,
    CORBA_dk_Typedef,
    CORBA_dk_Alias,
    CORBA_dk_Struct,
    CORBA_dk_Union,
    CORBA_dk_Enum,
    CORBA_dk_Primitive,
    CORBA_dk_String,
    CORBA_dk_Sequence,
    CORBA_dk_Array,
    CORBA_dk_Repository
};

OB_IMPORT extern OBTypeCodeConst CORBA__tc_DefinitionKind;

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

protected:

    CORBA_IRObject() { }

public:

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

    static inline CORBA_IRObject_ptr
    _nil()
    {
        return 0;
    }

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

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

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

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

OB_IMPORT extern OBTypeCodeConst CORBA__tc_IRObject;

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

protected:

    CORBA_IDLType() { }

public:

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

    static inline CORBA_IDLType_ptr
    _nil()
    {
        return 0;
    }

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

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

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

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

OB_IMPORT extern OBTypeCodeConst CORBA__tc_IDLType;

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

    CORBA_Identifier_var name;
    CORBA_TypeCode_var type;
    CORBA_IDLType_var type_def;
};

typedef OBVarVar< CORBA_StructMember > CORBA_StructMember_var;

OB_IMPORT extern OBTypeCodeConst CORBA__tc_StructMember;

//
// IDL:omg.org/CORBA/StructMemberSeq:1.0
//
typedef OBVarSeq< CORBA_StructMember > CORBA_StructMemberSeq;
typedef OBSeqVar< OBVarSeq< CORBA_StructMember > > CORBA_StructMemberSeq_var;
OB_IMPORT extern OBTypeCodeConst CORBA__tc_StructMemberSeq;

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

    CORBA_Identifier_var name;
    CORBA_Any label;
    CORBA_TypeCode_var type;
    CORBA_IDLType_var type_def;
};

typedef OBVarVar< CORBA_UnionMember > CORBA_UnionMember_var;

OB_IMPORT extern OBTypeCodeConst CORBA__tc_UnionMember;

//
// IDL:omg.org/CORBA/UnionMemberSeq:1.0
//
typedef OBVarSeq< CORBA_UnionMember > CORBA_UnionMemberSeq;
typedef OBSeqVar< OBVarSeq< CORBA_UnionMember > > CORBA_UnionMemberSeq_var;
OB_IMPORT extern OBTypeCodeConst CORBA__tc_UnionMemberSeq;

//
// IDL:omg.org/CORBA/EnumMemberSeq:1.0
//
typedef OBStrSeq CORBA_EnumMemberSeq;
typedef OBSeqVar< OBStrSeq > CORBA_EnumMemberSeq_var;
OB_IMPORT extern OBTypeCodeConst CORBA__tc_EnumMemberSeq;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

//
// OBVarSeq< CORBA_StructMember >
//
#ifndef OB_use_OBVarSeq_CORBA__StructMember
#define OB_use_OBVarSeq_CORBA__StructMember
#define OB_use_OBVarSeq_CORBA__StructMember_from_IntRepMember_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_IntRepMember_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_IntRepMember_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

#endif
