#ifndef __corbaidl_hh__
#define __corbaidl_hh__

#ifndef USE_omniORB_logStream
#define USE_omniORB_logStream
#endif

#ifndef __CORBA_H_EXTERNAL_GUARD__
#define __CORBA_H_EXTERNAL_GUARD__
#include <omniORB2/CORBA.h>
#endif

#ifdef _LC_attr
# error "A local CPP macro _LC_attr has already been defined."
#else
# ifdef  USE_stub_in_nt_dll
#  define _LC_attr _OMNIORB_NTDLL_IMPORT
# else
#  define _LC_attr
# endif
#endif


_CORBA_MODULE CORBA

_CORBA_MODULE_BEG

#ifndef __CORBA_mIDLType__
#define __CORBA_mIDLType__
  class   IDLType;
  typedef IDLType* IDLType_ptr;
  typedef IDLType_ptr IDLTypeRef;
  class _proxy_IDLType;
  class _sk_IDLType;
  class _nil_IDLType;

  class IDLType_Helper {
    public:
    static IDLType_ptr _nil();
    static CORBA::Boolean is_nil(IDLType_ptr p);
    static void release(IDLType_ptr p);
    static void duplicate(IDLType_ptr p);
    static size_t NP_alignedSize(IDLType_ptr obj,size_t initialoffset);
    static void marshalObjRef(IDLType_ptr obj,NetBufferedStream &s);
    static IDLType_ptr unmarshalObjRef(NetBufferedStream &s);
    static void marshalObjRef(IDLType_ptr obj,MemBufferedStream &s);
    static IDLType_ptr unmarshalObjRef(MemBufferedStream &s);
  };
  typedef _CORBA_ObjRef_Var<IDLType,IDLType_Helper> IDLType_var;

#endif
#ifndef __CORBA_mImplementationDef__
#define __CORBA_mImplementationDef__
  class   ImplementationDef;
  typedef ImplementationDef* ImplementationDef_ptr;
  typedef ImplementationDef_ptr ImplementationDefRef;
  class _proxy_ImplementationDef;
  class _sk_ImplementationDef;
  class _nil_ImplementationDef;

  class ImplementationDef_Helper {
    public:
    static ImplementationDef_ptr _nil();
    static CORBA::Boolean is_nil(ImplementationDef_ptr p);
    static void release(ImplementationDef_ptr p);
    static void duplicate(ImplementationDef_ptr p);
    static size_t NP_alignedSize(ImplementationDef_ptr obj,size_t initialoffset);
    static void marshalObjRef(ImplementationDef_ptr obj,NetBufferedStream &s);
    static ImplementationDef_ptr unmarshalObjRef(NetBufferedStream &s);
    static void marshalObjRef(ImplementationDef_ptr obj,MemBufferedStream &s);
    static ImplementationDef_ptr unmarshalObjRef(MemBufferedStream &s);
  };
  typedef _CORBA_ObjRef_Var<ImplementationDef,ImplementationDef_Helper> ImplementationDef_var;

#endif
#ifndef __CORBA_mInterfaceDef__
#define __CORBA_mInterfaceDef__
  class   InterfaceDef;
  typedef InterfaceDef* InterfaceDef_ptr;
  typedef InterfaceDef_ptr InterfaceDefRef;
  class _proxy_InterfaceDef;
  class _sk_InterfaceDef;
  class _nil_InterfaceDef;

  class InterfaceDef_Helper {
    public:
    static InterfaceDef_ptr _nil();
    static CORBA::Boolean is_nil(InterfaceDef_ptr p);
    static void release(InterfaceDef_ptr p);
    static void duplicate(InterfaceDef_ptr p);
    static size_t NP_alignedSize(InterfaceDef_ptr obj,size_t initialoffset);
    static void marshalObjRef(InterfaceDef_ptr obj,NetBufferedStream &s);
    static InterfaceDef_ptr unmarshalObjRef(NetBufferedStream &s);
    static void marshalObjRef(InterfaceDef_ptr obj,MemBufferedStream &s);
    static InterfaceDef_ptr unmarshalObjRef(MemBufferedStream &s);
  };
  typedef _CORBA_ObjRef_Var<InterfaceDef,InterfaceDef_Helper> InterfaceDef_var;

#endif
#ifndef __CORBA_mOperationDef__
#define __CORBA_mOperationDef__
  class   OperationDef;
  typedef OperationDef* OperationDef_ptr;
  typedef OperationDef_ptr OperationDefRef;
  class _proxy_OperationDef;
  class _sk_OperationDef;
  class _nil_OperationDef;

  class OperationDef_Helper {
    public:
    static OperationDef_ptr _nil();
    static CORBA::Boolean is_nil(OperationDef_ptr p);
    static void release(OperationDef_ptr p);
    static void duplicate(OperationDef_ptr p);
    static size_t NP_alignedSize(OperationDef_ptr obj,size_t initialoffset);
    static void marshalObjRef(OperationDef_ptr obj,NetBufferedStream &s);
    static OperationDef_ptr unmarshalObjRef(NetBufferedStream &s);
    static void marshalObjRef(OperationDef_ptr obj,MemBufferedStream &s);
    static OperationDef_ptr unmarshalObjRef(MemBufferedStream &s);
  };
  typedef _CORBA_ObjRef_Var<OperationDef,OperationDef_Helper> OperationDef_var;

#endif
  _CORBA_MODULE_VAR const CORBA::TypeCode_ptr _tc_Identifier;
  typedef char* Identifier;
  typedef CORBA::String_var Identifier_var;
  struct StructMember {
    CORBA::String_member name;
    CORBA::TypeCode_member type;
    _CORBA_ObjRef_Member<IDLType,IDLType_Helper> type_def;
    
    size_t NP_alignedSize(size_t initialoffset) const;
    void operator>>= (NetBufferedStream &) const;
    void operator<<= (NetBufferedStream &);
    void operator>>= (MemBufferedStream &) const;
    void operator<<= (MemBufferedStream &);
  };

  typedef _CORBA_ConstrType_Variable_Var<StructMember> StructMember_var;

  _CORBA_MODULE_VAR const CORBA::TypeCode_ptr _tc_StructMember;

  _CORBA_MODULE_VAR const CORBA::TypeCode_ptr _tc_StructMemberSeq;
  typedef _CORBA_Unbounded_Sequence<StructMember > StructMemberSeq;
  typedef _CORBA_Sequence_Var<StructMemberSeq, StructMember > StructMemberSeq_var;

  struct UnionMember {
    CORBA::String_member name;
    CORBA::Any label;
    CORBA::TypeCode_member type;
    _CORBA_ObjRef_Member<IDLType,IDLType_Helper> type_def;
    
    size_t NP_alignedSize(size_t initialoffset) const;
    void operator>>= (NetBufferedStream &) const;
    void operator<<= (NetBufferedStream &);
    void operator>>= (MemBufferedStream &) const;
    void operator<<= (MemBufferedStream &);
  };

  typedef _CORBA_ConstrType_Variable_Var<UnionMember> UnionMember_var;

  _CORBA_MODULE_VAR const CORBA::TypeCode_ptr _tc_UnionMember;

  _CORBA_MODULE_VAR const CORBA::TypeCode_ptr _tc_UnionMemberSeq;
  typedef _CORBA_Unbounded_Sequence<UnionMember > UnionMemberSeq;
  typedef _CORBA_Sequence_Var<UnionMemberSeq, UnionMember > UnionMemberSeq_var;

  _CORBA_MODULE_VAR const CORBA::TypeCode_ptr _tc_EnumMemberSeq;
  typedef _CORBA_Unbounded_Sequence<CORBA::String_member > EnumMemberSeq;
  typedef _CORBA_Sequence_Var<EnumMemberSeq, CORBA::String_member > EnumMemberSeq_var;


_CORBA_MODULE_END

extern void operator<<=(CORBA::Any& _a, const CORBA::StructMember& _s);
extern void operator<<=(CORBA::Any& _a, CORBA::StructMember* _sp);
extern CORBA::Boolean operator>>=(const CORBA::Any& _a, CORBA::StructMember*& _sp);

#ifndef __0RL_seq_any_s0_cCORBA_mStructMember__
#define __0RL_seq_any_s0_cCORBA_mStructMember__
#define __0RL_seq_anyimpl_CORBA_mStructMemberSeq__
extern void _0RL_seq_anyinsert_CORBA_mStructMemberSeq(CORBA::Any&, const _CORBA_Unbounded_Sequence<CORBA::StructMember >&);

inline void operator<<=(CORBA::Any& a, const _CORBA_Unbounded_Sequence<CORBA::StructMember >& s)
{
  _0RL_seq_anyinsert_CORBA_mStructMemberSeq(a, s);
}

inline void operator<<=(CORBA::Any& a, _CORBA_Unbounded_Sequence<CORBA::StructMember >* sp)
{
  _0RL_seq_anyinsert_CORBA_mStructMemberSeq(a, *sp);
  delete sp;
}

extern CORBA::Boolean _0RL_seq_anyextract_CORBA_mStructMemberSeq(const CORBA::Any&, _CORBA_Unbounded_Sequence<CORBA::StructMember >*&);

inline CORBA::Boolean operator>>=(const CORBA::Any& a, _CORBA_Unbounded_Sequence<CORBA::StructMember >*& sp)
{
  return _0RL_seq_anyextract_CORBA_mStructMemberSeq(a, sp);
}

#endif

extern void operator<<=(CORBA::Any& _a, const CORBA::UnionMember& _s);
extern void operator<<=(CORBA::Any& _a, CORBA::UnionMember* _sp);
extern CORBA::Boolean operator>>=(const CORBA::Any& _a, CORBA::UnionMember*& _sp);

#ifndef __0RL_seq_any_s0_cCORBA_mUnionMember__
#define __0RL_seq_any_s0_cCORBA_mUnionMember__
#define __0RL_seq_anyimpl_CORBA_mUnionMemberSeq__
extern void _0RL_seq_anyinsert_CORBA_mUnionMemberSeq(CORBA::Any&, const _CORBA_Unbounded_Sequence<CORBA::UnionMember >&);

inline void operator<<=(CORBA::Any& a, const _CORBA_Unbounded_Sequence<CORBA::UnionMember >& s)
{
  _0RL_seq_anyinsert_CORBA_mUnionMemberSeq(a, s);
}

inline void operator<<=(CORBA::Any& a, _CORBA_Unbounded_Sequence<CORBA::UnionMember >* sp)
{
  _0RL_seq_anyinsert_CORBA_mUnionMemberSeq(a, *sp);
  delete sp;
}

extern CORBA::Boolean _0RL_seq_anyextract_CORBA_mUnionMemberSeq(const CORBA::Any&, _CORBA_Unbounded_Sequence<CORBA::UnionMember >*&);

inline CORBA::Boolean operator>>=(const CORBA::Any& a, _CORBA_Unbounded_Sequence<CORBA::UnionMember >*& sp)
{
  return _0RL_seq_anyextract_CORBA_mUnionMemberSeq(a, sp);
}

#endif

#ifndef __0RL_seq_any_s0_cstring__
#define __0RL_seq_any_s0_cstring__
#define __0RL_seq_anyimpl_CORBA_mEnumMemberSeq__
extern void _0RL_seq_anyinsert_CORBA_mEnumMemberSeq(CORBA::Any&, const _CORBA_Unbounded_Sequence<CORBA::String_member >&);

inline void operator<<=(CORBA::Any& a, const _CORBA_Unbounded_Sequence<CORBA::String_member >& s)
{
  _0RL_seq_anyinsert_CORBA_mEnumMemberSeq(a, s);
}

inline void operator<<=(CORBA::Any& a, _CORBA_Unbounded_Sequence<CORBA::String_member >* sp)
{
  _0RL_seq_anyinsert_CORBA_mEnumMemberSeq(a, *sp);
  delete sp;
}

extern CORBA::Boolean _0RL_seq_anyextract_CORBA_mEnumMemberSeq(const CORBA::Any&, _CORBA_Unbounded_Sequence<CORBA::String_member >*&);

inline CORBA::Boolean operator>>=(const CORBA::Any& a, _CORBA_Unbounded_Sequence<CORBA::String_member >*& sp)
{
  return _0RL_seq_anyextract_CORBA_mEnumMemberSeq(a, sp);
}

#endif


#undef _LC_attr

#endif // __corbaidl_hh__
