// **********************************************************************
//
// 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_IFR2_fwd_h__
#define __OB_IFR2_fwd_h__

#include <OB/Template.h>

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


#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 CORBA
{

class Repository;
typedef Repository* Repository_ptr;
typedef Repository* RepositoryRef;

OB_IMPORT extern OB::TypeCodeConst _tc_Repository;

class Contained;
typedef Contained* Contained_ptr;
typedef Contained* ContainedRef;

OB_IMPORT extern OB::TypeCodeConst _tc_Contained;

class ModuleDef;
typedef ModuleDef* ModuleDef_ptr;
typedef ModuleDef* ModuleDefRef;

OB_IMPORT extern OB::TypeCodeConst _tc_ModuleDef;

class ConstantDef;
typedef ConstantDef* ConstantDef_ptr;
typedef ConstantDef* ConstantDefRef;

OB_IMPORT extern OB::TypeCodeConst _tc_ConstantDef;

class StructDef;
typedef StructDef* StructDef_ptr;
typedef StructDef* StructDefRef;

OB_IMPORT extern OB::TypeCodeConst _tc_StructDef;

class UnionDef;
typedef UnionDef* UnionDef_ptr;
typedef UnionDef* UnionDefRef;

OB_IMPORT extern OB::TypeCodeConst _tc_UnionDef;

class EnumDef;
typedef EnumDef* EnumDef_ptr;
typedef EnumDef* EnumDefRef;

OB_IMPORT extern OB::TypeCodeConst _tc_EnumDef;

class AliasDef;
typedef AliasDef* AliasDef_ptr;
typedef AliasDef* AliasDefRef;

OB_IMPORT extern OB::TypeCodeConst _tc_AliasDef;

class AbstractInterfaceDef;
typedef AbstractInterfaceDef* AbstractInterfaceDef_ptr;
typedef AbstractInterfaceDef* AbstractInterfaceDefRef;

OB_IMPORT extern OB::TypeCodeConst _tc_AbstractInterfaceDef;

class LocalInterfaceDef;
typedef LocalInterfaceDef* LocalInterfaceDef_ptr;
typedef LocalInterfaceDef* LocalInterfaceDefRef;

OB_IMPORT extern OB::TypeCodeConst _tc_LocalInterfaceDef;

class NativeDef;
typedef NativeDef* NativeDef_ptr;
typedef NativeDef* NativeDefRef;

OB_IMPORT extern OB::TypeCodeConst _tc_NativeDef;

class ValueDef;
typedef ValueDef* ValueDef_ptr;
typedef ValueDef* ValueDefRef;

OB_IMPORT extern OB::TypeCodeConst _tc_ValueDef;

class ValueBoxDef;
typedef ValueBoxDef* ValueBoxDef_ptr;
typedef ValueBoxDef* ValueBoxDefRef;

OB_IMPORT extern OB::TypeCodeConst _tc_ValueBoxDef;

class Container;
typedef Container* Container_ptr;
typedef Container* ContainerRef;

OB_IMPORT extern OB::TypeCodeConst _tc_Container;

class AttributeDef;
typedef AttributeDef* AttributeDef_ptr;
typedef AttributeDef* AttributeDefRef;

OB_IMPORT extern OB::TypeCodeConst _tc_AttributeDef;

class ExceptionDef;
typedef ExceptionDef* ExceptionDef_ptr;
typedef ExceptionDef* ExceptionDefRef;

OB_IMPORT extern OB::TypeCodeConst _tc_ExceptionDef;

class OperationDef;
typedef OperationDef* OperationDef_ptr;
typedef OperationDef* OperationDefRef;

OB_IMPORT extern OB::TypeCodeConst _tc_OperationDef;

class InterfaceDef;
typedef InterfaceDef* InterfaceDef_ptr;
typedef InterfaceDef* InterfaceDefRef;

OB_IMPORT extern OB::TypeCodeConst _tc_InterfaceDef;

} // End of namespace CORBA

void OBDuplicate(CORBA::Repository_ptr);
void OBRelease(CORBA::Repository_ptr);

void OBMarshal(CORBA::Repository_ptr, OB::OutputStreamImpl*);
void OBUnmarshal(CORBA::Repository_ptr&, OB::InputStreamImpl*);

void OBDuplicate(CORBA::Contained_ptr);
void OBRelease(CORBA::Contained_ptr);

void OBMarshal(CORBA::Contained_ptr, OB::OutputStreamImpl*);
void OBUnmarshal(CORBA::Contained_ptr&, OB::InputStreamImpl*);

void OBDuplicate(CORBA::ModuleDef_ptr);
void OBRelease(CORBA::ModuleDef_ptr);

void OBMarshal(CORBA::ModuleDef_ptr, OB::OutputStreamImpl*);
void OBUnmarshal(CORBA::ModuleDef_ptr&, OB::InputStreamImpl*);

void OBDuplicate(CORBA::ConstantDef_ptr);
void OBRelease(CORBA::ConstantDef_ptr);

void OBMarshal(CORBA::ConstantDef_ptr, OB::OutputStreamImpl*);
void OBUnmarshal(CORBA::ConstantDef_ptr&, OB::InputStreamImpl*);

void OBDuplicate(CORBA::StructDef_ptr);
void OBRelease(CORBA::StructDef_ptr);

void OBMarshal(CORBA::StructDef_ptr, OB::OutputStreamImpl*);
void OBUnmarshal(CORBA::StructDef_ptr&, OB::InputStreamImpl*);

void OBDuplicate(CORBA::UnionDef_ptr);
void OBRelease(CORBA::UnionDef_ptr);

void OBMarshal(CORBA::UnionDef_ptr, OB::OutputStreamImpl*);
void OBUnmarshal(CORBA::UnionDef_ptr&, OB::InputStreamImpl*);

void OBDuplicate(CORBA::EnumDef_ptr);
void OBRelease(CORBA::EnumDef_ptr);

void OBMarshal(CORBA::EnumDef_ptr, OB::OutputStreamImpl*);
void OBUnmarshal(CORBA::EnumDef_ptr&, OB::InputStreamImpl*);

void OBDuplicate(CORBA::AliasDef_ptr);
void OBRelease(CORBA::AliasDef_ptr);

void OBMarshal(CORBA::AliasDef_ptr, OB::OutputStreamImpl*);
void OBUnmarshal(CORBA::AliasDef_ptr&, OB::InputStreamImpl*);

void OBDuplicate(CORBA::AbstractInterfaceDef_ptr);
void OBRelease(CORBA::AbstractInterfaceDef_ptr);

void OBMarshal(CORBA::AbstractInterfaceDef_ptr, OB::OutputStreamImpl*);
void OBUnmarshal(CORBA::AbstractInterfaceDef_ptr&, OB::InputStreamImpl*);

void OBDuplicate(CORBA::LocalInterfaceDef_ptr);
void OBRelease(CORBA::LocalInterfaceDef_ptr);

void OBMarshal(CORBA::LocalInterfaceDef_ptr, OB::OutputStreamImpl*);
void OBUnmarshal(CORBA::LocalInterfaceDef_ptr&, OB::InputStreamImpl*);

void OBDuplicate(CORBA::NativeDef_ptr);
void OBRelease(CORBA::NativeDef_ptr);

void OBMarshal(CORBA::NativeDef_ptr, OB::OutputStreamImpl*);
void OBUnmarshal(CORBA::NativeDef_ptr&, OB::InputStreamImpl*);

void OBDuplicate(CORBA::ValueDef_ptr);
void OBRelease(CORBA::ValueDef_ptr);

void OBMarshal(CORBA::ValueDef_ptr, OB::OutputStreamImpl*);
void OBUnmarshal(CORBA::ValueDef_ptr&, OB::InputStreamImpl*);

void OBDuplicate(CORBA::ValueBoxDef_ptr);
void OBRelease(CORBA::ValueBoxDef_ptr);

void OBMarshal(CORBA::ValueBoxDef_ptr, OB::OutputStreamImpl*);
void OBUnmarshal(CORBA::ValueBoxDef_ptr&, OB::InputStreamImpl*);

void OBDuplicate(CORBA::Container_ptr);
void OBRelease(CORBA::Container_ptr);

void OBMarshal(CORBA::Container_ptr, OB::OutputStreamImpl*);
void OBUnmarshal(CORBA::Container_ptr&, OB::InputStreamImpl*);

void OBDuplicate(CORBA::AttributeDef_ptr);
void OBRelease(CORBA::AttributeDef_ptr);

void OBMarshal(CORBA::AttributeDef_ptr, OB::OutputStreamImpl*);
void OBUnmarshal(CORBA::AttributeDef_ptr&, OB::InputStreamImpl*);

void OBDuplicate(CORBA::ExceptionDef_ptr);
void OBRelease(CORBA::ExceptionDef_ptr);

void OBMarshal(CORBA::ExceptionDef_ptr, OB::OutputStreamImpl*);
void OBUnmarshal(CORBA::ExceptionDef_ptr&, OB::InputStreamImpl*);

void OBDuplicate(CORBA::OperationDef_ptr);
void OBRelease(CORBA::OperationDef_ptr);

void OBMarshal(CORBA::OperationDef_ptr, OB::OutputStreamImpl*);
void OBUnmarshal(CORBA::OperationDef_ptr&, OB::InputStreamImpl*);

void OBDuplicate(CORBA::InterfaceDef_ptr);
void OBRelease(CORBA::InterfaceDef_ptr);

void OBMarshal(CORBA::InterfaceDef_ptr, OB::OutputStreamImpl*);
void OBUnmarshal(CORBA::InterfaceDef_ptr&, OB::InputStreamImpl*);

namespace CORBA
{

typedef OB::ObjVar< Repository > Repository_var;
typedef OB::ObjOut< Repository > Repository_out;

typedef OB::ObjVar< Contained > Contained_var;
typedef OB::ObjOut< Contained > Contained_out;

typedef OB::ObjVar< ModuleDef > ModuleDef_var;
typedef OB::ObjOut< ModuleDef > ModuleDef_out;

typedef OB::ObjVar< ConstantDef > ConstantDef_var;
typedef OB::ObjOut< ConstantDef > ConstantDef_out;

typedef OB::ObjVar< StructDef > StructDef_var;
typedef OB::ObjOut< StructDef > StructDef_out;

typedef OB::ObjVar< UnionDef > UnionDef_var;
typedef OB::ObjOut< UnionDef > UnionDef_out;

typedef OB::ObjVar< EnumDef > EnumDef_var;
typedef OB::ObjOut< EnumDef > EnumDef_out;

typedef OB::ObjVar< AliasDef > AliasDef_var;
typedef OB::ObjOut< AliasDef > AliasDef_out;

typedef OB::ObjVar< AbstractInterfaceDef > AbstractInterfaceDef_var;
typedef OB::ObjOut< AbstractInterfaceDef > AbstractInterfaceDef_out;

typedef OB::ObjVar< LocalInterfaceDef > LocalInterfaceDef_var;
typedef OB::ObjOut< LocalInterfaceDef > LocalInterfaceDef_out;

typedef OB::ObjVar< NativeDef > NativeDef_var;
typedef OB::ObjOut< NativeDef > NativeDef_out;

typedef OB::ObjVar< ValueDef > ValueDef_var;
typedef OB::ObjOut< ValueDef > ValueDef_out;

typedef OB::ObjVar< ValueBoxDef > ValueBoxDef_var;
typedef OB::ObjOut< ValueBoxDef > ValueBoxDef_out;

typedef OB::ObjVar< Container > Container_var;
typedef OB::ObjOut< Container > Container_out;

typedef OB::ObjVar< AttributeDef > AttributeDef_var;
typedef OB::ObjOut< AttributeDef > AttributeDef_out;

typedef OB::ObjVar< ExceptionDef > ExceptionDef_var;
typedef OB::ObjOut< ExceptionDef > ExceptionDef_out;

typedef OB::ObjVar< OperationDef > OperationDef_var;
typedef OB::ObjOut< OperationDef > OperationDef_out;

typedef OB::ObjVar< InterfaceDef > InterfaceDef_var;
typedef OB::ObjOut< InterfaceDef > InterfaceDef_out;

} // End of namespace CORBA

#endif
