libcos4-dev 4.1.6-2.1+b1 / usr / include / COS / CosRelationships.hh

// This file is generated by omniidl (C++ backend)- omniORB_4_1. Do not edit.
#ifndef __CosRelationships_hh__
#define __CosRelationships_hh__

#ifndef __CORBA_H_EXTERNAL_GUARD__
#include <omniORB4/CORBA.h>
#endif

#ifndef  USE_stub_in_nt_dll
# define USE_stub_in_nt_dll_NOT_DEFINED_CosRelationships
#endif
#ifndef  USE_core_stub_in_nt_dll
# define USE_core_stub_in_nt_dll_NOT_DEFINED_CosRelationships
#endif
#ifndef  USE_dyn_stub_in_nt_dll
# define USE_dyn_stub_in_nt_dll_NOT_DEFINED_CosRelationships
#endif


#include "COS_sysdep.h"
#ifndef __corbaidl_hh_EXTERNAL_GUARD__
#define __corbaidl_hh_EXTERNAL_GUARD__
#include "corbaidl.hh"
#endif
#ifndef __boxes_hh_EXTERNAL_GUARD__
#define __boxes_hh_EXTERNAL_GUARD__
#include "boxes.hh"
#endif
#ifndef __ir_hh_EXTERNAL_GUARD__
#define __ir_hh_EXTERNAL_GUARD__
#include "ir.hh"
#endif
#ifndef __CosObjectIdentity_hh_EXTERNAL_GUARD__
#define __CosObjectIdentity_hh_EXTERNAL_GUARD__
#include "CosObjectIdentity.hh"
#endif



#ifdef USE_stub_in_nt_dll
# ifndef USE_core_stub_in_nt_dll
#  define USE_core_stub_in_nt_dll
# endif
# ifndef USE_dyn_stub_in_nt_dll
#  define USE_dyn_stub_in_nt_dll
# endif
#endif

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

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





_CORBA_MODULE CosRelationships

_CORBA_MODULE_BEG

#ifndef __CosRelationships_mRoleFactory__
#define __CosRelationships_mRoleFactory__

  class RoleFactory;
  class _objref_RoleFactory;
  class _impl_RoleFactory;
  
  typedef _objref_RoleFactory* RoleFactory_ptr;
  typedef RoleFactory_ptr RoleFactoryRef;

  class RoleFactory_Helper {
  public:
    typedef RoleFactory_ptr _ptr_type;

    static _ptr_type _nil();
    static _CORBA_Boolean is_nil(_ptr_type);
    static void release(_ptr_type);
    static void duplicate(_ptr_type);
    static void marshalObjRef(_ptr_type, cdrStream&);
    static _ptr_type unmarshalObjRef(cdrStream&);
  };

  typedef _CORBA_ObjRef_Var<_objref_RoleFactory, RoleFactory_Helper> RoleFactory_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_RoleFactory,RoleFactory_Helper > RoleFactory_out;

#endif

#ifndef __CosRelationships_mRelationshipFactory__
#define __CosRelationships_mRelationshipFactory__

  class RelationshipFactory;
  class _objref_RelationshipFactory;
  class _impl_RelationshipFactory;
  
  typedef _objref_RelationshipFactory* RelationshipFactory_ptr;
  typedef RelationshipFactory_ptr RelationshipFactoryRef;

  class RelationshipFactory_Helper {
  public:
    typedef RelationshipFactory_ptr _ptr_type;

    static _ptr_type _nil();
    static _CORBA_Boolean is_nil(_ptr_type);
    static void release(_ptr_type);
    static void duplicate(_ptr_type);
    static void marshalObjRef(_ptr_type, cdrStream&);
    static _ptr_type unmarshalObjRef(cdrStream&);
  };

  typedef _CORBA_ObjRef_Var<_objref_RelationshipFactory, RelationshipFactory_Helper> RelationshipFactory_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_RelationshipFactory,RelationshipFactory_Helper > RelationshipFactory_out;

#endif

#ifndef __CosRelationships_mRelationship__
#define __CosRelationships_mRelationship__

  class Relationship;
  class _objref_Relationship;
  class _impl_Relationship;
  
  typedef _objref_Relationship* Relationship_ptr;
  typedef Relationship_ptr RelationshipRef;

  class Relationship_Helper {
  public:
    typedef Relationship_ptr _ptr_type;

    static _ptr_type _nil();
    static _CORBA_Boolean is_nil(_ptr_type);
    static void release(_ptr_type);
    static void duplicate(_ptr_type);
    static void marshalObjRef(_ptr_type, cdrStream&);
    static _ptr_type unmarshalObjRef(cdrStream&);
  };

  typedef _CORBA_ObjRef_Var<_objref_Relationship, Relationship_Helper> Relationship_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_Relationship,Relationship_Helper > Relationship_out;

#endif

#ifndef __CosRelationships_mRole__
#define __CosRelationships_mRole__

  class Role;
  class _objref_Role;
  class _impl_Role;
  
  typedef _objref_Role* Role_ptr;
  typedef Role_ptr RoleRef;

  class Role_Helper {
  public:
    typedef Role_ptr _ptr_type;

    static _ptr_type _nil();
    static _CORBA_Boolean is_nil(_ptr_type);
    static void release(_ptr_type);
    static void duplicate(_ptr_type);
    static void marshalObjRef(_ptr_type, cdrStream&);
    static _ptr_type unmarshalObjRef(cdrStream&);
  };

  typedef _CORBA_ObjRef_Var<_objref_Role, Role_Helper> Role_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_Role,Role_Helper > Role_out;

#endif

#ifndef __CosRelationships_mRelationshipIterator__
#define __CosRelationships_mRelationshipIterator__

  class RelationshipIterator;
  class _objref_RelationshipIterator;
  class _impl_RelationshipIterator;
  
  typedef _objref_RelationshipIterator* RelationshipIterator_ptr;
  typedef RelationshipIterator_ptr RelationshipIteratorRef;

  class RelationshipIterator_Helper {
  public:
    typedef RelationshipIterator_ptr _ptr_type;

    static _ptr_type _nil();
    static _CORBA_Boolean is_nil(_ptr_type);
    static void release(_ptr_type);
    static void duplicate(_ptr_type);
    static void marshalObjRef(_ptr_type, cdrStream&);
    static _ptr_type unmarshalObjRef(cdrStream&);
  };

  typedef _CORBA_ObjRef_Var<_objref_RelationshipIterator, RelationshipIterator_Helper> RelationshipIterator_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_RelationshipIterator,RelationshipIterator_Helper > RelationshipIterator_out;

#endif

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_RelatedObject;

  typedef ::CORBA::Object RelatedObject;
  typedef ::CORBA::Object_ptr RelatedObject_ptr;
  typedef ::CORBA::ObjectRef RelatedObjectRef;
  
  typedef ::CORBA::Object_Helper RelatedObject_Helper;
  
  typedef ::CORBA::Object_var RelatedObject_var;
  typedef ::CORBA::Object_out RelatedObject_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_Roles;

  class Roles_var;

  class Roles : public _CORBA_Unbounded_Sequence_ObjRef< _objref_Role, _CORBA_ObjRef_Element< _objref_Role, Role_Helper> , Role_Helper >  {
  public:
    typedef Roles_var _var_type;
    inline Roles() {}
    inline Roles(const Roles& _s)
      : _CORBA_Unbounded_Sequence_ObjRef< _objref_Role, _CORBA_ObjRef_Element< _objref_Role, Role_Helper> , Role_Helper > (_s) {}

    inline Roles(_CORBA_ULong _max)
      : _CORBA_Unbounded_Sequence_ObjRef< _objref_Role, _CORBA_ObjRef_Element< _objref_Role, Role_Helper> , Role_Helper > (_max) {}
    inline Roles(_CORBA_ULong _max, _CORBA_ULong _len, Role_ptr* _val, _CORBA_Boolean _rel=0)
      : _CORBA_Unbounded_Sequence_ObjRef< _objref_Role, _CORBA_ObjRef_Element< _objref_Role, Role_Helper> , Role_Helper > (_max, _len, _val, _rel) {}

  

    inline Roles& operator = (const Roles& _s) {
      _CORBA_Unbounded_Sequence_ObjRef< _objref_Role, _CORBA_ObjRef_Element< _objref_Role, Role_Helper> , Role_Helper > ::operator=(_s);
      return *this;
    }
  };

  class Roles_out;

  class Roles_var {
  public:
    inline Roles_var() : _pd_seq(0) {}
    inline Roles_var(Roles* _s) : _pd_seq(_s) {}
    inline Roles_var(const Roles_var& _s) {
      if( _s._pd_seq )  _pd_seq = new Roles(*_s._pd_seq);
      else              _pd_seq = 0;
    }
    inline ~Roles_var() { if( _pd_seq )  delete _pd_seq; }
      
    inline Roles_var& operator = (Roles* _s) {
      if( _pd_seq )  delete _pd_seq;
      _pd_seq = _s;
      return *this;
    }
    inline Roles_var& operator = (const Roles_var& _s) {
      if( _s._pd_seq ) {
        if( !_pd_seq )  _pd_seq = new Roles;
        *_pd_seq = *_s._pd_seq;
      } else if( _pd_seq ) {
        delete _pd_seq;
        _pd_seq = 0;
      }
      return *this;
    }
    inline _CORBA_ObjRef_Element< _objref_Role, Role_Helper>  operator [] (_CORBA_ULong _s) {
      return (*_pd_seq)[_s];
    }

  

    inline Roles* operator -> () { return _pd_seq; }
    inline const Roles* operator -> () const { return _pd_seq; }
#if defined(__GNUG__)
    inline operator Roles& () const { return *_pd_seq; }
#else
    inline operator const Roles& () const { return *_pd_seq; }
    inline operator Roles& () { return *_pd_seq; }
#endif
      
    inline const Roles& in() const { return *_pd_seq; }
    inline Roles&       inout()    { return *_pd_seq; }
    inline Roles*&      out() {
      if( _pd_seq ) { delete _pd_seq; _pd_seq = 0; }
      return _pd_seq;
    }
    inline Roles* _retn() { Roles* tmp = _pd_seq; _pd_seq = 0; return tmp; }
      
    friend class Roles_out;
    
  private:
    Roles* _pd_seq;
  };

  class Roles_out {
  public:
    inline Roles_out(Roles*& _s) : _data(_s) { _data = 0; }
    inline Roles_out(Roles_var& _s)
      : _data(_s._pd_seq) { _s = (Roles*) 0; }
    inline Roles_out(const Roles_out& _s) : _data(_s._data) {}
    inline Roles_out& operator = (const Roles_out& _s) {
      _data = _s._data;
      return *this;
    }
    inline Roles_out& operator = (Roles* _s) {
      _data = _s;
      return *this;
    }
    inline operator Roles*&()  { return _data; }
    inline Roles*& ptr()       { return _data; }
    inline Roles* operator->() { return _data; }

    inline _CORBA_ObjRef_Element< _objref_Role, Role_Helper>  operator [] (_CORBA_ULong _i) {
      return (*_data)[_i];
    }

  

    Roles*& _data;

  private:
    Roles_out();
    Roles_out& operator=(const Roles_var&);
  };

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_RoleName;

  typedef char* RoleName;
  typedef ::CORBA::String_var RoleName_var;
  typedef ::CORBA::String_out RoleName_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_RoleNames;

  class RoleNames_var;

  class RoleNames : public _CORBA_Unbounded_Sequence_String {
  public:
    typedef RoleNames_var _var_type;
    inline RoleNames() {}
    inline RoleNames(const RoleNames& _s)
      : _CORBA_Unbounded_Sequence_String(_s) {}

    inline RoleNames(_CORBA_ULong _max)
      : _CORBA_Unbounded_Sequence_String(_max) {}
    inline RoleNames(_CORBA_ULong _max, _CORBA_ULong _len, char** _val, _CORBA_Boolean _rel=0)
      : _CORBA_Unbounded_Sequence_String(_max, _len, _val, _rel) {}

  

    inline RoleNames& operator = (const RoleNames& _s) {
      _CORBA_Unbounded_Sequence_String::operator=(_s);
      return *this;
    }
  };

  class RoleNames_out;

  class RoleNames_var {
  public:
    inline RoleNames_var() : _pd_seq(0) {}
    inline RoleNames_var(RoleNames* _s) : _pd_seq(_s) {}
    inline RoleNames_var(const RoleNames_var& _s) {
      if( _s._pd_seq )  _pd_seq = new RoleNames(*_s._pd_seq);
      else              _pd_seq = 0;
    }
    inline ~RoleNames_var() { if( _pd_seq )  delete _pd_seq; }
      
    inline RoleNames_var& operator = (RoleNames* _s) {
      if( _pd_seq )  delete _pd_seq;
      _pd_seq = _s;
      return *this;
    }
    inline RoleNames_var& operator = (const RoleNames_var& _s) {
      if( _s._pd_seq ) {
        if( !_pd_seq )  _pd_seq = new RoleNames;
        *_pd_seq = *_s._pd_seq;
      } else if( _pd_seq ) {
        delete _pd_seq;
        _pd_seq = 0;
      }
      return *this;
    }
    inline _CORBA_String_element operator [] (_CORBA_ULong _s) {
      return (*_pd_seq)[_s];
    }

  

    inline RoleNames* operator -> () { return _pd_seq; }
    inline const RoleNames* operator -> () const { return _pd_seq; }
#if defined(__GNUG__)
    inline operator RoleNames& () const { return *_pd_seq; }
#else
    inline operator const RoleNames& () const { return *_pd_seq; }
    inline operator RoleNames& () { return *_pd_seq; }
#endif
      
    inline const RoleNames& in() const { return *_pd_seq; }
    inline RoleNames&       inout()    { return *_pd_seq; }
    inline RoleNames*&      out() {
      if( _pd_seq ) { delete _pd_seq; _pd_seq = 0; }
      return _pd_seq;
    }
    inline RoleNames* _retn() { RoleNames* tmp = _pd_seq; _pd_seq = 0; return tmp; }
      
    friend class RoleNames_out;
    
  private:
    RoleNames* _pd_seq;
  };

  class RoleNames_out {
  public:
    inline RoleNames_out(RoleNames*& _s) : _data(_s) { _data = 0; }
    inline RoleNames_out(RoleNames_var& _s)
      : _data(_s._pd_seq) { _s = (RoleNames*) 0; }
    inline RoleNames_out(const RoleNames_out& _s) : _data(_s._data) {}
    inline RoleNames_out& operator = (const RoleNames_out& _s) {
      _data = _s._data;
      return *this;
    }
    inline RoleNames_out& operator = (RoleNames* _s) {
      _data = _s;
      return *this;
    }
    inline operator RoleNames*&()  { return _data; }
    inline RoleNames*& ptr()       { return _data; }
    inline RoleNames* operator->() { return _data; }

    inline _CORBA_String_element operator [] (_CORBA_ULong _i) {
      return (*_data)[_i];
    }

  

    RoleNames*& _data;

  private:
    RoleNames_out();
    RoleNames_out& operator=(const RoleNames_var&);
  };

  struct NamedRole {
    typedef _CORBA_ConstrType_Variable_Var<NamedRole> _var_type;

    
    ::CORBA::String_member name;

    _CORBA_ObjRef_Member< _objref_Role, Role_Helper>  aRole;

  

    void operator>>= (cdrStream &) const;
    void operator<<= (cdrStream &);
  };

  typedef NamedRole::_var_type NamedRole_var;

  typedef _CORBA_ConstrType_Variable_OUT_arg< NamedRole,NamedRole_var > NamedRole_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_NamedRole;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_NamedRoles;

  class NamedRoles_var;

  class NamedRoles : public _CORBA_Unbounded_Sequence< NamedRole >  {
  public:
    typedef NamedRoles_var _var_type;
    inline NamedRoles() {}
    inline NamedRoles(const NamedRoles& _s)
      : _CORBA_Unbounded_Sequence< NamedRole > (_s) {}

    inline NamedRoles(_CORBA_ULong _max)
      : _CORBA_Unbounded_Sequence< NamedRole > (_max) {}
    inline NamedRoles(_CORBA_ULong _max, _CORBA_ULong _len, NamedRole* _val, _CORBA_Boolean _rel=0)
      : _CORBA_Unbounded_Sequence< NamedRole > (_max, _len, _val, _rel) {}

  

    inline NamedRoles& operator = (const NamedRoles& _s) {
      _CORBA_Unbounded_Sequence< NamedRole > ::operator=(_s);
      return *this;
    }
  };

  class NamedRoles_out;

  class NamedRoles_var {
  public:
    inline NamedRoles_var() : _pd_seq(0) {}
    inline NamedRoles_var(NamedRoles* _s) : _pd_seq(_s) {}
    inline NamedRoles_var(const NamedRoles_var& _s) {
      if( _s._pd_seq )  _pd_seq = new NamedRoles(*_s._pd_seq);
      else              _pd_seq = 0;
    }
    inline ~NamedRoles_var() { if( _pd_seq )  delete _pd_seq; }
      
    inline NamedRoles_var& operator = (NamedRoles* _s) {
      if( _pd_seq )  delete _pd_seq;
      _pd_seq = _s;
      return *this;
    }
    inline NamedRoles_var& operator = (const NamedRoles_var& _s) {
      if( _s._pd_seq ) {
        if( !_pd_seq )  _pd_seq = new NamedRoles;
        *_pd_seq = *_s._pd_seq;
      } else if( _pd_seq ) {
        delete _pd_seq;
        _pd_seq = 0;
      }
      return *this;
    }
    inline NamedRole& operator [] (_CORBA_ULong _s) {
      return (*_pd_seq)[_s];
    }

  

    inline NamedRoles* operator -> () { return _pd_seq; }
    inline const NamedRoles* operator -> () const { return _pd_seq; }
#if defined(__GNUG__)
    inline operator NamedRoles& () const { return *_pd_seq; }
#else
    inline operator const NamedRoles& () const { return *_pd_seq; }
    inline operator NamedRoles& () { return *_pd_seq; }
#endif
      
    inline const NamedRoles& in() const { return *_pd_seq; }
    inline NamedRoles&       inout()    { return *_pd_seq; }
    inline NamedRoles*&      out() {
      if( _pd_seq ) { delete _pd_seq; _pd_seq = 0; }
      return _pd_seq;
    }
    inline NamedRoles* _retn() { NamedRoles* tmp = _pd_seq; _pd_seq = 0; return tmp; }
      
    friend class NamedRoles_out;
    
  private:
    NamedRoles* _pd_seq;
  };

  class NamedRoles_out {
  public:
    inline NamedRoles_out(NamedRoles*& _s) : _data(_s) { _data = 0; }
    inline NamedRoles_out(NamedRoles_var& _s)
      : _data(_s._pd_seq) { _s = (NamedRoles*) 0; }
    inline NamedRoles_out(const NamedRoles_out& _s) : _data(_s._data) {}
    inline NamedRoles_out& operator = (const NamedRoles_out& _s) {
      _data = _s._data;
      return *this;
    }
    inline NamedRoles_out& operator = (NamedRoles* _s) {
      _data = _s;
      return *this;
    }
    inline operator NamedRoles*&()  { return _data; }
    inline NamedRoles*& ptr()       { return _data; }
    inline NamedRoles* operator->() { return _data; }

    inline NamedRole& operator [] (_CORBA_ULong _i) {
      return (*_data)[_i];
    }

  

    NamedRoles*& _data;

  private:
    NamedRoles_out();
    NamedRoles_out& operator=(const NamedRoles_var&);
  };

  struct RelationshipHandle {
    typedef _CORBA_ConstrType_Variable_Var<RelationshipHandle> _var_type;

    
    _CORBA_ObjRef_Member< _objref_Relationship, Relationship_Helper>  the_relationship;

    CosObjectIdentity::ObjectIdentifier constant_random_id;

  

    void operator>>= (cdrStream &) const;
    void operator<<= (cdrStream &);
  };

  typedef RelationshipHandle::_var_type RelationshipHandle_var;

  typedef _CORBA_ConstrType_Variable_OUT_arg< RelationshipHandle,RelationshipHandle_var > RelationshipHandle_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_RelationshipHandle;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_RelationshipHandles;

  class RelationshipHandles_var;

  class RelationshipHandles : public _CORBA_Unbounded_Sequence< RelationshipHandle >  {
  public:
    typedef RelationshipHandles_var _var_type;
    inline RelationshipHandles() {}
    inline RelationshipHandles(const RelationshipHandles& _s)
      : _CORBA_Unbounded_Sequence< RelationshipHandle > (_s) {}

    inline RelationshipHandles(_CORBA_ULong _max)
      : _CORBA_Unbounded_Sequence< RelationshipHandle > (_max) {}
    inline RelationshipHandles(_CORBA_ULong _max, _CORBA_ULong _len, RelationshipHandle* _val, _CORBA_Boolean _rel=0)
      : _CORBA_Unbounded_Sequence< RelationshipHandle > (_max, _len, _val, _rel) {}

  

    inline RelationshipHandles& operator = (const RelationshipHandles& _s) {
      _CORBA_Unbounded_Sequence< RelationshipHandle > ::operator=(_s);
      return *this;
    }
  };

  class RelationshipHandles_out;

  class RelationshipHandles_var {
  public:
    inline RelationshipHandles_var() : _pd_seq(0) {}
    inline RelationshipHandles_var(RelationshipHandles* _s) : _pd_seq(_s) {}
    inline RelationshipHandles_var(const RelationshipHandles_var& _s) {
      if( _s._pd_seq )  _pd_seq = new RelationshipHandles(*_s._pd_seq);
      else              _pd_seq = 0;
    }
    inline ~RelationshipHandles_var() { if( _pd_seq )  delete _pd_seq; }
      
    inline RelationshipHandles_var& operator = (RelationshipHandles* _s) {
      if( _pd_seq )  delete _pd_seq;
      _pd_seq = _s;
      return *this;
    }
    inline RelationshipHandles_var& operator = (const RelationshipHandles_var& _s) {
      if( _s._pd_seq ) {
        if( !_pd_seq )  _pd_seq = new RelationshipHandles;
        *_pd_seq = *_s._pd_seq;
      } else if( _pd_seq ) {
        delete _pd_seq;
        _pd_seq = 0;
      }
      return *this;
    }
    inline RelationshipHandle& operator [] (_CORBA_ULong _s) {
      return (*_pd_seq)[_s];
    }

  

    inline RelationshipHandles* operator -> () { return _pd_seq; }
    inline const RelationshipHandles* operator -> () const { return _pd_seq; }
#if defined(__GNUG__)
    inline operator RelationshipHandles& () const { return *_pd_seq; }
#else
    inline operator const RelationshipHandles& () const { return *_pd_seq; }
    inline operator RelationshipHandles& () { return *_pd_seq; }
#endif
      
    inline const RelationshipHandles& in() const { return *_pd_seq; }
    inline RelationshipHandles&       inout()    { return *_pd_seq; }
    inline RelationshipHandles*&      out() {
      if( _pd_seq ) { delete _pd_seq; _pd_seq = 0; }
      return _pd_seq;
    }
    inline RelationshipHandles* _retn() { RelationshipHandles* tmp = _pd_seq; _pd_seq = 0; return tmp; }
      
    friend class RelationshipHandles_out;
    
  private:
    RelationshipHandles* _pd_seq;
  };

  class RelationshipHandles_out {
  public:
    inline RelationshipHandles_out(RelationshipHandles*& _s) : _data(_s) { _data = 0; }
    inline RelationshipHandles_out(RelationshipHandles_var& _s)
      : _data(_s._pd_seq) { _s = (RelationshipHandles*) 0; }
    inline RelationshipHandles_out(const RelationshipHandles_out& _s) : _data(_s._data) {}
    inline RelationshipHandles_out& operator = (const RelationshipHandles_out& _s) {
      _data = _s._data;
      return *this;
    }
    inline RelationshipHandles_out& operator = (RelationshipHandles* _s) {
      _data = _s;
      return *this;
    }
    inline operator RelationshipHandles*&()  { return _data; }
    inline RelationshipHandles*& ptr()       { return _data; }
    inline RelationshipHandles* operator->() { return _data; }

    inline RelationshipHandle& operator [] (_CORBA_ULong _i) {
      return (*_data)[_i];
    }

  

    RelationshipHandles*& _data;

  private:
    RelationshipHandles_out();
    RelationshipHandles_out& operator=(const RelationshipHandles_var&);
  };

#ifndef __CosRelationships_mRelationshipFactory__
#define __CosRelationships_mRelationshipFactory__

  class RelationshipFactory;
  class _objref_RelationshipFactory;
  class _impl_RelationshipFactory;
  
  typedef _objref_RelationshipFactory* RelationshipFactory_ptr;
  typedef RelationshipFactory_ptr RelationshipFactoryRef;

  class RelationshipFactory_Helper {
  public:
    typedef RelationshipFactory_ptr _ptr_type;

    static _ptr_type _nil();
    static _CORBA_Boolean is_nil(_ptr_type);
    static void release(_ptr_type);
    static void duplicate(_ptr_type);
    static void marshalObjRef(_ptr_type, cdrStream&);
    static _ptr_type unmarshalObjRef(cdrStream&);
  };

  typedef _CORBA_ObjRef_Var<_objref_RelationshipFactory, RelationshipFactory_Helper> RelationshipFactory_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_RelationshipFactory,RelationshipFactory_Helper > RelationshipFactory_out;

#endif

  // interface RelationshipFactory
  class RelationshipFactory {
  public:
    // Declarations for this interface type.
    typedef RelationshipFactory_ptr _ptr_type;
    typedef RelationshipFactory_var _var_type;

    static _ptr_type _duplicate(_ptr_type);
    static _ptr_type _narrow(::CORBA::Object_ptr);
    static _ptr_type _unchecked_narrow(::CORBA::Object_ptr);
    
    static _ptr_type _nil();

    static inline void _marshalObjRef(_ptr_type, cdrStream&);

    static inline _ptr_type _unmarshalObjRef(cdrStream& s) {
      omniObjRef* o = omniObjRef::_unMarshal(_PD_repoId,s);
      if (o)
        return (_ptr_type) o->_ptrToObjRef(_PD_repoId);
      else
        return _nil();
    }

    static _core_attr const char* _PD_repoId;

    // Other IDL defined within this scope.
    struct NamedRoleType {
      typedef _CORBA_ConstrType_Variable_Var<NamedRoleType> _var_type;

      
      ::CORBA::String_member name;

      _CORBA_ObjRef_Member< CORBA::_objref_InterfaceDef, CORBA::InterfaceDef_Helper>  named_role_type;

    

      void operator>>= (cdrStream &) const;
      void operator<<= (cdrStream &);
    };

    typedef NamedRoleType::_var_type NamedRoleType_var;

    typedef _CORBA_ConstrType_Variable_OUT_arg< NamedRoleType,NamedRoleType_var > NamedRoleType_out;

    static _dyn_attr const ::CORBA::TypeCode_ptr _tc_NamedRoleType;

    static _dyn_attr const ::CORBA::TypeCode_ptr _tc_NamedRoleTypes;

    class NamedRoleTypes_var;

    class NamedRoleTypes : public _CORBA_Unbounded_Sequence< NamedRoleType >  {
    public:
      typedef NamedRoleTypes_var _var_type;
      inline NamedRoleTypes() {}
      inline NamedRoleTypes(const NamedRoleTypes& _s)
        : _CORBA_Unbounded_Sequence< NamedRoleType > (_s) {}

      inline NamedRoleTypes(_CORBA_ULong _max)
        : _CORBA_Unbounded_Sequence< NamedRoleType > (_max) {}
      inline NamedRoleTypes(_CORBA_ULong _max, _CORBA_ULong _len, NamedRoleType* _val, _CORBA_Boolean _rel=0)
        : _CORBA_Unbounded_Sequence< NamedRoleType > (_max, _len, _val, _rel) {}

    

      inline NamedRoleTypes& operator = (const NamedRoleTypes& _s) {
        _CORBA_Unbounded_Sequence< NamedRoleType > ::operator=(_s);
        return *this;
      }
    };

    class NamedRoleTypes_out;

    class NamedRoleTypes_var {
    public:
      inline NamedRoleTypes_var() : _pd_seq(0) {}
      inline NamedRoleTypes_var(NamedRoleTypes* _s) : _pd_seq(_s) {}
      inline NamedRoleTypes_var(const NamedRoleTypes_var& _s) {
        if( _s._pd_seq )  _pd_seq = new NamedRoleTypes(*_s._pd_seq);
        else              _pd_seq = 0;
      }
      inline ~NamedRoleTypes_var() { if( _pd_seq )  delete _pd_seq; }
        
      inline NamedRoleTypes_var& operator = (NamedRoleTypes* _s) {
        if( _pd_seq )  delete _pd_seq;
        _pd_seq = _s;
        return *this;
      }
      inline NamedRoleTypes_var& operator = (const NamedRoleTypes_var& _s) {
        if( _s._pd_seq ) {
          if( !_pd_seq )  _pd_seq = new NamedRoleTypes;
          *_pd_seq = *_s._pd_seq;
        } else if( _pd_seq ) {
          delete _pd_seq;
          _pd_seq = 0;
        }
        return *this;
      }
      inline NamedRoleType& operator [] (_CORBA_ULong _s) {
        return (*_pd_seq)[_s];
      }

    

      inline NamedRoleTypes* operator -> () { return _pd_seq; }
      inline const NamedRoleTypes* operator -> () const { return _pd_seq; }
#if defined(__GNUG__)
      inline operator NamedRoleTypes& () const { return *_pd_seq; }
#else
      inline operator const NamedRoleTypes& () const { return *_pd_seq; }
      inline operator NamedRoleTypes& () { return *_pd_seq; }
#endif
        
      inline const NamedRoleTypes& in() const { return *_pd_seq; }
      inline NamedRoleTypes&       inout()    { return *_pd_seq; }
      inline NamedRoleTypes*&      out() {
        if( _pd_seq ) { delete _pd_seq; _pd_seq = 0; }
        return _pd_seq;
      }
      inline NamedRoleTypes* _retn() { NamedRoleTypes* tmp = _pd_seq; _pd_seq = 0; return tmp; }
        
      friend class NamedRoleTypes_out;
      
    private:
      NamedRoleTypes* _pd_seq;
    };

    class NamedRoleTypes_out {
    public:
      inline NamedRoleTypes_out(NamedRoleTypes*& _s) : _data(_s) { _data = 0; }
      inline NamedRoleTypes_out(NamedRoleTypes_var& _s)
        : _data(_s._pd_seq) { _s = (NamedRoleTypes*) 0; }
      inline NamedRoleTypes_out(const NamedRoleTypes_out& _s) : _data(_s._data) {}
      inline NamedRoleTypes_out& operator = (const NamedRoleTypes_out& _s) {
        _data = _s._data;
        return *this;
      }
      inline NamedRoleTypes_out& operator = (NamedRoleTypes* _s) {
        _data = _s;
        return *this;
      }
      inline operator NamedRoleTypes*&()  { return _data; }
      inline NamedRoleTypes*& ptr()       { return _data; }
      inline NamedRoleTypes* operator->() { return _data; }

      inline NamedRoleType& operator [] (_CORBA_ULong _i) {
        return (*_data)[_i];
      }

    

      NamedRoleTypes*& _data;

    private:
      NamedRoleTypes_out();
      NamedRoleTypes_out& operator=(const NamedRoleTypes_var&);
    };

    class RoleTypeError : public ::CORBA::UserException {
    public:
      
      NamedRoles culprits;

    

      inline RoleTypeError() {
        pd_insertToAnyFn    = insertToAnyFn;
        pd_insertToAnyFnNCP = insertToAnyFnNCP;
      }
      RoleTypeError(const RoleTypeError&);
      RoleTypeError(const NamedRoles i_culprits);
      RoleTypeError& operator=(const RoleTypeError&);
      virtual ~RoleTypeError();
      virtual void _raise() const;
      static RoleTypeError* _downcast(::CORBA::Exception*);
      static const RoleTypeError* _downcast(const ::CORBA::Exception*);
      static inline RoleTypeError* _narrow(::CORBA::Exception* _e) {
        return _downcast(_e);
      }
      
      void operator>>=(cdrStream&) const ;
      void operator<<=(cdrStream&) ;

      static _core_attr insertExceptionToAny    insertToAnyFn;
      static _core_attr insertExceptionToAnyNCP insertToAnyFnNCP;

      virtual ::CORBA::Exception* _NP_duplicate() const;

      static _core_attr const char* _PD_repoId;
      static _core_attr const char* _PD_typeId;

    private:
      virtual const char* _NP_typeId() const;
      virtual const char* _NP_repoId(int*) const;
      virtual void _NP_marshal(cdrStream&) const;
    };

    static _dyn_attr const ::CORBA::TypeCode_ptr _tc_RoleTypeError;

    class MaxCardinalityExceeded : public ::CORBA::UserException {
    public:
      
      NamedRoles culprits;

    

      inline MaxCardinalityExceeded() {
        pd_insertToAnyFn    = insertToAnyFn;
        pd_insertToAnyFnNCP = insertToAnyFnNCP;
      }
      MaxCardinalityExceeded(const MaxCardinalityExceeded&);
      MaxCardinalityExceeded(const NamedRoles i_culprits);
      MaxCardinalityExceeded& operator=(const MaxCardinalityExceeded&);
      virtual ~MaxCardinalityExceeded();
      virtual void _raise() const;
      static MaxCardinalityExceeded* _downcast(::CORBA::Exception*);
      static const MaxCardinalityExceeded* _downcast(const ::CORBA::Exception*);
      static inline MaxCardinalityExceeded* _narrow(::CORBA::Exception* _e) {
        return _downcast(_e);
      }
      
      void operator>>=(cdrStream&) const ;
      void operator<<=(cdrStream&) ;

      static _core_attr insertExceptionToAny    insertToAnyFn;
      static _core_attr insertExceptionToAnyNCP insertToAnyFnNCP;

      virtual ::CORBA::Exception* _NP_duplicate() const;

      static _core_attr const char* _PD_repoId;
      static _core_attr const char* _PD_typeId;

    private:
      virtual const char* _NP_typeId() const;
      virtual const char* _NP_repoId(int*) const;
      virtual void _NP_marshal(cdrStream&) const;
    };

    static _dyn_attr const ::CORBA::TypeCode_ptr _tc_MaxCardinalityExceeded;

    class DegreeError : public ::CORBA::UserException {
    public:
      
      ::CORBA::UShort required_degree;

    

      inline DegreeError() {
        pd_insertToAnyFn    = insertToAnyFn;
        pd_insertToAnyFnNCP = insertToAnyFnNCP;
      }
      DegreeError(const DegreeError&);
      DegreeError(::CORBA::UShort i_required_degree);
      DegreeError& operator=(const DegreeError&);
      virtual ~DegreeError();
      virtual void _raise() const;
      static DegreeError* _downcast(::CORBA::Exception*);
      static const DegreeError* _downcast(const ::CORBA::Exception*);
      static inline DegreeError* _narrow(::CORBA::Exception* _e) {
        return _downcast(_e);
      }
      
      void operator>>=(cdrStream&) const ;
      void operator<<=(cdrStream&) ;

      static _core_attr insertExceptionToAny    insertToAnyFn;
      static _core_attr insertExceptionToAnyNCP insertToAnyFnNCP;

      virtual ::CORBA::Exception* _NP_duplicate() const;

      static _core_attr const char* _PD_repoId;
      static _core_attr const char* _PD_typeId;

    private:
      virtual const char* _NP_typeId() const;
      virtual const char* _NP_repoId(int*) const;
      virtual void _NP_marshal(cdrStream&) const;
    };

    static _dyn_attr const ::CORBA::TypeCode_ptr _tc_DegreeError;

    class DuplicateRoleName : public ::CORBA::UserException {
    public:
      
      NamedRoles culprits;

    

      inline DuplicateRoleName() {
        pd_insertToAnyFn    = insertToAnyFn;
        pd_insertToAnyFnNCP = insertToAnyFnNCP;
      }
      DuplicateRoleName(const DuplicateRoleName&);
      DuplicateRoleName(const NamedRoles i_culprits);
      DuplicateRoleName& operator=(const DuplicateRoleName&);
      virtual ~DuplicateRoleName();
      virtual void _raise() const;
      static DuplicateRoleName* _downcast(::CORBA::Exception*);
      static const DuplicateRoleName* _downcast(const ::CORBA::Exception*);
      static inline DuplicateRoleName* _narrow(::CORBA::Exception* _e) {
        return _downcast(_e);
      }
      
      void operator>>=(cdrStream&) const ;
      void operator<<=(cdrStream&) ;

      static _core_attr insertExceptionToAny    insertToAnyFn;
      static _core_attr insertExceptionToAnyNCP insertToAnyFnNCP;

      virtual ::CORBA::Exception* _NP_duplicate() const;

      static _core_attr const char* _PD_repoId;
      static _core_attr const char* _PD_typeId;

    private:
      virtual const char* _NP_typeId() const;
      virtual const char* _NP_repoId(int*) const;
      virtual void _NP_marshal(cdrStream&) const;
    };

    static _dyn_attr const ::CORBA::TypeCode_ptr _tc_DuplicateRoleName;

    class UnknownRoleName : public ::CORBA::UserException {
    public:
      
      NamedRoles culprits;

    

      inline UnknownRoleName() {
        pd_insertToAnyFn    = insertToAnyFn;
        pd_insertToAnyFnNCP = insertToAnyFnNCP;
      }
      UnknownRoleName(const UnknownRoleName&);
      UnknownRoleName(const NamedRoles i_culprits);
      UnknownRoleName& operator=(const UnknownRoleName&);
      virtual ~UnknownRoleName();
      virtual void _raise() const;
      static UnknownRoleName* _downcast(::CORBA::Exception*);
      static const UnknownRoleName* _downcast(const ::CORBA::Exception*);
      static inline UnknownRoleName* _narrow(::CORBA::Exception* _e) {
        return _downcast(_e);
      }
      
      void operator>>=(cdrStream&) const ;
      void operator<<=(cdrStream&) ;

      static _core_attr insertExceptionToAny    insertToAnyFn;
      static _core_attr insertExceptionToAnyNCP insertToAnyFnNCP;

      virtual ::CORBA::Exception* _NP_duplicate() const;

      static _core_attr const char* _PD_repoId;
      static _core_attr const char* _PD_typeId;

    private:
      virtual const char* _NP_typeId() const;
      virtual const char* _NP_repoId(int*) const;
      virtual void _NP_marshal(cdrStream&) const;
    };

    static _dyn_attr const ::CORBA::TypeCode_ptr _tc_UnknownRoleName;

  
  };

  class _objref_RelationshipFactory :
    public virtual ::CORBA::Object,
    public virtual omniObjRef
  {
  public:
    Relationship_ptr create(const ::CosRelationships::NamedRoles& named_roles);
    CORBA::InterfaceDef_ptr relationship_type();
    ::CORBA::UShort degree();
    RelationshipFactory::NamedRoleTypes* named_role_types();

    inline _objref_RelationshipFactory()  { _PR_setobj(0); }  // nil
    _objref_RelationshipFactory(omniIOR*, omniIdentity*);

  protected:
    virtual ~_objref_RelationshipFactory();

    
  private:
    virtual void* _ptrToObjRef(const char*);

    _objref_RelationshipFactory(const _objref_RelationshipFactory&);
    _objref_RelationshipFactory& operator = (const _objref_RelationshipFactory&);
    // not implemented

    friend class RelationshipFactory;
  };

  class _pof_RelationshipFactory : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_RelationshipFactory() : _OMNI_NS(proxyObjectFactory)(RelationshipFactory::_PD_repoId) {}
    virtual ~_pof_RelationshipFactory();

    virtual omniObjRef* newObjRef(omniIOR*,omniIdentity*);
    virtual _CORBA_Boolean is_a(const char*) const;
  };

  class _impl_RelationshipFactory :
    public virtual omniServant
  {
  public:
    virtual ~_impl_RelationshipFactory();

    virtual Relationship_ptr create(const ::CosRelationships::NamedRoles& named_roles) = 0;
    virtual CORBA::InterfaceDef_ptr relationship_type() = 0;
    virtual ::CORBA::UShort degree() = 0;
    virtual RelationshipFactory::NamedRoleTypes* named_role_types() = 0;
    
  public:  // Really protected, workaround for xlC
    virtual _CORBA_Boolean _dispatch(omniCallHandle&);

  private:
    virtual void* _ptrToInterface(const char*);
    virtual const char* _mostDerivedRepoId();
    
  };


  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_RelationshipFactory;

#ifndef __CosRelationships_mRelationship__
#define __CosRelationships_mRelationship__

  class Relationship;
  class _objref_Relationship;
  class _impl_Relationship;
  
  typedef _objref_Relationship* Relationship_ptr;
  typedef Relationship_ptr RelationshipRef;

  class Relationship_Helper {
  public:
    typedef Relationship_ptr _ptr_type;

    static _ptr_type _nil();
    static _CORBA_Boolean is_nil(_ptr_type);
    static void release(_ptr_type);
    static void duplicate(_ptr_type);
    static void marshalObjRef(_ptr_type, cdrStream&);
    static _ptr_type unmarshalObjRef(cdrStream&);
  };

  typedef _CORBA_ObjRef_Var<_objref_Relationship, Relationship_Helper> Relationship_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_Relationship,Relationship_Helper > Relationship_out;

#endif

  // interface Relationship
  class Relationship {
  public:
    // Declarations for this interface type.
    typedef Relationship_ptr _ptr_type;
    typedef Relationship_var _var_type;

    static _ptr_type _duplicate(_ptr_type);
    static _ptr_type _narrow(::CORBA::Object_ptr);
    static _ptr_type _unchecked_narrow(::CORBA::Object_ptr);
    
    static _ptr_type _nil();

    static inline void _marshalObjRef(_ptr_type, cdrStream&);

    static inline _ptr_type _unmarshalObjRef(cdrStream& s) {
      omniObjRef* o = omniObjRef::_unMarshal(_PD_repoId,s);
      if (o)
        return (_ptr_type) o->_ptrToObjRef(_PD_repoId);
      else
        return _nil();
    }

    static _core_attr const char* _PD_repoId;

    // Other IDL defined within this scope.
    class CannotUnlink : public ::CORBA::UserException {
    public:
      
      Roles offending_roles;

    

      inline CannotUnlink() {
        pd_insertToAnyFn    = insertToAnyFn;
        pd_insertToAnyFnNCP = insertToAnyFnNCP;
      }
      CannotUnlink(const CannotUnlink&);
      CannotUnlink(const Roles i_offending_roles);
      CannotUnlink& operator=(const CannotUnlink&);
      virtual ~CannotUnlink();
      virtual void _raise() const;
      static CannotUnlink* _downcast(::CORBA::Exception*);
      static const CannotUnlink* _downcast(const ::CORBA::Exception*);
      static inline CannotUnlink* _narrow(::CORBA::Exception* _e) {
        return _downcast(_e);
      }
      
      void operator>>=(cdrStream&) const ;
      void operator<<=(cdrStream&) ;

      static _core_attr insertExceptionToAny    insertToAnyFn;
      static _core_attr insertExceptionToAnyNCP insertToAnyFnNCP;

      virtual ::CORBA::Exception* _NP_duplicate() const;

      static _core_attr const char* _PD_repoId;
      static _core_attr const char* _PD_typeId;

    private:
      virtual const char* _NP_typeId() const;
      virtual const char* _NP_repoId(int*) const;
      virtual void _NP_marshal(cdrStream&) const;
    };

    static _dyn_attr const ::CORBA::TypeCode_ptr _tc_CannotUnlink;

  
  };

  class _objref_Relationship :
    public virtual CosObjectIdentity::_objref_IdentifiableObject
  {
  public:
    void destroy();
    NamedRoles* named_roles();

    inline _objref_Relationship()  { _PR_setobj(0); }  // nil
    _objref_Relationship(omniIOR*, omniIdentity*);

  protected:
    virtual ~_objref_Relationship();

    
  private:
    virtual void* _ptrToObjRef(const char*);

    _objref_Relationship(const _objref_Relationship&);
    _objref_Relationship& operator = (const _objref_Relationship&);
    // not implemented

    friend class Relationship;
  };

  class _pof_Relationship : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_Relationship() : _OMNI_NS(proxyObjectFactory)(Relationship::_PD_repoId) {}
    virtual ~_pof_Relationship();

    virtual omniObjRef* newObjRef(omniIOR*,omniIdentity*);
    virtual _CORBA_Boolean is_a(const char*) const;
  };

  class _impl_Relationship :
    public virtual CosObjectIdentity::_impl_IdentifiableObject
  {
  public:
    virtual ~_impl_Relationship();

    virtual void destroy() = 0;
    virtual NamedRoles* named_roles() = 0;
    
  public:  // Really protected, workaround for xlC
    virtual _CORBA_Boolean _dispatch(omniCallHandle&);

  private:
    virtual void* _ptrToInterface(const char*);
    virtual const char* _mostDerivedRepoId();
    
  };


  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_Relationship;

#ifndef __CosRelationships_mRole__
#define __CosRelationships_mRole__

  class Role;
  class _objref_Role;
  class _impl_Role;
  
  typedef _objref_Role* Role_ptr;
  typedef Role_ptr RoleRef;

  class Role_Helper {
  public:
    typedef Role_ptr _ptr_type;

    static _ptr_type _nil();
    static _CORBA_Boolean is_nil(_ptr_type);
    static void release(_ptr_type);
    static void duplicate(_ptr_type);
    static void marshalObjRef(_ptr_type, cdrStream&);
    static _ptr_type unmarshalObjRef(cdrStream&);
  };

  typedef _CORBA_ObjRef_Var<_objref_Role, Role_Helper> Role_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_Role,Role_Helper > Role_out;

#endif

  // interface Role
  class Role {
  public:
    // Declarations for this interface type.
    typedef Role_ptr _ptr_type;
    typedef Role_var _var_type;

    static _ptr_type _duplicate(_ptr_type);
    static _ptr_type _narrow(::CORBA::Object_ptr);
    static _ptr_type _unchecked_narrow(::CORBA::Object_ptr);
    
    static _ptr_type _nil();

    static inline void _marshalObjRef(_ptr_type, cdrStream&);

    static inline _ptr_type _unmarshalObjRef(cdrStream& s) {
      omniObjRef* o = omniObjRef::_unMarshal(_PD_repoId,s);
      if (o)
        return (_ptr_type) o->_ptrToObjRef(_PD_repoId);
      else
        return _nil();
    }

    static _core_attr const char* _PD_repoId;

    // Other IDL defined within this scope.
    class UnknownRoleName : public ::CORBA::UserException {
    public:
      
      

      inline UnknownRoleName() {
        pd_insertToAnyFn    = insertToAnyFn;
        pd_insertToAnyFnNCP = insertToAnyFnNCP;
      }
      UnknownRoleName(const UnknownRoleName&);
      
      UnknownRoleName& operator=(const UnknownRoleName&);
      virtual ~UnknownRoleName();
      virtual void _raise() const;
      static UnknownRoleName* _downcast(::CORBA::Exception*);
      static const UnknownRoleName* _downcast(const ::CORBA::Exception*);
      static inline UnknownRoleName* _narrow(::CORBA::Exception* _e) {
        return _downcast(_e);
      }
      
      inline void operator>>=(cdrStream&) const { }
      inline void operator<<=(cdrStream&) { }

      static _core_attr insertExceptionToAny    insertToAnyFn;
      static _core_attr insertExceptionToAnyNCP insertToAnyFnNCP;

      virtual ::CORBA::Exception* _NP_duplicate() const;

      static _core_attr const char* _PD_repoId;
      static _core_attr const char* _PD_typeId;

    private:
      virtual const char* _NP_typeId() const;
      virtual const char* _NP_repoId(int*) const;
      virtual void _NP_marshal(cdrStream&) const;
    };

    static _dyn_attr const ::CORBA::TypeCode_ptr _tc_UnknownRoleName;

    class UnknownRelationship : public ::CORBA::UserException {
    public:
      
      

      inline UnknownRelationship() {
        pd_insertToAnyFn    = insertToAnyFn;
        pd_insertToAnyFnNCP = insertToAnyFnNCP;
      }
      UnknownRelationship(const UnknownRelationship&);
      
      UnknownRelationship& operator=(const UnknownRelationship&);
      virtual ~UnknownRelationship();
      virtual void _raise() const;
      static UnknownRelationship* _downcast(::CORBA::Exception*);
      static const UnknownRelationship* _downcast(const ::CORBA::Exception*);
      static inline UnknownRelationship* _narrow(::CORBA::Exception* _e) {
        return _downcast(_e);
      }
      
      inline void operator>>=(cdrStream&) const { }
      inline void operator<<=(cdrStream&) { }

      static _core_attr insertExceptionToAny    insertToAnyFn;
      static _core_attr insertExceptionToAnyNCP insertToAnyFnNCP;

      virtual ::CORBA::Exception* _NP_duplicate() const;

      static _core_attr const char* _PD_repoId;
      static _core_attr const char* _PD_typeId;

    private:
      virtual const char* _NP_typeId() const;
      virtual const char* _NP_repoId(int*) const;
      virtual void _NP_marshal(cdrStream&) const;
    };

    static _dyn_attr const ::CORBA::TypeCode_ptr _tc_UnknownRelationship;

    class RelationshipTypeError : public ::CORBA::UserException {
    public:
      
      

      inline RelationshipTypeError() {
        pd_insertToAnyFn    = insertToAnyFn;
        pd_insertToAnyFnNCP = insertToAnyFnNCP;
      }
      RelationshipTypeError(const RelationshipTypeError&);
      
      RelationshipTypeError& operator=(const RelationshipTypeError&);
      virtual ~RelationshipTypeError();
      virtual void _raise() const;
      static RelationshipTypeError* _downcast(::CORBA::Exception*);
      static const RelationshipTypeError* _downcast(const ::CORBA::Exception*);
      static inline RelationshipTypeError* _narrow(::CORBA::Exception* _e) {
        return _downcast(_e);
      }
      
      inline void operator>>=(cdrStream&) const { }
      inline void operator<<=(cdrStream&) { }

      static _core_attr insertExceptionToAny    insertToAnyFn;
      static _core_attr insertExceptionToAnyNCP insertToAnyFnNCP;

      virtual ::CORBA::Exception* _NP_duplicate() const;

      static _core_attr const char* _PD_repoId;
      static _core_attr const char* _PD_typeId;

    private:
      virtual const char* _NP_typeId() const;
      virtual const char* _NP_repoId(int*) const;
      virtual void _NP_marshal(cdrStream&) const;
    };

    static _dyn_attr const ::CORBA::TypeCode_ptr _tc_RelationshipTypeError;

    class CannotDestroyRelationship : public ::CORBA::UserException {
    public:
      
      RelationshipHandles offenders;

    

      inline CannotDestroyRelationship() {
        pd_insertToAnyFn    = insertToAnyFn;
        pd_insertToAnyFnNCP = insertToAnyFnNCP;
      }
      CannotDestroyRelationship(const CannotDestroyRelationship&);
      CannotDestroyRelationship(const RelationshipHandles i_offenders);
      CannotDestroyRelationship& operator=(const CannotDestroyRelationship&);
      virtual ~CannotDestroyRelationship();
      virtual void _raise() const;
      static CannotDestroyRelationship* _downcast(::CORBA::Exception*);
      static const CannotDestroyRelationship* _downcast(const ::CORBA::Exception*);
      static inline CannotDestroyRelationship* _narrow(::CORBA::Exception* _e) {
        return _downcast(_e);
      }
      
      void operator>>=(cdrStream&) const ;
      void operator<<=(cdrStream&) ;

      static _core_attr insertExceptionToAny    insertToAnyFn;
      static _core_attr insertExceptionToAnyNCP insertToAnyFnNCP;

      virtual ::CORBA::Exception* _NP_duplicate() const;

      static _core_attr const char* _PD_repoId;
      static _core_attr const char* _PD_typeId;

    private:
      virtual const char* _NP_typeId() const;
      virtual const char* _NP_repoId(int*) const;
      virtual void _NP_marshal(cdrStream&) const;
    };

    static _dyn_attr const ::CORBA::TypeCode_ptr _tc_CannotDestroyRelationship;

    class ParticipatingInRelationship : public ::CORBA::UserException {
    public:
      
      RelationshipHandles the_relationships;

    

      inline ParticipatingInRelationship() {
        pd_insertToAnyFn    = insertToAnyFn;
        pd_insertToAnyFnNCP = insertToAnyFnNCP;
      }
      ParticipatingInRelationship(const ParticipatingInRelationship&);
      ParticipatingInRelationship(const RelationshipHandles i_the_relationships);
      ParticipatingInRelationship& operator=(const ParticipatingInRelationship&);
      virtual ~ParticipatingInRelationship();
      virtual void _raise() const;
      static ParticipatingInRelationship* _downcast(::CORBA::Exception*);
      static const ParticipatingInRelationship* _downcast(const ::CORBA::Exception*);
      static inline ParticipatingInRelationship* _narrow(::CORBA::Exception* _e) {
        return _downcast(_e);
      }
      
      void operator>>=(cdrStream&) const ;
      void operator<<=(cdrStream&) ;

      static _core_attr insertExceptionToAny    insertToAnyFn;
      static _core_attr insertExceptionToAnyNCP insertToAnyFnNCP;

      virtual ::CORBA::Exception* _NP_duplicate() const;

      static _core_attr const char* _PD_repoId;
      static _core_attr const char* _PD_typeId;

    private:
      virtual const char* _NP_typeId() const;
      virtual const char* _NP_repoId(int*) const;
      virtual void _NP_marshal(cdrStream&) const;
    };

    static _dyn_attr const ::CORBA::TypeCode_ptr _tc_ParticipatingInRelationship;

  
  };

  class _objref_Role :
    public virtual ::CORBA::Object,
    public virtual omniObjRef
  {
  public:
    ::CORBA::Object_ptr get_other_related_object(const ::CosRelationships::RelationshipHandle& rel, const char* target_name);
    Role_ptr get_other_role(const ::CosRelationships::RelationshipHandle& rel, const char* target_name);
    void get_relationships(::CORBA::ULong how_many, ::CosRelationships::RelationshipHandles_out rels, ::CosRelationships::RelationshipIterator_out iterator);
    void destroy_relationships();
    void destroy();
    ::CORBA::Boolean check_minimum_cardinality();
    void link(const ::CosRelationships::RelationshipHandle& rel, const ::CosRelationships::NamedRoles& named_roles);
    void unlink(const ::CosRelationships::RelationshipHandle& rel);
    ::CORBA::Object_ptr related_object();

    inline _objref_Role()  { _PR_setobj(0); }  // nil
    _objref_Role(omniIOR*, omniIdentity*);

  protected:
    virtual ~_objref_Role();

    
  private:
    virtual void* _ptrToObjRef(const char*);

    _objref_Role(const _objref_Role&);
    _objref_Role& operator = (const _objref_Role&);
    // not implemented

    friend class Role;
  };

  class _pof_Role : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_Role() : _OMNI_NS(proxyObjectFactory)(Role::_PD_repoId) {}
    virtual ~_pof_Role();

    virtual omniObjRef* newObjRef(omniIOR*,omniIdentity*);
    virtual _CORBA_Boolean is_a(const char*) const;
  };

  class _impl_Role :
    public virtual omniServant
  {
  public:
    virtual ~_impl_Role();

    virtual ::CORBA::Object_ptr get_other_related_object(const ::CosRelationships::RelationshipHandle& rel, const char* target_name) = 0;
    virtual Role_ptr get_other_role(const ::CosRelationships::RelationshipHandle& rel, const char* target_name) = 0;
    virtual void get_relationships(::CORBA::ULong how_many, ::CosRelationships::RelationshipHandles_out rels, ::CosRelationships::RelationshipIterator_out iterator) = 0;
    virtual void destroy_relationships() = 0;
    virtual void destroy() = 0;
    virtual ::CORBA::Boolean check_minimum_cardinality() = 0;
    virtual void link(const ::CosRelationships::RelationshipHandle& rel, const ::CosRelationships::NamedRoles& named_roles) = 0;
    virtual void unlink(const ::CosRelationships::RelationshipHandle& rel) = 0;
    virtual ::CORBA::Object_ptr related_object() = 0;
    
  public:  // Really protected, workaround for xlC
    virtual _CORBA_Boolean _dispatch(omniCallHandle&);

  private:
    virtual void* _ptrToInterface(const char*);
    virtual const char* _mostDerivedRepoId();
    
  };


  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_Role;

#ifndef __CosRelationships_mRoleFactory__
#define __CosRelationships_mRoleFactory__

  class RoleFactory;
  class _objref_RoleFactory;
  class _impl_RoleFactory;
  
  typedef _objref_RoleFactory* RoleFactory_ptr;
  typedef RoleFactory_ptr RoleFactoryRef;

  class RoleFactory_Helper {
  public:
    typedef RoleFactory_ptr _ptr_type;

    static _ptr_type _nil();
    static _CORBA_Boolean is_nil(_ptr_type);
    static void release(_ptr_type);
    static void duplicate(_ptr_type);
    static void marshalObjRef(_ptr_type, cdrStream&);
    static _ptr_type unmarshalObjRef(cdrStream&);
  };

  typedef _CORBA_ObjRef_Var<_objref_RoleFactory, RoleFactory_Helper> RoleFactory_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_RoleFactory,RoleFactory_Helper > RoleFactory_out;

#endif

  // interface RoleFactory
  class RoleFactory {
  public:
    // Declarations for this interface type.
    typedef RoleFactory_ptr _ptr_type;
    typedef RoleFactory_var _var_type;

    static _ptr_type _duplicate(_ptr_type);
    static _ptr_type _narrow(::CORBA::Object_ptr);
    static _ptr_type _unchecked_narrow(::CORBA::Object_ptr);
    
    static _ptr_type _nil();

    static inline void _marshalObjRef(_ptr_type, cdrStream&);

    static inline _ptr_type _unmarshalObjRef(cdrStream& s) {
      omniObjRef* o = omniObjRef::_unMarshal(_PD_repoId,s);
      if (o)
        return (_ptr_type) o->_ptrToObjRef(_PD_repoId);
      else
        return _nil();
    }

    static _core_attr const char* _PD_repoId;

    // Other IDL defined within this scope.
    class NilRelatedObject : public ::CORBA::UserException {
    public:
      
      

      inline NilRelatedObject() {
        pd_insertToAnyFn    = insertToAnyFn;
        pd_insertToAnyFnNCP = insertToAnyFnNCP;
      }
      NilRelatedObject(const NilRelatedObject&);
      
      NilRelatedObject& operator=(const NilRelatedObject&);
      virtual ~NilRelatedObject();
      virtual void _raise() const;
      static NilRelatedObject* _downcast(::CORBA::Exception*);
      static const NilRelatedObject* _downcast(const ::CORBA::Exception*);
      static inline NilRelatedObject* _narrow(::CORBA::Exception* _e) {
        return _downcast(_e);
      }
      
      inline void operator>>=(cdrStream&) const { }
      inline void operator<<=(cdrStream&) { }

      static _core_attr insertExceptionToAny    insertToAnyFn;
      static _core_attr insertExceptionToAnyNCP insertToAnyFnNCP;

      virtual ::CORBA::Exception* _NP_duplicate() const;

      static _core_attr const char* _PD_repoId;
      static _core_attr const char* _PD_typeId;

    private:
      virtual const char* _NP_typeId() const;
      virtual const char* _NP_repoId(int*) const;
      virtual void _NP_marshal(cdrStream&) const;
    };

    static _dyn_attr const ::CORBA::TypeCode_ptr _tc_NilRelatedObject;

    class RelatedObjectTypeError : public ::CORBA::UserException {
    public:
      
      

      inline RelatedObjectTypeError() {
        pd_insertToAnyFn    = insertToAnyFn;
        pd_insertToAnyFnNCP = insertToAnyFnNCP;
      }
      RelatedObjectTypeError(const RelatedObjectTypeError&);
      
      RelatedObjectTypeError& operator=(const RelatedObjectTypeError&);
      virtual ~RelatedObjectTypeError();
      virtual void _raise() const;
      static RelatedObjectTypeError* _downcast(::CORBA::Exception*);
      static const RelatedObjectTypeError* _downcast(const ::CORBA::Exception*);
      static inline RelatedObjectTypeError* _narrow(::CORBA::Exception* _e) {
        return _downcast(_e);
      }
      
      inline void operator>>=(cdrStream&) const { }
      inline void operator<<=(cdrStream&) { }

      static _core_attr insertExceptionToAny    insertToAnyFn;
      static _core_attr insertExceptionToAnyNCP insertToAnyFnNCP;

      virtual ::CORBA::Exception* _NP_duplicate() const;

      static _core_attr const char* _PD_repoId;
      static _core_attr const char* _PD_typeId;

    private:
      virtual const char* _NP_typeId() const;
      virtual const char* _NP_repoId(int*) const;
      virtual void _NP_marshal(cdrStream&) const;
    };

    static _dyn_attr const ::CORBA::TypeCode_ptr _tc_RelatedObjectTypeError;

    static _dyn_attr const ::CORBA::TypeCode_ptr _tc_InterfaceDefs;

    class InterfaceDefs_var;

    class InterfaceDefs : public _CORBA_Unbounded_Sequence_ObjRef< CORBA::_objref_InterfaceDef, _CORBA_ObjRef_Element< CORBA::_objref_InterfaceDef, CORBA::InterfaceDef_Helper> , CORBA::InterfaceDef_Helper >  {
    public:
      typedef InterfaceDefs_var _var_type;
      inline InterfaceDefs() {}
      inline InterfaceDefs(const InterfaceDefs& _s)
        : _CORBA_Unbounded_Sequence_ObjRef< CORBA::_objref_InterfaceDef, _CORBA_ObjRef_Element< CORBA::_objref_InterfaceDef, CORBA::InterfaceDef_Helper> , CORBA::InterfaceDef_Helper > (_s) {}

      inline InterfaceDefs(_CORBA_ULong _max)
        : _CORBA_Unbounded_Sequence_ObjRef< CORBA::_objref_InterfaceDef, _CORBA_ObjRef_Element< CORBA::_objref_InterfaceDef, CORBA::InterfaceDef_Helper> , CORBA::InterfaceDef_Helper > (_max) {}
      inline InterfaceDefs(_CORBA_ULong _max, _CORBA_ULong _len, CORBA::InterfaceDef_ptr* _val, _CORBA_Boolean _rel=0)
        : _CORBA_Unbounded_Sequence_ObjRef< CORBA::_objref_InterfaceDef, _CORBA_ObjRef_Element< CORBA::_objref_InterfaceDef, CORBA::InterfaceDef_Helper> , CORBA::InterfaceDef_Helper > (_max, _len, _val, _rel) {}

    

      inline InterfaceDefs& operator = (const InterfaceDefs& _s) {
        _CORBA_Unbounded_Sequence_ObjRef< CORBA::_objref_InterfaceDef, _CORBA_ObjRef_Element< CORBA::_objref_InterfaceDef, CORBA::InterfaceDef_Helper> , CORBA::InterfaceDef_Helper > ::operator=(_s);
        return *this;
      }
    };

    class InterfaceDefs_out;

    class InterfaceDefs_var {
    public:
      inline InterfaceDefs_var() : _pd_seq(0) {}
      inline InterfaceDefs_var(InterfaceDefs* _s) : _pd_seq(_s) {}
      inline InterfaceDefs_var(const InterfaceDefs_var& _s) {
        if( _s._pd_seq )  _pd_seq = new InterfaceDefs(*_s._pd_seq);
        else              _pd_seq = 0;
      }
      inline ~InterfaceDefs_var() { if( _pd_seq )  delete _pd_seq; }
        
      inline InterfaceDefs_var& operator = (InterfaceDefs* _s) {
        if( _pd_seq )  delete _pd_seq;
        _pd_seq = _s;
        return *this;
      }
      inline InterfaceDefs_var& operator = (const InterfaceDefs_var& _s) {
        if( _s._pd_seq ) {
          if( !_pd_seq )  _pd_seq = new InterfaceDefs;
          *_pd_seq = *_s._pd_seq;
        } else if( _pd_seq ) {
          delete _pd_seq;
          _pd_seq = 0;
        }
        return *this;
      }
      inline _CORBA_ObjRef_Element< CORBA::_objref_InterfaceDef, CORBA::InterfaceDef_Helper>  operator [] (_CORBA_ULong _s) {
        return (*_pd_seq)[_s];
      }

    

      inline InterfaceDefs* operator -> () { return _pd_seq; }
      inline const InterfaceDefs* operator -> () const { return _pd_seq; }
#if defined(__GNUG__)
      inline operator InterfaceDefs& () const { return *_pd_seq; }
#else
      inline operator const InterfaceDefs& () const { return *_pd_seq; }
      inline operator InterfaceDefs& () { return *_pd_seq; }
#endif
        
      inline const InterfaceDefs& in() const { return *_pd_seq; }
      inline InterfaceDefs&       inout()    { return *_pd_seq; }
      inline InterfaceDefs*&      out() {
        if( _pd_seq ) { delete _pd_seq; _pd_seq = 0; }
        return _pd_seq;
      }
      inline InterfaceDefs* _retn() { InterfaceDefs* tmp = _pd_seq; _pd_seq = 0; return tmp; }
        
      friend class InterfaceDefs_out;
      
    private:
      InterfaceDefs* _pd_seq;
    };

    class InterfaceDefs_out {
    public:
      inline InterfaceDefs_out(InterfaceDefs*& _s) : _data(_s) { _data = 0; }
      inline InterfaceDefs_out(InterfaceDefs_var& _s)
        : _data(_s._pd_seq) { _s = (InterfaceDefs*) 0; }
      inline InterfaceDefs_out(const InterfaceDefs_out& _s) : _data(_s._data) {}
      inline InterfaceDefs_out& operator = (const InterfaceDefs_out& _s) {
        _data = _s._data;
        return *this;
      }
      inline InterfaceDefs_out& operator = (InterfaceDefs* _s) {
        _data = _s;
        return *this;
      }
      inline operator InterfaceDefs*&()  { return _data; }
      inline InterfaceDefs*& ptr()       { return _data; }
      inline InterfaceDefs* operator->() { return _data; }

      inline _CORBA_ObjRef_Element< CORBA::_objref_InterfaceDef, CORBA::InterfaceDef_Helper>  operator [] (_CORBA_ULong _i) {
        return (*_data)[_i];
      }

    

      InterfaceDefs*& _data;

    private:
      InterfaceDefs_out();
      InterfaceDefs_out& operator=(const InterfaceDefs_var&);
    };

  
  };

  class _objref_RoleFactory :
    public virtual ::CORBA::Object,
    public virtual omniObjRef
  {
  public:
    Role_ptr create_role(::CORBA::Object_ptr related_object);
    CORBA::InterfaceDef_ptr role_type();
    ::CORBA::ULong max_cardinality();
    ::CORBA::ULong min_cardinality();
    RoleFactory::InterfaceDefs* related_object_types();

    inline _objref_RoleFactory()  { _PR_setobj(0); }  // nil
    _objref_RoleFactory(omniIOR*, omniIdentity*);

  protected:
    virtual ~_objref_RoleFactory();

    
  private:
    virtual void* _ptrToObjRef(const char*);

    _objref_RoleFactory(const _objref_RoleFactory&);
    _objref_RoleFactory& operator = (const _objref_RoleFactory&);
    // not implemented

    friend class RoleFactory;
  };

  class _pof_RoleFactory : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_RoleFactory() : _OMNI_NS(proxyObjectFactory)(RoleFactory::_PD_repoId) {}
    virtual ~_pof_RoleFactory();

    virtual omniObjRef* newObjRef(omniIOR*,omniIdentity*);
    virtual _CORBA_Boolean is_a(const char*) const;
  };

  class _impl_RoleFactory :
    public virtual omniServant
  {
  public:
    virtual ~_impl_RoleFactory();

    virtual Role_ptr create_role(::CORBA::Object_ptr related_object) = 0;
    virtual CORBA::InterfaceDef_ptr role_type() = 0;
    virtual ::CORBA::ULong max_cardinality() = 0;
    virtual ::CORBA::ULong min_cardinality() = 0;
    virtual RoleFactory::InterfaceDefs* related_object_types() = 0;
    
  public:  // Really protected, workaround for xlC
    virtual _CORBA_Boolean _dispatch(omniCallHandle&);

  private:
    virtual void* _ptrToInterface(const char*);
    virtual const char* _mostDerivedRepoId();
    
  };


  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_RoleFactory;

#ifndef __CosRelationships_mRelationshipIterator__
#define __CosRelationships_mRelationshipIterator__

  class RelationshipIterator;
  class _objref_RelationshipIterator;
  class _impl_RelationshipIterator;
  
  typedef _objref_RelationshipIterator* RelationshipIterator_ptr;
  typedef RelationshipIterator_ptr RelationshipIteratorRef;

  class RelationshipIterator_Helper {
  public:
    typedef RelationshipIterator_ptr _ptr_type;

    static _ptr_type _nil();
    static _CORBA_Boolean is_nil(_ptr_type);
    static void release(_ptr_type);
    static void duplicate(_ptr_type);
    static void marshalObjRef(_ptr_type, cdrStream&);
    static _ptr_type unmarshalObjRef(cdrStream&);
  };

  typedef _CORBA_ObjRef_Var<_objref_RelationshipIterator, RelationshipIterator_Helper> RelationshipIterator_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_RelationshipIterator,RelationshipIterator_Helper > RelationshipIterator_out;

#endif

  // interface RelationshipIterator
  class RelationshipIterator {
  public:
    // Declarations for this interface type.
    typedef RelationshipIterator_ptr _ptr_type;
    typedef RelationshipIterator_var _var_type;

    static _ptr_type _duplicate(_ptr_type);
    static _ptr_type _narrow(::CORBA::Object_ptr);
    static _ptr_type _unchecked_narrow(::CORBA::Object_ptr);
    
    static _ptr_type _nil();

    static inline void _marshalObjRef(_ptr_type, cdrStream&);

    static inline _ptr_type _unmarshalObjRef(cdrStream& s) {
      omniObjRef* o = omniObjRef::_unMarshal(_PD_repoId,s);
      if (o)
        return (_ptr_type) o->_ptrToObjRef(_PD_repoId);
      else
        return _nil();
    }

    static _core_attr const char* _PD_repoId;

    // Other IDL defined within this scope.
    
  };

  class _objref_RelationshipIterator :
    public virtual ::CORBA::Object,
    public virtual omniObjRef
  {
  public:
    ::CORBA::Boolean next_one(::CosRelationships::RelationshipHandle_out rel);
    ::CORBA::Boolean next_n(::CORBA::ULong how_many, ::CosRelationships::RelationshipHandles_out rels);
    void destroy();

    inline _objref_RelationshipIterator()  { _PR_setobj(0); }  // nil
    _objref_RelationshipIterator(omniIOR*, omniIdentity*);

  protected:
    virtual ~_objref_RelationshipIterator();

    
  private:
    virtual void* _ptrToObjRef(const char*);

    _objref_RelationshipIterator(const _objref_RelationshipIterator&);
    _objref_RelationshipIterator& operator = (const _objref_RelationshipIterator&);
    // not implemented

    friend class RelationshipIterator;
  };

  class _pof_RelationshipIterator : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_RelationshipIterator() : _OMNI_NS(proxyObjectFactory)(RelationshipIterator::_PD_repoId) {}
    virtual ~_pof_RelationshipIterator();

    virtual omniObjRef* newObjRef(omniIOR*,omniIdentity*);
    virtual _CORBA_Boolean is_a(const char*) const;
  };

  class _impl_RelationshipIterator :
    public virtual omniServant
  {
  public:
    virtual ~_impl_RelationshipIterator();

    virtual ::CORBA::Boolean next_one(::CosRelationships::RelationshipHandle_out rel) = 0;
    virtual ::CORBA::Boolean next_n(::CORBA::ULong how_many, ::CosRelationships::RelationshipHandles_out rels) = 0;
    virtual void destroy() = 0;
    
  public:  // Really protected, workaround for xlC
    virtual _CORBA_Boolean _dispatch(omniCallHandle&);

  private:
    virtual void* _ptrToInterface(const char*);
    virtual const char* _mostDerivedRepoId();
    
  };


  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_RelationshipIterator;

_CORBA_MODULE_END



_CORBA_MODULE POA_CosRelationships
_CORBA_MODULE_BEG

  class RelationshipFactory :
    public virtual CosRelationships::_impl_RelationshipFactory,
    public virtual ::PortableServer::ServantBase
  {
  public:
    virtual ~RelationshipFactory();

    inline ::CosRelationships::RelationshipFactory_ptr _this() {
      return (::CosRelationships::RelationshipFactory_ptr) _do_this(::CosRelationships::RelationshipFactory::_PD_repoId);
    }
  };

  class Relationship :
    public virtual CosRelationships::_impl_Relationship,
    public virtual POA_CosObjectIdentity::IdentifiableObject
  {
  public:
    virtual ~Relationship();

    inline ::CosRelationships::Relationship_ptr _this() {
      return (::CosRelationships::Relationship_ptr) _do_this(::CosRelationships::Relationship::_PD_repoId);
    }
  };

  class Role :
    public virtual CosRelationships::_impl_Role,
    public virtual ::PortableServer::ServantBase
  {
  public:
    virtual ~Role();

    inline ::CosRelationships::Role_ptr _this() {
      return (::CosRelationships::Role_ptr) _do_this(::CosRelationships::Role::_PD_repoId);
    }
  };

  class RoleFactory :
    public virtual CosRelationships::_impl_RoleFactory,
    public virtual ::PortableServer::ServantBase
  {
  public:
    virtual ~RoleFactory();

    inline ::CosRelationships::RoleFactory_ptr _this() {
      return (::CosRelationships::RoleFactory_ptr) _do_this(::CosRelationships::RoleFactory::_PD_repoId);
    }
  };

  class RelationshipIterator :
    public virtual CosRelationships::_impl_RelationshipIterator,
    public virtual ::PortableServer::ServantBase
  {
  public:
    virtual ~RelationshipIterator();

    inline ::CosRelationships::RelationshipIterator_ptr _this() {
      return (::CosRelationships::RelationshipIterator_ptr) _do_this(::CosRelationships::RelationshipIterator::_PD_repoId);
    }
  };

_CORBA_MODULE_END



_CORBA_MODULE OBV_CosRelationships
_CORBA_MODULE_BEG

_CORBA_MODULE_END





#undef _core_attr
#undef _dyn_attr

void operator<<=(::CORBA::Any& _a, const CosRelationships::Roles& _s);
void operator<<=(::CORBA::Any& _a, CosRelationships::Roles* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, CosRelationships::Roles*& _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const CosRelationships::Roles*& _sp);

void operator<<=(::CORBA::Any& _a, const CosRelationships::RoleNames& _s);
void operator<<=(::CORBA::Any& _a, CosRelationships::RoleNames* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, CosRelationships::RoleNames*& _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const CosRelationships::RoleNames*& _sp);

extern void operator<<=(::CORBA::Any& _a, const CosRelationships::NamedRole& _s);
extern void operator<<=(::CORBA::Any& _a, CosRelationships::NamedRole* _sp);
extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, CosRelationships::NamedRole*& _sp);
extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const CosRelationships::NamedRole*& _sp);

void operator<<=(::CORBA::Any& _a, const CosRelationships::NamedRoles& _s);
void operator<<=(::CORBA::Any& _a, CosRelationships::NamedRoles* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, CosRelationships::NamedRoles*& _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const CosRelationships::NamedRoles*& _sp);

extern void operator<<=(::CORBA::Any& _a, const CosRelationships::RelationshipHandle& _s);
extern void operator<<=(::CORBA::Any& _a, CosRelationships::RelationshipHandle* _sp);
extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, CosRelationships::RelationshipHandle*& _sp);
extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const CosRelationships::RelationshipHandle*& _sp);

void operator<<=(::CORBA::Any& _a, const CosRelationships::RelationshipHandles& _s);
void operator<<=(::CORBA::Any& _a, CosRelationships::RelationshipHandles* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, CosRelationships::RelationshipHandles*& _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const CosRelationships::RelationshipHandles*& _sp);

extern void operator<<=(::CORBA::Any& _a, const CosRelationships::RelationshipFactory::NamedRoleType& _s);
extern void operator<<=(::CORBA::Any& _a, CosRelationships::RelationshipFactory::NamedRoleType* _sp);
extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, CosRelationships::RelationshipFactory::NamedRoleType*& _sp);
extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const CosRelationships::RelationshipFactory::NamedRoleType*& _sp);

void operator<<=(::CORBA::Any& _a, const CosRelationships::RelationshipFactory::NamedRoleTypes& _s);
void operator<<=(::CORBA::Any& _a, CosRelationships::RelationshipFactory::NamedRoleTypes* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, CosRelationships::RelationshipFactory::NamedRoleTypes*& _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const CosRelationships::RelationshipFactory::NamedRoleTypes*& _sp);

void operator<<=(::CORBA::Any& _a, const CosRelationships::RelationshipFactory::RoleTypeError& _s);
void operator<<=(::CORBA::Any& _a, const CosRelationships::RelationshipFactory::RoleTypeError* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const CosRelationships::RelationshipFactory::RoleTypeError*& _sp);

void operator<<=(::CORBA::Any& _a, const CosRelationships::RelationshipFactory::MaxCardinalityExceeded& _s);
void operator<<=(::CORBA::Any& _a, const CosRelationships::RelationshipFactory::MaxCardinalityExceeded* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const CosRelationships::RelationshipFactory::MaxCardinalityExceeded*& _sp);

void operator<<=(::CORBA::Any& _a, const CosRelationships::RelationshipFactory::DegreeError& _s);
void operator<<=(::CORBA::Any& _a, const CosRelationships::RelationshipFactory::DegreeError* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const CosRelationships::RelationshipFactory::DegreeError*& _sp);

void operator<<=(::CORBA::Any& _a, const CosRelationships::RelationshipFactory::DuplicateRoleName& _s);
void operator<<=(::CORBA::Any& _a, const CosRelationships::RelationshipFactory::DuplicateRoleName* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const CosRelationships::RelationshipFactory::DuplicateRoleName*& _sp);

void operator<<=(::CORBA::Any& _a, const CosRelationships::RelationshipFactory::UnknownRoleName& _s);
void operator<<=(::CORBA::Any& _a, const CosRelationships::RelationshipFactory::UnknownRoleName* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const CosRelationships::RelationshipFactory::UnknownRoleName*& _sp);

void operator<<=(::CORBA::Any& _a, CosRelationships::RelationshipFactory_ptr _s);
void operator<<=(::CORBA::Any& _a, CosRelationships::RelationshipFactory_ptr* _s);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, CosRelationships::RelationshipFactory_ptr& _s);

void operator<<=(::CORBA::Any& _a, const CosRelationships::Relationship::CannotUnlink& _s);
void operator<<=(::CORBA::Any& _a, const CosRelationships::Relationship::CannotUnlink* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const CosRelationships::Relationship::CannotUnlink*& _sp);

void operator<<=(::CORBA::Any& _a, CosRelationships::Relationship_ptr _s);
void operator<<=(::CORBA::Any& _a, CosRelationships::Relationship_ptr* _s);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, CosRelationships::Relationship_ptr& _s);

void operator<<=(::CORBA::Any& _a, const CosRelationships::Role::UnknownRoleName& _s);
void operator<<=(::CORBA::Any& _a, const CosRelationships::Role::UnknownRoleName* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const CosRelationships::Role::UnknownRoleName*& _sp);

void operator<<=(::CORBA::Any& _a, const CosRelationships::Role::UnknownRelationship& _s);
void operator<<=(::CORBA::Any& _a, const CosRelationships::Role::UnknownRelationship* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const CosRelationships::Role::UnknownRelationship*& _sp);

void operator<<=(::CORBA::Any& _a, const CosRelationships::Role::RelationshipTypeError& _s);
void operator<<=(::CORBA::Any& _a, const CosRelationships::Role::RelationshipTypeError* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const CosRelationships::Role::RelationshipTypeError*& _sp);

void operator<<=(::CORBA::Any& _a, const CosRelationships::Role::CannotDestroyRelationship& _s);
void operator<<=(::CORBA::Any& _a, const CosRelationships::Role::CannotDestroyRelationship* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const CosRelationships::Role::CannotDestroyRelationship*& _sp);

void operator<<=(::CORBA::Any& _a, const CosRelationships::Role::ParticipatingInRelationship& _s);
void operator<<=(::CORBA::Any& _a, const CosRelationships::Role::ParticipatingInRelationship* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const CosRelationships::Role::ParticipatingInRelationship*& _sp);

void operator<<=(::CORBA::Any& _a, CosRelationships::Role_ptr _s);
void operator<<=(::CORBA::Any& _a, CosRelationships::Role_ptr* _s);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, CosRelationships::Role_ptr& _s);

void operator<<=(::CORBA::Any& _a, const CosRelationships::RoleFactory::NilRelatedObject& _s);
void operator<<=(::CORBA::Any& _a, const CosRelationships::RoleFactory::NilRelatedObject* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const CosRelationships::RoleFactory::NilRelatedObject*& _sp);

void operator<<=(::CORBA::Any& _a, const CosRelationships::RoleFactory::RelatedObjectTypeError& _s);
void operator<<=(::CORBA::Any& _a, const CosRelationships::RoleFactory::RelatedObjectTypeError* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const CosRelationships::RoleFactory::RelatedObjectTypeError*& _sp);

void operator<<=(::CORBA::Any& _a, const CosRelationships::RoleFactory::InterfaceDefs& _s);
void operator<<=(::CORBA::Any& _a, CosRelationships::RoleFactory::InterfaceDefs* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, CosRelationships::RoleFactory::InterfaceDefs*& _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const CosRelationships::RoleFactory::InterfaceDefs*& _sp);

void operator<<=(::CORBA::Any& _a, CosRelationships::RoleFactory_ptr _s);
void operator<<=(::CORBA::Any& _a, CosRelationships::RoleFactory_ptr* _s);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, CosRelationships::RoleFactory_ptr& _s);

void operator<<=(::CORBA::Any& _a, CosRelationships::RelationshipIterator_ptr _s);
void operator<<=(::CORBA::Any& _a, CosRelationships::RelationshipIterator_ptr* _s);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, CosRelationships::RelationshipIterator_ptr& _s);



inline void
CosRelationships::RelationshipFactory::_marshalObjRef(::CosRelationships::RelationshipFactory_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosRelationships::Relationship::_marshalObjRef(::CosRelationships::Relationship_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosRelationships::Role::_marshalObjRef(::CosRelationships::Role_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosRelationships::RoleFactory::_marshalObjRef(::CosRelationships::RoleFactory_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosRelationships::RelationshipIterator::_marshalObjRef(::CosRelationships::RelationshipIterator_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}




#ifdef   USE_stub_in_nt_dll_NOT_DEFINED_CosRelationships
# undef  USE_stub_in_nt_dll
# undef  USE_stub_in_nt_dll_NOT_DEFINED_CosRelationships
#endif
#ifdef   USE_core_stub_in_nt_dll_NOT_DEFINED_CosRelationships
# undef  USE_core_stub_in_nt_dll
# undef  USE_core_stub_in_nt_dll_NOT_DEFINED_CosRelationships
#endif
#ifdef   USE_dyn_stub_in_nt_dll_NOT_DEFINED_CosRelationships
# undef  USE_dyn_stub_in_nt_dll
# undef  USE_dyn_stub_in_nt_dll_NOT_DEFINED_CosRelationships
#endif

#endif  // __CosRelationships_hh__