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

// This file is generated by omniidl (C++ backend)- omniORB_4_1. Do not edit.
#ifndef __CosCollection_hh__
#define __CosCollection_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_CosCollection
#endif
#ifndef  USE_core_stub_in_nt_dll
# define USE_core_stub_in_nt_dll_NOT_DEFINED_CosCollection
#endif
#ifndef  USE_dyn_stub_in_nt_dll
# define USE_dyn_stub_in_nt_dll_NOT_DEFINED_CosCollection
#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



#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 CosCollection

_CORBA_MODULE_BEG

#ifndef __CosCollection_mCollection__
#define __CosCollection_mCollection__

  class Collection;
  class _objref_Collection;
  class _impl_Collection;
  
  typedef _objref_Collection* Collection_ptr;
  typedef Collection_ptr CollectionRef;

  class Collection_Helper {
  public:
    typedef Collection_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_Collection, Collection_Helper> Collection_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_Collection,Collection_Helper > Collection_out;

#endif

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_AnySequence;

  class AnySequence_var;

  class AnySequence : public _CORBA_Unbounded_Sequence< ::CORBA::Any >  {
  public:
    typedef AnySequence_var _var_type;
    inline AnySequence() {}
    inline AnySequence(const AnySequence& _s)
      : _CORBA_Unbounded_Sequence< ::CORBA::Any > (_s) {}

    inline AnySequence(_CORBA_ULong _max)
      : _CORBA_Unbounded_Sequence< ::CORBA::Any > (_max) {}
    inline AnySequence(_CORBA_ULong _max, _CORBA_ULong _len, ::CORBA::Any* _val, _CORBA_Boolean _rel=0)
      : _CORBA_Unbounded_Sequence< ::CORBA::Any > (_max, _len, _val, _rel) {}

  

    inline AnySequence& operator = (const AnySequence& _s) {
      _CORBA_Unbounded_Sequence< ::CORBA::Any > ::operator=(_s);
      return *this;
    }
  };

  class AnySequence_out;

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

  

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

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

    inline ::CORBA::Any& operator [] (_CORBA_ULong _i) {
      return (*_data)[_i];
    }

  

    AnySequence*& _data;

  private:
    AnySequence_out();
    AnySequence_out& operator=(const AnySequence_var&);
  };

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_Istring;

  typedef char* Istring;
  typedef ::CORBA::String_var Istring_var;
  typedef ::CORBA::String_out Istring_out;

  struct NVPair {
    typedef _CORBA_ConstrType_Variable_Var<NVPair> _var_type;

    
    ::CORBA::String_member name;

    ::CORBA::Any value;

  

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

  typedef NVPair::_var_type NVPair_var;

  typedef _CORBA_ConstrType_Variable_OUT_arg< NVPair,NVPair_var > NVPair_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_NVPair;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_ParameterList;

  class ParameterList_var;

  class ParameterList : public _CORBA_Unbounded_Sequence< NVPair >  {
  public:
    typedef ParameterList_var _var_type;
    inline ParameterList() {}
    inline ParameterList(const ParameterList& _s)
      : _CORBA_Unbounded_Sequence< NVPair > (_s) {}

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

  

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

  class ParameterList_out;

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

  

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

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

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

  

    ParameterList*& _data;

  private:
    ParameterList_out();
    ParameterList_out& operator=(const ParameterList_var&);
  };

  class EmptyCollection : public ::CORBA::UserException {
  public:
    
    

    inline EmptyCollection() {
      pd_insertToAnyFn    = insertToAnyFn;
      pd_insertToAnyFnNCP = insertToAnyFnNCP;
    }
    EmptyCollection(const EmptyCollection&);
    
    EmptyCollection& operator=(const EmptyCollection&);
    virtual ~EmptyCollection();
    virtual void _raise() const;
    static EmptyCollection* _downcast(::CORBA::Exception*);
    static const EmptyCollection* _downcast(const ::CORBA::Exception*);
    static inline EmptyCollection* _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;
  };

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_EmptyCollection;

  class PositionInvalid : public ::CORBA::UserException {
  public:
    
    

    inline PositionInvalid() {
      pd_insertToAnyFn    = insertToAnyFn;
      pd_insertToAnyFnNCP = insertToAnyFnNCP;
    }
    PositionInvalid(const PositionInvalid&);
    
    PositionInvalid& operator=(const PositionInvalid&);
    virtual ~PositionInvalid();
    virtual void _raise() const;
    static PositionInvalid* _downcast(::CORBA::Exception*);
    static const PositionInvalid* _downcast(const ::CORBA::Exception*);
    static inline PositionInvalid* _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;
  };

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_PositionInvalid;

  enum IteratorInvalidReason { is_invalid, is_not_for_collection, is_const /*, __max_IteratorInvalidReason=0xffffffff */ };
  typedef IteratorInvalidReason& IteratorInvalidReason_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_IteratorInvalidReason;

  class IteratorInvalid : public ::CORBA::UserException {
  public:
    
    IteratorInvalidReason why;

  

    inline IteratorInvalid() {
      pd_insertToAnyFn    = insertToAnyFn;
      pd_insertToAnyFnNCP = insertToAnyFnNCP;
    }
    IteratorInvalid(const IteratorInvalid&);
    IteratorInvalid(IteratorInvalidReason i_why);
    IteratorInvalid& operator=(const IteratorInvalid&);
    virtual ~IteratorInvalid();
    virtual void _raise() const;
    static IteratorInvalid* _downcast(::CORBA::Exception*);
    static const IteratorInvalid* _downcast(const ::CORBA::Exception*);
    static inline IteratorInvalid* _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;
  };

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_IteratorInvalid;

  class IteratorInBetween : public ::CORBA::UserException {
  public:
    
    

    inline IteratorInBetween() {
      pd_insertToAnyFn    = insertToAnyFn;
      pd_insertToAnyFnNCP = insertToAnyFnNCP;
    }
    IteratorInBetween(const IteratorInBetween&);
    
    IteratorInBetween& operator=(const IteratorInBetween&);
    virtual ~IteratorInBetween();
    virtual void _raise() const;
    static IteratorInBetween* _downcast(::CORBA::Exception*);
    static const IteratorInBetween* _downcast(const ::CORBA::Exception*);
    static inline IteratorInBetween* _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;
  };

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_IteratorInBetween;

  enum ElementInvalidReason { element_type_invalid, positioning_property_invalid, element_exists /*, __max_ElementInvalidReason=0xffffffff */ };
  typedef ElementInvalidReason& ElementInvalidReason_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_ElementInvalidReason;

  class ElementInvalid : public ::CORBA::UserException {
  public:
    
    ElementInvalidReason why;

  

    inline ElementInvalid() {
      pd_insertToAnyFn    = insertToAnyFn;
      pd_insertToAnyFnNCP = insertToAnyFnNCP;
    }
    ElementInvalid(const ElementInvalid&);
    ElementInvalid(ElementInvalidReason i_why);
    ElementInvalid& operator=(const ElementInvalid&);
    virtual ~ElementInvalid();
    virtual void _raise() const;
    static ElementInvalid* _downcast(::CORBA::Exception*);
    static const ElementInvalid* _downcast(const ::CORBA::Exception*);
    static inline ElementInvalid* _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;
  };

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_ElementInvalid;

  class KeyInvalid : public ::CORBA::UserException {
  public:
    
    

    inline KeyInvalid() {
      pd_insertToAnyFn    = insertToAnyFn;
      pd_insertToAnyFnNCP = insertToAnyFnNCP;
    }
    KeyInvalid(const KeyInvalid&);
    
    KeyInvalid& operator=(const KeyInvalid&);
    virtual ~KeyInvalid();
    virtual void _raise() const;
    static KeyInvalid* _downcast(::CORBA::Exception*);
    static const KeyInvalid* _downcast(const ::CORBA::Exception*);
    static inline KeyInvalid* _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;
  };

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_KeyInvalid;

  class ParameterInvalid : public ::CORBA::UserException {
  public:
    
    ::CORBA::ULong which;

    ::CORBA::String_member why;

  

    inline ParameterInvalid() {
      pd_insertToAnyFn    = insertToAnyFn;
      pd_insertToAnyFnNCP = insertToAnyFnNCP;
    }
    ParameterInvalid(const ParameterInvalid&);
    ParameterInvalid(::CORBA::ULong i_which, const char* i_why);
    ParameterInvalid& operator=(const ParameterInvalid&);
    virtual ~ParameterInvalid();
    virtual void _raise() const;
    static ParameterInvalid* _downcast(::CORBA::Exception*);
    static const ParameterInvalid* _downcast(const ::CORBA::Exception*);
    static inline ParameterInvalid* _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;
  };

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_ParameterInvalid;

#ifndef __CosCollection_mOperations__
#define __CosCollection_mOperations__

  class Operations;
  class _objref_Operations;
  class _impl_Operations;
  
  typedef _objref_Operations* Operations_ptr;
  typedef Operations_ptr OperationsRef;

  class Operations_Helper {
  public:
    typedef Operations_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_Operations, Operations_Helper> Operations_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_Operations,Operations_Helper > Operations_out;

#endif

  // interface Operations
  class Operations {
  public:
    // Declarations for this interface type.
    typedef Operations_ptr _ptr_type;
    typedef Operations_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_Operations :
    public virtual ::CORBA::Object,
    public virtual omniObjRef
  {
  public:
    ::CORBA::Boolean check_element_type(const ::CORBA::Any& element);
    ::CORBA::Boolean equal(const ::CORBA::Any& element1, const ::CORBA::Any& element2);
    ::CORBA::Long compare(const ::CORBA::Any& element1, const ::CORBA::Any& element2);
    ::CORBA::ULong hash(const ::CORBA::Any& element, ::CORBA::ULong value);
    ::CORBA::Any* key(const ::CORBA::Any& element);
    ::CORBA::Boolean check_key_type(const ::CORBA::Any& a_key);
    ::CORBA::Boolean key_equal(const ::CORBA::Any& a_key1, const ::CORBA::Any& a_key2);
    ::CORBA::Long key_compare(const ::CORBA::Any& a_key1, const ::CORBA::Any& a_key2);
    ::CORBA::ULong key_hash(const ::CORBA::Any& thisKey, ::CORBA::ULong value);
    void destroy();
    ::CORBA::TypeCode_ptr element_type();
    ::CORBA::TypeCode_ptr key_type();

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

  protected:
    virtual ~_objref_Operations();

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

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

    friend class Operations;
  };

  class _pof_Operations : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_Operations() : _OMNI_NS(proxyObjectFactory)(Operations::_PD_repoId) {}
    virtual ~_pof_Operations();

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

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

    virtual ::CORBA::Boolean check_element_type(const ::CORBA::Any& element) = 0;
    virtual ::CORBA::Boolean equal(const ::CORBA::Any& element1, const ::CORBA::Any& element2) = 0;
    virtual ::CORBA::Long compare(const ::CORBA::Any& element1, const ::CORBA::Any& element2) = 0;
    virtual ::CORBA::ULong hash(const ::CORBA::Any& element, ::CORBA::ULong value) = 0;
    virtual ::CORBA::Any* key(const ::CORBA::Any& element) = 0;
    virtual ::CORBA::Boolean check_key_type(const ::CORBA::Any& a_key) = 0;
    virtual ::CORBA::Boolean key_equal(const ::CORBA::Any& a_key1, const ::CORBA::Any& a_key2) = 0;
    virtual ::CORBA::Long key_compare(const ::CORBA::Any& a_key1, const ::CORBA::Any& a_key2) = 0;
    virtual ::CORBA::ULong key_hash(const ::CORBA::Any& thisKey, ::CORBA::ULong value) = 0;
    virtual void destroy() = 0;
    virtual ::CORBA::TypeCode_ptr element_type() = 0;
    virtual ::CORBA::TypeCode_ptr key_type() = 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_Operations;

#ifndef __CosCollection_mCommand__
#define __CosCollection_mCommand__

  class Command;
  class _objref_Command;
  class _impl_Command;
  
  typedef _objref_Command* Command_ptr;
  typedef Command_ptr CommandRef;

  class Command_Helper {
  public:
    typedef Command_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_Command, Command_Helper> Command_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_Command,Command_Helper > Command_out;

#endif

  // interface Command
  class Command {
  public:
    // Declarations for this interface type.
    typedef Command_ptr _ptr_type;
    typedef Command_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_Command :
    public virtual ::CORBA::Object,
    public virtual omniObjRef
  {
  public:
    ::CORBA::Boolean do_on(const ::CORBA::Any& element);

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

  protected:
    virtual ~_objref_Command();

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

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

    friend class Command;
  };

  class _pof_Command : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_Command() : _OMNI_NS(proxyObjectFactory)(Command::_PD_repoId) {}
    virtual ~_pof_Command();

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

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

    virtual ::CORBA::Boolean do_on(const ::CORBA::Any& element) = 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_Command;

#ifndef __CosCollection_mComparator__
#define __CosCollection_mComparator__

  class Comparator;
  class _objref_Comparator;
  class _impl_Comparator;
  
  typedef _objref_Comparator* Comparator_ptr;
  typedef Comparator_ptr ComparatorRef;

  class Comparator_Helper {
  public:
    typedef Comparator_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_Comparator, Comparator_Helper> Comparator_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_Comparator,Comparator_Helper > Comparator_out;

#endif

  // interface Comparator
  class Comparator {
  public:
    // Declarations for this interface type.
    typedef Comparator_ptr _ptr_type;
    typedef Comparator_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_Comparator :
    public virtual ::CORBA::Object,
    public virtual omniObjRef
  {
  public:
    ::CORBA::Long compare(const ::CORBA::Any& element1, const ::CORBA::Any& element2);

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

  protected:
    virtual ~_objref_Comparator();

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

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

    friend class Comparator;
  };

  class _pof_Comparator : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_Comparator() : _OMNI_NS(proxyObjectFactory)(Comparator::_PD_repoId) {}
    virtual ~_pof_Comparator();

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

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

    virtual ::CORBA::Long compare(const ::CORBA::Any& element1, const ::CORBA::Any& element2) = 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_Comparator;

#ifndef __CosCollection_mIterator__
#define __CosCollection_mIterator__

  class Iterator;
  class _objref_Iterator;
  class _impl_Iterator;
  
  typedef _objref_Iterator* Iterator_ptr;
  typedef Iterator_ptr IteratorRef;

  class Iterator_Helper {
  public:
    typedef Iterator_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_Iterator, Iterator_Helper> Iterator_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_Iterator,Iterator_Helper > Iterator_out;

#endif

  // interface Iterator
  class Iterator {
  public:
    // Declarations for this interface type.
    typedef Iterator_ptr _ptr_type;
    typedef Iterator_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_Iterator :
    public virtual ::CORBA::Object,
    public virtual omniObjRef
  {
  public:
    ::CORBA::Boolean set_to_first_element();
    ::CORBA::Boolean set_to_next_element();
    ::CORBA::Boolean set_to_next_nth_element(::CORBA::ULong n);
    ::CORBA::Boolean retrieve_element(::CORBA::Any_OUT_arg element);
    ::CORBA::Boolean retrieve_element_set_to_next(::CORBA::Any_OUT_arg element, ::CORBA::Boolean& more);
    ::CORBA::Boolean retrieve_next_n_elements(::CORBA::ULong n, ::CosCollection::AnySequence_out result, ::CORBA::Boolean& more);
    ::CORBA::Boolean not_equal_retrieve_element_set_to_next(::CosCollection::Iterator_ptr test, ::CORBA::Any_OUT_arg element);
    void remove_element();
    ::CORBA::Boolean remove_element_set_to_next();
    ::CORBA::Boolean remove_next_n_elements(::CORBA::ULong n, ::CORBA::ULong& actual_number);
    ::CORBA::Boolean not_equal_remove_element_set_to_next(::CosCollection::Iterator_ptr test);
    void replace_element(const ::CORBA::Any& element);
    ::CORBA::Boolean replace_element_set_to_next(const ::CORBA::Any& element);
    ::CORBA::Boolean replace_next_n_elements(const ::CosCollection::AnySequence& elements, ::CORBA::ULong& actual_number);
    ::CORBA::Boolean not_equal_replace_element_set_to_next(::CosCollection::Iterator_ptr test, const ::CORBA::Any& element);
    ::CORBA::Boolean add_element_set_iterator(const ::CORBA::Any& element);
    ::CORBA::Boolean add_n_elements_set_iterator(const ::CosCollection::AnySequence& elements, ::CORBA::ULong& actual_number);
    void invalidate();
    ::CORBA::Boolean is_valid();
    ::CORBA::Boolean is_in_between();
    ::CORBA::Boolean is_for(::CosCollection::Collection_ptr collector);
    ::CORBA::Boolean is_const();
    ::CORBA::Boolean is_equal(::CosCollection::Iterator_ptr test);
    Iterator_ptr clone();
    void assign(::CosCollection::Iterator_ptr from_where);
    void destroy();

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

  protected:
    virtual ~_objref_Iterator();

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

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

    friend class Iterator;
  };

  class _pof_Iterator : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_Iterator() : _OMNI_NS(proxyObjectFactory)(Iterator::_PD_repoId) {}
    virtual ~_pof_Iterator();

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

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

    virtual ::CORBA::Boolean set_to_first_element() = 0;
    virtual ::CORBA::Boolean set_to_next_element() = 0;
    virtual ::CORBA::Boolean set_to_next_nth_element(::CORBA::ULong n) = 0;
    virtual ::CORBA::Boolean retrieve_element(::CORBA::Any_OUT_arg element) = 0;
    virtual ::CORBA::Boolean retrieve_element_set_to_next(::CORBA::Any_OUT_arg element, ::CORBA::Boolean& more) = 0;
    virtual ::CORBA::Boolean retrieve_next_n_elements(::CORBA::ULong n, ::CosCollection::AnySequence_out result, ::CORBA::Boolean& more) = 0;
    virtual ::CORBA::Boolean not_equal_retrieve_element_set_to_next(::CosCollection::Iterator_ptr test, ::CORBA::Any_OUT_arg element) = 0;
    virtual void remove_element() = 0;
    virtual ::CORBA::Boolean remove_element_set_to_next() = 0;
    virtual ::CORBA::Boolean remove_next_n_elements(::CORBA::ULong n, ::CORBA::ULong& actual_number) = 0;
    virtual ::CORBA::Boolean not_equal_remove_element_set_to_next(::CosCollection::Iterator_ptr test) = 0;
    virtual void replace_element(const ::CORBA::Any& element) = 0;
    virtual ::CORBA::Boolean replace_element_set_to_next(const ::CORBA::Any& element) = 0;
    virtual ::CORBA::Boolean replace_next_n_elements(const ::CosCollection::AnySequence& elements, ::CORBA::ULong& actual_number) = 0;
    virtual ::CORBA::Boolean not_equal_replace_element_set_to_next(::CosCollection::Iterator_ptr test, const ::CORBA::Any& element) = 0;
    virtual ::CORBA::Boolean add_element_set_iterator(const ::CORBA::Any& element) = 0;
    virtual ::CORBA::Boolean add_n_elements_set_iterator(const ::CosCollection::AnySequence& elements, ::CORBA::ULong& actual_number) = 0;
    virtual void invalidate() = 0;
    virtual ::CORBA::Boolean is_valid() = 0;
    virtual ::CORBA::Boolean is_in_between() = 0;
    virtual ::CORBA::Boolean is_for(::CosCollection::Collection_ptr collector) = 0;
    virtual ::CORBA::Boolean is_const() = 0;
    virtual ::CORBA::Boolean is_equal(::CosCollection::Iterator_ptr test) = 0;
    virtual Iterator_ptr clone() = 0;
    virtual void assign(::CosCollection::Iterator_ptr from_where) = 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_Iterator;

#ifndef __CosCollection_mOrderedIterator__
#define __CosCollection_mOrderedIterator__

  class OrderedIterator;
  class _objref_OrderedIterator;
  class _impl_OrderedIterator;
  
  typedef _objref_OrderedIterator* OrderedIterator_ptr;
  typedef OrderedIterator_ptr OrderedIteratorRef;

  class OrderedIterator_Helper {
  public:
    typedef OrderedIterator_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_OrderedIterator, OrderedIterator_Helper> OrderedIterator_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_OrderedIterator,OrderedIterator_Helper > OrderedIterator_out;

#endif

  // interface OrderedIterator
  class OrderedIterator {
  public:
    // Declarations for this interface type.
    typedef OrderedIterator_ptr _ptr_type;
    typedef OrderedIterator_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_OrderedIterator :
    public virtual _objref_Iterator
  {
  public:
    ::CORBA::Boolean set_to_last_element();
    ::CORBA::Boolean set_to_previous_element();
    ::CORBA::Boolean set_to_nth_previous_element(::CORBA::ULong n);
    void set_to_position(::CORBA::ULong position);
    ::CORBA::ULong position();
    ::CORBA::Boolean retrieve_element_set_to_previous(::CORBA::Any_OUT_arg element, ::CORBA::Boolean& more);
    ::CORBA::Boolean retrieve_previous_n_elements(::CORBA::ULong n, ::CosCollection::AnySequence_out result, ::CORBA::Boolean& more);
    ::CORBA::Boolean not_equal_retrieve_element_set_to_previous(::CosCollection::Iterator_ptr test, ::CORBA::Any_OUT_arg element);
    ::CORBA::Boolean remove_element_set_to_previous();
    ::CORBA::Boolean remove_previous_n_elements(::CORBA::ULong n, ::CORBA::ULong& actual_number);
    ::CORBA::Boolean not_equal_remove_element_set_to_previous(::CosCollection::Iterator_ptr test);
    ::CORBA::Boolean replace_element_set_to_previous(const ::CORBA::Any& element);
    ::CORBA::Boolean replace_previous_n_elements(const ::CosCollection::AnySequence& elements, ::CORBA::ULong& actual_number);
    ::CORBA::Boolean not_equal_replace_element_set_to_previous(::CosCollection::Iterator_ptr test, const ::CORBA::Any& element);
    ::CORBA::Boolean is_first();
    ::CORBA::Boolean is_last();
    ::CORBA::Boolean is_for_same(::CosCollection::Iterator_ptr test);
    ::CORBA::Boolean is_reverse();

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

  protected:
    virtual ~_objref_OrderedIterator();

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

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

    friend class OrderedIterator;
  };

  class _pof_OrderedIterator : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_OrderedIterator() : _OMNI_NS(proxyObjectFactory)(OrderedIterator::_PD_repoId) {}
    virtual ~_pof_OrderedIterator();

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

  class _impl_OrderedIterator :
    public virtual _impl_Iterator
  {
  public:
    virtual ~_impl_OrderedIterator();

    virtual ::CORBA::Boolean set_to_last_element() = 0;
    virtual ::CORBA::Boolean set_to_previous_element() = 0;
    virtual ::CORBA::Boolean set_to_nth_previous_element(::CORBA::ULong n) = 0;
    virtual void set_to_position(::CORBA::ULong position) = 0;
    virtual ::CORBA::ULong position() = 0;
    virtual ::CORBA::Boolean retrieve_element_set_to_previous(::CORBA::Any_OUT_arg element, ::CORBA::Boolean& more) = 0;
    virtual ::CORBA::Boolean retrieve_previous_n_elements(::CORBA::ULong n, ::CosCollection::AnySequence_out result, ::CORBA::Boolean& more) = 0;
    virtual ::CORBA::Boolean not_equal_retrieve_element_set_to_previous(::CosCollection::Iterator_ptr test, ::CORBA::Any_OUT_arg element) = 0;
    virtual ::CORBA::Boolean remove_element_set_to_previous() = 0;
    virtual ::CORBA::Boolean remove_previous_n_elements(::CORBA::ULong n, ::CORBA::ULong& actual_number) = 0;
    virtual ::CORBA::Boolean not_equal_remove_element_set_to_previous(::CosCollection::Iterator_ptr test) = 0;
    virtual ::CORBA::Boolean replace_element_set_to_previous(const ::CORBA::Any& element) = 0;
    virtual ::CORBA::Boolean replace_previous_n_elements(const ::CosCollection::AnySequence& elements, ::CORBA::ULong& actual_number) = 0;
    virtual ::CORBA::Boolean not_equal_replace_element_set_to_previous(::CosCollection::Iterator_ptr test, const ::CORBA::Any& element) = 0;
    virtual ::CORBA::Boolean is_first() = 0;
    virtual ::CORBA::Boolean is_last() = 0;
    virtual ::CORBA::Boolean is_for_same(::CosCollection::Iterator_ptr test) = 0;
    virtual ::CORBA::Boolean is_reverse() = 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_OrderedIterator;

#ifndef __CosCollection_mSequentialIterator__
#define __CosCollection_mSequentialIterator__

  class SequentialIterator;
  class _objref_SequentialIterator;
  class _impl_SequentialIterator;
  
  typedef _objref_SequentialIterator* SequentialIterator_ptr;
  typedef SequentialIterator_ptr SequentialIteratorRef;

  class SequentialIterator_Helper {
  public:
    typedef SequentialIterator_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_SequentialIterator, SequentialIterator_Helper> SequentialIterator_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_SequentialIterator,SequentialIterator_Helper > SequentialIterator_out;

#endif

  // interface SequentialIterator
  class SequentialIterator {
  public:
    // Declarations for this interface type.
    typedef SequentialIterator_ptr _ptr_type;
    typedef SequentialIterator_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_SequentialIterator :
    public virtual _objref_OrderedIterator
  {
  public:
    ::CORBA::Boolean add_element_as_next_set_iterator(const ::CORBA::Any& element);
    void add_n_elements_as_next_set_iterator(const ::CosCollection::AnySequence& elements);
    ::CORBA::Boolean add_element_as_previous_set_iterator(const ::CORBA::Any& element);
    void add_n_elements_as_previous_set_iterator(const ::CosCollection::AnySequence& elements);

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

  protected:
    virtual ~_objref_SequentialIterator();

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

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

    friend class SequentialIterator;
  };

  class _pof_SequentialIterator : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_SequentialIterator() : _OMNI_NS(proxyObjectFactory)(SequentialIterator::_PD_repoId) {}
    virtual ~_pof_SequentialIterator();

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

  class _impl_SequentialIterator :
    public virtual _impl_OrderedIterator
  {
  public:
    virtual ~_impl_SequentialIterator();

    virtual ::CORBA::Boolean add_element_as_next_set_iterator(const ::CORBA::Any& element) = 0;
    virtual void add_n_elements_as_next_set_iterator(const ::CosCollection::AnySequence& elements) = 0;
    virtual ::CORBA::Boolean add_element_as_previous_set_iterator(const ::CORBA::Any& element) = 0;
    virtual void add_n_elements_as_previous_set_iterator(const ::CosCollection::AnySequence& elements) = 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_SequentialIterator;

#ifndef __CosCollection_mKeyIterator__
#define __CosCollection_mKeyIterator__

  class KeyIterator;
  class _objref_KeyIterator;
  class _impl_KeyIterator;
  
  typedef _objref_KeyIterator* KeyIterator_ptr;
  typedef KeyIterator_ptr KeyIteratorRef;

  class KeyIterator_Helper {
  public:
    typedef KeyIterator_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_KeyIterator, KeyIterator_Helper> KeyIterator_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_KeyIterator,KeyIterator_Helper > KeyIterator_out;

#endif

  // interface KeyIterator
  class KeyIterator {
  public:
    // Declarations for this interface type.
    typedef KeyIterator_ptr _ptr_type;
    typedef KeyIterator_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_KeyIterator :
    public virtual _objref_Iterator
  {
  public:
    ::CORBA::Boolean set_to_element_with_key(const ::CORBA::Any& a_key);
    ::CORBA::Boolean set_to_next_element_with_key(const ::CORBA::Any& a_key);
    ::CORBA::Boolean set_to_next_element_with_different_key();
    ::CORBA::Boolean retrieve_key(::CORBA::Any_OUT_arg a_key);
    ::CORBA::Boolean retrieve_next_n_keys(::CosCollection::AnySequence_out some_keys);

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

  protected:
    virtual ~_objref_KeyIterator();

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

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

    friend class KeyIterator;
  };

  class _pof_KeyIterator : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_KeyIterator() : _OMNI_NS(proxyObjectFactory)(KeyIterator::_PD_repoId) {}
    virtual ~_pof_KeyIterator();

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

  class _impl_KeyIterator :
    public virtual _impl_Iterator
  {
  public:
    virtual ~_impl_KeyIterator();

    virtual ::CORBA::Boolean set_to_element_with_key(const ::CORBA::Any& a_key) = 0;
    virtual ::CORBA::Boolean set_to_next_element_with_key(const ::CORBA::Any& a_key) = 0;
    virtual ::CORBA::Boolean set_to_next_element_with_different_key() = 0;
    virtual ::CORBA::Boolean retrieve_key(::CORBA::Any_OUT_arg a_key) = 0;
    virtual ::CORBA::Boolean retrieve_next_n_keys(::CosCollection::AnySequence_out some_keys) = 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_KeyIterator;

#ifndef __CosCollection_mEqualityIterator__
#define __CosCollection_mEqualityIterator__

  class EqualityIterator;
  class _objref_EqualityIterator;
  class _impl_EqualityIterator;
  
  typedef _objref_EqualityIterator* EqualityIterator_ptr;
  typedef EqualityIterator_ptr EqualityIteratorRef;

  class EqualityIterator_Helper {
  public:
    typedef EqualityIterator_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_EqualityIterator, EqualityIterator_Helper> EqualityIterator_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_EqualityIterator,EqualityIterator_Helper > EqualityIterator_out;

#endif

  // interface EqualityIterator
  class EqualityIterator {
  public:
    // Declarations for this interface type.
    typedef EqualityIterator_ptr _ptr_type;
    typedef EqualityIterator_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_EqualityIterator :
    public virtual _objref_Iterator
  {
  public:
    ::CORBA::Boolean set_to_element_with_value(const ::CORBA::Any& element);
    ::CORBA::Boolean set_to_next_element_with_value(const ::CORBA::Any& element);
    ::CORBA::Boolean set_to_next_element_with_different_value();

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

  protected:
    virtual ~_objref_EqualityIterator();

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

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

    friend class EqualityIterator;
  };

  class _pof_EqualityIterator : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_EqualityIterator() : _OMNI_NS(proxyObjectFactory)(EqualityIterator::_PD_repoId) {}
    virtual ~_pof_EqualityIterator();

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

  class _impl_EqualityIterator :
    public virtual _impl_Iterator
  {
  public:
    virtual ~_impl_EqualityIterator();

    virtual ::CORBA::Boolean set_to_element_with_value(const ::CORBA::Any& element) = 0;
    virtual ::CORBA::Boolean set_to_next_element_with_value(const ::CORBA::Any& element) = 0;
    virtual ::CORBA::Boolean set_to_next_element_with_different_value() = 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_EqualityIterator;

#ifndef __CosCollection_mEqualityKeyIterator__
#define __CosCollection_mEqualityKeyIterator__

  class EqualityKeyIterator;
  class _objref_EqualityKeyIterator;
  class _impl_EqualityKeyIterator;
  
  typedef _objref_EqualityKeyIterator* EqualityKeyIterator_ptr;
  typedef EqualityKeyIterator_ptr EqualityKeyIteratorRef;

  class EqualityKeyIterator_Helper {
  public:
    typedef EqualityKeyIterator_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_EqualityKeyIterator, EqualityKeyIterator_Helper> EqualityKeyIterator_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_EqualityKeyIterator,EqualityKeyIterator_Helper > EqualityKeyIterator_out;

#endif

  // interface EqualityKeyIterator
  class EqualityKeyIterator {
  public:
    // Declarations for this interface type.
    typedef EqualityKeyIterator_ptr _ptr_type;
    typedef EqualityKeyIterator_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_EqualityKeyIterator :
    public virtual _objref_EqualityIterator,
    public virtual _objref_KeyIterator
  {
  public:
    

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

  protected:
    virtual ~_objref_EqualityKeyIterator();

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

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

    friend class EqualityKeyIterator;
  };

  class _pof_EqualityKeyIterator : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_EqualityKeyIterator() : _OMNI_NS(proxyObjectFactory)(EqualityKeyIterator::_PD_repoId) {}
    virtual ~_pof_EqualityKeyIterator();

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

  class _impl_EqualityKeyIterator :
    public virtual _impl_EqualityIterator,
    public virtual _impl_KeyIterator
  {
  public:
    virtual ~_impl_EqualityKeyIterator();

    
    
  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_EqualityKeyIterator;

#ifndef __CosCollection_mSortedIterator__
#define __CosCollection_mSortedIterator__

  class SortedIterator;
  class _objref_SortedIterator;
  class _impl_SortedIterator;
  
  typedef _objref_SortedIterator* SortedIterator_ptr;
  typedef SortedIterator_ptr SortedIteratorRef;

  class SortedIterator_Helper {
  public:
    typedef SortedIterator_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_SortedIterator, SortedIterator_Helper> SortedIterator_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_SortedIterator,SortedIterator_Helper > SortedIterator_out;

#endif

  // interface SortedIterator
  class SortedIterator {
  public:
    // Declarations for this interface type.
    typedef SortedIterator_ptr _ptr_type;
    typedef SortedIterator_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_SortedIterator :
    public virtual _objref_OrderedIterator
  {
  public:
    

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

  protected:
    virtual ~_objref_SortedIterator();

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

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

    friend class SortedIterator;
  };

  class _pof_SortedIterator : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_SortedIterator() : _OMNI_NS(proxyObjectFactory)(SortedIterator::_PD_repoId) {}
    virtual ~_pof_SortedIterator();

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

  class _impl_SortedIterator :
    public virtual _impl_OrderedIterator
  {
  public:
    virtual ~_impl_SortedIterator();

    
    
  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_SortedIterator;

  enum LowerBoundStyle { equal_lo, greater, greater_or_equal /*, __max_LowerBoundStyle=0xffffffff */ };
  typedef LowerBoundStyle& LowerBoundStyle_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_LowerBoundStyle;

  enum UpperBoundStyle { equal_up, less, less_or_equal /*, __max_UpperBoundStyle=0xffffffff */ };
  typedef UpperBoundStyle& UpperBoundStyle_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_UpperBoundStyle;

#ifndef __CosCollection_mKeySortedIterator__
#define __CosCollection_mKeySortedIterator__

  class KeySortedIterator;
  class _objref_KeySortedIterator;
  class _impl_KeySortedIterator;
  
  typedef _objref_KeySortedIterator* KeySortedIterator_ptr;
  typedef KeySortedIterator_ptr KeySortedIteratorRef;

  class KeySortedIterator_Helper {
  public:
    typedef KeySortedIterator_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_KeySortedIterator, KeySortedIterator_Helper> KeySortedIterator_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_KeySortedIterator,KeySortedIterator_Helper > KeySortedIterator_out;

#endif

  // interface KeySortedIterator
  class KeySortedIterator {
  public:
    // Declarations for this interface type.
    typedef KeySortedIterator_ptr _ptr_type;
    typedef KeySortedIterator_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_KeySortedIterator :
    public virtual _objref_KeyIterator,
    public virtual _objref_SortedIterator
  {
  public:
    ::CORBA::Boolean set_to_first_element_with_key(const ::CORBA::Any& a_key, ::CosCollection::LowerBoundStyle style);
    ::CORBA::Boolean set_to_last_element_with_key(const ::CORBA::Any& a_key, ::CosCollection::UpperBoundStyle style);
    ::CORBA::Boolean set_to_previous_element_with_key(const ::CORBA::Any& a_key);
    ::CORBA::Boolean set_to_previous_element_with_different_key();
    ::CORBA::Boolean retrieve_previous_n_keys(::CosCollection::AnySequence_out some_keys);

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

  protected:
    virtual ~_objref_KeySortedIterator();

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

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

    friend class KeySortedIterator;
  };

  class _pof_KeySortedIterator : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_KeySortedIterator() : _OMNI_NS(proxyObjectFactory)(KeySortedIterator::_PD_repoId) {}
    virtual ~_pof_KeySortedIterator();

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

  class _impl_KeySortedIterator :
    public virtual _impl_KeyIterator,
    public virtual _impl_SortedIterator
  {
  public:
    virtual ~_impl_KeySortedIterator();

    virtual ::CORBA::Boolean set_to_first_element_with_key(const ::CORBA::Any& a_key, ::CosCollection::LowerBoundStyle style) = 0;
    virtual ::CORBA::Boolean set_to_last_element_with_key(const ::CORBA::Any& a_key, ::CosCollection::UpperBoundStyle style) = 0;
    virtual ::CORBA::Boolean set_to_previous_element_with_key(const ::CORBA::Any& a_key) = 0;
    virtual ::CORBA::Boolean set_to_previous_element_with_different_key() = 0;
    virtual ::CORBA::Boolean retrieve_previous_n_keys(::CosCollection::AnySequence_out some_keys) = 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_KeySortedIterator;

#ifndef __CosCollection_mEqualitySortedIterator__
#define __CosCollection_mEqualitySortedIterator__

  class EqualitySortedIterator;
  class _objref_EqualitySortedIterator;
  class _impl_EqualitySortedIterator;
  
  typedef _objref_EqualitySortedIterator* EqualitySortedIterator_ptr;
  typedef EqualitySortedIterator_ptr EqualitySortedIteratorRef;

  class EqualitySortedIterator_Helper {
  public:
    typedef EqualitySortedIterator_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_EqualitySortedIterator, EqualitySortedIterator_Helper> EqualitySortedIterator_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_EqualitySortedIterator,EqualitySortedIterator_Helper > EqualitySortedIterator_out;

#endif

  // interface EqualitySortedIterator
  class EqualitySortedIterator {
  public:
    // Declarations for this interface type.
    typedef EqualitySortedIterator_ptr _ptr_type;
    typedef EqualitySortedIterator_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_EqualitySortedIterator :
    public virtual _objref_EqualityIterator,
    public virtual _objref_SortedIterator
  {
  public:
    ::CORBA::Boolean set_to_first_element_with_value(const ::CORBA::Any& element, ::CosCollection::LowerBoundStyle style);
    ::CORBA::Boolean set_to_last_element_with_value(const ::CORBA::Any& element, ::CosCollection::UpperBoundStyle style);
    ::CORBA::Boolean set_to_previous_element_with_value(const ::CORBA::Any& elementally);
    ::CORBA::Boolean set_to_previous_element_with_different_value();

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

  protected:
    virtual ~_objref_EqualitySortedIterator();

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

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

    friend class EqualitySortedIterator;
  };

  class _pof_EqualitySortedIterator : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_EqualitySortedIterator() : _OMNI_NS(proxyObjectFactory)(EqualitySortedIterator::_PD_repoId) {}
    virtual ~_pof_EqualitySortedIterator();

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

  class _impl_EqualitySortedIterator :
    public virtual _impl_EqualityIterator,
    public virtual _impl_SortedIterator
  {
  public:
    virtual ~_impl_EqualitySortedIterator();

    virtual ::CORBA::Boolean set_to_first_element_with_value(const ::CORBA::Any& element, ::CosCollection::LowerBoundStyle style) = 0;
    virtual ::CORBA::Boolean set_to_last_element_with_value(const ::CORBA::Any& element, ::CosCollection::UpperBoundStyle style) = 0;
    virtual ::CORBA::Boolean set_to_previous_element_with_value(const ::CORBA::Any& elementally) = 0;
    virtual ::CORBA::Boolean set_to_previous_element_with_different_value() = 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_EqualitySortedIterator;

#ifndef __CosCollection_mEqualityKeySortedIterator__
#define __CosCollection_mEqualityKeySortedIterator__

  class EqualityKeySortedIterator;
  class _objref_EqualityKeySortedIterator;
  class _impl_EqualityKeySortedIterator;
  
  typedef _objref_EqualityKeySortedIterator* EqualityKeySortedIterator_ptr;
  typedef EqualityKeySortedIterator_ptr EqualityKeySortedIteratorRef;

  class EqualityKeySortedIterator_Helper {
  public:
    typedef EqualityKeySortedIterator_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_EqualityKeySortedIterator, EqualityKeySortedIterator_Helper> EqualityKeySortedIterator_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_EqualityKeySortedIterator,EqualityKeySortedIterator_Helper > EqualityKeySortedIterator_out;

#endif

  // interface EqualityKeySortedIterator
  class EqualityKeySortedIterator {
  public:
    // Declarations for this interface type.
    typedef EqualityKeySortedIterator_ptr _ptr_type;
    typedef EqualityKeySortedIterator_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_EqualityKeySortedIterator :
    public virtual _objref_EqualitySortedIterator,
    public virtual _objref_KeySortedIterator
  {
  public:
    

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

  protected:
    virtual ~_objref_EqualityKeySortedIterator();

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

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

    friend class EqualityKeySortedIterator;
  };

  class _pof_EqualityKeySortedIterator : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_EqualityKeySortedIterator() : _OMNI_NS(proxyObjectFactory)(EqualityKeySortedIterator::_PD_repoId) {}
    virtual ~_pof_EqualityKeySortedIterator();

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

  class _impl_EqualityKeySortedIterator :
    public virtual _impl_EqualitySortedIterator,
    public virtual _impl_KeySortedIterator
  {
  public:
    virtual ~_impl_EqualityKeySortedIterator();

    
    
  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_EqualityKeySortedIterator;

#ifndef __CosCollection_mEqualitySequentialIterator__
#define __CosCollection_mEqualitySequentialIterator__

  class EqualitySequentialIterator;
  class _objref_EqualitySequentialIterator;
  class _impl_EqualitySequentialIterator;
  
  typedef _objref_EqualitySequentialIterator* EqualitySequentialIterator_ptr;
  typedef EqualitySequentialIterator_ptr EqualitySequentialIteratorRef;

  class EqualitySequentialIterator_Helper {
  public:
    typedef EqualitySequentialIterator_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_EqualitySequentialIterator, EqualitySequentialIterator_Helper> EqualitySequentialIterator_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_EqualitySequentialIterator,EqualitySequentialIterator_Helper > EqualitySequentialIterator_out;

#endif

  // interface EqualitySequentialIterator
  class EqualitySequentialIterator {
  public:
    // Declarations for this interface type.
    typedef EqualitySequentialIterator_ptr _ptr_type;
    typedef EqualitySequentialIterator_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_EqualitySequentialIterator :
    public virtual _objref_EqualityIterator,
    public virtual _objref_SequentialIterator
  {
  public:
    ::CORBA::Boolean set_to_first_element_with_value(const ::CORBA::Any& element);
    ::CORBA::Boolean set_to_last_element_with_value(const ::CORBA::Any& element);
    ::CORBA::Boolean set_to_previous_element_with_value(const ::CORBA::Any& element);

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

  protected:
    virtual ~_objref_EqualitySequentialIterator();

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

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

    friend class EqualitySequentialIterator;
  };

  class _pof_EqualitySequentialIterator : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_EqualitySequentialIterator() : _OMNI_NS(proxyObjectFactory)(EqualitySequentialIterator::_PD_repoId) {}
    virtual ~_pof_EqualitySequentialIterator();

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

  class _impl_EqualitySequentialIterator :
    public virtual _impl_EqualityIterator,
    public virtual _impl_SequentialIterator
  {
  public:
    virtual ~_impl_EqualitySequentialIterator();

    virtual ::CORBA::Boolean set_to_first_element_with_value(const ::CORBA::Any& element) = 0;
    virtual ::CORBA::Boolean set_to_last_element_with_value(const ::CORBA::Any& element) = 0;
    virtual ::CORBA::Boolean set_to_previous_element_with_value(const ::CORBA::Any& element) = 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_EqualitySequentialIterator;

#ifndef __CosCollection_mCollection__
#define __CosCollection_mCollection__

  class Collection;
  class _objref_Collection;
  class _impl_Collection;
  
  typedef _objref_Collection* Collection_ptr;
  typedef Collection_ptr CollectionRef;

  class Collection_Helper {
  public:
    typedef Collection_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_Collection, Collection_Helper> Collection_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_Collection,Collection_Helper > Collection_out;

#endif

  // interface Collection
  class Collection {
  public:
    // Declarations for this interface type.
    typedef Collection_ptr _ptr_type;
    typedef Collection_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_Collection :
    public virtual ::CORBA::Object,
    public virtual omniObjRef
  {
  public:
    ::CORBA::Boolean add_element(const ::CORBA::Any& element);
    ::CORBA::Boolean add_element_set_iterator(const ::CORBA::Any& element, ::CosCollection::Iterator_ptr where);
    void add_all_from(::CosCollection::Collection_ptr collector);
    void remove_element_at(::CosCollection::Iterator_ptr where);
    ::CORBA::ULong remove_all();
    void replace_element_at(::CosCollection::Iterator_ptr where, const ::CORBA::Any& element);
    ::CORBA::Boolean retrieve_element_at(::CosCollection::Iterator_ptr where, ::CORBA::Any_OUT_arg element);
    ::CORBA::Boolean all_elements_do(::CosCollection::Command_ptr what);
    ::CORBA::ULong number_of_elements();
    ::CORBA::Boolean is_empty();
    void destroy();
    Iterator_ptr create_iterator(::CORBA::Boolean read_only);
    ::CORBA::TypeCode_ptr element_type();

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

  protected:
    virtual ~_objref_Collection();

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

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

    friend class Collection;
  };

  class _pof_Collection : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_Collection() : _OMNI_NS(proxyObjectFactory)(Collection::_PD_repoId) {}
    virtual ~_pof_Collection();

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

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

    virtual ::CORBA::Boolean add_element(const ::CORBA::Any& element) = 0;
    virtual ::CORBA::Boolean add_element_set_iterator(const ::CORBA::Any& element, ::CosCollection::Iterator_ptr where) = 0;
    virtual void add_all_from(::CosCollection::Collection_ptr collector) = 0;
    virtual void remove_element_at(::CosCollection::Iterator_ptr where) = 0;
    virtual ::CORBA::ULong remove_all() = 0;
    virtual void replace_element_at(::CosCollection::Iterator_ptr where, const ::CORBA::Any& element) = 0;
    virtual ::CORBA::Boolean retrieve_element_at(::CosCollection::Iterator_ptr where, ::CORBA::Any_OUT_arg element) = 0;
    virtual ::CORBA::Boolean all_elements_do(::CosCollection::Command_ptr what) = 0;
    virtual ::CORBA::ULong number_of_elements() = 0;
    virtual ::CORBA::Boolean is_empty() = 0;
    virtual void destroy() = 0;
    virtual Iterator_ptr create_iterator(::CORBA::Boolean read_only) = 0;
    virtual ::CORBA::TypeCode_ptr element_type() = 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_Collection;

#ifndef __CosCollection_mOrderedCollection__
#define __CosCollection_mOrderedCollection__

  class OrderedCollection;
  class _objref_OrderedCollection;
  class _impl_OrderedCollection;
  
  typedef _objref_OrderedCollection* OrderedCollection_ptr;
  typedef OrderedCollection_ptr OrderedCollectionRef;

  class OrderedCollection_Helper {
  public:
    typedef OrderedCollection_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_OrderedCollection, OrderedCollection_Helper> OrderedCollection_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_OrderedCollection,OrderedCollection_Helper > OrderedCollection_out;

#endif

  // interface OrderedCollection
  class OrderedCollection {
  public:
    // Declarations for this interface type.
    typedef OrderedCollection_ptr _ptr_type;
    typedef OrderedCollection_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_OrderedCollection :
    public virtual _objref_Collection
  {
  public:
    void remove_element_at_position(::CORBA::ULong position);
    void remove_first_element();
    void remove_last_element();
    ::CORBA::Boolean retrieve_element_at_position(::CORBA::ULong position, ::CORBA::Any_OUT_arg element);
    ::CORBA::Boolean retrieve_first_element(::CORBA::Any_OUT_arg element);
    ::CORBA::Boolean retrieve_last_element(::CORBA::Any_OUT_arg element);
    OrderedIterator_ptr create_ordered_iterator(::CORBA::Boolean read_only, ::CORBA::Boolean reverse_iteration);

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

  protected:
    virtual ~_objref_OrderedCollection();

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

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

    friend class OrderedCollection;
  };

  class _pof_OrderedCollection : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_OrderedCollection() : _OMNI_NS(proxyObjectFactory)(OrderedCollection::_PD_repoId) {}
    virtual ~_pof_OrderedCollection();

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

  class _impl_OrderedCollection :
    public virtual _impl_Collection
  {
  public:
    virtual ~_impl_OrderedCollection();

    virtual void remove_element_at_position(::CORBA::ULong position) = 0;
    virtual void remove_first_element() = 0;
    virtual void remove_last_element() = 0;
    virtual ::CORBA::Boolean retrieve_element_at_position(::CORBA::ULong position, ::CORBA::Any_OUT_arg element) = 0;
    virtual ::CORBA::Boolean retrieve_first_element(::CORBA::Any_OUT_arg element) = 0;
    virtual ::CORBA::Boolean retrieve_last_element(::CORBA::Any_OUT_arg element) = 0;
    virtual OrderedIterator_ptr create_ordered_iterator(::CORBA::Boolean read_only, ::CORBA::Boolean reverse_iteration) = 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_OrderedCollection;

#ifndef __CosCollection_mSequentialCollection__
#define __CosCollection_mSequentialCollection__

  class SequentialCollection;
  class _objref_SequentialCollection;
  class _impl_SequentialCollection;
  
  typedef _objref_SequentialCollection* SequentialCollection_ptr;
  typedef SequentialCollection_ptr SequentialCollectionRef;

  class SequentialCollection_Helper {
  public:
    typedef SequentialCollection_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_SequentialCollection, SequentialCollection_Helper> SequentialCollection_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_SequentialCollection,SequentialCollection_Helper > SequentialCollection_out;

#endif

  // interface SequentialCollection
  class SequentialCollection {
  public:
    // Declarations for this interface type.
    typedef SequentialCollection_ptr _ptr_type;
    typedef SequentialCollection_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_SequentialCollection :
    public virtual _objref_OrderedCollection
  {
  public:
    void add_element_as_first(const ::CORBA::Any& element);
    void add_element_as_first_set_iterator(const ::CORBA::Any& element, ::CosCollection::Iterator_ptr where);
    void add_element_as_last(const ::CORBA::Any& element);
    void add_element_as_last_set_iterator(const ::CORBA::Any& element, ::CosCollection::Iterator_ptr where);
    void add_element_as_next(const ::CORBA::Any& element, ::CosCollection::Iterator_ptr where);
    void add_element_as_previous(const ::CORBA::Any& element, ::CosCollection::Iterator_ptr where);
    void add_element_at_position(::CORBA::ULong position, const ::CORBA::Any& element);
    void add_element_at_position_set_iterator(::CORBA::ULong position, const ::CORBA::Any& element, ::CosCollection::Iterator_ptr where);
    void replace_element_at_position(::CORBA::ULong position, const ::CORBA::Any& element);
    void replace_first_element(const ::CORBA::Any& element);
    void replace_last_element(const ::CORBA::Any& element);
    void sort(::CosCollection::Comparator_ptr comparison);
    void reverse();

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

  protected:
    virtual ~_objref_SequentialCollection();

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

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

    friend class SequentialCollection;
  };

  class _pof_SequentialCollection : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_SequentialCollection() : _OMNI_NS(proxyObjectFactory)(SequentialCollection::_PD_repoId) {}
    virtual ~_pof_SequentialCollection();

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

  class _impl_SequentialCollection :
    public virtual _impl_OrderedCollection
  {
  public:
    virtual ~_impl_SequentialCollection();

    virtual void add_element_as_first(const ::CORBA::Any& element) = 0;
    virtual void add_element_as_first_set_iterator(const ::CORBA::Any& element, ::CosCollection::Iterator_ptr where) = 0;
    virtual void add_element_as_last(const ::CORBA::Any& element) = 0;
    virtual void add_element_as_last_set_iterator(const ::CORBA::Any& element, ::CosCollection::Iterator_ptr where) = 0;
    virtual void add_element_as_next(const ::CORBA::Any& element, ::CosCollection::Iterator_ptr where) = 0;
    virtual void add_element_as_previous(const ::CORBA::Any& element, ::CosCollection::Iterator_ptr where) = 0;
    virtual void add_element_at_position(::CORBA::ULong position, const ::CORBA::Any& element) = 0;
    virtual void add_element_at_position_set_iterator(::CORBA::ULong position, const ::CORBA::Any& element, ::CosCollection::Iterator_ptr where) = 0;
    virtual void replace_element_at_position(::CORBA::ULong position, const ::CORBA::Any& element) = 0;
    virtual void replace_first_element(const ::CORBA::Any& element) = 0;
    virtual void replace_last_element(const ::CORBA::Any& element) = 0;
    virtual void sort(::CosCollection::Comparator_ptr comparison) = 0;
    virtual void reverse() = 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_SequentialCollection;

#ifndef __CosCollection_mSortedCollection__
#define __CosCollection_mSortedCollection__

  class SortedCollection;
  class _objref_SortedCollection;
  class _impl_SortedCollection;
  
  typedef _objref_SortedCollection* SortedCollection_ptr;
  typedef SortedCollection_ptr SortedCollectionRef;

  class SortedCollection_Helper {
  public:
    typedef SortedCollection_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_SortedCollection, SortedCollection_Helper> SortedCollection_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_SortedCollection,SortedCollection_Helper > SortedCollection_out;

#endif

  // interface SortedCollection
  class SortedCollection {
  public:
    // Declarations for this interface type.
    typedef SortedCollection_ptr _ptr_type;
    typedef SortedCollection_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_SortedCollection :
    public virtual _objref_OrderedCollection
  {
  public:
    

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

  protected:
    virtual ~_objref_SortedCollection();

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

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

    friend class SortedCollection;
  };

  class _pof_SortedCollection : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_SortedCollection() : _OMNI_NS(proxyObjectFactory)(SortedCollection::_PD_repoId) {}
    virtual ~_pof_SortedCollection();

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

  class _impl_SortedCollection :
    public virtual _impl_OrderedCollection
  {
  public:
    virtual ~_impl_SortedCollection();

    
    
  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_SortedCollection;

#ifndef __CosCollection_mEqualityCollection__
#define __CosCollection_mEqualityCollection__

  class EqualityCollection;
  class _objref_EqualityCollection;
  class _impl_EqualityCollection;
  
  typedef _objref_EqualityCollection* EqualityCollection_ptr;
  typedef EqualityCollection_ptr EqualityCollectionRef;

  class EqualityCollection_Helper {
  public:
    typedef EqualityCollection_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_EqualityCollection, EqualityCollection_Helper> EqualityCollection_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_EqualityCollection,EqualityCollection_Helper > EqualityCollection_out;

#endif

  // interface EqualityCollection
  class EqualityCollection {
  public:
    // Declarations for this interface type.
    typedef EqualityCollection_ptr _ptr_type;
    typedef EqualityCollection_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_EqualityCollection :
    public virtual _objref_Collection
  {
  public:
    ::CORBA::Boolean contains_element(const ::CORBA::Any& element);
    ::CORBA::Boolean contains_all_from(::CosCollection::Collection_ptr collector);
    ::CORBA::Boolean locate_or_add_element(const ::CORBA::Any& element);
    ::CORBA::Boolean locate_or_add_element_set_iterator(const ::CORBA::Any& element, ::CosCollection::Iterator_ptr where);
    ::CORBA::Boolean locate_element(const ::CORBA::Any& element, ::CosCollection::Iterator_ptr where);
    ::CORBA::Boolean locate_next_element(const ::CORBA::Any& element, ::CosCollection::Iterator_ptr where);
    ::CORBA::Boolean locate_next_different_element(::CosCollection::Iterator_ptr where);
    ::CORBA::Boolean remove_element(const ::CORBA::Any& element);
    ::CORBA::ULong remove_all_occurrences(const ::CORBA::Any& element);
    ::CORBA::ULong number_of_different_elements();
    ::CORBA::ULong number_of_occurrences(const ::CORBA::Any& element);

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

  protected:
    virtual ~_objref_EqualityCollection();

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

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

    friend class EqualityCollection;
  };

  class _pof_EqualityCollection : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_EqualityCollection() : _OMNI_NS(proxyObjectFactory)(EqualityCollection::_PD_repoId) {}
    virtual ~_pof_EqualityCollection();

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

  class _impl_EqualityCollection :
    public virtual _impl_Collection
  {
  public:
    virtual ~_impl_EqualityCollection();

    virtual ::CORBA::Boolean contains_element(const ::CORBA::Any& element) = 0;
    virtual ::CORBA::Boolean contains_all_from(::CosCollection::Collection_ptr collector) = 0;
    virtual ::CORBA::Boolean locate_or_add_element(const ::CORBA::Any& element) = 0;
    virtual ::CORBA::Boolean locate_or_add_element_set_iterator(const ::CORBA::Any& element, ::CosCollection::Iterator_ptr where) = 0;
    virtual ::CORBA::Boolean locate_element(const ::CORBA::Any& element, ::CosCollection::Iterator_ptr where) = 0;
    virtual ::CORBA::Boolean locate_next_element(const ::CORBA::Any& element, ::CosCollection::Iterator_ptr where) = 0;
    virtual ::CORBA::Boolean locate_next_different_element(::CosCollection::Iterator_ptr where) = 0;
    virtual ::CORBA::Boolean remove_element(const ::CORBA::Any& element) = 0;
    virtual ::CORBA::ULong remove_all_occurrences(const ::CORBA::Any& element) = 0;
    virtual ::CORBA::ULong number_of_different_elements() = 0;
    virtual ::CORBA::ULong number_of_occurrences(const ::CORBA::Any& element) = 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_EqualityCollection;

#ifndef __CosCollection_mKeyCollection__
#define __CosCollection_mKeyCollection__

  class KeyCollection;
  class _objref_KeyCollection;
  class _impl_KeyCollection;
  
  typedef _objref_KeyCollection* KeyCollection_ptr;
  typedef KeyCollection_ptr KeyCollectionRef;

  class KeyCollection_Helper {
  public:
    typedef KeyCollection_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_KeyCollection, KeyCollection_Helper> KeyCollection_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_KeyCollection,KeyCollection_Helper > KeyCollection_out;

#endif

  // interface KeyCollection
  class KeyCollection {
  public:
    // Declarations for this interface type.
    typedef KeyCollection_ptr _ptr_type;
    typedef KeyCollection_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_KeyCollection :
    public virtual _objref_Collection
  {
  public:
    ::CORBA::Boolean contains_element_with_key(const ::CORBA::Any& a_key);
    ::CORBA::Boolean contains_all_keys_from(::CosCollection::KeyCollection_ptr collector);
    ::CORBA::Boolean locate_or_add_element_with_key(const ::CORBA::Any& element);
    ::CORBA::Boolean locate_or_add_element_with_key_set_iterator(const ::CORBA::Any& element, ::CosCollection::Iterator_ptr where);
    ::CORBA::Boolean add_or_replace_element_with_key(const ::CORBA::Any& element);
    ::CORBA::Boolean add_or_replace_element_with_key_set_iterator(const ::CORBA::Any& element, ::CosCollection::Iterator_ptr where);
    ::CORBA::Boolean remove_element_with_key(const ::CORBA::Any& a_key);
    ::CORBA::ULong remove_all_elements_with_key(const ::CORBA::Any& a_key);
    ::CORBA::Boolean replace_element_with_key(const ::CORBA::Any& element);
    ::CORBA::Boolean replace_element_with_key_set_iterator(const ::CORBA::Any& element, ::CosCollection::Iterator_ptr where);
    ::CORBA::Boolean retrieve_element_with_key(const ::CORBA::Any& a_key, ::CORBA::Any_OUT_arg element);
    void key(const ::CORBA::Any& element, ::CORBA::Any_OUT_arg a_key);
    void keys(const ::CosCollection::AnySequence& elements, ::CosCollection::AnySequence_out some_keys);
    ::CORBA::Boolean locate_element_with_key(const ::CORBA::Any& key, ::CosCollection::Iterator_ptr where);
    ::CORBA::Boolean locate_next_element_with_key(const ::CORBA::Any& key, ::CosCollection::Iterator_ptr where);
    ::CORBA::Boolean locate_next_element_with_different_key(::CosCollection::Iterator_ptr where);
    ::CORBA::ULong number_of_different_keys();
    ::CORBA::ULong number_of_elements_with_key(const ::CORBA::Any& a_key);
    ::CORBA::TypeCode_ptr key_type();

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

  protected:
    virtual ~_objref_KeyCollection();

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

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

    friend class KeyCollection;
  };

  class _pof_KeyCollection : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_KeyCollection() : _OMNI_NS(proxyObjectFactory)(KeyCollection::_PD_repoId) {}
    virtual ~_pof_KeyCollection();

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

  class _impl_KeyCollection :
    public virtual _impl_Collection
  {
  public:
    virtual ~_impl_KeyCollection();

    virtual ::CORBA::Boolean contains_element_with_key(const ::CORBA::Any& a_key) = 0;
    virtual ::CORBA::Boolean contains_all_keys_from(::CosCollection::KeyCollection_ptr collector) = 0;
    virtual ::CORBA::Boolean locate_or_add_element_with_key(const ::CORBA::Any& element) = 0;
    virtual ::CORBA::Boolean locate_or_add_element_with_key_set_iterator(const ::CORBA::Any& element, ::CosCollection::Iterator_ptr where) = 0;
    virtual ::CORBA::Boolean add_or_replace_element_with_key(const ::CORBA::Any& element) = 0;
    virtual ::CORBA::Boolean add_or_replace_element_with_key_set_iterator(const ::CORBA::Any& element, ::CosCollection::Iterator_ptr where) = 0;
    virtual ::CORBA::Boolean remove_element_with_key(const ::CORBA::Any& a_key) = 0;
    virtual ::CORBA::ULong remove_all_elements_with_key(const ::CORBA::Any& a_key) = 0;
    virtual ::CORBA::Boolean replace_element_with_key(const ::CORBA::Any& element) = 0;
    virtual ::CORBA::Boolean replace_element_with_key_set_iterator(const ::CORBA::Any& element, ::CosCollection::Iterator_ptr where) = 0;
    virtual ::CORBA::Boolean retrieve_element_with_key(const ::CORBA::Any& a_key, ::CORBA::Any_OUT_arg element) = 0;
    virtual void key(const ::CORBA::Any& element, ::CORBA::Any_OUT_arg a_key) = 0;
    virtual void keys(const ::CosCollection::AnySequence& elements, ::CosCollection::AnySequence_out some_keys) = 0;
    virtual ::CORBA::Boolean locate_element_with_key(const ::CORBA::Any& key, ::CosCollection::Iterator_ptr where) = 0;
    virtual ::CORBA::Boolean locate_next_element_with_key(const ::CORBA::Any& key, ::CosCollection::Iterator_ptr where) = 0;
    virtual ::CORBA::Boolean locate_next_element_with_different_key(::CosCollection::Iterator_ptr where) = 0;
    virtual ::CORBA::ULong number_of_different_keys() = 0;
    virtual ::CORBA::ULong number_of_elements_with_key(const ::CORBA::Any& a_key) = 0;
    virtual ::CORBA::TypeCode_ptr key_type() = 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_KeyCollection;

#ifndef __CosCollection_mEqualityKeyCollection__
#define __CosCollection_mEqualityKeyCollection__

  class EqualityKeyCollection;
  class _objref_EqualityKeyCollection;
  class _impl_EqualityKeyCollection;
  
  typedef _objref_EqualityKeyCollection* EqualityKeyCollection_ptr;
  typedef EqualityKeyCollection_ptr EqualityKeyCollectionRef;

  class EqualityKeyCollection_Helper {
  public:
    typedef EqualityKeyCollection_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_EqualityKeyCollection, EqualityKeyCollection_Helper> EqualityKeyCollection_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_EqualityKeyCollection,EqualityKeyCollection_Helper > EqualityKeyCollection_out;

#endif

  // interface EqualityKeyCollection
  class EqualityKeyCollection {
  public:
    // Declarations for this interface type.
    typedef EqualityKeyCollection_ptr _ptr_type;
    typedef EqualityKeyCollection_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_EqualityKeyCollection :
    public virtual _objref_EqualityCollection,
    public virtual _objref_KeyCollection
  {
  public:
    

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

  protected:
    virtual ~_objref_EqualityKeyCollection();

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

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

    friend class EqualityKeyCollection;
  };

  class _pof_EqualityKeyCollection : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_EqualityKeyCollection() : _OMNI_NS(proxyObjectFactory)(EqualityKeyCollection::_PD_repoId) {}
    virtual ~_pof_EqualityKeyCollection();

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

  class _impl_EqualityKeyCollection :
    public virtual _impl_EqualityCollection,
    public virtual _impl_KeyCollection
  {
  public:
    virtual ~_impl_EqualityKeyCollection();

    
    
  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_EqualityKeyCollection;

#ifndef __CosCollection_mKeySortedCollection__
#define __CosCollection_mKeySortedCollection__

  class KeySortedCollection;
  class _objref_KeySortedCollection;
  class _impl_KeySortedCollection;
  
  typedef _objref_KeySortedCollection* KeySortedCollection_ptr;
  typedef KeySortedCollection_ptr KeySortedCollectionRef;

  class KeySortedCollection_Helper {
  public:
    typedef KeySortedCollection_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_KeySortedCollection, KeySortedCollection_Helper> KeySortedCollection_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_KeySortedCollection,KeySortedCollection_Helper > KeySortedCollection_out;

#endif

  // interface KeySortedCollection
  class KeySortedCollection {
  public:
    // Declarations for this interface type.
    typedef KeySortedCollection_ptr _ptr_type;
    typedef KeySortedCollection_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_KeySortedCollection :
    public virtual _objref_KeyCollection,
    public virtual _objref_SortedCollection
  {
  public:
    ::CORBA::Boolean locate_first_element_with_key(const ::CORBA::Any& key, ::CosCollection::Iterator_ptr where);
    ::CORBA::Boolean locate_last_element_with_key(const ::CORBA::Any& key, ::CosCollection::Iterator_ptr where);
    ::CORBA::Boolean locate_previous_element_with_key(const ::CORBA::Any& key, ::CosCollection::Iterator_ptr where);
    ::CORBA::Boolean locate_previous_element_with_different_key(::CosCollection::Iterator_ptr where);

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

  protected:
    virtual ~_objref_KeySortedCollection();

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

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

    friend class KeySortedCollection;
  };

  class _pof_KeySortedCollection : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_KeySortedCollection() : _OMNI_NS(proxyObjectFactory)(KeySortedCollection::_PD_repoId) {}
    virtual ~_pof_KeySortedCollection();

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

  class _impl_KeySortedCollection :
    public virtual _impl_KeyCollection,
    public virtual _impl_SortedCollection
  {
  public:
    virtual ~_impl_KeySortedCollection();

    virtual ::CORBA::Boolean locate_first_element_with_key(const ::CORBA::Any& key, ::CosCollection::Iterator_ptr where) = 0;
    virtual ::CORBA::Boolean locate_last_element_with_key(const ::CORBA::Any& key, ::CosCollection::Iterator_ptr where) = 0;
    virtual ::CORBA::Boolean locate_previous_element_with_key(const ::CORBA::Any& key, ::CosCollection::Iterator_ptr where) = 0;
    virtual ::CORBA::Boolean locate_previous_element_with_different_key(::CosCollection::Iterator_ptr where) = 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_KeySortedCollection;

#ifndef __CosCollection_mEqualitySortedCollection__
#define __CosCollection_mEqualitySortedCollection__

  class EqualitySortedCollection;
  class _objref_EqualitySortedCollection;
  class _impl_EqualitySortedCollection;
  
  typedef _objref_EqualitySortedCollection* EqualitySortedCollection_ptr;
  typedef EqualitySortedCollection_ptr EqualitySortedCollectionRef;

  class EqualitySortedCollection_Helper {
  public:
    typedef EqualitySortedCollection_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_EqualitySortedCollection, EqualitySortedCollection_Helper> EqualitySortedCollection_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_EqualitySortedCollection,EqualitySortedCollection_Helper > EqualitySortedCollection_out;

#endif

  // interface EqualitySortedCollection
  class EqualitySortedCollection {
  public:
    // Declarations for this interface type.
    typedef EqualitySortedCollection_ptr _ptr_type;
    typedef EqualitySortedCollection_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_EqualitySortedCollection :
    public virtual _objref_EqualityCollection,
    public virtual _objref_SortedCollection
  {
  public:
    ::CORBA::Boolean locate_first_element(const ::CORBA::Any& element, ::CosCollection::Iterator_ptr where);
    ::CORBA::Boolean locate_last_element(const ::CORBA::Any& element, ::CosCollection::Iterator_ptr where);
    ::CORBA::Boolean locate_previous_element(const ::CORBA::Any& element, ::CosCollection::Iterator_ptr where);
    ::CORBA::Boolean locate_previous_different_element(::CosCollection::Iterator_ptr where);

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

  protected:
    virtual ~_objref_EqualitySortedCollection();

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

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

    friend class EqualitySortedCollection;
  };

  class _pof_EqualitySortedCollection : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_EqualitySortedCollection() : _OMNI_NS(proxyObjectFactory)(EqualitySortedCollection::_PD_repoId) {}
    virtual ~_pof_EqualitySortedCollection();

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

  class _impl_EqualitySortedCollection :
    public virtual _impl_EqualityCollection,
    public virtual _impl_SortedCollection
  {
  public:
    virtual ~_impl_EqualitySortedCollection();

    virtual ::CORBA::Boolean locate_first_element(const ::CORBA::Any& element, ::CosCollection::Iterator_ptr where) = 0;
    virtual ::CORBA::Boolean locate_last_element(const ::CORBA::Any& element, ::CosCollection::Iterator_ptr where) = 0;
    virtual ::CORBA::Boolean locate_previous_element(const ::CORBA::Any& element, ::CosCollection::Iterator_ptr where) = 0;
    virtual ::CORBA::Boolean locate_previous_different_element(::CosCollection::Iterator_ptr where) = 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_EqualitySortedCollection;

#ifndef __CosCollection_mEqualityKeySortedCollection__
#define __CosCollection_mEqualityKeySortedCollection__

  class EqualityKeySortedCollection;
  class _objref_EqualityKeySortedCollection;
  class _impl_EqualityKeySortedCollection;
  
  typedef _objref_EqualityKeySortedCollection* EqualityKeySortedCollection_ptr;
  typedef EqualityKeySortedCollection_ptr EqualityKeySortedCollectionRef;

  class EqualityKeySortedCollection_Helper {
  public:
    typedef EqualityKeySortedCollection_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_EqualityKeySortedCollection, EqualityKeySortedCollection_Helper> EqualityKeySortedCollection_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_EqualityKeySortedCollection,EqualityKeySortedCollection_Helper > EqualityKeySortedCollection_out;

#endif

  // interface EqualityKeySortedCollection
  class EqualityKeySortedCollection {
  public:
    // Declarations for this interface type.
    typedef EqualityKeySortedCollection_ptr _ptr_type;
    typedef EqualityKeySortedCollection_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_EqualityKeySortedCollection :
    public virtual _objref_EqualityCollection,
    public virtual _objref_KeyCollection,
    public virtual _objref_SortedCollection
  {
  public:
    

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

  protected:
    virtual ~_objref_EqualityKeySortedCollection();

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

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

    friend class EqualityKeySortedCollection;
  };

  class _pof_EqualityKeySortedCollection : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_EqualityKeySortedCollection() : _OMNI_NS(proxyObjectFactory)(EqualityKeySortedCollection::_PD_repoId) {}
    virtual ~_pof_EqualityKeySortedCollection();

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

  class _impl_EqualityKeySortedCollection :
    public virtual _impl_EqualityCollection,
    public virtual _impl_KeyCollection,
    public virtual _impl_SortedCollection
  {
  public:
    virtual ~_impl_EqualityKeySortedCollection();

    
    
  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_EqualityKeySortedCollection;

#ifndef __CosCollection_mEqualitySequentialCollection__
#define __CosCollection_mEqualitySequentialCollection__

  class EqualitySequentialCollection;
  class _objref_EqualitySequentialCollection;
  class _impl_EqualitySequentialCollection;
  
  typedef _objref_EqualitySequentialCollection* EqualitySequentialCollection_ptr;
  typedef EqualitySequentialCollection_ptr EqualitySequentialCollectionRef;

  class EqualitySequentialCollection_Helper {
  public:
    typedef EqualitySequentialCollection_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_EqualitySequentialCollection, EqualitySequentialCollection_Helper> EqualitySequentialCollection_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_EqualitySequentialCollection,EqualitySequentialCollection_Helper > EqualitySequentialCollection_out;

#endif

  // interface EqualitySequentialCollection
  class EqualitySequentialCollection {
  public:
    // Declarations for this interface type.
    typedef EqualitySequentialCollection_ptr _ptr_type;
    typedef EqualitySequentialCollection_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_EqualitySequentialCollection :
    public virtual _objref_EqualityCollection,
    public virtual _objref_SequentialCollection
  {
  public:
    ::CORBA::Boolean locate_first_element_with_value(const ::CORBA::Any& element, ::CosCollection::Iterator_ptr where);
    ::CORBA::Boolean locate_last_element_with_value(const ::CORBA::Any& element, ::CosCollection::Iterator_ptr where);
    ::CORBA::Boolean locate_previous_element_with_value(const ::CORBA::Any& element, ::CosCollection::Iterator_ptr where);

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

  protected:
    virtual ~_objref_EqualitySequentialCollection();

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

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

    friend class EqualitySequentialCollection;
  };

  class _pof_EqualitySequentialCollection : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_EqualitySequentialCollection() : _OMNI_NS(proxyObjectFactory)(EqualitySequentialCollection::_PD_repoId) {}
    virtual ~_pof_EqualitySequentialCollection();

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

  class _impl_EqualitySequentialCollection :
    public virtual _impl_EqualityCollection,
    public virtual _impl_SequentialCollection
  {
  public:
    virtual ~_impl_EqualitySequentialCollection();

    virtual ::CORBA::Boolean locate_first_element_with_value(const ::CORBA::Any& element, ::CosCollection::Iterator_ptr where) = 0;
    virtual ::CORBA::Boolean locate_last_element_with_value(const ::CORBA::Any& element, ::CosCollection::Iterator_ptr where) = 0;
    virtual ::CORBA::Boolean locate_previous_element_with_value(const ::CORBA::Any& element, ::CosCollection::Iterator_ptr where) = 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_EqualitySequentialCollection;

#ifndef __CosCollection_mKeySet__
#define __CosCollection_mKeySet__

  class KeySet;
  class _objref_KeySet;
  class _impl_KeySet;
  
  typedef _objref_KeySet* KeySet_ptr;
  typedef KeySet_ptr KeySetRef;

  class KeySet_Helper {
  public:
    typedef KeySet_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_KeySet, KeySet_Helper> KeySet_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_KeySet,KeySet_Helper > KeySet_out;

#endif

  // interface KeySet
  class KeySet {
  public:
    // Declarations for this interface type.
    typedef KeySet_ptr _ptr_type;
    typedef KeySet_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_KeySet :
    public virtual _objref_KeyCollection
  {
  public:
    

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

  protected:
    virtual ~_objref_KeySet();

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

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

    friend class KeySet;
  };

  class _pof_KeySet : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_KeySet() : _OMNI_NS(proxyObjectFactory)(KeySet::_PD_repoId) {}
    virtual ~_pof_KeySet();

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

  class _impl_KeySet :
    public virtual _impl_KeyCollection
  {
  public:
    virtual ~_impl_KeySet();

    
    
  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_KeySet;

#ifndef __CosCollection_mKeyBag__
#define __CosCollection_mKeyBag__

  class KeyBag;
  class _objref_KeyBag;
  class _impl_KeyBag;
  
  typedef _objref_KeyBag* KeyBag_ptr;
  typedef KeyBag_ptr KeyBagRef;

  class KeyBag_Helper {
  public:
    typedef KeyBag_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_KeyBag, KeyBag_Helper> KeyBag_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_KeyBag,KeyBag_Helper > KeyBag_out;

#endif

  // interface KeyBag
  class KeyBag {
  public:
    // Declarations for this interface type.
    typedef KeyBag_ptr _ptr_type;
    typedef KeyBag_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_KeyBag :
    public virtual _objref_KeyCollection
  {
  public:
    

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

  protected:
    virtual ~_objref_KeyBag();

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

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

    friend class KeyBag;
  };

  class _pof_KeyBag : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_KeyBag() : _OMNI_NS(proxyObjectFactory)(KeyBag::_PD_repoId) {}
    virtual ~_pof_KeyBag();

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

  class _impl_KeyBag :
    public virtual _impl_KeyCollection
  {
  public:
    virtual ~_impl_KeyBag();

    
    
  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_KeyBag;

#ifndef __CosCollection_mMap__
#define __CosCollection_mMap__

  class Map;
  class _objref_Map;
  class _impl_Map;
  
  typedef _objref_Map* Map_ptr;
  typedef Map_ptr MapRef;

  class Map_Helper {
  public:
    typedef Map_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_Map, Map_Helper> Map_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_Map,Map_Helper > Map_out;

#endif

  // interface Map
  class Map {
  public:
    // Declarations for this interface type.
    typedef Map_ptr _ptr_type;
    typedef Map_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_Map :
    public virtual _objref_EqualityKeyCollection
  {
  public:
    void difference_with(::CosCollection::Map_ptr collector);
    void add_difference(::CosCollection::Map_ptr collector1, ::CosCollection::Map_ptr collector2);
    void intersection_with(::CosCollection::Map_ptr collector);
    void add_intersection(::CosCollection::Map_ptr collector1, ::CosCollection::Map_ptr collector2);
    void union_with(::CosCollection::Map_ptr collector);
    void add_union(::CosCollection::Map_ptr collector1, ::CosCollection::Map_ptr collector2);
    ::CORBA::Boolean equal(::CosCollection::Map_ptr collector);
    ::CORBA::Boolean not_equal(::CosCollection::Map_ptr collector);

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

  protected:
    virtual ~_objref_Map();

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

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

    friend class Map;
  };

  class _pof_Map : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_Map() : _OMNI_NS(proxyObjectFactory)(Map::_PD_repoId) {}
    virtual ~_pof_Map();

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

  class _impl_Map :
    public virtual _impl_EqualityKeyCollection
  {
  public:
    virtual ~_impl_Map();

    virtual void difference_with(::CosCollection::Map_ptr collector) = 0;
    virtual void add_difference(::CosCollection::Map_ptr collector1, ::CosCollection::Map_ptr collector2) = 0;
    virtual void intersection_with(::CosCollection::Map_ptr collector) = 0;
    virtual void add_intersection(::CosCollection::Map_ptr collector1, ::CosCollection::Map_ptr collector2) = 0;
    virtual void union_with(::CosCollection::Map_ptr collector) = 0;
    virtual void add_union(::CosCollection::Map_ptr collector1, ::CosCollection::Map_ptr collector2) = 0;
    virtual ::CORBA::Boolean equal(::CosCollection::Map_ptr collector) = 0;
    virtual ::CORBA::Boolean not_equal(::CosCollection::Map_ptr collector) = 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_Map;

#ifndef __CosCollection_mRelation__
#define __CosCollection_mRelation__

  class Relation;
  class _objref_Relation;
  class _impl_Relation;
  
  typedef _objref_Relation* Relation_ptr;
  typedef Relation_ptr RelationRef;

  class Relation_Helper {
  public:
    typedef Relation_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_Relation, Relation_Helper> Relation_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_Relation,Relation_Helper > Relation_out;

#endif

  // interface Relation
  class Relation {
  public:
    // Declarations for this interface type.
    typedef Relation_ptr _ptr_type;
    typedef Relation_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_Relation :
    public virtual _objref_EqualityKeyCollection
  {
  public:
    

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

  protected:
    virtual ~_objref_Relation();

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

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

    friend class Relation;
  };

  class _pof_Relation : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_Relation() : _OMNI_NS(proxyObjectFactory)(Relation::_PD_repoId) {}
    virtual ~_pof_Relation();

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

  class _impl_Relation :
    public virtual _impl_EqualityKeyCollection
  {
  public:
    virtual ~_impl_Relation();

    
    
  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_Relation;

#ifndef __CosCollection_mSet__
#define __CosCollection_mSet__

  class Set;
  class _objref_Set;
  class _impl_Set;
  
  typedef _objref_Set* Set_ptr;
  typedef Set_ptr SetRef;

  class Set_Helper {
  public:
    typedef Set_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_Set, Set_Helper> Set_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_Set,Set_Helper > Set_out;

#endif

  // interface Set
  class Set {
  public:
    // Declarations for this interface type.
    typedef Set_ptr _ptr_type;
    typedef Set_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_Set :
    public virtual _objref_EqualityCollection
  {
  public:
    

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

  protected:
    virtual ~_objref_Set();

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

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

    friend class Set;
  };

  class _pof_Set : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_Set() : _OMNI_NS(proxyObjectFactory)(Set::_PD_repoId) {}
    virtual ~_pof_Set();

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

  class _impl_Set :
    public virtual _impl_EqualityCollection
  {
  public:
    virtual ~_impl_Set();

    
    
  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_Set;

#ifndef __CosCollection_mBag__
#define __CosCollection_mBag__

  class Bag;
  class _objref_Bag;
  class _impl_Bag;
  
  typedef _objref_Bag* Bag_ptr;
  typedef Bag_ptr BagRef;

  class Bag_Helper {
  public:
    typedef Bag_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_Bag, Bag_Helper> Bag_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_Bag,Bag_Helper > Bag_out;

#endif

  // interface Bag
  class Bag {
  public:
    // Declarations for this interface type.
    typedef Bag_ptr _ptr_type;
    typedef Bag_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_Bag :
    public virtual _objref_EqualityCollection
  {
  public:
    

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

  protected:
    virtual ~_objref_Bag();

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

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

    friend class Bag;
  };

  class _pof_Bag : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_Bag() : _OMNI_NS(proxyObjectFactory)(Bag::_PD_repoId) {}
    virtual ~_pof_Bag();

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

  class _impl_Bag :
    public virtual _impl_EqualityCollection
  {
  public:
    virtual ~_impl_Bag();

    
    
  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_Bag;

#ifndef __CosCollection_mKeySortedSet__
#define __CosCollection_mKeySortedSet__

  class KeySortedSet;
  class _objref_KeySortedSet;
  class _impl_KeySortedSet;
  
  typedef _objref_KeySortedSet* KeySortedSet_ptr;
  typedef KeySortedSet_ptr KeySortedSetRef;

  class KeySortedSet_Helper {
  public:
    typedef KeySortedSet_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_KeySortedSet, KeySortedSet_Helper> KeySortedSet_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_KeySortedSet,KeySortedSet_Helper > KeySortedSet_out;

#endif

  // interface KeySortedSet
  class KeySortedSet {
  public:
    // Declarations for this interface type.
    typedef KeySortedSet_ptr _ptr_type;
    typedef KeySortedSet_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_KeySortedSet :
    public virtual _objref_KeySortedCollection
  {
  public:
    ::CORBA::Long compare(::CosCollection::KeySortedSet_ptr collector, ::CosCollection::Comparator_ptr comparison);

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

  protected:
    virtual ~_objref_KeySortedSet();

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

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

    friend class KeySortedSet;
  };

  class _pof_KeySortedSet : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_KeySortedSet() : _OMNI_NS(proxyObjectFactory)(KeySortedSet::_PD_repoId) {}
    virtual ~_pof_KeySortedSet();

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

  class _impl_KeySortedSet :
    public virtual _impl_KeySortedCollection
  {
  public:
    virtual ~_impl_KeySortedSet();

    virtual ::CORBA::Long compare(::CosCollection::KeySortedSet_ptr collector, ::CosCollection::Comparator_ptr comparison) = 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_KeySortedSet;

#ifndef __CosCollection_mKeySortedBag__
#define __CosCollection_mKeySortedBag__

  class KeySortedBag;
  class _objref_KeySortedBag;
  class _impl_KeySortedBag;
  
  typedef _objref_KeySortedBag* KeySortedBag_ptr;
  typedef KeySortedBag_ptr KeySortedBagRef;

  class KeySortedBag_Helper {
  public:
    typedef KeySortedBag_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_KeySortedBag, KeySortedBag_Helper> KeySortedBag_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_KeySortedBag,KeySortedBag_Helper > KeySortedBag_out;

#endif

  // interface KeySortedBag
  class KeySortedBag {
  public:
    // Declarations for this interface type.
    typedef KeySortedBag_ptr _ptr_type;
    typedef KeySortedBag_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_KeySortedBag :
    public virtual _objref_KeySortedCollection
  {
  public:
    ::CORBA::Long compare(::CosCollection::KeySortedBag_ptr collector, ::CosCollection::Comparator_ptr comparison);

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

  protected:
    virtual ~_objref_KeySortedBag();

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

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

    friend class KeySortedBag;
  };

  class _pof_KeySortedBag : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_KeySortedBag() : _OMNI_NS(proxyObjectFactory)(KeySortedBag::_PD_repoId) {}
    virtual ~_pof_KeySortedBag();

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

  class _impl_KeySortedBag :
    public virtual _impl_KeySortedCollection
  {
  public:
    virtual ~_impl_KeySortedBag();

    virtual ::CORBA::Long compare(::CosCollection::KeySortedBag_ptr collector, ::CosCollection::Comparator_ptr comparison) = 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_KeySortedBag;

#ifndef __CosCollection_mSortedMap__
#define __CosCollection_mSortedMap__

  class SortedMap;
  class _objref_SortedMap;
  class _impl_SortedMap;
  
  typedef _objref_SortedMap* SortedMap_ptr;
  typedef SortedMap_ptr SortedMapRef;

  class SortedMap_Helper {
  public:
    typedef SortedMap_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_SortedMap, SortedMap_Helper> SortedMap_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_SortedMap,SortedMap_Helper > SortedMap_out;

#endif

  // interface SortedMap
  class SortedMap {
  public:
    // Declarations for this interface type.
    typedef SortedMap_ptr _ptr_type;
    typedef SortedMap_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_SortedMap :
    public virtual _objref_EqualityKeySortedCollection
  {
  public:
    ::CORBA::Long compare(::CosCollection::SortedMap_ptr collector, ::CosCollection::Comparator_ptr comparison);

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

  protected:
    virtual ~_objref_SortedMap();

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

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

    friend class SortedMap;
  };

  class _pof_SortedMap : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_SortedMap() : _OMNI_NS(proxyObjectFactory)(SortedMap::_PD_repoId) {}
    virtual ~_pof_SortedMap();

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

  class _impl_SortedMap :
    public virtual _impl_EqualityKeySortedCollection
  {
  public:
    virtual ~_impl_SortedMap();

    virtual ::CORBA::Long compare(::CosCollection::SortedMap_ptr collector, ::CosCollection::Comparator_ptr comparison) = 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_SortedMap;

#ifndef __CosCollection_mSortedRelation__
#define __CosCollection_mSortedRelation__

  class SortedRelation;
  class _objref_SortedRelation;
  class _impl_SortedRelation;
  
  typedef _objref_SortedRelation* SortedRelation_ptr;
  typedef SortedRelation_ptr SortedRelationRef;

  class SortedRelation_Helper {
  public:
    typedef SortedRelation_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_SortedRelation, SortedRelation_Helper> SortedRelation_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_SortedRelation,SortedRelation_Helper > SortedRelation_out;

#endif

  // interface SortedRelation
  class SortedRelation {
  public:
    // Declarations for this interface type.
    typedef SortedRelation_ptr _ptr_type;
    typedef SortedRelation_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_SortedRelation :
    public virtual _objref_EqualityKeySortedCollection
  {
  public:
    ::CORBA::Long compare(::CosCollection::SortedRelation_ptr collector, ::CosCollection::Comparator_ptr comparison);

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

  protected:
    virtual ~_objref_SortedRelation();

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

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

    friend class SortedRelation;
  };

  class _pof_SortedRelation : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_SortedRelation() : _OMNI_NS(proxyObjectFactory)(SortedRelation::_PD_repoId) {}
    virtual ~_pof_SortedRelation();

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

  class _impl_SortedRelation :
    public virtual _impl_EqualityKeySortedCollection
  {
  public:
    virtual ~_impl_SortedRelation();

    virtual ::CORBA::Long compare(::CosCollection::SortedRelation_ptr collector, ::CosCollection::Comparator_ptr comparison) = 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_SortedRelation;

#ifndef __CosCollection_mSortedSet__
#define __CosCollection_mSortedSet__

  class SortedSet;
  class _objref_SortedSet;
  class _impl_SortedSet;
  
  typedef _objref_SortedSet* SortedSet_ptr;
  typedef SortedSet_ptr SortedSetRef;

  class SortedSet_Helper {
  public:
    typedef SortedSet_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_SortedSet, SortedSet_Helper> SortedSet_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_SortedSet,SortedSet_Helper > SortedSet_out;

#endif

  // interface SortedSet
  class SortedSet {
  public:
    // Declarations for this interface type.
    typedef SortedSet_ptr _ptr_type;
    typedef SortedSet_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_SortedSet :
    public virtual _objref_EqualitySortedCollection
  {
  public:
    ::CORBA::Long compare(::CosCollection::SortedSet_ptr collector, ::CosCollection::Comparator_ptr comparison);

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

  protected:
    virtual ~_objref_SortedSet();

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

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

    friend class SortedSet;
  };

  class _pof_SortedSet : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_SortedSet() : _OMNI_NS(proxyObjectFactory)(SortedSet::_PD_repoId) {}
    virtual ~_pof_SortedSet();

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

  class _impl_SortedSet :
    public virtual _impl_EqualitySortedCollection
  {
  public:
    virtual ~_impl_SortedSet();

    virtual ::CORBA::Long compare(::CosCollection::SortedSet_ptr collector, ::CosCollection::Comparator_ptr comparison) = 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_SortedSet;

#ifndef __CosCollection_mSortedBag__
#define __CosCollection_mSortedBag__

  class SortedBag;
  class _objref_SortedBag;
  class _impl_SortedBag;
  
  typedef _objref_SortedBag* SortedBag_ptr;
  typedef SortedBag_ptr SortedBagRef;

  class SortedBag_Helper {
  public:
    typedef SortedBag_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_SortedBag, SortedBag_Helper> SortedBag_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_SortedBag,SortedBag_Helper > SortedBag_out;

#endif

  // interface SortedBag
  class SortedBag {
  public:
    // Declarations for this interface type.
    typedef SortedBag_ptr _ptr_type;
    typedef SortedBag_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_SortedBag :
    public virtual _objref_EqualitySortedCollection
  {
  public:
    ::CORBA::Long compare(::CosCollection::SortedBag_ptr collector, ::CosCollection::Comparator_ptr comparison);

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

  protected:
    virtual ~_objref_SortedBag();

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

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

    friend class SortedBag;
  };

  class _pof_SortedBag : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_SortedBag() : _OMNI_NS(proxyObjectFactory)(SortedBag::_PD_repoId) {}
    virtual ~_pof_SortedBag();

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

  class _impl_SortedBag :
    public virtual _impl_EqualitySortedCollection
  {
  public:
    virtual ~_impl_SortedBag();

    virtual ::CORBA::Long compare(::CosCollection::SortedBag_ptr collector, ::CosCollection::Comparator_ptr comparison) = 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_SortedBag;

#ifndef __CosCollection_mCSequence__
#define __CosCollection_mCSequence__

  class CSequence;
  class _objref_CSequence;
  class _impl_CSequence;
  
  typedef _objref_CSequence* CSequence_ptr;
  typedef CSequence_ptr CSequenceRef;

  class CSequence_Helper {
  public:
    typedef CSequence_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_CSequence, CSequence_Helper> CSequence_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_CSequence,CSequence_Helper > CSequence_out;

#endif

  // interface CSequence
  class CSequence {
  public:
    // Declarations for this interface type.
    typedef CSequence_ptr _ptr_type;
    typedef CSequence_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_CSequence :
    public virtual _objref_SequentialCollection
  {
  public:
    ::CORBA::Long compare(::CosCollection::CSequence_ptr collector, ::CosCollection::Comparator_ptr comparison);

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

  protected:
    virtual ~_objref_CSequence();

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

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

    friend class CSequence;
  };

  class _pof_CSequence : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_CSequence() : _OMNI_NS(proxyObjectFactory)(CSequence::_PD_repoId) {}
    virtual ~_pof_CSequence();

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

  class _impl_CSequence :
    public virtual _impl_SequentialCollection
  {
  public:
    virtual ~_impl_CSequence();

    virtual ::CORBA::Long compare(::CosCollection::CSequence_ptr collector, ::CosCollection::Comparator_ptr comparison) = 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_CSequence;

#ifndef __CosCollection_mEqualitySequence__
#define __CosCollection_mEqualitySequence__

  class EqualitySequence;
  class _objref_EqualitySequence;
  class _impl_EqualitySequence;
  
  typedef _objref_EqualitySequence* EqualitySequence_ptr;
  typedef EqualitySequence_ptr EqualitySequenceRef;

  class EqualitySequence_Helper {
  public:
    typedef EqualitySequence_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_EqualitySequence, EqualitySequence_Helper> EqualitySequence_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_EqualitySequence,EqualitySequence_Helper > EqualitySequence_out;

#endif

  // interface EqualitySequence
  class EqualitySequence {
  public:
    // Declarations for this interface type.
    typedef EqualitySequence_ptr _ptr_type;
    typedef EqualitySequence_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_EqualitySequence :
    public virtual _objref_EqualitySequentialCollection
  {
  public:
    ::CORBA::Boolean equal(::CosCollection::EqualitySequence_ptr collector);
    ::CORBA::Boolean not_equal(::CosCollection::EqualitySequence_ptr collector);
    ::CORBA::Long compare(::CosCollection::EqualitySequence_ptr collector, ::CosCollection::Comparator_ptr comparison);

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

  protected:
    virtual ~_objref_EqualitySequence();

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

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

    friend class EqualitySequence;
  };

  class _pof_EqualitySequence : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_EqualitySequence() : _OMNI_NS(proxyObjectFactory)(EqualitySequence::_PD_repoId) {}
    virtual ~_pof_EqualitySequence();

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

  class _impl_EqualitySequence :
    public virtual _impl_EqualitySequentialCollection
  {
  public:
    virtual ~_impl_EqualitySequence();

    virtual ::CORBA::Boolean equal(::CosCollection::EqualitySequence_ptr collector) = 0;
    virtual ::CORBA::Boolean not_equal(::CosCollection::EqualitySequence_ptr collector) = 0;
    virtual ::CORBA::Long compare(::CosCollection::EqualitySequence_ptr collector, ::CosCollection::Comparator_ptr comparison) = 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_EqualitySequence;

#ifndef __CosCollection_mHeap__
#define __CosCollection_mHeap__

  class Heap;
  class _objref_Heap;
  class _impl_Heap;
  
  typedef _objref_Heap* Heap_ptr;
  typedef Heap_ptr HeapRef;

  class Heap_Helper {
  public:
    typedef Heap_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_Heap, Heap_Helper> Heap_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_Heap,Heap_Helper > Heap_out;

#endif

  // interface Heap
  class Heap {
  public:
    // Declarations for this interface type.
    typedef Heap_ptr _ptr_type;
    typedef Heap_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_Heap :
    public virtual _objref_Collection
  {
  public:
    

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

  protected:
    virtual ~_objref_Heap();

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

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

    friend class Heap;
  };

  class _pof_Heap : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_Heap() : _OMNI_NS(proxyObjectFactory)(Heap::_PD_repoId) {}
    virtual ~_pof_Heap();

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

  class _impl_Heap :
    public virtual _impl_Collection
  {
  public:
    virtual ~_impl_Heap();

    
    
  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_Heap;

#ifndef __CosCollection_mRestrictedAccessCollection__
#define __CosCollection_mRestrictedAccessCollection__

  class RestrictedAccessCollection;
  class _objref_RestrictedAccessCollection;
  class _impl_RestrictedAccessCollection;
  
  typedef _objref_RestrictedAccessCollection* RestrictedAccessCollection_ptr;
  typedef RestrictedAccessCollection_ptr RestrictedAccessCollectionRef;

  class RestrictedAccessCollection_Helper {
  public:
    typedef RestrictedAccessCollection_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_RestrictedAccessCollection, RestrictedAccessCollection_Helper> RestrictedAccessCollection_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_RestrictedAccessCollection,RestrictedAccessCollection_Helper > RestrictedAccessCollection_out;

#endif

  // interface RestrictedAccessCollection
  class RestrictedAccessCollection {
  public:
    // Declarations for this interface type.
    typedef RestrictedAccessCollection_ptr _ptr_type;
    typedef RestrictedAccessCollection_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_RestrictedAccessCollection :
    public virtual ::CORBA::Object,
    public virtual omniObjRef
  {
  public:
    ::CORBA::Boolean unfilled();
    ::CORBA::ULong size();
    void purge();

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

  protected:
    virtual ~_objref_RestrictedAccessCollection();

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

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

    friend class RestrictedAccessCollection;
  };

  class _pof_RestrictedAccessCollection : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_RestrictedAccessCollection() : _OMNI_NS(proxyObjectFactory)(RestrictedAccessCollection::_PD_repoId) {}
    virtual ~_pof_RestrictedAccessCollection();

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

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

    virtual ::CORBA::Boolean unfilled() = 0;
    virtual ::CORBA::ULong size() = 0;
    virtual void purge() = 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_RestrictedAccessCollection;

#ifndef __CosCollection_mQueue__
#define __CosCollection_mQueue__

  class Queue;
  class _objref_Queue;
  class _impl_Queue;
  
  typedef _objref_Queue* Queue_ptr;
  typedef Queue_ptr QueueRef;

  class Queue_Helper {
  public:
    typedef Queue_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_Queue, Queue_Helper> Queue_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_Queue,Queue_Helper > Queue_out;

#endif

  // interface Queue
  class Queue {
  public:
    // Declarations for this interface type.
    typedef Queue_ptr _ptr_type;
    typedef Queue_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_Queue :
    public virtual _objref_RestrictedAccessCollection
  {
  public:
    void enqueue(const ::CORBA::Any& element);
    void dequeue();
    ::CORBA::Boolean element_dequeue(::CORBA::Any_OUT_arg element);

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

  protected:
    virtual ~_objref_Queue();

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

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

    friend class Queue;
  };

  class _pof_Queue : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_Queue() : _OMNI_NS(proxyObjectFactory)(Queue::_PD_repoId) {}
    virtual ~_pof_Queue();

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

  class _impl_Queue :
    public virtual _impl_RestrictedAccessCollection
  {
  public:
    virtual ~_impl_Queue();

    virtual void enqueue(const ::CORBA::Any& element) = 0;
    virtual void dequeue() = 0;
    virtual ::CORBA::Boolean element_dequeue(::CORBA::Any_OUT_arg element) = 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_Queue;

#ifndef __CosCollection_mDeque__
#define __CosCollection_mDeque__

  class Deque;
  class _objref_Deque;
  class _impl_Deque;
  
  typedef _objref_Deque* Deque_ptr;
  typedef Deque_ptr DequeRef;

  class Deque_Helper {
  public:
    typedef Deque_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_Deque, Deque_Helper> Deque_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_Deque,Deque_Helper > Deque_out;

#endif

  // interface Deque
  class Deque {
  public:
    // Declarations for this interface type.
    typedef Deque_ptr _ptr_type;
    typedef Deque_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_Deque :
    public virtual _objref_RestrictedAccessCollection
  {
  public:
    void enqueue_as_first(const ::CORBA::Any& element);
    void enqueue_as_last(const ::CORBA::Any& element);
    void dequeue_first();
    ::CORBA::Boolean element_dequeue_first(::CORBA::Any_OUT_arg element);
    void dequeue_last();
    ::CORBA::Boolean element_dequeue_last(::CORBA::Any_OUT_arg element);

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

  protected:
    virtual ~_objref_Deque();

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

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

    friend class Deque;
  };

  class _pof_Deque : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_Deque() : _OMNI_NS(proxyObjectFactory)(Deque::_PD_repoId) {}
    virtual ~_pof_Deque();

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

  class _impl_Deque :
    public virtual _impl_RestrictedAccessCollection
  {
  public:
    virtual ~_impl_Deque();

    virtual void enqueue_as_first(const ::CORBA::Any& element) = 0;
    virtual void enqueue_as_last(const ::CORBA::Any& element) = 0;
    virtual void dequeue_first() = 0;
    virtual ::CORBA::Boolean element_dequeue_first(::CORBA::Any_OUT_arg element) = 0;
    virtual void dequeue_last() = 0;
    virtual ::CORBA::Boolean element_dequeue_last(::CORBA::Any_OUT_arg element) = 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_Deque;

#ifndef __CosCollection_mStack__
#define __CosCollection_mStack__

  class Stack;
  class _objref_Stack;
  class _impl_Stack;
  
  typedef _objref_Stack* Stack_ptr;
  typedef Stack_ptr StackRef;

  class Stack_Helper {
  public:
    typedef Stack_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_Stack, Stack_Helper> Stack_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_Stack,Stack_Helper > Stack_out;

#endif

  // interface Stack
  class Stack {
  public:
    // Declarations for this interface type.
    typedef Stack_ptr _ptr_type;
    typedef Stack_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_Stack :
    public virtual _objref_RestrictedAccessCollection
  {
  public:
    void push(const ::CORBA::Any& element);
    void pop();
    ::CORBA::Boolean element_pop(::CORBA::Any_OUT_arg element);
    ::CORBA::Boolean top(::CORBA::Any_OUT_arg element);

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

  protected:
    virtual ~_objref_Stack();

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

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

    friend class Stack;
  };

  class _pof_Stack : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_Stack() : _OMNI_NS(proxyObjectFactory)(Stack::_PD_repoId) {}
    virtual ~_pof_Stack();

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

  class _impl_Stack :
    public virtual _impl_RestrictedAccessCollection
  {
  public:
    virtual ~_impl_Stack();

    virtual void push(const ::CORBA::Any& element) = 0;
    virtual void pop() = 0;
    virtual ::CORBA::Boolean element_pop(::CORBA::Any_OUT_arg element) = 0;
    virtual ::CORBA::Boolean top(::CORBA::Any_OUT_arg element) = 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_Stack;

#ifndef __CosCollection_mPriorityQueue__
#define __CosCollection_mPriorityQueue__

  class PriorityQueue;
  class _objref_PriorityQueue;
  class _impl_PriorityQueue;
  
  typedef _objref_PriorityQueue* PriorityQueue_ptr;
  typedef PriorityQueue_ptr PriorityQueueRef;

  class PriorityQueue_Helper {
  public:
    typedef PriorityQueue_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_PriorityQueue, PriorityQueue_Helper> PriorityQueue_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_PriorityQueue,PriorityQueue_Helper > PriorityQueue_out;

#endif

  // interface PriorityQueue
  class PriorityQueue {
  public:
    // Declarations for this interface type.
    typedef PriorityQueue_ptr _ptr_type;
    typedef PriorityQueue_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_PriorityQueue :
    public virtual _objref_RestrictedAccessCollection
  {
  public:
    void enqueue(const ::CORBA::Any& element);
    void dequeue();
    ::CORBA::Boolean element_dequeue(::CORBA::Any_OUT_arg element);

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

  protected:
    virtual ~_objref_PriorityQueue();

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

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

    friend class PriorityQueue;
  };

  class _pof_PriorityQueue : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_PriorityQueue() : _OMNI_NS(proxyObjectFactory)(PriorityQueue::_PD_repoId) {}
    virtual ~_pof_PriorityQueue();

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

  class _impl_PriorityQueue :
    public virtual _impl_RestrictedAccessCollection
  {
  public:
    virtual ~_impl_PriorityQueue();

    virtual void enqueue(const ::CORBA::Any& element) = 0;
    virtual void dequeue() = 0;
    virtual ::CORBA::Boolean element_dequeue(::CORBA::Any_OUT_arg element) = 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_PriorityQueue;

#ifndef __CosCollection_mCollectionFactory__
#define __CosCollection_mCollectionFactory__

  class CollectionFactory;
  class _objref_CollectionFactory;
  class _impl_CollectionFactory;
  
  typedef _objref_CollectionFactory* CollectionFactory_ptr;
  typedef CollectionFactory_ptr CollectionFactoryRef;

  class CollectionFactory_Helper {
  public:
    typedef CollectionFactory_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_CollectionFactory, CollectionFactory_Helper> CollectionFactory_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_CollectionFactory,CollectionFactory_Helper > CollectionFactory_out;

#endif

  // interface CollectionFactory
  class CollectionFactory {
  public:
    // Declarations for this interface type.
    typedef CollectionFactory_ptr _ptr_type;
    typedef CollectionFactory_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_CollectionFactory :
    public virtual ::CORBA::Object,
    public virtual omniObjRef
  {
  public:
    Collection_ptr generic_create(const ::CosCollection::ParameterList& parameters);

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

  protected:
    virtual ~_objref_CollectionFactory();

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

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

    friend class CollectionFactory;
  };

  class _pof_CollectionFactory : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_CollectionFactory() : _OMNI_NS(proxyObjectFactory)(CollectionFactory::_PD_repoId) {}
    virtual ~_pof_CollectionFactory();

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

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

    virtual Collection_ptr generic_create(const ::CosCollection::ParameterList& parameters) = 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_CollectionFactory;

#ifndef __CosCollection_mCollectionFactories__
#define __CosCollection_mCollectionFactories__

  class CollectionFactories;
  class _objref_CollectionFactories;
  class _impl_CollectionFactories;
  
  typedef _objref_CollectionFactories* CollectionFactories_ptr;
  typedef CollectionFactories_ptr CollectionFactoriesRef;

  class CollectionFactories_Helper {
  public:
    typedef CollectionFactories_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_CollectionFactories, CollectionFactories_Helper> CollectionFactories_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_CollectionFactories,CollectionFactories_Helper > CollectionFactories_out;

#endif

  // interface CollectionFactories
  class CollectionFactories {
  public:
    // Declarations for this interface type.
    typedef CollectionFactories_ptr _ptr_type;
    typedef CollectionFactories_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_CollectionFactories :
    public virtual _objref_CollectionFactory
  {
  public:
    ::CORBA::Boolean add_factory(const char* collection_interface, const char* impl_category, const char* impl_interface, ::CosCollection::CollectionFactory_ptr c_factory);
    ::CORBA::Boolean remove_factory(const char* collection_interface, const char* impl_category, const char* impl_interface);
    Collection_ptr create(const ::CosCollection::ParameterList& parameters);

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

  protected:
    virtual ~_objref_CollectionFactories();

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

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

    friend class CollectionFactories;
  };

  class _pof_CollectionFactories : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_CollectionFactories() : _OMNI_NS(proxyObjectFactory)(CollectionFactories::_PD_repoId) {}
    virtual ~_pof_CollectionFactories();

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

  class _impl_CollectionFactories :
    public virtual _impl_CollectionFactory
  {
  public:
    virtual ~_impl_CollectionFactories();

    virtual ::CORBA::Boolean add_factory(const char* collection_interface, const char* impl_category, const char* impl_interface, ::CosCollection::CollectionFactory_ptr c_factory) = 0;
    virtual ::CORBA::Boolean remove_factory(const char* collection_interface, const char* impl_category, const char* impl_interface) = 0;
    virtual Collection_ptr create(const ::CosCollection::ParameterList& parameters) = 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_CollectionFactories;

#ifndef __CosCollection_mRACollectionFactory__
#define __CosCollection_mRACollectionFactory__

  class RACollectionFactory;
  class _objref_RACollectionFactory;
  class _impl_RACollectionFactory;
  
  typedef _objref_RACollectionFactory* RACollectionFactory_ptr;
  typedef RACollectionFactory_ptr RACollectionFactoryRef;

  class RACollectionFactory_Helper {
  public:
    typedef RACollectionFactory_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_RACollectionFactory, RACollectionFactory_Helper> RACollectionFactory_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_RACollectionFactory,RACollectionFactory_Helper > RACollectionFactory_out;

#endif

  // interface RACollectionFactory
  class RACollectionFactory {
  public:
    // Declarations for this interface type.
    typedef RACollectionFactory_ptr _ptr_type;
    typedef RACollectionFactory_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_RACollectionFactory :
    public virtual ::CORBA::Object,
    public virtual omniObjRef
  {
  public:
    RestrictedAccessCollection_ptr generic_create(const ::CosCollection::ParameterList& parameters);

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

  protected:
    virtual ~_objref_RACollectionFactory();

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

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

    friend class RACollectionFactory;
  };

  class _pof_RACollectionFactory : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_RACollectionFactory() : _OMNI_NS(proxyObjectFactory)(RACollectionFactory::_PD_repoId) {}
    virtual ~_pof_RACollectionFactory();

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

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

    virtual RestrictedAccessCollection_ptr generic_create(const ::CosCollection::ParameterList& parameters) = 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_RACollectionFactory;

#ifndef __CosCollection_mRACollectionFactories__
#define __CosCollection_mRACollectionFactories__

  class RACollectionFactories;
  class _objref_RACollectionFactories;
  class _impl_RACollectionFactories;
  
  typedef _objref_RACollectionFactories* RACollectionFactories_ptr;
  typedef RACollectionFactories_ptr RACollectionFactoriesRef;

  class RACollectionFactories_Helper {
  public:
    typedef RACollectionFactories_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_RACollectionFactories, RACollectionFactories_Helper> RACollectionFactories_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_RACollectionFactories,RACollectionFactories_Helper > RACollectionFactories_out;

#endif

  // interface RACollectionFactories
  class RACollectionFactories {
  public:
    // Declarations for this interface type.
    typedef RACollectionFactories_ptr _ptr_type;
    typedef RACollectionFactories_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_RACollectionFactories :
    public virtual _objref_RACollectionFactory
  {
  public:
    ::CORBA::Boolean add_factory(const char* collection_interface, const char* impl_category, const char* impl_interface, ::CosCollection::RACollectionFactory_ptr rac_factory);
    ::CORBA::Boolean remove_factory(const char* collection_interface, const char* impl_category, const char* impl_interface);
    Collection_ptr create(const ::CosCollection::ParameterList& parameters);

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

  protected:
    virtual ~_objref_RACollectionFactories();

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

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

    friend class RACollectionFactories;
  };

  class _pof_RACollectionFactories : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_RACollectionFactories() : _OMNI_NS(proxyObjectFactory)(RACollectionFactories::_PD_repoId) {}
    virtual ~_pof_RACollectionFactories();

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

  class _impl_RACollectionFactories :
    public virtual _impl_RACollectionFactory
  {
  public:
    virtual ~_impl_RACollectionFactories();

    virtual ::CORBA::Boolean add_factory(const char* collection_interface, const char* impl_category, const char* impl_interface, ::CosCollection::RACollectionFactory_ptr rac_factory) = 0;
    virtual ::CORBA::Boolean remove_factory(const char* collection_interface, const char* impl_category, const char* impl_interface) = 0;
    virtual Collection_ptr create(const ::CosCollection::ParameterList& parameters) = 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_RACollectionFactories;

#ifndef __CosCollection_mKeySetFactory__
#define __CosCollection_mKeySetFactory__

  class KeySetFactory;
  class _objref_KeySetFactory;
  class _impl_KeySetFactory;
  
  typedef _objref_KeySetFactory* KeySetFactory_ptr;
  typedef KeySetFactory_ptr KeySetFactoryRef;

  class KeySetFactory_Helper {
  public:
    typedef KeySetFactory_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_KeySetFactory, KeySetFactory_Helper> KeySetFactory_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_KeySetFactory,KeySetFactory_Helper > KeySetFactory_out;

#endif

  // interface KeySetFactory
  class KeySetFactory {
  public:
    // Declarations for this interface type.
    typedef KeySetFactory_ptr _ptr_type;
    typedef KeySetFactory_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_KeySetFactory :
    public virtual _objref_CollectionFactory
  {
  public:
    KeySet_ptr create(::CosCollection::Operations_ptr ops, ::CORBA::ULong expected_size);

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

  protected:
    virtual ~_objref_KeySetFactory();

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

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

    friend class KeySetFactory;
  };

  class _pof_KeySetFactory : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_KeySetFactory() : _OMNI_NS(proxyObjectFactory)(KeySetFactory::_PD_repoId) {}
    virtual ~_pof_KeySetFactory();

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

  class _impl_KeySetFactory :
    public virtual _impl_CollectionFactory
  {
  public:
    virtual ~_impl_KeySetFactory();

    virtual KeySet_ptr create(::CosCollection::Operations_ptr ops, ::CORBA::ULong expected_size) = 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_KeySetFactory;

#ifndef __CosCollection_mKeyBagFactory__
#define __CosCollection_mKeyBagFactory__

  class KeyBagFactory;
  class _objref_KeyBagFactory;
  class _impl_KeyBagFactory;
  
  typedef _objref_KeyBagFactory* KeyBagFactory_ptr;
  typedef KeyBagFactory_ptr KeyBagFactoryRef;

  class KeyBagFactory_Helper {
  public:
    typedef KeyBagFactory_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_KeyBagFactory, KeyBagFactory_Helper> KeyBagFactory_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_KeyBagFactory,KeyBagFactory_Helper > KeyBagFactory_out;

#endif

  // interface KeyBagFactory
  class KeyBagFactory {
  public:
    // Declarations for this interface type.
    typedef KeyBagFactory_ptr _ptr_type;
    typedef KeyBagFactory_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_KeyBagFactory :
    public virtual _objref_CollectionFactory
  {
  public:
    KeyBag_ptr create(::CosCollection::Operations_ptr ops, ::CORBA::ULong expected_size);

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

  protected:
    virtual ~_objref_KeyBagFactory();

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

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

    friend class KeyBagFactory;
  };

  class _pof_KeyBagFactory : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_KeyBagFactory() : _OMNI_NS(proxyObjectFactory)(KeyBagFactory::_PD_repoId) {}
    virtual ~_pof_KeyBagFactory();

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

  class _impl_KeyBagFactory :
    public virtual _impl_CollectionFactory
  {
  public:
    virtual ~_impl_KeyBagFactory();

    virtual KeyBag_ptr create(::CosCollection::Operations_ptr ops, ::CORBA::ULong expected_size) = 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_KeyBagFactory;

#ifndef __CosCollection_mMapFactory__
#define __CosCollection_mMapFactory__

  class MapFactory;
  class _objref_MapFactory;
  class _impl_MapFactory;
  
  typedef _objref_MapFactory* MapFactory_ptr;
  typedef MapFactory_ptr MapFactoryRef;

  class MapFactory_Helper {
  public:
    typedef MapFactory_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_MapFactory, MapFactory_Helper> MapFactory_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_MapFactory,MapFactory_Helper > MapFactory_out;

#endif

  // interface MapFactory
  class MapFactory {
  public:
    // Declarations for this interface type.
    typedef MapFactory_ptr _ptr_type;
    typedef MapFactory_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_MapFactory :
    public virtual _objref_CollectionFactory
  {
  public:
    Map_ptr create(::CosCollection::Operations_ptr ops, ::CORBA::ULong expected_size);

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

  protected:
    virtual ~_objref_MapFactory();

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

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

    friend class MapFactory;
  };

  class _pof_MapFactory : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_MapFactory() : _OMNI_NS(proxyObjectFactory)(MapFactory::_PD_repoId) {}
    virtual ~_pof_MapFactory();

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

  class _impl_MapFactory :
    public virtual _impl_CollectionFactory
  {
  public:
    virtual ~_impl_MapFactory();

    virtual Map_ptr create(::CosCollection::Operations_ptr ops, ::CORBA::ULong expected_size) = 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_MapFactory;

#ifndef __CosCollection_mRelationFactory__
#define __CosCollection_mRelationFactory__

  class RelationFactory;
  class _objref_RelationFactory;
  class _impl_RelationFactory;
  
  typedef _objref_RelationFactory* RelationFactory_ptr;
  typedef RelationFactory_ptr RelationFactoryRef;

  class RelationFactory_Helper {
  public:
    typedef RelationFactory_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_RelationFactory, RelationFactory_Helper> RelationFactory_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_RelationFactory,RelationFactory_Helper > RelationFactory_out;

#endif

  // interface RelationFactory
  class RelationFactory {
  public:
    // Declarations for this interface type.
    typedef RelationFactory_ptr _ptr_type;
    typedef RelationFactory_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_RelationFactory :
    public virtual _objref_CollectionFactory
  {
  public:
    Relation_ptr create(::CosCollection::Operations_ptr ops, ::CORBA::ULong expected_size);

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

  protected:
    virtual ~_objref_RelationFactory();

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

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

    friend class RelationFactory;
  };

  class _pof_RelationFactory : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_RelationFactory() : _OMNI_NS(proxyObjectFactory)(RelationFactory::_PD_repoId) {}
    virtual ~_pof_RelationFactory();

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

  class _impl_RelationFactory :
    public virtual _impl_CollectionFactory
  {
  public:
    virtual ~_impl_RelationFactory();

    virtual Relation_ptr create(::CosCollection::Operations_ptr ops, ::CORBA::ULong expected_size) = 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_RelationFactory;

#ifndef __CosCollection_mSetFactory__
#define __CosCollection_mSetFactory__

  class SetFactory;
  class _objref_SetFactory;
  class _impl_SetFactory;
  
  typedef _objref_SetFactory* SetFactory_ptr;
  typedef SetFactory_ptr SetFactoryRef;

  class SetFactory_Helper {
  public:
    typedef SetFactory_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_SetFactory, SetFactory_Helper> SetFactory_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_SetFactory,SetFactory_Helper > SetFactory_out;

#endif

  // interface SetFactory
  class SetFactory {
  public:
    // Declarations for this interface type.
    typedef SetFactory_ptr _ptr_type;
    typedef SetFactory_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_SetFactory :
    public virtual _objref_CollectionFactory
  {
  public:
    Set_ptr create(::CosCollection::Operations_ptr ops, ::CORBA::ULong expected_size);

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

  protected:
    virtual ~_objref_SetFactory();

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

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

    friend class SetFactory;
  };

  class _pof_SetFactory : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_SetFactory() : _OMNI_NS(proxyObjectFactory)(SetFactory::_PD_repoId) {}
    virtual ~_pof_SetFactory();

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

  class _impl_SetFactory :
    public virtual _impl_CollectionFactory
  {
  public:
    virtual ~_impl_SetFactory();

    virtual Set_ptr create(::CosCollection::Operations_ptr ops, ::CORBA::ULong expected_size) = 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_SetFactory;

#ifndef __CosCollection_mBagFactory__
#define __CosCollection_mBagFactory__

  class BagFactory;
  class _objref_BagFactory;
  class _impl_BagFactory;
  
  typedef _objref_BagFactory* BagFactory_ptr;
  typedef BagFactory_ptr BagFactoryRef;

  class BagFactory_Helper {
  public:
    typedef BagFactory_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_BagFactory, BagFactory_Helper> BagFactory_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_BagFactory,BagFactory_Helper > BagFactory_out;

#endif

  // interface BagFactory
  class BagFactory {
  public:
    // Declarations for this interface type.
    typedef BagFactory_ptr _ptr_type;
    typedef BagFactory_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_BagFactory :
    public virtual ::CORBA::Object,
    public virtual omniObjRef
  {
  public:
    Bag_ptr create(::CosCollection::Operations_ptr ops, ::CORBA::ULong expected_size);

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

  protected:
    virtual ~_objref_BagFactory();

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

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

    friend class BagFactory;
  };

  class _pof_BagFactory : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_BagFactory() : _OMNI_NS(proxyObjectFactory)(BagFactory::_PD_repoId) {}
    virtual ~_pof_BagFactory();

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

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

    virtual Bag_ptr create(::CosCollection::Operations_ptr ops, ::CORBA::ULong expected_size) = 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_BagFactory;

#ifndef __CosCollection_mKeySortedSetFactory__
#define __CosCollection_mKeySortedSetFactory__

  class KeySortedSetFactory;
  class _objref_KeySortedSetFactory;
  class _impl_KeySortedSetFactory;
  
  typedef _objref_KeySortedSetFactory* KeySortedSetFactory_ptr;
  typedef KeySortedSetFactory_ptr KeySortedSetFactoryRef;

  class KeySortedSetFactory_Helper {
  public:
    typedef KeySortedSetFactory_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_KeySortedSetFactory, KeySortedSetFactory_Helper> KeySortedSetFactory_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_KeySortedSetFactory,KeySortedSetFactory_Helper > KeySortedSetFactory_out;

#endif

  // interface KeySortedSetFactory
  class KeySortedSetFactory {
  public:
    // Declarations for this interface type.
    typedef KeySortedSetFactory_ptr _ptr_type;
    typedef KeySortedSetFactory_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_KeySortedSetFactory :
    public virtual ::CORBA::Object,
    public virtual omniObjRef
  {
  public:
    KeySortedSet_ptr create(::CosCollection::Operations_ptr ops, ::CORBA::ULong expected_size);

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

  protected:
    virtual ~_objref_KeySortedSetFactory();

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

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

    friend class KeySortedSetFactory;
  };

  class _pof_KeySortedSetFactory : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_KeySortedSetFactory() : _OMNI_NS(proxyObjectFactory)(KeySortedSetFactory::_PD_repoId) {}
    virtual ~_pof_KeySortedSetFactory();

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

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

    virtual KeySortedSet_ptr create(::CosCollection::Operations_ptr ops, ::CORBA::ULong expected_size) = 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_KeySortedSetFactory;

#ifndef __CosCollection_mKeySortedBagFactory__
#define __CosCollection_mKeySortedBagFactory__

  class KeySortedBagFactory;
  class _objref_KeySortedBagFactory;
  class _impl_KeySortedBagFactory;
  
  typedef _objref_KeySortedBagFactory* KeySortedBagFactory_ptr;
  typedef KeySortedBagFactory_ptr KeySortedBagFactoryRef;

  class KeySortedBagFactory_Helper {
  public:
    typedef KeySortedBagFactory_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_KeySortedBagFactory, KeySortedBagFactory_Helper> KeySortedBagFactory_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_KeySortedBagFactory,KeySortedBagFactory_Helper > KeySortedBagFactory_out;

#endif

  // interface KeySortedBagFactory
  class KeySortedBagFactory {
  public:
    // Declarations for this interface type.
    typedef KeySortedBagFactory_ptr _ptr_type;
    typedef KeySortedBagFactory_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_KeySortedBagFactory :
    public virtual _objref_CollectionFactory
  {
  public:
    KeySortedBag_ptr create(::CosCollection::Operations_ptr ops, ::CORBA::ULong expected_size);

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

  protected:
    virtual ~_objref_KeySortedBagFactory();

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

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

    friend class KeySortedBagFactory;
  };

  class _pof_KeySortedBagFactory : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_KeySortedBagFactory() : _OMNI_NS(proxyObjectFactory)(KeySortedBagFactory::_PD_repoId) {}
    virtual ~_pof_KeySortedBagFactory();

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

  class _impl_KeySortedBagFactory :
    public virtual _impl_CollectionFactory
  {
  public:
    virtual ~_impl_KeySortedBagFactory();

    virtual KeySortedBag_ptr create(::CosCollection::Operations_ptr ops, ::CORBA::ULong expected_size) = 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_KeySortedBagFactory;

#ifndef __CosCollection_mSortedMapFactory__
#define __CosCollection_mSortedMapFactory__

  class SortedMapFactory;
  class _objref_SortedMapFactory;
  class _impl_SortedMapFactory;
  
  typedef _objref_SortedMapFactory* SortedMapFactory_ptr;
  typedef SortedMapFactory_ptr SortedMapFactoryRef;

  class SortedMapFactory_Helper {
  public:
    typedef SortedMapFactory_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_SortedMapFactory, SortedMapFactory_Helper> SortedMapFactory_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_SortedMapFactory,SortedMapFactory_Helper > SortedMapFactory_out;

#endif

  // interface SortedMapFactory
  class SortedMapFactory {
  public:
    // Declarations for this interface type.
    typedef SortedMapFactory_ptr _ptr_type;
    typedef SortedMapFactory_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_SortedMapFactory :
    public virtual _objref_CollectionFactory
  {
  public:
    SortedMap_ptr create(::CosCollection::Operations_ptr ops, ::CORBA::ULong expected_size);

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

  protected:
    virtual ~_objref_SortedMapFactory();

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

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

    friend class SortedMapFactory;
  };

  class _pof_SortedMapFactory : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_SortedMapFactory() : _OMNI_NS(proxyObjectFactory)(SortedMapFactory::_PD_repoId) {}
    virtual ~_pof_SortedMapFactory();

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

  class _impl_SortedMapFactory :
    public virtual _impl_CollectionFactory
  {
  public:
    virtual ~_impl_SortedMapFactory();

    virtual SortedMap_ptr create(::CosCollection::Operations_ptr ops, ::CORBA::ULong expected_size) = 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_SortedMapFactory;

#ifndef __CosCollection_mSortedRelationFactory__
#define __CosCollection_mSortedRelationFactory__

  class SortedRelationFactory;
  class _objref_SortedRelationFactory;
  class _impl_SortedRelationFactory;
  
  typedef _objref_SortedRelationFactory* SortedRelationFactory_ptr;
  typedef SortedRelationFactory_ptr SortedRelationFactoryRef;

  class SortedRelationFactory_Helper {
  public:
    typedef SortedRelationFactory_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_SortedRelationFactory, SortedRelationFactory_Helper> SortedRelationFactory_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_SortedRelationFactory,SortedRelationFactory_Helper > SortedRelationFactory_out;

#endif

  // interface SortedRelationFactory
  class SortedRelationFactory {
  public:
    // Declarations for this interface type.
    typedef SortedRelationFactory_ptr _ptr_type;
    typedef SortedRelationFactory_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_SortedRelationFactory :
    public virtual _objref_CollectionFactory
  {
  public:
    SortedRelation_ptr create(::CosCollection::Operations_ptr ops, ::CORBA::ULong expected_size);

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

  protected:
    virtual ~_objref_SortedRelationFactory();

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

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

    friend class SortedRelationFactory;
  };

  class _pof_SortedRelationFactory : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_SortedRelationFactory() : _OMNI_NS(proxyObjectFactory)(SortedRelationFactory::_PD_repoId) {}
    virtual ~_pof_SortedRelationFactory();

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

  class _impl_SortedRelationFactory :
    public virtual _impl_CollectionFactory
  {
  public:
    virtual ~_impl_SortedRelationFactory();

    virtual SortedRelation_ptr create(::CosCollection::Operations_ptr ops, ::CORBA::ULong expected_size) = 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_SortedRelationFactory;

#ifndef __CosCollection_mSortedSetFactory__
#define __CosCollection_mSortedSetFactory__

  class SortedSetFactory;
  class _objref_SortedSetFactory;
  class _impl_SortedSetFactory;
  
  typedef _objref_SortedSetFactory* SortedSetFactory_ptr;
  typedef SortedSetFactory_ptr SortedSetFactoryRef;

  class SortedSetFactory_Helper {
  public:
    typedef SortedSetFactory_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_SortedSetFactory, SortedSetFactory_Helper> SortedSetFactory_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_SortedSetFactory,SortedSetFactory_Helper > SortedSetFactory_out;

#endif

  // interface SortedSetFactory
  class SortedSetFactory {
  public:
    // Declarations for this interface type.
    typedef SortedSetFactory_ptr _ptr_type;
    typedef SortedSetFactory_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_SortedSetFactory :
    public virtual _objref_CollectionFactory
  {
  public:
    SortedSet_ptr create(::CosCollection::Operations_ptr ops, ::CORBA::ULong expected_size);

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

  protected:
    virtual ~_objref_SortedSetFactory();

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

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

    friend class SortedSetFactory;
  };

  class _pof_SortedSetFactory : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_SortedSetFactory() : _OMNI_NS(proxyObjectFactory)(SortedSetFactory::_PD_repoId) {}
    virtual ~_pof_SortedSetFactory();

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

  class _impl_SortedSetFactory :
    public virtual _impl_CollectionFactory
  {
  public:
    virtual ~_impl_SortedSetFactory();

    virtual SortedSet_ptr create(::CosCollection::Operations_ptr ops, ::CORBA::ULong expected_size) = 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_SortedSetFactory;

#ifndef __CosCollection_mSortedBagFactory__
#define __CosCollection_mSortedBagFactory__

  class SortedBagFactory;
  class _objref_SortedBagFactory;
  class _impl_SortedBagFactory;
  
  typedef _objref_SortedBagFactory* SortedBagFactory_ptr;
  typedef SortedBagFactory_ptr SortedBagFactoryRef;

  class SortedBagFactory_Helper {
  public:
    typedef SortedBagFactory_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_SortedBagFactory, SortedBagFactory_Helper> SortedBagFactory_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_SortedBagFactory,SortedBagFactory_Helper > SortedBagFactory_out;

#endif

  // interface SortedBagFactory
  class SortedBagFactory {
  public:
    // Declarations for this interface type.
    typedef SortedBagFactory_ptr _ptr_type;
    typedef SortedBagFactory_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_SortedBagFactory :
    public virtual ::CORBA::Object,
    public virtual omniObjRef
  {
  public:
    SortedBag_ptr create(::CosCollection::Operations_ptr ops, ::CORBA::ULong expected_size);

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

  protected:
    virtual ~_objref_SortedBagFactory();

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

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

    friend class SortedBagFactory;
  };

  class _pof_SortedBagFactory : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_SortedBagFactory() : _OMNI_NS(proxyObjectFactory)(SortedBagFactory::_PD_repoId) {}
    virtual ~_pof_SortedBagFactory();

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

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

    virtual SortedBag_ptr create(::CosCollection::Operations_ptr ops, ::CORBA::ULong expected_size) = 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_SortedBagFactory;

#ifndef __CosCollection_mSequenceFactory__
#define __CosCollection_mSequenceFactory__

  class SequenceFactory;
  class _objref_SequenceFactory;
  class _impl_SequenceFactory;
  
  typedef _objref_SequenceFactory* SequenceFactory_ptr;
  typedef SequenceFactory_ptr SequenceFactoryRef;

  class SequenceFactory_Helper {
  public:
    typedef SequenceFactory_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_SequenceFactory, SequenceFactory_Helper> SequenceFactory_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_SequenceFactory,SequenceFactory_Helper > SequenceFactory_out;

#endif

  // interface SequenceFactory
  class SequenceFactory {
  public:
    // Declarations for this interface type.
    typedef SequenceFactory_ptr _ptr_type;
    typedef SequenceFactory_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_SequenceFactory :
    public virtual _objref_CollectionFactory
  {
  public:
    CSequence_ptr create(::CosCollection::Operations_ptr ops, ::CORBA::ULong expected_size);

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

  protected:
    virtual ~_objref_SequenceFactory();

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

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

    friend class SequenceFactory;
  };

  class _pof_SequenceFactory : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_SequenceFactory() : _OMNI_NS(proxyObjectFactory)(SequenceFactory::_PD_repoId) {}
    virtual ~_pof_SequenceFactory();

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

  class _impl_SequenceFactory :
    public virtual _impl_CollectionFactory
  {
  public:
    virtual ~_impl_SequenceFactory();

    virtual CSequence_ptr create(::CosCollection::Operations_ptr ops, ::CORBA::ULong expected_size) = 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_SequenceFactory;

#ifndef __CosCollection_mEqualitySequenceFactory__
#define __CosCollection_mEqualitySequenceFactory__

  class EqualitySequenceFactory;
  class _objref_EqualitySequenceFactory;
  class _impl_EqualitySequenceFactory;
  
  typedef _objref_EqualitySequenceFactory* EqualitySequenceFactory_ptr;
  typedef EqualitySequenceFactory_ptr EqualitySequenceFactoryRef;

  class EqualitySequenceFactory_Helper {
  public:
    typedef EqualitySequenceFactory_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_EqualitySequenceFactory, EqualitySequenceFactory_Helper> EqualitySequenceFactory_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_EqualitySequenceFactory,EqualitySequenceFactory_Helper > EqualitySequenceFactory_out;

#endif

  // interface EqualitySequenceFactory
  class EqualitySequenceFactory {
  public:
    // Declarations for this interface type.
    typedef EqualitySequenceFactory_ptr _ptr_type;
    typedef EqualitySequenceFactory_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_EqualitySequenceFactory :
    public virtual _objref_CollectionFactory
  {
  public:
    EqualitySequence_ptr create(::CosCollection::Operations_ptr ops, ::CORBA::ULong expected_size);

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

  protected:
    virtual ~_objref_EqualitySequenceFactory();

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

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

    friend class EqualitySequenceFactory;
  };

  class _pof_EqualitySequenceFactory : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_EqualitySequenceFactory() : _OMNI_NS(proxyObjectFactory)(EqualitySequenceFactory::_PD_repoId) {}
    virtual ~_pof_EqualitySequenceFactory();

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

  class _impl_EqualitySequenceFactory :
    public virtual _impl_CollectionFactory
  {
  public:
    virtual ~_impl_EqualitySequenceFactory();

    virtual EqualitySequence_ptr create(::CosCollection::Operations_ptr ops, ::CORBA::ULong expected_size) = 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_EqualitySequenceFactory;

#ifndef __CosCollection_mHeapFactory__
#define __CosCollection_mHeapFactory__

  class HeapFactory;
  class _objref_HeapFactory;
  class _impl_HeapFactory;
  
  typedef _objref_HeapFactory* HeapFactory_ptr;
  typedef HeapFactory_ptr HeapFactoryRef;

  class HeapFactory_Helper {
  public:
    typedef HeapFactory_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_HeapFactory, HeapFactory_Helper> HeapFactory_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_HeapFactory,HeapFactory_Helper > HeapFactory_out;

#endif

  // interface HeapFactory
  class HeapFactory {
  public:
    // Declarations for this interface type.
    typedef HeapFactory_ptr _ptr_type;
    typedef HeapFactory_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_HeapFactory :
    public virtual _objref_CollectionFactory
  {
  public:
    Heap_ptr create(::CosCollection::Operations_ptr ops, ::CORBA::ULong expected_size);

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

  protected:
    virtual ~_objref_HeapFactory();

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

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

    friend class HeapFactory;
  };

  class _pof_HeapFactory : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_HeapFactory() : _OMNI_NS(proxyObjectFactory)(HeapFactory::_PD_repoId) {}
    virtual ~_pof_HeapFactory();

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

  class _impl_HeapFactory :
    public virtual _impl_CollectionFactory
  {
  public:
    virtual ~_impl_HeapFactory();

    virtual Heap_ptr create(::CosCollection::Operations_ptr ops, ::CORBA::ULong expected_size) = 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_HeapFactory;

#ifndef __CosCollection_mQueueFactory__
#define __CosCollection_mQueueFactory__

  class QueueFactory;
  class _objref_QueueFactory;
  class _impl_QueueFactory;
  
  typedef _objref_QueueFactory* QueueFactory_ptr;
  typedef QueueFactory_ptr QueueFactoryRef;

  class QueueFactory_Helper {
  public:
    typedef QueueFactory_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_QueueFactory, QueueFactory_Helper> QueueFactory_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_QueueFactory,QueueFactory_Helper > QueueFactory_out;

#endif

  // interface QueueFactory
  class QueueFactory {
  public:
    // Declarations for this interface type.
    typedef QueueFactory_ptr _ptr_type;
    typedef QueueFactory_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_QueueFactory :
    public virtual _objref_RACollectionFactory
  {
  public:
    Queue_ptr create(::CosCollection::Operations_ptr ops, ::CORBA::ULong expected_size);

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

  protected:
    virtual ~_objref_QueueFactory();

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

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

    friend class QueueFactory;
  };

  class _pof_QueueFactory : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_QueueFactory() : _OMNI_NS(proxyObjectFactory)(QueueFactory::_PD_repoId) {}
    virtual ~_pof_QueueFactory();

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

  class _impl_QueueFactory :
    public virtual _impl_RACollectionFactory
  {
  public:
    virtual ~_impl_QueueFactory();

    virtual Queue_ptr create(::CosCollection::Operations_ptr ops, ::CORBA::ULong expected_size) = 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_QueueFactory;

#ifndef __CosCollection_mStackFactory__
#define __CosCollection_mStackFactory__

  class StackFactory;
  class _objref_StackFactory;
  class _impl_StackFactory;
  
  typedef _objref_StackFactory* StackFactory_ptr;
  typedef StackFactory_ptr StackFactoryRef;

  class StackFactory_Helper {
  public:
    typedef StackFactory_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_StackFactory, StackFactory_Helper> StackFactory_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_StackFactory,StackFactory_Helper > StackFactory_out;

#endif

  // interface StackFactory
  class StackFactory {
  public:
    // Declarations for this interface type.
    typedef StackFactory_ptr _ptr_type;
    typedef StackFactory_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_StackFactory :
    public virtual _objref_RACollectionFactory
  {
  public:
    Stack_ptr create(::CosCollection::Operations_ptr ops, ::CORBA::ULong expected_size);

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

  protected:
    virtual ~_objref_StackFactory();

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

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

    friend class StackFactory;
  };

  class _pof_StackFactory : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_StackFactory() : _OMNI_NS(proxyObjectFactory)(StackFactory::_PD_repoId) {}
    virtual ~_pof_StackFactory();

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

  class _impl_StackFactory :
    public virtual _impl_RACollectionFactory
  {
  public:
    virtual ~_impl_StackFactory();

    virtual Stack_ptr create(::CosCollection::Operations_ptr ops, ::CORBA::ULong expected_size) = 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_StackFactory;

#ifndef __CosCollection_mDequeFactory__
#define __CosCollection_mDequeFactory__

  class DequeFactory;
  class _objref_DequeFactory;
  class _impl_DequeFactory;
  
  typedef _objref_DequeFactory* DequeFactory_ptr;
  typedef DequeFactory_ptr DequeFactoryRef;

  class DequeFactory_Helper {
  public:
    typedef DequeFactory_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_DequeFactory, DequeFactory_Helper> DequeFactory_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_DequeFactory,DequeFactory_Helper > DequeFactory_out;

#endif

  // interface DequeFactory
  class DequeFactory {
  public:
    // Declarations for this interface type.
    typedef DequeFactory_ptr _ptr_type;
    typedef DequeFactory_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_DequeFactory :
    public virtual _objref_RACollectionFactory
  {
  public:
    Deque_ptr create(::CosCollection::Operations_ptr ops, ::CORBA::ULong expected_size);

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

  protected:
    virtual ~_objref_DequeFactory();

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

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

    friend class DequeFactory;
  };

  class _pof_DequeFactory : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_DequeFactory() : _OMNI_NS(proxyObjectFactory)(DequeFactory::_PD_repoId) {}
    virtual ~_pof_DequeFactory();

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

  class _impl_DequeFactory :
    public virtual _impl_RACollectionFactory
  {
  public:
    virtual ~_impl_DequeFactory();

    virtual Deque_ptr create(::CosCollection::Operations_ptr ops, ::CORBA::ULong expected_size) = 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_DequeFactory;

#ifndef __CosCollection_mPriorityQueueFactory__
#define __CosCollection_mPriorityQueueFactory__

  class PriorityQueueFactory;
  class _objref_PriorityQueueFactory;
  class _impl_PriorityQueueFactory;
  
  typedef _objref_PriorityQueueFactory* PriorityQueueFactory_ptr;
  typedef PriorityQueueFactory_ptr PriorityQueueFactoryRef;

  class PriorityQueueFactory_Helper {
  public:
    typedef PriorityQueueFactory_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_PriorityQueueFactory, PriorityQueueFactory_Helper> PriorityQueueFactory_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_PriorityQueueFactory,PriorityQueueFactory_Helper > PriorityQueueFactory_out;

#endif

  // interface PriorityQueueFactory
  class PriorityQueueFactory {
  public:
    // Declarations for this interface type.
    typedef PriorityQueueFactory_ptr _ptr_type;
    typedef PriorityQueueFactory_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_PriorityQueueFactory :
    public virtual _objref_RACollectionFactory
  {
  public:
    PriorityQueue_ptr create(::CosCollection::Operations_ptr ops, ::CORBA::ULong expected_size);

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

  protected:
    virtual ~_objref_PriorityQueueFactory();

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

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

    friend class PriorityQueueFactory;
  };

  class _pof_PriorityQueueFactory : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_PriorityQueueFactory() : _OMNI_NS(proxyObjectFactory)(PriorityQueueFactory::_PD_repoId) {}
    virtual ~_pof_PriorityQueueFactory();

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

  class _impl_PriorityQueueFactory :
    public virtual _impl_RACollectionFactory
  {
  public:
    virtual ~_impl_PriorityQueueFactory();

    virtual PriorityQueue_ptr create(::CosCollection::Operations_ptr ops, ::CORBA::ULong expected_size) = 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_PriorityQueueFactory;

_CORBA_MODULE_END



_CORBA_MODULE POA_CosCollection
_CORBA_MODULE_BEG

  class Operations :
    public virtual CosCollection::_impl_Operations,
    public virtual ::PortableServer::ServantBase
  {
  public:
    virtual ~Operations();

    inline ::CosCollection::Operations_ptr _this() {
      return (::CosCollection::Operations_ptr) _do_this(::CosCollection::Operations::_PD_repoId);
    }
  };

  class Command :
    public virtual CosCollection::_impl_Command,
    public virtual ::PortableServer::ServantBase
  {
  public:
    virtual ~Command();

    inline ::CosCollection::Command_ptr _this() {
      return (::CosCollection::Command_ptr) _do_this(::CosCollection::Command::_PD_repoId);
    }
  };

  class Comparator :
    public virtual CosCollection::_impl_Comparator,
    public virtual ::PortableServer::ServantBase
  {
  public:
    virtual ~Comparator();

    inline ::CosCollection::Comparator_ptr _this() {
      return (::CosCollection::Comparator_ptr) _do_this(::CosCollection::Comparator::_PD_repoId);
    }
  };

  class Iterator :
    public virtual CosCollection::_impl_Iterator,
    public virtual ::PortableServer::ServantBase
  {
  public:
    virtual ~Iterator();

    inline ::CosCollection::Iterator_ptr _this() {
      return (::CosCollection::Iterator_ptr) _do_this(::CosCollection::Iterator::_PD_repoId);
    }
  };

  class OrderedIterator :
    public virtual CosCollection::_impl_OrderedIterator,
    public virtual Iterator
  {
  public:
    virtual ~OrderedIterator();

    inline ::CosCollection::OrderedIterator_ptr _this() {
      return (::CosCollection::OrderedIterator_ptr) _do_this(::CosCollection::OrderedIterator::_PD_repoId);
    }
  };

  class SequentialIterator :
    public virtual CosCollection::_impl_SequentialIterator,
    public virtual OrderedIterator
  {
  public:
    virtual ~SequentialIterator();

    inline ::CosCollection::SequentialIterator_ptr _this() {
      return (::CosCollection::SequentialIterator_ptr) _do_this(::CosCollection::SequentialIterator::_PD_repoId);
    }
  };

  class KeyIterator :
    public virtual CosCollection::_impl_KeyIterator,
    public virtual Iterator
  {
  public:
    virtual ~KeyIterator();

    inline ::CosCollection::KeyIterator_ptr _this() {
      return (::CosCollection::KeyIterator_ptr) _do_this(::CosCollection::KeyIterator::_PD_repoId);
    }
  };

  class EqualityIterator :
    public virtual CosCollection::_impl_EqualityIterator,
    public virtual Iterator
  {
  public:
    virtual ~EqualityIterator();

    inline ::CosCollection::EqualityIterator_ptr _this() {
      return (::CosCollection::EqualityIterator_ptr) _do_this(::CosCollection::EqualityIterator::_PD_repoId);
    }
  };

  class EqualityKeyIterator :
    public virtual CosCollection::_impl_EqualityKeyIterator,
    public virtual EqualityIterator,
      public virtual KeyIterator
  {
  public:
    virtual ~EqualityKeyIterator();

    inline ::CosCollection::EqualityKeyIterator_ptr _this() {
      return (::CosCollection::EqualityKeyIterator_ptr) _do_this(::CosCollection::EqualityKeyIterator::_PD_repoId);
    }
  };

  class SortedIterator :
    public virtual CosCollection::_impl_SortedIterator,
    public virtual OrderedIterator
  {
  public:
    virtual ~SortedIterator();

    inline ::CosCollection::SortedIterator_ptr _this() {
      return (::CosCollection::SortedIterator_ptr) _do_this(::CosCollection::SortedIterator::_PD_repoId);
    }
  };

  class KeySortedIterator :
    public virtual CosCollection::_impl_KeySortedIterator,
    public virtual KeyIterator,
      public virtual SortedIterator
  {
  public:
    virtual ~KeySortedIterator();

    inline ::CosCollection::KeySortedIterator_ptr _this() {
      return (::CosCollection::KeySortedIterator_ptr) _do_this(::CosCollection::KeySortedIterator::_PD_repoId);
    }
  };

  class EqualitySortedIterator :
    public virtual CosCollection::_impl_EqualitySortedIterator,
    public virtual EqualityIterator,
      public virtual SortedIterator
  {
  public:
    virtual ~EqualitySortedIterator();

    inline ::CosCollection::EqualitySortedIterator_ptr _this() {
      return (::CosCollection::EqualitySortedIterator_ptr) _do_this(::CosCollection::EqualitySortedIterator::_PD_repoId);
    }
  };

  class EqualityKeySortedIterator :
    public virtual CosCollection::_impl_EqualityKeySortedIterator,
    public virtual EqualitySortedIterator,
      public virtual KeySortedIterator
  {
  public:
    virtual ~EqualityKeySortedIterator();

    inline ::CosCollection::EqualityKeySortedIterator_ptr _this() {
      return (::CosCollection::EqualityKeySortedIterator_ptr) _do_this(::CosCollection::EqualityKeySortedIterator::_PD_repoId);
    }
  };

  class EqualitySequentialIterator :
    public virtual CosCollection::_impl_EqualitySequentialIterator,
    public virtual EqualityIterator,
      public virtual SequentialIterator
  {
  public:
    virtual ~EqualitySequentialIterator();

    inline ::CosCollection::EqualitySequentialIterator_ptr _this() {
      return (::CosCollection::EqualitySequentialIterator_ptr) _do_this(::CosCollection::EqualitySequentialIterator::_PD_repoId);
    }
  };

  class Collection :
    public virtual CosCollection::_impl_Collection,
    public virtual ::PortableServer::ServantBase
  {
  public:
    virtual ~Collection();

    inline ::CosCollection::Collection_ptr _this() {
      return (::CosCollection::Collection_ptr) _do_this(::CosCollection::Collection::_PD_repoId);
    }
  };

  class OrderedCollection :
    public virtual CosCollection::_impl_OrderedCollection,
    public virtual Collection
  {
  public:
    virtual ~OrderedCollection();

    inline ::CosCollection::OrderedCollection_ptr _this() {
      return (::CosCollection::OrderedCollection_ptr) _do_this(::CosCollection::OrderedCollection::_PD_repoId);
    }
  };

  class SequentialCollection :
    public virtual CosCollection::_impl_SequentialCollection,
    public virtual OrderedCollection
  {
  public:
    virtual ~SequentialCollection();

    inline ::CosCollection::SequentialCollection_ptr _this() {
      return (::CosCollection::SequentialCollection_ptr) _do_this(::CosCollection::SequentialCollection::_PD_repoId);
    }
  };

  class SortedCollection :
    public virtual CosCollection::_impl_SortedCollection,
    public virtual OrderedCollection
  {
  public:
    virtual ~SortedCollection();

    inline ::CosCollection::SortedCollection_ptr _this() {
      return (::CosCollection::SortedCollection_ptr) _do_this(::CosCollection::SortedCollection::_PD_repoId);
    }
  };

  class EqualityCollection :
    public virtual CosCollection::_impl_EqualityCollection,
    public virtual Collection
  {
  public:
    virtual ~EqualityCollection();

    inline ::CosCollection::EqualityCollection_ptr _this() {
      return (::CosCollection::EqualityCollection_ptr) _do_this(::CosCollection::EqualityCollection::_PD_repoId);
    }
  };

  class KeyCollection :
    public virtual CosCollection::_impl_KeyCollection,
    public virtual Collection
  {
  public:
    virtual ~KeyCollection();

    inline ::CosCollection::KeyCollection_ptr _this() {
      return (::CosCollection::KeyCollection_ptr) _do_this(::CosCollection::KeyCollection::_PD_repoId);
    }
  };

  class EqualityKeyCollection :
    public virtual CosCollection::_impl_EqualityKeyCollection,
    public virtual EqualityCollection,
      public virtual KeyCollection
  {
  public:
    virtual ~EqualityKeyCollection();

    inline ::CosCollection::EqualityKeyCollection_ptr _this() {
      return (::CosCollection::EqualityKeyCollection_ptr) _do_this(::CosCollection::EqualityKeyCollection::_PD_repoId);
    }
  };

  class KeySortedCollection :
    public virtual CosCollection::_impl_KeySortedCollection,
    public virtual KeyCollection,
      public virtual SortedCollection
  {
  public:
    virtual ~KeySortedCollection();

    inline ::CosCollection::KeySortedCollection_ptr _this() {
      return (::CosCollection::KeySortedCollection_ptr) _do_this(::CosCollection::KeySortedCollection::_PD_repoId);
    }
  };

  class EqualitySortedCollection :
    public virtual CosCollection::_impl_EqualitySortedCollection,
    public virtual EqualityCollection,
      public virtual SortedCollection
  {
  public:
    virtual ~EqualitySortedCollection();

    inline ::CosCollection::EqualitySortedCollection_ptr _this() {
      return (::CosCollection::EqualitySortedCollection_ptr) _do_this(::CosCollection::EqualitySortedCollection::_PD_repoId);
    }
  };

  class EqualityKeySortedCollection :
    public virtual CosCollection::_impl_EqualityKeySortedCollection,
    public virtual EqualityCollection,
      public virtual KeyCollection,
      public virtual SortedCollection
  {
  public:
    virtual ~EqualityKeySortedCollection();

    inline ::CosCollection::EqualityKeySortedCollection_ptr _this() {
      return (::CosCollection::EqualityKeySortedCollection_ptr) _do_this(::CosCollection::EqualityKeySortedCollection::_PD_repoId);
    }
  };

  class EqualitySequentialCollection :
    public virtual CosCollection::_impl_EqualitySequentialCollection,
    public virtual EqualityCollection,
      public virtual SequentialCollection
  {
  public:
    virtual ~EqualitySequentialCollection();

    inline ::CosCollection::EqualitySequentialCollection_ptr _this() {
      return (::CosCollection::EqualitySequentialCollection_ptr) _do_this(::CosCollection::EqualitySequentialCollection::_PD_repoId);
    }
  };

  class KeySet :
    public virtual CosCollection::_impl_KeySet,
    public virtual KeyCollection
  {
  public:
    virtual ~KeySet();

    inline ::CosCollection::KeySet_ptr _this() {
      return (::CosCollection::KeySet_ptr) _do_this(::CosCollection::KeySet::_PD_repoId);
    }
  };

  class KeyBag :
    public virtual CosCollection::_impl_KeyBag,
    public virtual KeyCollection
  {
  public:
    virtual ~KeyBag();

    inline ::CosCollection::KeyBag_ptr _this() {
      return (::CosCollection::KeyBag_ptr) _do_this(::CosCollection::KeyBag::_PD_repoId);
    }
  };

  class Map :
    public virtual CosCollection::_impl_Map,
    public virtual EqualityKeyCollection
  {
  public:
    virtual ~Map();

    inline ::CosCollection::Map_ptr _this() {
      return (::CosCollection::Map_ptr) _do_this(::CosCollection::Map::_PD_repoId);
    }
  };

  class Relation :
    public virtual CosCollection::_impl_Relation,
    public virtual EqualityKeyCollection
  {
  public:
    virtual ~Relation();

    inline ::CosCollection::Relation_ptr _this() {
      return (::CosCollection::Relation_ptr) _do_this(::CosCollection::Relation::_PD_repoId);
    }
  };

  class Set :
    public virtual CosCollection::_impl_Set,
    public virtual EqualityCollection
  {
  public:
    virtual ~Set();

    inline ::CosCollection::Set_ptr _this() {
      return (::CosCollection::Set_ptr) _do_this(::CosCollection::Set::_PD_repoId);
    }
  };

  class Bag :
    public virtual CosCollection::_impl_Bag,
    public virtual EqualityCollection
  {
  public:
    virtual ~Bag();

    inline ::CosCollection::Bag_ptr _this() {
      return (::CosCollection::Bag_ptr) _do_this(::CosCollection::Bag::_PD_repoId);
    }
  };

  class KeySortedSet :
    public virtual CosCollection::_impl_KeySortedSet,
    public virtual KeySortedCollection
  {
  public:
    virtual ~KeySortedSet();

    inline ::CosCollection::KeySortedSet_ptr _this() {
      return (::CosCollection::KeySortedSet_ptr) _do_this(::CosCollection::KeySortedSet::_PD_repoId);
    }
  };

  class KeySortedBag :
    public virtual CosCollection::_impl_KeySortedBag,
    public virtual KeySortedCollection
  {
  public:
    virtual ~KeySortedBag();

    inline ::CosCollection::KeySortedBag_ptr _this() {
      return (::CosCollection::KeySortedBag_ptr) _do_this(::CosCollection::KeySortedBag::_PD_repoId);
    }
  };

  class SortedMap :
    public virtual CosCollection::_impl_SortedMap,
    public virtual EqualityKeySortedCollection
  {
  public:
    virtual ~SortedMap();

    inline ::CosCollection::SortedMap_ptr _this() {
      return (::CosCollection::SortedMap_ptr) _do_this(::CosCollection::SortedMap::_PD_repoId);
    }
  };

  class SortedRelation :
    public virtual CosCollection::_impl_SortedRelation,
    public virtual EqualityKeySortedCollection
  {
  public:
    virtual ~SortedRelation();

    inline ::CosCollection::SortedRelation_ptr _this() {
      return (::CosCollection::SortedRelation_ptr) _do_this(::CosCollection::SortedRelation::_PD_repoId);
    }
  };

  class SortedSet :
    public virtual CosCollection::_impl_SortedSet,
    public virtual EqualitySortedCollection
  {
  public:
    virtual ~SortedSet();

    inline ::CosCollection::SortedSet_ptr _this() {
      return (::CosCollection::SortedSet_ptr) _do_this(::CosCollection::SortedSet::_PD_repoId);
    }
  };

  class SortedBag :
    public virtual CosCollection::_impl_SortedBag,
    public virtual EqualitySortedCollection
  {
  public:
    virtual ~SortedBag();

    inline ::CosCollection::SortedBag_ptr _this() {
      return (::CosCollection::SortedBag_ptr) _do_this(::CosCollection::SortedBag::_PD_repoId);
    }
  };

  class CSequence :
    public virtual CosCollection::_impl_CSequence,
    public virtual SequentialCollection
  {
  public:
    virtual ~CSequence();

    inline ::CosCollection::CSequence_ptr _this() {
      return (::CosCollection::CSequence_ptr) _do_this(::CosCollection::CSequence::_PD_repoId);
    }
  };

  class EqualitySequence :
    public virtual CosCollection::_impl_EqualitySequence,
    public virtual EqualitySequentialCollection
  {
  public:
    virtual ~EqualitySequence();

    inline ::CosCollection::EqualitySequence_ptr _this() {
      return (::CosCollection::EqualitySequence_ptr) _do_this(::CosCollection::EqualitySequence::_PD_repoId);
    }
  };

  class Heap :
    public virtual CosCollection::_impl_Heap,
    public virtual Collection
  {
  public:
    virtual ~Heap();

    inline ::CosCollection::Heap_ptr _this() {
      return (::CosCollection::Heap_ptr) _do_this(::CosCollection::Heap::_PD_repoId);
    }
  };

  class RestrictedAccessCollection :
    public virtual CosCollection::_impl_RestrictedAccessCollection,
    public virtual ::PortableServer::ServantBase
  {
  public:
    virtual ~RestrictedAccessCollection();

    inline ::CosCollection::RestrictedAccessCollection_ptr _this() {
      return (::CosCollection::RestrictedAccessCollection_ptr) _do_this(::CosCollection::RestrictedAccessCollection::_PD_repoId);
    }
  };

  class Queue :
    public virtual CosCollection::_impl_Queue,
    public virtual RestrictedAccessCollection
  {
  public:
    virtual ~Queue();

    inline ::CosCollection::Queue_ptr _this() {
      return (::CosCollection::Queue_ptr) _do_this(::CosCollection::Queue::_PD_repoId);
    }
  };

  class Deque :
    public virtual CosCollection::_impl_Deque,
    public virtual RestrictedAccessCollection
  {
  public:
    virtual ~Deque();

    inline ::CosCollection::Deque_ptr _this() {
      return (::CosCollection::Deque_ptr) _do_this(::CosCollection::Deque::_PD_repoId);
    }
  };

  class Stack :
    public virtual CosCollection::_impl_Stack,
    public virtual RestrictedAccessCollection
  {
  public:
    virtual ~Stack();

    inline ::CosCollection::Stack_ptr _this() {
      return (::CosCollection::Stack_ptr) _do_this(::CosCollection::Stack::_PD_repoId);
    }
  };

  class PriorityQueue :
    public virtual CosCollection::_impl_PriorityQueue,
    public virtual RestrictedAccessCollection
  {
  public:
    virtual ~PriorityQueue();

    inline ::CosCollection::PriorityQueue_ptr _this() {
      return (::CosCollection::PriorityQueue_ptr) _do_this(::CosCollection::PriorityQueue::_PD_repoId);
    }
  };

  class CollectionFactory :
    public virtual CosCollection::_impl_CollectionFactory,
    public virtual ::PortableServer::ServantBase
  {
  public:
    virtual ~CollectionFactory();

    inline ::CosCollection::CollectionFactory_ptr _this() {
      return (::CosCollection::CollectionFactory_ptr) _do_this(::CosCollection::CollectionFactory::_PD_repoId);
    }
  };

  class CollectionFactories :
    public virtual CosCollection::_impl_CollectionFactories,
    public virtual CollectionFactory
  {
  public:
    virtual ~CollectionFactories();

    inline ::CosCollection::CollectionFactories_ptr _this() {
      return (::CosCollection::CollectionFactories_ptr) _do_this(::CosCollection::CollectionFactories::_PD_repoId);
    }
  };

  class RACollectionFactory :
    public virtual CosCollection::_impl_RACollectionFactory,
    public virtual ::PortableServer::ServantBase
  {
  public:
    virtual ~RACollectionFactory();

    inline ::CosCollection::RACollectionFactory_ptr _this() {
      return (::CosCollection::RACollectionFactory_ptr) _do_this(::CosCollection::RACollectionFactory::_PD_repoId);
    }
  };

  class RACollectionFactories :
    public virtual CosCollection::_impl_RACollectionFactories,
    public virtual RACollectionFactory
  {
  public:
    virtual ~RACollectionFactories();

    inline ::CosCollection::RACollectionFactories_ptr _this() {
      return (::CosCollection::RACollectionFactories_ptr) _do_this(::CosCollection::RACollectionFactories::_PD_repoId);
    }
  };

  class KeySetFactory :
    public virtual CosCollection::_impl_KeySetFactory,
    public virtual CollectionFactory
  {
  public:
    virtual ~KeySetFactory();

    inline ::CosCollection::KeySetFactory_ptr _this() {
      return (::CosCollection::KeySetFactory_ptr) _do_this(::CosCollection::KeySetFactory::_PD_repoId);
    }
  };

  class KeyBagFactory :
    public virtual CosCollection::_impl_KeyBagFactory,
    public virtual CollectionFactory
  {
  public:
    virtual ~KeyBagFactory();

    inline ::CosCollection::KeyBagFactory_ptr _this() {
      return (::CosCollection::KeyBagFactory_ptr) _do_this(::CosCollection::KeyBagFactory::_PD_repoId);
    }
  };

  class MapFactory :
    public virtual CosCollection::_impl_MapFactory,
    public virtual CollectionFactory
  {
  public:
    virtual ~MapFactory();

    inline ::CosCollection::MapFactory_ptr _this() {
      return (::CosCollection::MapFactory_ptr) _do_this(::CosCollection::MapFactory::_PD_repoId);
    }
  };

  class RelationFactory :
    public virtual CosCollection::_impl_RelationFactory,
    public virtual CollectionFactory
  {
  public:
    virtual ~RelationFactory();

    inline ::CosCollection::RelationFactory_ptr _this() {
      return (::CosCollection::RelationFactory_ptr) _do_this(::CosCollection::RelationFactory::_PD_repoId);
    }
  };

  class SetFactory :
    public virtual CosCollection::_impl_SetFactory,
    public virtual CollectionFactory
  {
  public:
    virtual ~SetFactory();

    inline ::CosCollection::SetFactory_ptr _this() {
      return (::CosCollection::SetFactory_ptr) _do_this(::CosCollection::SetFactory::_PD_repoId);
    }
  };

  class BagFactory :
    public virtual CosCollection::_impl_BagFactory,
    public virtual ::PortableServer::ServantBase
  {
  public:
    virtual ~BagFactory();

    inline ::CosCollection::BagFactory_ptr _this() {
      return (::CosCollection::BagFactory_ptr) _do_this(::CosCollection::BagFactory::_PD_repoId);
    }
  };

  class KeySortedSetFactory :
    public virtual CosCollection::_impl_KeySortedSetFactory,
    public virtual ::PortableServer::ServantBase
  {
  public:
    virtual ~KeySortedSetFactory();

    inline ::CosCollection::KeySortedSetFactory_ptr _this() {
      return (::CosCollection::KeySortedSetFactory_ptr) _do_this(::CosCollection::KeySortedSetFactory::_PD_repoId);
    }
  };

  class KeySortedBagFactory :
    public virtual CosCollection::_impl_KeySortedBagFactory,
    public virtual CollectionFactory
  {
  public:
    virtual ~KeySortedBagFactory();

    inline ::CosCollection::KeySortedBagFactory_ptr _this() {
      return (::CosCollection::KeySortedBagFactory_ptr) _do_this(::CosCollection::KeySortedBagFactory::_PD_repoId);
    }
  };

  class SortedMapFactory :
    public virtual CosCollection::_impl_SortedMapFactory,
    public virtual CollectionFactory
  {
  public:
    virtual ~SortedMapFactory();

    inline ::CosCollection::SortedMapFactory_ptr _this() {
      return (::CosCollection::SortedMapFactory_ptr) _do_this(::CosCollection::SortedMapFactory::_PD_repoId);
    }
  };

  class SortedRelationFactory :
    public virtual CosCollection::_impl_SortedRelationFactory,
    public virtual CollectionFactory
  {
  public:
    virtual ~SortedRelationFactory();

    inline ::CosCollection::SortedRelationFactory_ptr _this() {
      return (::CosCollection::SortedRelationFactory_ptr) _do_this(::CosCollection::SortedRelationFactory::_PD_repoId);
    }
  };

  class SortedSetFactory :
    public virtual CosCollection::_impl_SortedSetFactory,
    public virtual CollectionFactory
  {
  public:
    virtual ~SortedSetFactory();

    inline ::CosCollection::SortedSetFactory_ptr _this() {
      return (::CosCollection::SortedSetFactory_ptr) _do_this(::CosCollection::SortedSetFactory::_PD_repoId);
    }
  };

  class SortedBagFactory :
    public virtual CosCollection::_impl_SortedBagFactory,
    public virtual ::PortableServer::ServantBase
  {
  public:
    virtual ~SortedBagFactory();

    inline ::CosCollection::SortedBagFactory_ptr _this() {
      return (::CosCollection::SortedBagFactory_ptr) _do_this(::CosCollection::SortedBagFactory::_PD_repoId);
    }
  };

  class SequenceFactory :
    public virtual CosCollection::_impl_SequenceFactory,
    public virtual CollectionFactory
  {
  public:
    virtual ~SequenceFactory();

    inline ::CosCollection::SequenceFactory_ptr _this() {
      return (::CosCollection::SequenceFactory_ptr) _do_this(::CosCollection::SequenceFactory::_PD_repoId);
    }
  };

  class EqualitySequenceFactory :
    public virtual CosCollection::_impl_EqualitySequenceFactory,
    public virtual CollectionFactory
  {
  public:
    virtual ~EqualitySequenceFactory();

    inline ::CosCollection::EqualitySequenceFactory_ptr _this() {
      return (::CosCollection::EqualitySequenceFactory_ptr) _do_this(::CosCollection::EqualitySequenceFactory::_PD_repoId);
    }
  };

  class HeapFactory :
    public virtual CosCollection::_impl_HeapFactory,
    public virtual CollectionFactory
  {
  public:
    virtual ~HeapFactory();

    inline ::CosCollection::HeapFactory_ptr _this() {
      return (::CosCollection::HeapFactory_ptr) _do_this(::CosCollection::HeapFactory::_PD_repoId);
    }
  };

  class QueueFactory :
    public virtual CosCollection::_impl_QueueFactory,
    public virtual RACollectionFactory
  {
  public:
    virtual ~QueueFactory();

    inline ::CosCollection::QueueFactory_ptr _this() {
      return (::CosCollection::QueueFactory_ptr) _do_this(::CosCollection::QueueFactory::_PD_repoId);
    }
  };

  class StackFactory :
    public virtual CosCollection::_impl_StackFactory,
    public virtual RACollectionFactory
  {
  public:
    virtual ~StackFactory();

    inline ::CosCollection::StackFactory_ptr _this() {
      return (::CosCollection::StackFactory_ptr) _do_this(::CosCollection::StackFactory::_PD_repoId);
    }
  };

  class DequeFactory :
    public virtual CosCollection::_impl_DequeFactory,
    public virtual RACollectionFactory
  {
  public:
    virtual ~DequeFactory();

    inline ::CosCollection::DequeFactory_ptr _this() {
      return (::CosCollection::DequeFactory_ptr) _do_this(::CosCollection::DequeFactory::_PD_repoId);
    }
  };

  class PriorityQueueFactory :
    public virtual CosCollection::_impl_PriorityQueueFactory,
    public virtual RACollectionFactory
  {
  public:
    virtual ~PriorityQueueFactory();

    inline ::CosCollection::PriorityQueueFactory_ptr _this() {
      return (::CosCollection::PriorityQueueFactory_ptr) _do_this(::CosCollection::PriorityQueueFactory::_PD_repoId);
    }
  };

_CORBA_MODULE_END



_CORBA_MODULE OBV_CosCollection
_CORBA_MODULE_BEG

_CORBA_MODULE_END





#undef _core_attr
#undef _dyn_attr

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

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

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

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

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

inline void operator >>=(CosCollection::IteratorInvalidReason _e, cdrStream& s) {
  ::operator>>=((::CORBA::ULong)_e, s);
}

inline void operator <<= (CosCollection::IteratorInvalidReason& _e, cdrStream& s) {
  ::CORBA::ULong _0RL_e;
  ::operator<<=(_0RL_e,s);
  if (_0RL_e <= CosCollection::is_const) {
    _e = (CosCollection::IteratorInvalidReason) _0RL_e;
  }
  else {
    OMNIORB_THROW(MARSHAL,_OMNI_NS(MARSHAL_InvalidEnumValue),
                  (::CORBA::CompletionStatus)s.completion());
  }
}

void operator<<=(::CORBA::Any& _a, CosCollection::IteratorInvalidReason _s);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, CosCollection::IteratorInvalidReason& _s);

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

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

inline void operator >>=(CosCollection::ElementInvalidReason _e, cdrStream& s) {
  ::operator>>=((::CORBA::ULong)_e, s);
}

inline void operator <<= (CosCollection::ElementInvalidReason& _e, cdrStream& s) {
  ::CORBA::ULong _0RL_e;
  ::operator<<=(_0RL_e,s);
  if (_0RL_e <= CosCollection::element_exists) {
    _e = (CosCollection::ElementInvalidReason) _0RL_e;
  }
  else {
    OMNIORB_THROW(MARSHAL,_OMNI_NS(MARSHAL_InvalidEnumValue),
                  (::CORBA::CompletionStatus)s.completion());
  }
}

void operator<<=(::CORBA::Any& _a, CosCollection::ElementInvalidReason _s);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, CosCollection::ElementInvalidReason& _s);

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

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

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

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

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

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

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

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

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

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

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

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

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

inline void operator >>=(CosCollection::LowerBoundStyle _e, cdrStream& s) {
  ::operator>>=((::CORBA::ULong)_e, s);
}

inline void operator <<= (CosCollection::LowerBoundStyle& _e, cdrStream& s) {
  ::CORBA::ULong _0RL_e;
  ::operator<<=(_0RL_e,s);
  if (_0RL_e <= CosCollection::greater_or_equal) {
    _e = (CosCollection::LowerBoundStyle) _0RL_e;
  }
  else {
    OMNIORB_THROW(MARSHAL,_OMNI_NS(MARSHAL_InvalidEnumValue),
                  (::CORBA::CompletionStatus)s.completion());
  }
}

void operator<<=(::CORBA::Any& _a, CosCollection::LowerBoundStyle _s);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, CosCollection::LowerBoundStyle& _s);

inline void operator >>=(CosCollection::UpperBoundStyle _e, cdrStream& s) {
  ::operator>>=((::CORBA::ULong)_e, s);
}

inline void operator <<= (CosCollection::UpperBoundStyle& _e, cdrStream& s) {
  ::CORBA::ULong _0RL_e;
  ::operator<<=(_0RL_e,s);
  if (_0RL_e <= CosCollection::less_or_equal) {
    _e = (CosCollection::UpperBoundStyle) _0RL_e;
  }
  else {
    OMNIORB_THROW(MARSHAL,_OMNI_NS(MARSHAL_InvalidEnumValue),
                  (::CORBA::CompletionStatus)s.completion());
  }
}

void operator<<=(::CORBA::Any& _a, CosCollection::UpperBoundStyle _s);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, CosCollection::UpperBoundStyle& _s);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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



inline void
CosCollection::Operations::_marshalObjRef(::CosCollection::Operations_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosCollection::Command::_marshalObjRef(::CosCollection::Command_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosCollection::Comparator::_marshalObjRef(::CosCollection::Comparator_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosCollection::Iterator::_marshalObjRef(::CosCollection::Iterator_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosCollection::OrderedIterator::_marshalObjRef(::CosCollection::OrderedIterator_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosCollection::SequentialIterator::_marshalObjRef(::CosCollection::SequentialIterator_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosCollection::KeyIterator::_marshalObjRef(::CosCollection::KeyIterator_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosCollection::EqualityIterator::_marshalObjRef(::CosCollection::EqualityIterator_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosCollection::EqualityKeyIterator::_marshalObjRef(::CosCollection::EqualityKeyIterator_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosCollection::SortedIterator::_marshalObjRef(::CosCollection::SortedIterator_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosCollection::KeySortedIterator::_marshalObjRef(::CosCollection::KeySortedIterator_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosCollection::EqualitySortedIterator::_marshalObjRef(::CosCollection::EqualitySortedIterator_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosCollection::EqualityKeySortedIterator::_marshalObjRef(::CosCollection::EqualityKeySortedIterator_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosCollection::EqualitySequentialIterator::_marshalObjRef(::CosCollection::EqualitySequentialIterator_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosCollection::Collection::_marshalObjRef(::CosCollection::Collection_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosCollection::OrderedCollection::_marshalObjRef(::CosCollection::OrderedCollection_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosCollection::SequentialCollection::_marshalObjRef(::CosCollection::SequentialCollection_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosCollection::SortedCollection::_marshalObjRef(::CosCollection::SortedCollection_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosCollection::EqualityCollection::_marshalObjRef(::CosCollection::EqualityCollection_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosCollection::KeyCollection::_marshalObjRef(::CosCollection::KeyCollection_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosCollection::EqualityKeyCollection::_marshalObjRef(::CosCollection::EqualityKeyCollection_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosCollection::KeySortedCollection::_marshalObjRef(::CosCollection::KeySortedCollection_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosCollection::EqualitySortedCollection::_marshalObjRef(::CosCollection::EqualitySortedCollection_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosCollection::EqualityKeySortedCollection::_marshalObjRef(::CosCollection::EqualityKeySortedCollection_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosCollection::EqualitySequentialCollection::_marshalObjRef(::CosCollection::EqualitySequentialCollection_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosCollection::KeySet::_marshalObjRef(::CosCollection::KeySet_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosCollection::KeyBag::_marshalObjRef(::CosCollection::KeyBag_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosCollection::Map::_marshalObjRef(::CosCollection::Map_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosCollection::Relation::_marshalObjRef(::CosCollection::Relation_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosCollection::Set::_marshalObjRef(::CosCollection::Set_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosCollection::Bag::_marshalObjRef(::CosCollection::Bag_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosCollection::KeySortedSet::_marshalObjRef(::CosCollection::KeySortedSet_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosCollection::KeySortedBag::_marshalObjRef(::CosCollection::KeySortedBag_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosCollection::SortedMap::_marshalObjRef(::CosCollection::SortedMap_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosCollection::SortedRelation::_marshalObjRef(::CosCollection::SortedRelation_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosCollection::SortedSet::_marshalObjRef(::CosCollection::SortedSet_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosCollection::SortedBag::_marshalObjRef(::CosCollection::SortedBag_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosCollection::CSequence::_marshalObjRef(::CosCollection::CSequence_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosCollection::EqualitySequence::_marshalObjRef(::CosCollection::EqualitySequence_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosCollection::Heap::_marshalObjRef(::CosCollection::Heap_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosCollection::RestrictedAccessCollection::_marshalObjRef(::CosCollection::RestrictedAccessCollection_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosCollection::Queue::_marshalObjRef(::CosCollection::Queue_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosCollection::Deque::_marshalObjRef(::CosCollection::Deque_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosCollection::Stack::_marshalObjRef(::CosCollection::Stack_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosCollection::PriorityQueue::_marshalObjRef(::CosCollection::PriorityQueue_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosCollection::CollectionFactory::_marshalObjRef(::CosCollection::CollectionFactory_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosCollection::CollectionFactories::_marshalObjRef(::CosCollection::CollectionFactories_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosCollection::RACollectionFactory::_marshalObjRef(::CosCollection::RACollectionFactory_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosCollection::RACollectionFactories::_marshalObjRef(::CosCollection::RACollectionFactories_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosCollection::KeySetFactory::_marshalObjRef(::CosCollection::KeySetFactory_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosCollection::KeyBagFactory::_marshalObjRef(::CosCollection::KeyBagFactory_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosCollection::MapFactory::_marshalObjRef(::CosCollection::MapFactory_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosCollection::RelationFactory::_marshalObjRef(::CosCollection::RelationFactory_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosCollection::SetFactory::_marshalObjRef(::CosCollection::SetFactory_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosCollection::BagFactory::_marshalObjRef(::CosCollection::BagFactory_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosCollection::KeySortedSetFactory::_marshalObjRef(::CosCollection::KeySortedSetFactory_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosCollection::KeySortedBagFactory::_marshalObjRef(::CosCollection::KeySortedBagFactory_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosCollection::SortedMapFactory::_marshalObjRef(::CosCollection::SortedMapFactory_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosCollection::SortedRelationFactory::_marshalObjRef(::CosCollection::SortedRelationFactory_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosCollection::SortedSetFactory::_marshalObjRef(::CosCollection::SortedSetFactory_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosCollection::SortedBagFactory::_marshalObjRef(::CosCollection::SortedBagFactory_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosCollection::SequenceFactory::_marshalObjRef(::CosCollection::SequenceFactory_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosCollection::EqualitySequenceFactory::_marshalObjRef(::CosCollection::EqualitySequenceFactory_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosCollection::HeapFactory::_marshalObjRef(::CosCollection::HeapFactory_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosCollection::QueueFactory::_marshalObjRef(::CosCollection::QueueFactory_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosCollection::StackFactory::_marshalObjRef(::CosCollection::StackFactory_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosCollection::DequeFactory::_marshalObjRef(::CosCollection::DequeFactory_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosCollection::PriorityQueueFactory::_marshalObjRef(::CosCollection::PriorityQueueFactory_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}




#ifdef   USE_stub_in_nt_dll_NOT_DEFINED_CosCollection
# undef  USE_stub_in_nt_dll
# undef  USE_stub_in_nt_dll_NOT_DEFINED_CosCollection
#endif
#ifdef   USE_core_stub_in_nt_dll_NOT_DEFINED_CosCollection
# undef  USE_core_stub_in_nt_dll
# undef  USE_core_stub_in_nt_dll_NOT_DEFINED_CosCollection
#endif
#ifdef   USE_dyn_stub_in_nt_dll_NOT_DEFINED_CosCollection
# undef  USE_dyn_stub_in_nt_dll
# undef  USE_dyn_stub_in_nt_dll_NOT_DEFINED_CosCollection
#endif

#endif  // __CosCollection_hh__