libcos4-dev 4.1.6-1 / usr / include / COS / CosTrading.hh

// This file is generated by omniidl (C++ backend)- omniORB_4_1. Do not edit.
#ifndef __CosTrading_hh__
#define __CosTrading_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_CosTrading
#endif
#ifndef  USE_core_stub_in_nt_dll
# define USE_core_stub_in_nt_dll_NOT_DEFINED_CosTrading
#endif
#ifndef  USE_dyn_stub_in_nt_dll
# define USE_dyn_stub_in_nt_dll_NOT_DEFINED_CosTrading
#endif


#include "COS_sysdep.h"



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

_CORBA_MODULE_BEG

#ifndef __CosTrading_mLookup__
#define __CosTrading_mLookup__

  class Lookup;
  class _objref_Lookup;
  class _impl_Lookup;
  
  typedef _objref_Lookup* Lookup_ptr;
  typedef Lookup_ptr LookupRef;

  class Lookup_Helper {
  public:
    typedef Lookup_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_Lookup, Lookup_Helper> Lookup_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_Lookup,Lookup_Helper > Lookup_out;

#endif

#ifndef __CosTrading_mRegister__
#define __CosTrading_mRegister__

  class Register;
  class _objref_Register;
  class _impl_Register;
  
  typedef _objref_Register* Register_ptr;
  typedef Register_ptr RegisterRef;

  class Register_Helper {
  public:
    typedef Register_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_Register, Register_Helper> Register_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_Register,Register_Helper > Register_out;

#endif

#ifndef __CosTrading_mLink__
#define __CosTrading_mLink__

  class Link;
  class _objref_Link;
  class _impl_Link;
  
  typedef _objref_Link* Link_ptr;
  typedef Link_ptr LinkRef;

  class Link_Helper {
  public:
    typedef Link_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_Link, Link_Helper> Link_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_Link,Link_Helper > Link_out;

#endif

#ifndef __CosTrading_mProxy__
#define __CosTrading_mProxy__

  class Proxy;
  class _objref_Proxy;
  class _impl_Proxy;
  
  typedef _objref_Proxy* Proxy_ptr;
  typedef Proxy_ptr ProxyRef;

  class Proxy_Helper {
  public:
    typedef Proxy_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_Proxy, Proxy_Helper> Proxy_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_Proxy,Proxy_Helper > Proxy_out;

#endif

#ifndef __CosTrading_mAdmin__
#define __CosTrading_mAdmin__

  class Admin;
  class _objref_Admin;
  class _impl_Admin;
  
  typedef _objref_Admin* Admin_ptr;
  typedef Admin_ptr AdminRef;

  class Admin_Helper {
  public:
    typedef Admin_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_Admin, Admin_Helper> Admin_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_Admin,Admin_Helper > Admin_out;

#endif

#ifndef __CosTrading_mOfferIterator__
#define __CosTrading_mOfferIterator__

  class OfferIterator;
  class _objref_OfferIterator;
  class _impl_OfferIterator;
  
  typedef _objref_OfferIterator* OfferIterator_ptr;
  typedef OfferIterator_ptr OfferIteratorRef;

  class OfferIterator_Helper {
  public:
    typedef OfferIterator_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_OfferIterator, OfferIterator_Helper> OfferIterator_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_OfferIterator,OfferIterator_Helper > OfferIterator_out;

#endif

#ifndef __CosTrading_mOfferIdIterator__
#define __CosTrading_mOfferIdIterator__

  class OfferIdIterator;
  class _objref_OfferIdIterator;
  class _impl_OfferIdIterator;
  
  typedef _objref_OfferIdIterator* OfferIdIterator_ptr;
  typedef OfferIdIterator_ptr OfferIdIteratorRef;

  class OfferIdIterator_Helper {
  public:
    typedef OfferIdIterator_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_OfferIdIterator, OfferIdIterator_Helper> OfferIdIterator_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_OfferIdIterator,OfferIdIterator_Helper > OfferIdIterator_out;

#endif

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

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_TypeRepository;

  typedef ::CORBA::Object TypeRepository;
  typedef ::CORBA::Object_ptr TypeRepository_ptr;
  typedef ::CORBA::ObjectRef TypeRepositoryRef;
  
  typedef ::CORBA::Object_Helper TypeRepository_Helper;
  
  typedef ::CORBA::Object_var TypeRepository_var;
  typedef ::CORBA::Object_out TypeRepository_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_PropertyName;

  typedef char* PropertyName;
  typedef ::CORBA::String_var PropertyName_var;
  typedef ::CORBA::String_out PropertyName_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_PropertyNameSeq;

  class PropertyNameSeq_var;

  class PropertyNameSeq : public _CORBA_Unbounded_Sequence_String {
  public:
    typedef PropertyNameSeq_var _var_type;
    inline PropertyNameSeq() {}
    inline PropertyNameSeq(const PropertyNameSeq& _s)
      : _CORBA_Unbounded_Sequence_String(_s) {}

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

  

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

  class PropertyNameSeq_out;

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

  

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

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

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

  

    PropertyNameSeq*& _data;

  private:
    PropertyNameSeq_out();
    PropertyNameSeq_out& operator=(const PropertyNameSeq_var&);
  };

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_PropertyValue;

  typedef ::CORBA::Any PropertyValue;
  typedef ::CORBA::Any_var PropertyValue_var;
  typedef ::CORBA::Any_out PropertyValue_out;

  struct Property {
    typedef _CORBA_ConstrType_Variable_Var<Property> _var_type;

    
    ::CORBA::String_member name;

    PropertyValue value;

  

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

  typedef Property::_var_type Property_var;

  typedef _CORBA_ConstrType_Variable_OUT_arg< Property,Property_var > Property_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_Property;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_PropertySeq;

  class PropertySeq_var;

  class PropertySeq : public _CORBA_Unbounded_Sequence< Property >  {
  public:
    typedef PropertySeq_var _var_type;
    inline PropertySeq() {}
    inline PropertySeq(const PropertySeq& _s)
      : _CORBA_Unbounded_Sequence< Property > (_s) {}

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

  

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

  class PropertySeq_out;

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

  

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

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

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

  

    PropertySeq*& _data;

  private:
    PropertySeq_out();
    PropertySeq_out& operator=(const PropertySeq_var&);
  };

  struct Offer {
    typedef _CORBA_ConstrType_Variable_Var<Offer> _var_type;

    
    ::CORBA::Object_Member reference;

    PropertySeq properties;

  

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

  typedef Offer::_var_type Offer_var;

  typedef _CORBA_ConstrType_Variable_OUT_arg< Offer,Offer_var > Offer_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_Offer;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_OfferSeq;

  class OfferSeq_var;

  class OfferSeq : public _CORBA_Unbounded_Sequence< Offer >  {
  public:
    typedef OfferSeq_var _var_type;
    inline OfferSeq() {}
    inline OfferSeq(const OfferSeq& _s)
      : _CORBA_Unbounded_Sequence< Offer > (_s) {}

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

  

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

  class OfferSeq_out;

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

  

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

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

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

  

    OfferSeq*& _data;

  private:
    OfferSeq_out();
    OfferSeq_out& operator=(const OfferSeq_var&);
  };

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_OfferId;

  typedef char* OfferId;
  typedef ::CORBA::String_var OfferId_var;
  typedef ::CORBA::String_out OfferId_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_OfferIdSeq;

  class OfferIdSeq_var;

  class OfferIdSeq : public _CORBA_Unbounded_Sequence_String {
  public:
    typedef OfferIdSeq_var _var_type;
    inline OfferIdSeq() {}
    inline OfferIdSeq(const OfferIdSeq& _s)
      : _CORBA_Unbounded_Sequence_String(_s) {}

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

  

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

  class OfferIdSeq_out;

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

  

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

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

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

  

    OfferIdSeq*& _data;

  private:
    OfferIdSeq_out();
    OfferIdSeq_out& operator=(const OfferIdSeq_var&);
  };

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_ServiceTypeName;

  typedef char* ServiceTypeName;
  typedef ::CORBA::String_var ServiceTypeName_var;
  typedef ::CORBA::String_out ServiceTypeName_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_Constraint;

  typedef char* Constraint;
  typedef ::CORBA::String_var Constraint_var;
  typedef ::CORBA::String_out Constraint_out;

  enum FollowOption { local_only, if_no_local, always /*, __max_FollowOption=0xffffffff */ };
  typedef FollowOption& FollowOption_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_FollowOption;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_LinkName;

  typedef char* LinkName;
  typedef ::CORBA::String_var LinkName_var;
  typedef ::CORBA::String_out LinkName_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_LinkNameSeq;

  class LinkNameSeq_var;

  class LinkNameSeq : public _CORBA_Unbounded_Sequence_String {
  public:
    typedef LinkNameSeq_var _var_type;
    inline LinkNameSeq() {}
    inline LinkNameSeq(const LinkNameSeq& _s)
      : _CORBA_Unbounded_Sequence_String(_s) {}

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

  

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

  class LinkNameSeq_out;

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

  

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

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

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

  

    LinkNameSeq*& _data;

  private:
    LinkNameSeq_out();
    LinkNameSeq_out& operator=(const LinkNameSeq_var&);
  };

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_TraderName;

  typedef LinkNameSeq TraderName;
  typedef LinkNameSeq_var TraderName_var;
  typedef LinkNameSeq_out TraderName_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_PolicyName;

  typedef char* PolicyName;
  typedef ::CORBA::String_var PolicyName_var;
  typedef ::CORBA::String_out PolicyName_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_PolicyNameSeq;

  class PolicyNameSeq_var;

  class PolicyNameSeq : public _CORBA_Unbounded_Sequence_String {
  public:
    typedef PolicyNameSeq_var _var_type;
    inline PolicyNameSeq() {}
    inline PolicyNameSeq(const PolicyNameSeq& _s)
      : _CORBA_Unbounded_Sequence_String(_s) {}

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

  

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

  class PolicyNameSeq_out;

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

  

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

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

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

  

    PolicyNameSeq*& _data;

  private:
    PolicyNameSeq_out();
    PolicyNameSeq_out& operator=(const PolicyNameSeq_var&);
  };

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_PolicyValue;

  typedef ::CORBA::Any PolicyValue;
  typedef ::CORBA::Any_var PolicyValue_var;
  typedef ::CORBA::Any_out PolicyValue_out;

  struct Policy {
    typedef _CORBA_ConstrType_Variable_Var<Policy> _var_type;

    
    ::CORBA::String_member name;

    PolicyValue value;

  

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

  typedef Policy::_var_type Policy_var;

  typedef _CORBA_ConstrType_Variable_OUT_arg< Policy,Policy_var > Policy_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_Policy;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_PolicySeq;

  class PolicySeq_var;

  class PolicySeq : public _CORBA_Unbounded_Sequence< Policy >  {
  public:
    typedef PolicySeq_var _var_type;
    inline PolicySeq() {}
    inline PolicySeq(const PolicySeq& _s)
      : _CORBA_Unbounded_Sequence< Policy > (_s) {}

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

  

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

  class PolicySeq_out;

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

  

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

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

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

  

    PolicySeq*& _data;

  private:
    PolicySeq_out();
    PolicySeq_out& operator=(const PolicySeq_var&);
  };

  class UnknownMaxLeft : public ::CORBA::UserException {
  public:
    
    

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

  class NotImplemented : public ::CORBA::UserException {
  public:
    
    

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

  class IllegalServiceType : public ::CORBA::UserException {
  public:
    
    ::CORBA::String_member type;

  

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

  class UnknownServiceType : public ::CORBA::UserException {
  public:
    
    ::CORBA::String_member type;

  

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

  class IllegalPropertyName : public ::CORBA::UserException {
  public:
    
    ::CORBA::String_member name;

  

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

  class DuplicatePropertyName : public ::CORBA::UserException {
  public:
    
    ::CORBA::String_member name;

  

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

  class PropertyTypeMismatch : public ::CORBA::UserException {
  public:
    
    ::CORBA::String_member type;

    Property prop;

  

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

  class MissingMandatoryProperty : public ::CORBA::UserException {
  public:
    
    ::CORBA::String_member type;

    ::CORBA::String_member name;

  

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

  class ReadonlyDynamicProperty : public ::CORBA::UserException {
  public:
    
    ::CORBA::String_member type;

    ::CORBA::String_member name;

  

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

  class IllegalConstraint : public ::CORBA::UserException {
  public:
    
    ::CORBA::String_member constr;

  

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

  class InvalidLookupRef : public ::CORBA::UserException {
  public:
    
    _CORBA_ObjRef_Member< _objref_Lookup, Lookup_Helper>  target;

  

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

  class IllegalOfferId : public ::CORBA::UserException {
  public:
    
    ::CORBA::String_member id;

  

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

  class UnknownOfferId : public ::CORBA::UserException {
  public:
    
    ::CORBA::String_member id;

  

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

  class DuplicatePolicyName : public ::CORBA::UserException {
  public:
    
    ::CORBA::String_member name;

  

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

#ifndef __CosTrading_mTraderComponents__
#define __CosTrading_mTraderComponents__

  class TraderComponents;
  class _objref_TraderComponents;
  class _impl_TraderComponents;
  
  typedef _objref_TraderComponents* TraderComponents_ptr;
  typedef TraderComponents_ptr TraderComponentsRef;

  class TraderComponents_Helper {
  public:
    typedef TraderComponents_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_TraderComponents, TraderComponents_Helper> TraderComponents_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_TraderComponents,TraderComponents_Helper > TraderComponents_out;

#endif

  // interface TraderComponents
  class TraderComponents {
  public:
    // Declarations for this interface type.
    typedef TraderComponents_ptr _ptr_type;
    typedef TraderComponents_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_TraderComponents :
    public virtual ::CORBA::Object,
    public virtual omniObjRef
  {
  public:
    Lookup_ptr lookup_if();
    Register_ptr register_if();
    Link_ptr link_if();
    Proxy_ptr proxy_if();
    Admin_ptr admin_if();

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

  protected:
    virtual ~_objref_TraderComponents();

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

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

    friend class TraderComponents;
  };

  class _pof_TraderComponents : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_TraderComponents() : _OMNI_NS(proxyObjectFactory)(TraderComponents::_PD_repoId) {}
    virtual ~_pof_TraderComponents();

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

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

    virtual Lookup_ptr lookup_if() = 0;
    virtual Register_ptr register_if() = 0;
    virtual Link_ptr link_if() = 0;
    virtual Proxy_ptr proxy_if() = 0;
    virtual Admin_ptr admin_if() = 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_TraderComponents;

#ifndef __CosTrading_mSupportAttributes__
#define __CosTrading_mSupportAttributes__

  class SupportAttributes;
  class _objref_SupportAttributes;
  class _impl_SupportAttributes;
  
  typedef _objref_SupportAttributes* SupportAttributes_ptr;
  typedef SupportAttributes_ptr SupportAttributesRef;

  class SupportAttributes_Helper {
  public:
    typedef SupportAttributes_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_SupportAttributes, SupportAttributes_Helper> SupportAttributes_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_SupportAttributes,SupportAttributes_Helper > SupportAttributes_out;

#endif

  // interface SupportAttributes
  class SupportAttributes {
  public:
    // Declarations for this interface type.
    typedef SupportAttributes_ptr _ptr_type;
    typedef SupportAttributes_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_SupportAttributes :
    public virtual ::CORBA::Object,
    public virtual omniObjRef
  {
  public:
    ::CORBA::Boolean supports_modifiable_properties();
    ::CORBA::Boolean supports_dynamic_properties();
    ::CORBA::Boolean supports_proxy_offers();
    ::CORBA::Object_ptr type_repos();

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

  protected:
    virtual ~_objref_SupportAttributes();

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

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

    friend class SupportAttributes;
  };

  class _pof_SupportAttributes : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_SupportAttributes() : _OMNI_NS(proxyObjectFactory)(SupportAttributes::_PD_repoId) {}
    virtual ~_pof_SupportAttributes();

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

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

    virtual ::CORBA::Boolean supports_modifiable_properties() = 0;
    virtual ::CORBA::Boolean supports_dynamic_properties() = 0;
    virtual ::CORBA::Boolean supports_proxy_offers() = 0;
    virtual ::CORBA::Object_ptr type_repos() = 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_SupportAttributes;

#ifndef __CosTrading_mImportAttributes__
#define __CosTrading_mImportAttributes__

  class ImportAttributes;
  class _objref_ImportAttributes;
  class _impl_ImportAttributes;
  
  typedef _objref_ImportAttributes* ImportAttributes_ptr;
  typedef ImportAttributes_ptr ImportAttributesRef;

  class ImportAttributes_Helper {
  public:
    typedef ImportAttributes_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_ImportAttributes, ImportAttributes_Helper> ImportAttributes_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_ImportAttributes,ImportAttributes_Helper > ImportAttributes_out;

#endif

  // interface ImportAttributes
  class ImportAttributes {
  public:
    // Declarations for this interface type.
    typedef ImportAttributes_ptr _ptr_type;
    typedef ImportAttributes_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_ImportAttributes :
    public virtual ::CORBA::Object,
    public virtual omniObjRef
  {
  public:
    ::CORBA::ULong def_search_card();
    ::CORBA::ULong max_search_card();
    ::CORBA::ULong def_match_card();
    ::CORBA::ULong max_match_card();
    ::CORBA::ULong def_return_card();
    ::CORBA::ULong max_return_card();
    ::CORBA::ULong max_list();
    ::CORBA::ULong def_hop_count();
    ::CORBA::ULong max_hop_count();
    FollowOption def_follow_policy();
    FollowOption max_follow_policy();

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

  protected:
    virtual ~_objref_ImportAttributes();

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

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

    friend class ImportAttributes;
  };

  class _pof_ImportAttributes : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_ImportAttributes() : _OMNI_NS(proxyObjectFactory)(ImportAttributes::_PD_repoId) {}
    virtual ~_pof_ImportAttributes();

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

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

    virtual ::CORBA::ULong def_search_card() = 0;
    virtual ::CORBA::ULong max_search_card() = 0;
    virtual ::CORBA::ULong def_match_card() = 0;
    virtual ::CORBA::ULong max_match_card() = 0;
    virtual ::CORBA::ULong def_return_card() = 0;
    virtual ::CORBA::ULong max_return_card() = 0;
    virtual ::CORBA::ULong max_list() = 0;
    virtual ::CORBA::ULong def_hop_count() = 0;
    virtual ::CORBA::ULong max_hop_count() = 0;
    virtual FollowOption def_follow_policy() = 0;
    virtual FollowOption max_follow_policy() = 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_ImportAttributes;

#ifndef __CosTrading_mLinkAttributes__
#define __CosTrading_mLinkAttributes__

  class LinkAttributes;
  class _objref_LinkAttributes;
  class _impl_LinkAttributes;
  
  typedef _objref_LinkAttributes* LinkAttributes_ptr;
  typedef LinkAttributes_ptr LinkAttributesRef;

  class LinkAttributes_Helper {
  public:
    typedef LinkAttributes_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_LinkAttributes, LinkAttributes_Helper> LinkAttributes_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_LinkAttributes,LinkAttributes_Helper > LinkAttributes_out;

#endif

  // interface LinkAttributes
  class LinkAttributes {
  public:
    // Declarations for this interface type.
    typedef LinkAttributes_ptr _ptr_type;
    typedef LinkAttributes_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_LinkAttributes :
    public virtual ::CORBA::Object,
    public virtual omniObjRef
  {
  public:
    FollowOption max_link_follow_policy();

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

  protected:
    virtual ~_objref_LinkAttributes();

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

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

    friend class LinkAttributes;
  };

  class _pof_LinkAttributes : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_LinkAttributes() : _OMNI_NS(proxyObjectFactory)(LinkAttributes::_PD_repoId) {}
    virtual ~_pof_LinkAttributes();

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

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

    virtual FollowOption max_link_follow_policy() = 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_LinkAttributes;

#ifndef __CosTrading_mLookup__
#define __CosTrading_mLookup__

  class Lookup;
  class _objref_Lookup;
  class _impl_Lookup;
  
  typedef _objref_Lookup* Lookup_ptr;
  typedef Lookup_ptr LookupRef;

  class Lookup_Helper {
  public:
    typedef Lookup_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_Lookup, Lookup_Helper> Lookup_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_Lookup,Lookup_Helper > Lookup_out;

#endif

  // interface Lookup
  class Lookup {
  public:
    // Declarations for this interface type.
    typedef Lookup_ptr _ptr_type;
    typedef Lookup_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.
    static _dyn_attr const ::CORBA::TypeCode_ptr _tc_Preference;

    typedef char* Preference;
    typedef ::CORBA::String_var Preference_var;
    typedef ::CORBA::String_out Preference_out;

    enum HowManyProps { none, some, all /*, __max_HowManyProps=0xffffffff */ };
    typedef HowManyProps& HowManyProps_out;

    static _dyn_attr const ::CORBA::TypeCode_ptr _tc_HowManyProps;

    class SpecifiedProps {
    public:

      typedef _CORBA_ConstrType_Variable_Var<SpecifiedProps> _var_type;

      

      SpecifiedProps(): _pd__initialised(0) {
        _default();

    
      }
      
      SpecifiedProps(const SpecifiedProps& _value) {
        _pd__initialised = _value._pd__initialised;
        if ((_pd__default = _value._pd__default)) {
          
        }
        else {
          switch(_value._pd__d) {
            case some: prop_names(_value._pd_prop_names); break;

              default: break;

        
          }
        }
        _pd__d = _value._pd__d;

    
      }

      ~SpecifiedProps() {}

      SpecifiedProps& operator=(const SpecifiedProps& _value) {
        _pd__initialised = _value._pd__initialised;
        if ((_pd__default = _value._pd__default)) {
          
        }
        else {
          switch(_value._pd__d) {
            case some: prop_names(_value._pd_prop_names); break;

              default: break;

        
          }
        }
        _pd__d = _value._pd__d;

    
        return *this;
      }

      HowManyProps _d() const { return _pd__d;}
      void _d(HowManyProps _value){
        // illegal to set discriminator before making a member active
        if (!_pd__initialised)
          OMNIORB_THROW(BAD_PARAM,_OMNI_NS(BAD_PARAM_InvalidUnionDiscValue),::CORBA::COMPLETED_NO);

        if (_value == _pd__d) return; // no change

        switch (_pd__d){
          case some: goto fail;
          default:
          switch (_value){
            case some: goto fail;
            default: _pd__d = _value; return;
          }

        };
        

        fail:
        OMNIORB_THROW(BAD_PARAM,_OMNI_NS(BAD_PARAM_InvalidUnionDiscValue),::CORBA::COMPLETED_NO);


    
      }

      void _default()
      {
        _pd__initialised = 1;
        _pd__d = none;
        _pd__default = 1;
      }

    

      const PropertyNameSeq &prop_names () const { return _pd_prop_names; }
      PropertyNameSeq &prop_names () { return _pd_prop_names; }
      void prop_names (const PropertyNameSeq& _value) {
        _pd__initialised = 1;
        _pd__d = some;
        _pd__default = 0;
        _pd_prop_names = _value;
      }

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

    private:
      HowManyProps _pd__d;
      _CORBA_Boolean _pd__default;
      _CORBA_Boolean _pd__initialised;

      
      PropertyNameSeq _pd_prop_names;

    
    };

    typedef SpecifiedProps::_var_type SpecifiedProps_var;

    typedef _CORBA_ConstrType_Variable_OUT_arg< SpecifiedProps,SpecifiedProps_var > SpecifiedProps_out;

    static _dyn_attr const ::CORBA::TypeCode_ptr _tc_SpecifiedProps;

    class IllegalPreference : public ::CORBA::UserException {
    public:
      
      ::CORBA::String_member pref;

    

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

      static _core_attr insertExceptionToAny    insertToAnyFn;
      static _core_attr insertExceptionToAnyNCP insertToAnyFnNCP;

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

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

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

    static _dyn_attr const ::CORBA::TypeCode_ptr _tc_IllegalPreference;

    class IllegalPolicyName : public ::CORBA::UserException {
    public:
      
      ::CORBA::String_member name;

    

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

      static _core_attr insertExceptionToAny    insertToAnyFn;
      static _core_attr insertExceptionToAnyNCP insertToAnyFnNCP;

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

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

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

    static _dyn_attr const ::CORBA::TypeCode_ptr _tc_IllegalPolicyName;

    class PolicyTypeMismatch : public ::CORBA::UserException {
    public:
      
      Policy the_policy;

    

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

      static _core_attr insertExceptionToAny    insertToAnyFn;
      static _core_attr insertExceptionToAnyNCP insertToAnyFnNCP;

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

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

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

    static _dyn_attr const ::CORBA::TypeCode_ptr _tc_PolicyTypeMismatch;

    class InvalidPolicyValue : public ::CORBA::UserException {
    public:
      
      Policy the_policy;

    

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

      static _core_attr insertExceptionToAny    insertToAnyFn;
      static _core_attr insertExceptionToAnyNCP insertToAnyFnNCP;

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

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

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

    static _dyn_attr const ::CORBA::TypeCode_ptr _tc_InvalidPolicyValue;

  
  };

  class _objref_Lookup :
    public virtual _objref_TraderComponents,
    public virtual _objref_SupportAttributes,
    public virtual _objref_ImportAttributes
  {
  public:
    void query(const char* type, const char* constr, const char* pref, const ::CosTrading::PolicySeq& policies, const ::CosTrading::Lookup::SpecifiedProps& desired_props, ::CORBA::ULong how_many, ::CosTrading::OfferSeq_out offers, ::CosTrading::OfferIterator_out offer_itr, ::CosTrading::PolicyNameSeq_out limits_applied);

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

  protected:
    virtual ~_objref_Lookup();

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

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

    friend class Lookup;
  };

  class _pof_Lookup : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_Lookup() : _OMNI_NS(proxyObjectFactory)(Lookup::_PD_repoId) {}
    virtual ~_pof_Lookup();

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

  class _impl_Lookup :
    public virtual _impl_TraderComponents,
    public virtual _impl_SupportAttributes,
    public virtual _impl_ImportAttributes
  {
  public:
    virtual ~_impl_Lookup();

    virtual void query(const char* type, const char* constr, const char* pref, const ::CosTrading::PolicySeq& policies, const ::CosTrading::Lookup::SpecifiedProps& desired_props, ::CORBA::ULong how_many, ::CosTrading::OfferSeq_out offers, ::CosTrading::OfferIterator_out offer_itr, ::CosTrading::PolicyNameSeq_out limits_applied) = 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_Lookup;

#ifndef __CosTrading_mRegister__
#define __CosTrading_mRegister__

  class Register;
  class _objref_Register;
  class _impl_Register;
  
  typedef _objref_Register* Register_ptr;
  typedef Register_ptr RegisterRef;

  class Register_Helper {
  public:
    typedef Register_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_Register, Register_Helper> Register_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_Register,Register_Helper > Register_out;

#endif

  // interface Register
  class Register {
  public:
    // Declarations for this interface type.
    typedef Register_ptr _ptr_type;
    typedef Register_var _var_type;

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

    static inline void _marshalObjRef(_ptr_type, cdrStream&);

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

    static _core_attr const char* _PD_repoId;

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

      
      ::CORBA::Object_Member reference;

      ::CORBA::String_member type;

      PropertySeq properties;

    

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

    typedef OfferInfo::_var_type OfferInfo_var;

    typedef _CORBA_ConstrType_Variable_OUT_arg< OfferInfo,OfferInfo_var > OfferInfo_out;

    static _dyn_attr const ::CORBA::TypeCode_ptr _tc_OfferInfo;

    class InvalidObjectRef : public ::CORBA::UserException {
    public:
      
      ::CORBA::Object_Member ref;

    

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

      static _core_attr insertExceptionToAny    insertToAnyFn;
      static _core_attr insertExceptionToAnyNCP insertToAnyFnNCP;

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

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

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

    static _dyn_attr const ::CORBA::TypeCode_ptr _tc_InvalidObjectRef;

    class UnknownPropertyName : public ::CORBA::UserException {
    public:
      
      ::CORBA::String_member name;

    

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

      static _core_attr insertExceptionToAny    insertToAnyFn;
      static _core_attr insertExceptionToAnyNCP insertToAnyFnNCP;

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

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

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

    static _dyn_attr const ::CORBA::TypeCode_ptr _tc_UnknownPropertyName;

    class InterfaceTypeMismatch : public ::CORBA::UserException {
    public:
      
      ::CORBA::String_member type;

      ::CORBA::Object_Member reference;

    

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

      static _core_attr insertExceptionToAny    insertToAnyFn;
      static _core_attr insertExceptionToAnyNCP insertToAnyFnNCP;

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

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

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

    static _dyn_attr const ::CORBA::TypeCode_ptr _tc_InterfaceTypeMismatch;

    class ProxyOfferId : public ::CORBA::UserException {
    public:
      
      ::CORBA::String_member id;

    

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

      static _core_attr insertExceptionToAny    insertToAnyFn;
      static _core_attr insertExceptionToAnyNCP insertToAnyFnNCP;

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

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

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

    static _dyn_attr const ::CORBA::TypeCode_ptr _tc_ProxyOfferId;

    class MandatoryProperty : public ::CORBA::UserException {
    public:
      
      ::CORBA::String_member type;

      ::CORBA::String_member name;

    

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

      static _core_attr insertExceptionToAny    insertToAnyFn;
      static _core_attr insertExceptionToAnyNCP insertToAnyFnNCP;

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

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

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

    static _dyn_attr const ::CORBA::TypeCode_ptr _tc_MandatoryProperty;

    class ReadonlyProperty : public ::CORBA::UserException {
    public:
      
      ::CORBA::String_member type;

      ::CORBA::String_member name;

    

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

      static _core_attr insertExceptionToAny    insertToAnyFn;
      static _core_attr insertExceptionToAnyNCP insertToAnyFnNCP;

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

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

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

    static _dyn_attr const ::CORBA::TypeCode_ptr _tc_ReadonlyProperty;

    class NoMatchingOffers : public ::CORBA::UserException {
    public:
      
      ::CORBA::String_member constr;

    

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

      static _core_attr insertExceptionToAny    insertToAnyFn;
      static _core_attr insertExceptionToAnyNCP insertToAnyFnNCP;

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

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

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

    static _dyn_attr const ::CORBA::TypeCode_ptr _tc_NoMatchingOffers;

    class IllegalTraderName : public ::CORBA::UserException {
    public:
      
      TraderName name;

    

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

      static _core_attr insertExceptionToAny    insertToAnyFn;
      static _core_attr insertExceptionToAnyNCP insertToAnyFnNCP;

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

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

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

    static _dyn_attr const ::CORBA::TypeCode_ptr _tc_IllegalTraderName;

    class UnknownTraderName : public ::CORBA::UserException {
    public:
      
      TraderName name;

    

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

      static _core_attr insertExceptionToAny    insertToAnyFn;
      static _core_attr insertExceptionToAnyNCP insertToAnyFnNCP;

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

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

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

    static _dyn_attr const ::CORBA::TypeCode_ptr _tc_UnknownTraderName;

    class RegisterNotSupported : public ::CORBA::UserException {
    public:
      
      TraderName name;

    

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

      static _core_attr insertExceptionToAny    insertToAnyFn;
      static _core_attr insertExceptionToAnyNCP insertToAnyFnNCP;

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

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

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

    static _dyn_attr const ::CORBA::TypeCode_ptr _tc_RegisterNotSupported;

  
  };

  class _objref_Register :
    public virtual _objref_TraderComponents,
    public virtual _objref_SupportAttributes
  {
  public:
    char* _cxx_export(::CORBA::Object_ptr reference, const char* type, const ::CosTrading::PropertySeq& properties);
    void withdraw(const char* id);
    Register::OfferInfo* describe(const char* id);
    void modify(const char* id, const ::CosTrading::PropertyNameSeq& del_list, const ::CosTrading::PropertySeq& modify_list);
    void withdraw_using_constraint(const char* type, const char* constr);
    Register_ptr resolve(const ::CosTrading::TraderName& name);

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

  protected:
    virtual ~_objref_Register();

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

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

    friend class Register;
  };

  class _pof_Register : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_Register() : _OMNI_NS(proxyObjectFactory)(Register::_PD_repoId) {}
    virtual ~_pof_Register();

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

  class _impl_Register :
    public virtual _impl_TraderComponents,
    public virtual _impl_SupportAttributes
  {
  public:
    virtual ~_impl_Register();

    virtual char* _cxx_export(::CORBA::Object_ptr reference, const char* type, const ::CosTrading::PropertySeq& properties) = 0;
    virtual void withdraw(const char* id) = 0;
    virtual Register::OfferInfo* describe(const char* id) = 0;
    virtual void modify(const char* id, const ::CosTrading::PropertyNameSeq& del_list, const ::CosTrading::PropertySeq& modify_list) = 0;
    virtual void withdraw_using_constraint(const char* type, const char* constr) = 0;
    virtual Register_ptr resolve(const ::CosTrading::TraderName& name) = 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_Register;

#ifndef __CosTrading_mLink__
#define __CosTrading_mLink__

  class Link;
  class _objref_Link;
  class _impl_Link;
  
  typedef _objref_Link* Link_ptr;
  typedef Link_ptr LinkRef;

  class Link_Helper {
  public:
    typedef Link_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_Link, Link_Helper> Link_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_Link,Link_Helper > Link_out;

#endif

  // interface Link
  class Link {
  public:
    // Declarations for this interface type.
    typedef Link_ptr _ptr_type;
    typedef Link_var _var_type;

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

    static inline void _marshalObjRef(_ptr_type, cdrStream&);

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

    static _core_attr const char* _PD_repoId;

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

      
      _CORBA_ObjRef_Member< _objref_Lookup, Lookup_Helper>  target;

      _CORBA_ObjRef_Member< _objref_Register, Register_Helper>  target_reg;

      FollowOption def_pass_on_follow_rule;

      FollowOption limiting_follow_rule;

    

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

    typedef LinkInfo::_var_type LinkInfo_var;

    typedef _CORBA_ConstrType_Variable_OUT_arg< LinkInfo,LinkInfo_var > LinkInfo_out;

    static _dyn_attr const ::CORBA::TypeCode_ptr _tc_LinkInfo;

    class IllegalLinkName : public ::CORBA::UserException {
    public:
      
      ::CORBA::String_member name;

    

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

      static _core_attr insertExceptionToAny    insertToAnyFn;
      static _core_attr insertExceptionToAnyNCP insertToAnyFnNCP;

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

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

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

    static _dyn_attr const ::CORBA::TypeCode_ptr _tc_IllegalLinkName;

    class UnknownLinkName : public ::CORBA::UserException {
    public:
      
      ::CORBA::String_member name;

    

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

      static _core_attr insertExceptionToAny    insertToAnyFn;
      static _core_attr insertExceptionToAnyNCP insertToAnyFnNCP;

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

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

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

    static _dyn_attr const ::CORBA::TypeCode_ptr _tc_UnknownLinkName;

    class DuplicateLinkName : public ::CORBA::UserException {
    public:
      
      ::CORBA::String_member name;

    

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

      static _core_attr insertExceptionToAny    insertToAnyFn;
      static _core_attr insertExceptionToAnyNCP insertToAnyFnNCP;

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

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

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

    static _dyn_attr const ::CORBA::TypeCode_ptr _tc_DuplicateLinkName;

    class DefaultFollowTooPermissive : public ::CORBA::UserException {
    public:
      
      FollowOption def_pass_on_follow_rule;

      FollowOption limiting_follow_rule;

    

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

      static _core_attr insertExceptionToAny    insertToAnyFn;
      static _core_attr insertExceptionToAnyNCP insertToAnyFnNCP;

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

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

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

    static _dyn_attr const ::CORBA::TypeCode_ptr _tc_DefaultFollowTooPermissive;

    class LimitingFollowTooPermissive : public ::CORBA::UserException {
    public:
      
      FollowOption limiting_follow_rule;

      FollowOption max_link_follow_policy;

    

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

      static _core_attr insertExceptionToAny    insertToAnyFn;
      static _core_attr insertExceptionToAnyNCP insertToAnyFnNCP;

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

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

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

    static _dyn_attr const ::CORBA::TypeCode_ptr _tc_LimitingFollowTooPermissive;

  
  };

  class _objref_Link :
    public virtual _objref_TraderComponents,
    public virtual _objref_SupportAttributes,
    public virtual _objref_LinkAttributes
  {
  public:
    void add_link(const char* name, ::CosTrading::Lookup_ptr target, ::CosTrading::FollowOption def_pass_on_follow_rule, ::CosTrading::FollowOption limiting_follow_rule);
    void remove_link(const char* name);
    Link::LinkInfo* describe_link(const char* name);
    LinkNameSeq* list_links();
    void modify_link(const char* name, ::CosTrading::FollowOption def_pass_on_follow_rule, ::CosTrading::FollowOption limiting_follow_rule);

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

  protected:
    virtual ~_objref_Link();

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

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

    friend class Link;
  };

  class _pof_Link : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_Link() : _OMNI_NS(proxyObjectFactory)(Link::_PD_repoId) {}
    virtual ~_pof_Link();

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

  class _impl_Link :
    public virtual _impl_TraderComponents,
    public virtual _impl_SupportAttributes,
    public virtual _impl_LinkAttributes
  {
  public:
    virtual ~_impl_Link();

    virtual void add_link(const char* name, ::CosTrading::Lookup_ptr target, ::CosTrading::FollowOption def_pass_on_follow_rule, ::CosTrading::FollowOption limiting_follow_rule) = 0;
    virtual void remove_link(const char* name) = 0;
    virtual Link::LinkInfo* describe_link(const char* name) = 0;
    virtual LinkNameSeq* list_links() = 0;
    virtual void modify_link(const char* name, ::CosTrading::FollowOption def_pass_on_follow_rule, ::CosTrading::FollowOption limiting_follow_rule) = 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_Link;

#ifndef __CosTrading_mProxy__
#define __CosTrading_mProxy__

  class Proxy;
  class _objref_Proxy;
  class _impl_Proxy;
  
  typedef _objref_Proxy* Proxy_ptr;
  typedef Proxy_ptr ProxyRef;

  class Proxy_Helper {
  public:
    typedef Proxy_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_Proxy, Proxy_Helper> Proxy_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_Proxy,Proxy_Helper > Proxy_out;

#endif

  // interface Proxy
  class Proxy {
  public:
    // Declarations for this interface type.
    typedef Proxy_ptr _ptr_type;
    typedef Proxy_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.
    static _dyn_attr const ::CORBA::TypeCode_ptr _tc_ConstraintRecipe;

    typedef char* ConstraintRecipe;
    typedef ::CORBA::String_var ConstraintRecipe_var;
    typedef ::CORBA::String_out ConstraintRecipe_out;

    struct ProxyInfo {
      typedef _CORBA_ConstrType_Variable_Var<ProxyInfo> _var_type;

      
      ::CORBA::String_member type;

      _CORBA_ObjRef_Member< _objref_Lookup, Lookup_Helper>  target;

      PropertySeq properties;

      ::CORBA::Boolean if_match_all;

      ::CORBA::String_member recipe;

      PolicySeq policies_to_pass_on;

    

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

    typedef ProxyInfo::_var_type ProxyInfo_var;

    typedef _CORBA_ConstrType_Variable_OUT_arg< ProxyInfo,ProxyInfo_var > ProxyInfo_out;

    static _dyn_attr const ::CORBA::TypeCode_ptr _tc_ProxyInfo;

    class IllegalRecipe : public ::CORBA::UserException {
    public:
      
      ::CORBA::String_member recipe;

    

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

      static _core_attr insertExceptionToAny    insertToAnyFn;
      static _core_attr insertExceptionToAnyNCP insertToAnyFnNCP;

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

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

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

    static _dyn_attr const ::CORBA::TypeCode_ptr _tc_IllegalRecipe;

    class NotProxyOfferId : public ::CORBA::UserException {
    public:
      
      ::CORBA::String_member id;

    

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

      static _core_attr insertExceptionToAny    insertToAnyFn;
      static _core_attr insertExceptionToAnyNCP insertToAnyFnNCP;

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

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

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

    static _dyn_attr const ::CORBA::TypeCode_ptr _tc_NotProxyOfferId;

  
  };

  class _objref_Proxy :
    public virtual _objref_TraderComponents,
    public virtual _objref_SupportAttributes
  {
  public:
    char* export_proxy(::CosTrading::Lookup_ptr target, const char* type, const ::CosTrading::PropertySeq& properties, ::CORBA::Boolean if_match_all, const char* recipe, const ::CosTrading::PolicySeq& policies_to_pass_on);
    void withdraw_proxy(const char* id);
    Proxy::ProxyInfo* describe_proxy(const char* id);

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

  protected:
    virtual ~_objref_Proxy();

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

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

    friend class Proxy;
  };

  class _pof_Proxy : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_Proxy() : _OMNI_NS(proxyObjectFactory)(Proxy::_PD_repoId) {}
    virtual ~_pof_Proxy();

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

  class _impl_Proxy :
    public virtual _impl_TraderComponents,
    public virtual _impl_SupportAttributes
  {
  public:
    virtual ~_impl_Proxy();

    virtual char* export_proxy(::CosTrading::Lookup_ptr target, const char* type, const ::CosTrading::PropertySeq& properties, ::CORBA::Boolean if_match_all, const char* recipe, const ::CosTrading::PolicySeq& policies_to_pass_on) = 0;
    virtual void withdraw_proxy(const char* id) = 0;
    virtual Proxy::ProxyInfo* describe_proxy(const char* id) = 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_Proxy;

#ifndef __CosTrading_mAdmin__
#define __CosTrading_mAdmin__

  class Admin;
  class _objref_Admin;
  class _impl_Admin;
  
  typedef _objref_Admin* Admin_ptr;
  typedef Admin_ptr AdminRef;

  class Admin_Helper {
  public:
    typedef Admin_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_Admin, Admin_Helper> Admin_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_Admin,Admin_Helper > Admin_out;

#endif

  // interface Admin
  class Admin {
  public:
    // Declarations for this interface type.
    typedef Admin_ptr _ptr_type;
    typedef Admin_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.
    static _dyn_attr const ::CORBA::TypeCode_ptr _tc_OctetSeq;

    class OctetSeq_var;

    class OctetSeq : public _CORBA_Unbounded_Sequence_Octet {
    public:
      typedef OctetSeq_var _var_type;
      inline OctetSeq() {}
      inline OctetSeq(const OctetSeq& _s)
        : _CORBA_Unbounded_Sequence_Octet(_s) {}

      inline OctetSeq(_CORBA_ULong _max)
        : _CORBA_Unbounded_Sequence_Octet(_max) {}
      inline OctetSeq(_CORBA_ULong _max, _CORBA_ULong _len, ::CORBA::Octet* _val, _CORBA_Boolean _rel=0)
        : _CORBA_Unbounded_Sequence_Octet(_max, _len, _val, _rel) {}

    

      inline OctetSeq& operator = (const OctetSeq& _s) {
        _CORBA_Unbounded_Sequence_Octet::operator=(_s);
        return *this;
      }
    };

    class OctetSeq_out;

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

    

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

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

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

    

      OctetSeq*& _data;

    private:
      OctetSeq_out();
      OctetSeq_out& operator=(const OctetSeq_var&);
    };

  
  };

  class _objref_Admin :
    public virtual _objref_TraderComponents,
    public virtual _objref_SupportAttributes,
    public virtual _objref_ImportAttributes,
    public virtual _objref_LinkAttributes
  {
  public:
    ::CORBA::ULong set_def_search_card(::CORBA::ULong value);
    ::CORBA::ULong set_max_search_card(::CORBA::ULong value);
    ::CORBA::ULong set_def_match_card(::CORBA::ULong value);
    ::CORBA::ULong set_max_match_card(::CORBA::ULong value);
    ::CORBA::ULong set_def_return_card(::CORBA::ULong value);
    ::CORBA::ULong set_max_return_card(::CORBA::ULong value);
    ::CORBA::ULong set_max_list(::CORBA::ULong value);
    ::CORBA::Boolean set_supports_modifiable_properties(::CORBA::Boolean value);
    ::CORBA::Boolean set_supports_dynamic_properties(::CORBA::Boolean value);
    ::CORBA::Boolean set_supports_proxy_offers(::CORBA::Boolean value);
    ::CORBA::ULong set_def_hop_count(::CORBA::ULong value);
    ::CORBA::ULong set_max_hop_count(::CORBA::ULong value);
    FollowOption set_def_follow_policy(::CosTrading::FollowOption policy);
    FollowOption set_max_follow_policy(::CosTrading::FollowOption policy);
    FollowOption set_max_link_follow_policy(::CosTrading::FollowOption policy);
    ::CORBA::Object_ptr set_type_repos(::CORBA::Object_ptr repository);
    Admin::OctetSeq* set_request_id_stem(const ::CosTrading::Admin::OctetSeq& stem);
    void list_offers(::CORBA::ULong how_many, ::CosTrading::OfferIdSeq_out ids, ::CosTrading::OfferIdIterator_out id_itr);
    void list_proxies(::CORBA::ULong how_many, ::CosTrading::OfferIdSeq_out ids, ::CosTrading::OfferIdIterator_out id_itr);
    Admin::OctetSeq* request_id_stem();

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

  protected:
    virtual ~_objref_Admin();

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

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

    friend class Admin;
  };

  class _pof_Admin : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_Admin() : _OMNI_NS(proxyObjectFactory)(Admin::_PD_repoId) {}
    virtual ~_pof_Admin();

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

  class _impl_Admin :
    public virtual _impl_TraderComponents,
    public virtual _impl_SupportAttributes,
    public virtual _impl_ImportAttributes,
    public virtual _impl_LinkAttributes
  {
  public:
    virtual ~_impl_Admin();

    virtual ::CORBA::ULong set_def_search_card(::CORBA::ULong value) = 0;
    virtual ::CORBA::ULong set_max_search_card(::CORBA::ULong value) = 0;
    virtual ::CORBA::ULong set_def_match_card(::CORBA::ULong value) = 0;
    virtual ::CORBA::ULong set_max_match_card(::CORBA::ULong value) = 0;
    virtual ::CORBA::ULong set_def_return_card(::CORBA::ULong value) = 0;
    virtual ::CORBA::ULong set_max_return_card(::CORBA::ULong value) = 0;
    virtual ::CORBA::ULong set_max_list(::CORBA::ULong value) = 0;
    virtual ::CORBA::Boolean set_supports_modifiable_properties(::CORBA::Boolean value) = 0;
    virtual ::CORBA::Boolean set_supports_dynamic_properties(::CORBA::Boolean value) = 0;
    virtual ::CORBA::Boolean set_supports_proxy_offers(::CORBA::Boolean value) = 0;
    virtual ::CORBA::ULong set_def_hop_count(::CORBA::ULong value) = 0;
    virtual ::CORBA::ULong set_max_hop_count(::CORBA::ULong value) = 0;
    virtual FollowOption set_def_follow_policy(::CosTrading::FollowOption policy) = 0;
    virtual FollowOption set_max_follow_policy(::CosTrading::FollowOption policy) = 0;
    virtual FollowOption set_max_link_follow_policy(::CosTrading::FollowOption policy) = 0;
    virtual ::CORBA::Object_ptr set_type_repos(::CORBA::Object_ptr repository) = 0;
    virtual Admin::OctetSeq* set_request_id_stem(const ::CosTrading::Admin::OctetSeq& stem) = 0;
    virtual void list_offers(::CORBA::ULong how_many, ::CosTrading::OfferIdSeq_out ids, ::CosTrading::OfferIdIterator_out id_itr) = 0;
    virtual void list_proxies(::CORBA::ULong how_many, ::CosTrading::OfferIdSeq_out ids, ::CosTrading::OfferIdIterator_out id_itr) = 0;
    virtual Admin::OctetSeq* request_id_stem() = 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_Admin;

#ifndef __CosTrading_mOfferIterator__
#define __CosTrading_mOfferIterator__

  class OfferIterator;
  class _objref_OfferIterator;
  class _impl_OfferIterator;
  
  typedef _objref_OfferIterator* OfferIterator_ptr;
  typedef OfferIterator_ptr OfferIteratorRef;

  class OfferIterator_Helper {
  public:
    typedef OfferIterator_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_OfferIterator, OfferIterator_Helper> OfferIterator_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_OfferIterator,OfferIterator_Helper > OfferIterator_out;

#endif

  // interface OfferIterator
  class OfferIterator {
  public:
    // Declarations for this interface type.
    typedef OfferIterator_ptr _ptr_type;
    typedef OfferIterator_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_OfferIterator :
    public virtual ::CORBA::Object,
    public virtual omniObjRef
  {
  public:
    ::CORBA::ULong max_left();
    ::CORBA::Boolean next_n(::CORBA::ULong n, ::CosTrading::OfferSeq_out offers);
    void destroy();

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

  protected:
    virtual ~_objref_OfferIterator();

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

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

    friend class OfferIterator;
  };

  class _pof_OfferIterator : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_OfferIterator() : _OMNI_NS(proxyObjectFactory)(OfferIterator::_PD_repoId) {}
    virtual ~_pof_OfferIterator();

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

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

    virtual ::CORBA::ULong max_left() = 0;
    virtual ::CORBA::Boolean next_n(::CORBA::ULong n, ::CosTrading::OfferSeq_out offers) = 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_OfferIterator;

#ifndef __CosTrading_mOfferIdIterator__
#define __CosTrading_mOfferIdIterator__

  class OfferIdIterator;
  class _objref_OfferIdIterator;
  class _impl_OfferIdIterator;
  
  typedef _objref_OfferIdIterator* OfferIdIterator_ptr;
  typedef OfferIdIterator_ptr OfferIdIteratorRef;

  class OfferIdIterator_Helper {
  public:
    typedef OfferIdIterator_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_OfferIdIterator, OfferIdIterator_Helper> OfferIdIterator_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_OfferIdIterator,OfferIdIterator_Helper > OfferIdIterator_out;

#endif

  // interface OfferIdIterator
  class OfferIdIterator {
  public:
    // Declarations for this interface type.
    typedef OfferIdIterator_ptr _ptr_type;
    typedef OfferIdIterator_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_OfferIdIterator :
    public virtual ::CORBA::Object,
    public virtual omniObjRef
  {
  public:
    ::CORBA::ULong max_left();
    ::CORBA::Boolean next_n(::CORBA::ULong n, ::CosTrading::OfferIdSeq_out ids);
    void destroy();

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

  protected:
    virtual ~_objref_OfferIdIterator();

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

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

    friend class OfferIdIterator;
  };

  class _pof_OfferIdIterator : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_OfferIdIterator() : _OMNI_NS(proxyObjectFactory)(OfferIdIterator::_PD_repoId) {}
    virtual ~_pof_OfferIdIterator();

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

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

    virtual ::CORBA::ULong max_left() = 0;
    virtual ::CORBA::Boolean next_n(::CORBA::ULong n, ::CosTrading::OfferIdSeq_out ids) = 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_OfferIdIterator;

_CORBA_MODULE_END



_CORBA_MODULE POA_CosTrading
_CORBA_MODULE_BEG

  class TraderComponents :
    public virtual CosTrading::_impl_TraderComponents,
    public virtual ::PortableServer::ServantBase
  {
  public:
    virtual ~TraderComponents();

    inline ::CosTrading::TraderComponents_ptr _this() {
      return (::CosTrading::TraderComponents_ptr) _do_this(::CosTrading::TraderComponents::_PD_repoId);
    }
  };

  class SupportAttributes :
    public virtual CosTrading::_impl_SupportAttributes,
    public virtual ::PortableServer::ServantBase
  {
  public:
    virtual ~SupportAttributes();

    inline ::CosTrading::SupportAttributes_ptr _this() {
      return (::CosTrading::SupportAttributes_ptr) _do_this(::CosTrading::SupportAttributes::_PD_repoId);
    }
  };

  class ImportAttributes :
    public virtual CosTrading::_impl_ImportAttributes,
    public virtual ::PortableServer::ServantBase
  {
  public:
    virtual ~ImportAttributes();

    inline ::CosTrading::ImportAttributes_ptr _this() {
      return (::CosTrading::ImportAttributes_ptr) _do_this(::CosTrading::ImportAttributes::_PD_repoId);
    }
  };

  class LinkAttributes :
    public virtual CosTrading::_impl_LinkAttributes,
    public virtual ::PortableServer::ServantBase
  {
  public:
    virtual ~LinkAttributes();

    inline ::CosTrading::LinkAttributes_ptr _this() {
      return (::CosTrading::LinkAttributes_ptr) _do_this(::CosTrading::LinkAttributes::_PD_repoId);
    }
  };

  class Lookup :
    public virtual CosTrading::_impl_Lookup,
    public virtual TraderComponents,
      public virtual SupportAttributes,
      public virtual ImportAttributes
  {
  public:
    virtual ~Lookup();

    inline ::CosTrading::Lookup_ptr _this() {
      return (::CosTrading::Lookup_ptr) _do_this(::CosTrading::Lookup::_PD_repoId);
    }
  };

  class Register :
    public virtual CosTrading::_impl_Register,
    public virtual TraderComponents,
      public virtual SupportAttributes
  {
  public:
    virtual ~Register();

    inline ::CosTrading::Register_ptr _this() {
      return (::CosTrading::Register_ptr) _do_this(::CosTrading::Register::_PD_repoId);
    }
  };

  class Link :
    public virtual CosTrading::_impl_Link,
    public virtual TraderComponents,
      public virtual SupportAttributes,
      public virtual LinkAttributes
  {
  public:
    virtual ~Link();

    inline ::CosTrading::Link_ptr _this() {
      return (::CosTrading::Link_ptr) _do_this(::CosTrading::Link::_PD_repoId);
    }
  };

  class Proxy :
    public virtual CosTrading::_impl_Proxy,
    public virtual TraderComponents,
      public virtual SupportAttributes
  {
  public:
    virtual ~Proxy();

    inline ::CosTrading::Proxy_ptr _this() {
      return (::CosTrading::Proxy_ptr) _do_this(::CosTrading::Proxy::_PD_repoId);
    }
  };

  class Admin :
    public virtual CosTrading::_impl_Admin,
    public virtual TraderComponents,
      public virtual SupportAttributes,
      public virtual ImportAttributes,
      public virtual LinkAttributes
  {
  public:
    virtual ~Admin();

    inline ::CosTrading::Admin_ptr _this() {
      return (::CosTrading::Admin_ptr) _do_this(::CosTrading::Admin::_PD_repoId);
    }
  };

  class OfferIterator :
    public virtual CosTrading::_impl_OfferIterator,
    public virtual ::PortableServer::ServantBase
  {
  public:
    virtual ~OfferIterator();

    inline ::CosTrading::OfferIterator_ptr _this() {
      return (::CosTrading::OfferIterator_ptr) _do_this(::CosTrading::OfferIterator::_PD_repoId);
    }
  };

  class OfferIdIterator :
    public virtual CosTrading::_impl_OfferIdIterator,
    public virtual ::PortableServer::ServantBase
  {
  public:
    virtual ~OfferIdIterator();

    inline ::CosTrading::OfferIdIterator_ptr _this() {
      return (::CosTrading::OfferIdIterator_ptr) _do_this(::CosTrading::OfferIdIterator::_PD_repoId);
    }
  };

_CORBA_MODULE_END



_CORBA_MODULE OBV_CosTrading
_CORBA_MODULE_BEG

_CORBA_MODULE_END





#undef _core_attr
#undef _dyn_attr

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

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

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

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

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

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

inline void operator >>=(CosTrading::FollowOption _e, cdrStream& s) {
  ::operator>>=((::CORBA::ULong)_e, s);
}

inline void operator <<= (CosTrading::FollowOption& _e, cdrStream& s) {
  ::CORBA::ULong _0RL_e;
  ::operator<<=(_0RL_e,s);
  if (_0RL_e <= CosTrading::always) {
    _e = (CosTrading::FollowOption) _0RL_e;
  }
  else {
    OMNIORB_THROW(MARSHAL,_OMNI_NS(MARSHAL_InvalidEnumValue),
                  (::CORBA::CompletionStatus)s.completion());
  }
}

void operator<<=(::CORBA::Any& _a, CosTrading::FollowOption _s);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, CosTrading::FollowOption& _s);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

inline void operator >>=(CosTrading::Lookup::HowManyProps _e, cdrStream& s) {
  ::operator>>=((::CORBA::ULong)_e, s);
}

inline void operator <<= (CosTrading::Lookup::HowManyProps& _e, cdrStream& s) {
  ::CORBA::ULong _0RL_e;
  ::operator<<=(_0RL_e,s);
  if (_0RL_e <= CosTrading::Lookup::all) {
    _e = (CosTrading::Lookup::HowManyProps) _0RL_e;
  }
  else {
    OMNIORB_THROW(MARSHAL,_OMNI_NS(MARSHAL_InvalidEnumValue),
                  (::CORBA::CompletionStatus)s.completion());
  }
}

void operator<<=(::CORBA::Any& _a, CosTrading::Lookup::HowManyProps _s);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, CosTrading::Lookup::HowManyProps& _s);

void operator<<=(::CORBA::Any& _a, const CosTrading::Lookup::SpecifiedProps& _s);
void operator<<=(::CORBA::Any& _a, CosTrading::Lookup::SpecifiedProps* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const CosTrading::Lookup::SpecifiedProps*& _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, CosTrading::Lookup::SpecifiedProps*& _sp);

void operator<<=(::CORBA::Any& _a, const CosTrading::Lookup::IllegalPreference& _s);
void operator<<=(::CORBA::Any& _a, const CosTrading::Lookup::IllegalPreference* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const CosTrading::Lookup::IllegalPreference*& _sp);

void operator<<=(::CORBA::Any& _a, const CosTrading::Lookup::IllegalPolicyName& _s);
void operator<<=(::CORBA::Any& _a, const CosTrading::Lookup::IllegalPolicyName* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const CosTrading::Lookup::IllegalPolicyName*& _sp);

void operator<<=(::CORBA::Any& _a, const CosTrading::Lookup::PolicyTypeMismatch& _s);
void operator<<=(::CORBA::Any& _a, const CosTrading::Lookup::PolicyTypeMismatch* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const CosTrading::Lookup::PolicyTypeMismatch*& _sp);

void operator<<=(::CORBA::Any& _a, const CosTrading::Lookup::InvalidPolicyValue& _s);
void operator<<=(::CORBA::Any& _a, const CosTrading::Lookup::InvalidPolicyValue* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const CosTrading::Lookup::InvalidPolicyValue*& _sp);

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

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

void operator<<=(::CORBA::Any& _a, const CosTrading::Register::InvalidObjectRef& _s);
void operator<<=(::CORBA::Any& _a, const CosTrading::Register::InvalidObjectRef* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const CosTrading::Register::InvalidObjectRef*& _sp);

void operator<<=(::CORBA::Any& _a, const CosTrading::Register::UnknownPropertyName& _s);
void operator<<=(::CORBA::Any& _a, const CosTrading::Register::UnknownPropertyName* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const CosTrading::Register::UnknownPropertyName*& _sp);

void operator<<=(::CORBA::Any& _a, const CosTrading::Register::InterfaceTypeMismatch& _s);
void operator<<=(::CORBA::Any& _a, const CosTrading::Register::InterfaceTypeMismatch* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const CosTrading::Register::InterfaceTypeMismatch*& _sp);

void operator<<=(::CORBA::Any& _a, const CosTrading::Register::ProxyOfferId& _s);
void operator<<=(::CORBA::Any& _a, const CosTrading::Register::ProxyOfferId* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const CosTrading::Register::ProxyOfferId*& _sp);

void operator<<=(::CORBA::Any& _a, const CosTrading::Register::MandatoryProperty& _s);
void operator<<=(::CORBA::Any& _a, const CosTrading::Register::MandatoryProperty* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const CosTrading::Register::MandatoryProperty*& _sp);

void operator<<=(::CORBA::Any& _a, const CosTrading::Register::ReadonlyProperty& _s);
void operator<<=(::CORBA::Any& _a, const CosTrading::Register::ReadonlyProperty* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const CosTrading::Register::ReadonlyProperty*& _sp);

void operator<<=(::CORBA::Any& _a, const CosTrading::Register::NoMatchingOffers& _s);
void operator<<=(::CORBA::Any& _a, const CosTrading::Register::NoMatchingOffers* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const CosTrading::Register::NoMatchingOffers*& _sp);

void operator<<=(::CORBA::Any& _a, const CosTrading::Register::IllegalTraderName& _s);
void operator<<=(::CORBA::Any& _a, const CosTrading::Register::IllegalTraderName* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const CosTrading::Register::IllegalTraderName*& _sp);

void operator<<=(::CORBA::Any& _a, const CosTrading::Register::UnknownTraderName& _s);
void operator<<=(::CORBA::Any& _a, const CosTrading::Register::UnknownTraderName* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const CosTrading::Register::UnknownTraderName*& _sp);

void operator<<=(::CORBA::Any& _a, const CosTrading::Register::RegisterNotSupported& _s);
void operator<<=(::CORBA::Any& _a, const CosTrading::Register::RegisterNotSupported* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const CosTrading::Register::RegisterNotSupported*& _sp);

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

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

void operator<<=(::CORBA::Any& _a, const CosTrading::Link::IllegalLinkName& _s);
void operator<<=(::CORBA::Any& _a, const CosTrading::Link::IllegalLinkName* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const CosTrading::Link::IllegalLinkName*& _sp);

void operator<<=(::CORBA::Any& _a, const CosTrading::Link::UnknownLinkName& _s);
void operator<<=(::CORBA::Any& _a, const CosTrading::Link::UnknownLinkName* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const CosTrading::Link::UnknownLinkName*& _sp);

void operator<<=(::CORBA::Any& _a, const CosTrading::Link::DuplicateLinkName& _s);
void operator<<=(::CORBA::Any& _a, const CosTrading::Link::DuplicateLinkName* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const CosTrading::Link::DuplicateLinkName*& _sp);

void operator<<=(::CORBA::Any& _a, const CosTrading::Link::DefaultFollowTooPermissive& _s);
void operator<<=(::CORBA::Any& _a, const CosTrading::Link::DefaultFollowTooPermissive* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const CosTrading::Link::DefaultFollowTooPermissive*& _sp);

void operator<<=(::CORBA::Any& _a, const CosTrading::Link::LimitingFollowTooPermissive& _s);
void operator<<=(::CORBA::Any& _a, const CosTrading::Link::LimitingFollowTooPermissive* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const CosTrading::Link::LimitingFollowTooPermissive*& _sp);

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

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

void operator<<=(::CORBA::Any& _a, const CosTrading::Proxy::IllegalRecipe& _s);
void operator<<=(::CORBA::Any& _a, const CosTrading::Proxy::IllegalRecipe* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const CosTrading::Proxy::IllegalRecipe*& _sp);

void operator<<=(::CORBA::Any& _a, const CosTrading::Proxy::NotProxyOfferId& _s);
void operator<<=(::CORBA::Any& _a, const CosTrading::Proxy::NotProxyOfferId* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const CosTrading::Proxy::NotProxyOfferId*& _sp);

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

void operator<<=(::CORBA::Any& _a, const CosTrading::Admin::OctetSeq& _s);
void operator<<=(::CORBA::Any& _a, CosTrading::Admin::OctetSeq* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, CosTrading::Admin::OctetSeq*& _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const CosTrading::Admin::OctetSeq*& _sp);

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

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

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



inline void
CosTrading::TraderComponents::_marshalObjRef(::CosTrading::TraderComponents_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosTrading::SupportAttributes::_marshalObjRef(::CosTrading::SupportAttributes_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosTrading::ImportAttributes::_marshalObjRef(::CosTrading::ImportAttributes_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosTrading::LinkAttributes::_marshalObjRef(::CosTrading::LinkAttributes_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosTrading::Lookup::_marshalObjRef(::CosTrading::Lookup_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosTrading::Register::_marshalObjRef(::CosTrading::Register_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosTrading::Link::_marshalObjRef(::CosTrading::Link_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosTrading::Proxy::_marshalObjRef(::CosTrading::Proxy_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosTrading::Admin::_marshalObjRef(::CosTrading::Admin_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosTrading::OfferIterator::_marshalObjRef(::CosTrading::OfferIterator_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosTrading::OfferIdIterator::_marshalObjRef(::CosTrading::OfferIdIterator_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}




#ifdef   USE_stub_in_nt_dll_NOT_DEFINED_CosTrading
# undef  USE_stub_in_nt_dll
# undef  USE_stub_in_nt_dll_NOT_DEFINED_CosTrading
#endif
#ifdef   USE_core_stub_in_nt_dll_NOT_DEFINED_CosTrading
# undef  USE_core_stub_in_nt_dll
# undef  USE_core_stub_in_nt_dll_NOT_DEFINED_CosTrading
#endif
#ifdef   USE_dyn_stub_in_nt_dll_NOT_DEFINED_CosTrading
# undef  USE_dyn_stub_in_nt_dll
# undef  USE_dyn_stub_in_nt_dll_NOT_DEFINED_CosTrading
#endif

#endif  // __CosTrading_hh__