libcos4-dev 4.1.6-2 / usr / include / COS / CosTradingRepos.hh

// This file is generated by omniidl (C++ backend)- omniORB_4_1. Do not edit.
#ifndef __CosTradingRepos_hh__
#define __CosTradingRepos_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_CosTradingRepos
#endif
#ifndef  USE_core_stub_in_nt_dll
# define USE_core_stub_in_nt_dll_NOT_DEFINED_CosTradingRepos
#endif
#ifndef  USE_dyn_stub_in_nt_dll
# define USE_dyn_stub_in_nt_dll_NOT_DEFINED_CosTradingRepos
#endif


#include "COS_sysdep.h"
#ifndef __corbaidl_hh_EXTERNAL_GUARD__
#define __corbaidl_hh_EXTERNAL_GUARD__
#include "corbaidl.hh"
#endif
#ifndef __boxes_hh_EXTERNAL_GUARD__
#define __boxes_hh_EXTERNAL_GUARD__
#include "boxes.hh"
#endif
#ifndef __CosTrading_hh_EXTERNAL_GUARD__
#define __CosTrading_hh_EXTERNAL_GUARD__
#include "CosTrading.hh"
#endif



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

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

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





_CORBA_MODULE CosTradingRepos

_CORBA_MODULE_BEG

#ifndef __CosTradingRepos_mServiceTypeRepository__
#define __CosTradingRepos_mServiceTypeRepository__

  class ServiceTypeRepository;
  class _objref_ServiceTypeRepository;
  class _impl_ServiceTypeRepository;
  
  typedef _objref_ServiceTypeRepository* ServiceTypeRepository_ptr;
  typedef ServiceTypeRepository_ptr ServiceTypeRepositoryRef;

  class ServiceTypeRepository_Helper {
  public:
    typedef ServiceTypeRepository_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_ServiceTypeRepository, ServiceTypeRepository_Helper> ServiceTypeRepository_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_ServiceTypeRepository,ServiceTypeRepository_Helper > ServiceTypeRepository_out;

#endif

  // interface ServiceTypeRepository
  class ServiceTypeRepository {
  public:
    // Declarations for this interface type.
    typedef ServiceTypeRepository_ptr _ptr_type;
    typedef ServiceTypeRepository_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_ServiceTypeNameSeq;

    class ServiceTypeNameSeq_var;

    class ServiceTypeNameSeq : public _CORBA_Unbounded_Sequence_String {
    public:
      typedef ServiceTypeNameSeq_var _var_type;
      inline ServiceTypeNameSeq() {}
      inline ServiceTypeNameSeq(const ServiceTypeNameSeq& _s)
        : _CORBA_Unbounded_Sequence_String(_s) {}

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

    

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

    class ServiceTypeNameSeq_out;

    class ServiceTypeNameSeq_var {
    public:
      inline ServiceTypeNameSeq_var() : _pd_seq(0) {}
      inline ServiceTypeNameSeq_var(ServiceTypeNameSeq* _s) : _pd_seq(_s) {}
      inline ServiceTypeNameSeq_var(const ServiceTypeNameSeq_var& _s) {
        if( _s._pd_seq )  _pd_seq = new ServiceTypeNameSeq(*_s._pd_seq);
        else              _pd_seq = 0;
      }
      inline ~ServiceTypeNameSeq_var() { if( _pd_seq )  delete _pd_seq; }
        
      inline ServiceTypeNameSeq_var& operator = (ServiceTypeNameSeq* _s) {
        if( _pd_seq )  delete _pd_seq;
        _pd_seq = _s;
        return *this;
      }
      inline ServiceTypeNameSeq_var& operator = (const ServiceTypeNameSeq_var& _s) {
        if( _s._pd_seq ) {
          if( !_pd_seq )  _pd_seq = new ServiceTypeNameSeq;
          *_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 ServiceTypeNameSeq* operator -> () { return _pd_seq; }
      inline const ServiceTypeNameSeq* operator -> () const { return _pd_seq; }
#if defined(__GNUG__)
      inline operator ServiceTypeNameSeq& () const { return *_pd_seq; }
#else
      inline operator const ServiceTypeNameSeq& () const { return *_pd_seq; }
      inline operator ServiceTypeNameSeq& () { return *_pd_seq; }
#endif
        
      inline const ServiceTypeNameSeq& in() const { return *_pd_seq; }
      inline ServiceTypeNameSeq&       inout()    { return *_pd_seq; }
      inline ServiceTypeNameSeq*&      out() {
        if( _pd_seq ) { delete _pd_seq; _pd_seq = 0; }
        return _pd_seq;
      }
      inline ServiceTypeNameSeq* _retn() { ServiceTypeNameSeq* tmp = _pd_seq; _pd_seq = 0; return tmp; }
        
      friend class ServiceTypeNameSeq_out;
      
    private:
      ServiceTypeNameSeq* _pd_seq;
    };

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

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

    

      ServiceTypeNameSeq*& _data;

    private:
      ServiceTypeNameSeq_out();
      ServiceTypeNameSeq_out& operator=(const ServiceTypeNameSeq_var&);
    };

    enum PropertyMode { PROP_NORMAL, PROP_READONLY, PROP_MANDATORY, PROP_MANDATORY_READONLY /*, __max_PropertyMode=0xffffffff */ };
    typedef PropertyMode& PropertyMode_out;

    static _dyn_attr const ::CORBA::TypeCode_ptr _tc_PropertyMode;

    struct PropStruct {
      typedef _CORBA_ConstrType_Variable_Var<PropStruct> _var_type;

      
      ::CORBA::String_member name;

      ::CORBA::TypeCode_member value_type;

      PropertyMode mode;

    

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

    typedef PropStruct::_var_type PropStruct_var;

    typedef _CORBA_ConstrType_Variable_OUT_arg< PropStruct,PropStruct_var > PropStruct_out;

    static _dyn_attr const ::CORBA::TypeCode_ptr _tc_PropStruct;

    static _dyn_attr const ::CORBA::TypeCode_ptr _tc_PropStructSeq;

    class PropStructSeq_var;

    class PropStructSeq : public _CORBA_Unbounded_Sequence< PropStruct >  {
    public:
      typedef PropStructSeq_var _var_type;
      inline PropStructSeq() {}
      inline PropStructSeq(const PropStructSeq& _s)
        : _CORBA_Unbounded_Sequence< PropStruct > (_s) {}

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

    

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

    class PropStructSeq_out;

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

    

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

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

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

    

      PropStructSeq*& _data;

    private:
      PropStructSeq_out();
      PropStructSeq_out& operator=(const PropStructSeq_var&);
    };

    static _dyn_attr const ::CORBA::TypeCode_ptr _tc_Identifier;

    typedef char* Identifier;
    typedef ::CORBA::String_var Identifier_var;
    typedef ::CORBA::String_out Identifier_out;

    struct IncarnationNumber {
      typedef _CORBA_ConstrType_Fix_Var<IncarnationNumber> _var_type;

      
      ::CORBA::ULong high;

      ::CORBA::ULong low;

    

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

    typedef IncarnationNumber::_var_type IncarnationNumber_var;

    typedef IncarnationNumber& IncarnationNumber_out;

    static _dyn_attr const ::CORBA::TypeCode_ptr _tc_IncarnationNumber;

    struct TypeStruct {
      typedef _CORBA_ConstrType_Variable_Var<TypeStruct> _var_type;

      
      ::CORBA::String_member if_name;

      PropStructSeq props;

      ServiceTypeNameSeq super_types;

      ::CORBA::Boolean masked;

      IncarnationNumber incarnation;

    

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

    typedef TypeStruct::_var_type TypeStruct_var;

    typedef _CORBA_ConstrType_Variable_OUT_arg< TypeStruct,TypeStruct_var > TypeStruct_out;

    static _dyn_attr const ::CORBA::TypeCode_ptr _tc_TypeStruct;

    enum ListOption { all, since /*, __max_ListOption=0xffffffff */ };
    typedef ListOption& ListOption_out;

    static _dyn_attr const ::CORBA::TypeCode_ptr _tc_ListOption;

    class SpecifiedServiceTypes {
    public:

      typedef _CORBA_ConstrType_Fix_Var<SpecifiedServiceTypes> _var_type;

      

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

    
      }
      
      SpecifiedServiceTypes(const SpecifiedServiceTypes& _value) {
        _pd__initialised = _value._pd__initialised;
        if ((_pd__default = _value._pd__default)) {
          
        }
        else {
          switch(_value._pd__d) {
            case since: incarnation(_value._pd_incarnation); break;

              default: break;

        
          }
        }
        _pd__d = _value._pd__d;

    
      }

      ~SpecifiedServiceTypes() {}

      SpecifiedServiceTypes& operator=(const SpecifiedServiceTypes& _value) {
        _pd__initialised = _value._pd__initialised;
        if ((_pd__default = _value._pd__default)) {
          
        }
        else {
          switch(_value._pd__d) {
            case since: incarnation(_value._pd_incarnation); break;

              default: break;

        
          }
        }
        _pd__d = _value._pd__d;

    
        return *this;
      }

      ListOption _d() const { return _pd__d;}
      void _d(ListOption _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 since: goto fail;
          default:
          switch (_value){
            case since: 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 = all;
        _pd__default = 1;
      }

    

      const IncarnationNumber &incarnation () const { return _pd_incarnation; }
      IncarnationNumber &incarnation () { return _pd_incarnation; }
      void incarnation (const IncarnationNumber& _value) {
        _pd__initialised = 1;
        _pd__d = since;
        _pd__default = 0;
        _pd_incarnation = _value;
      }

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

    private:
      ListOption _pd__d;
      _CORBA_Boolean _pd__default;
      _CORBA_Boolean _pd__initialised;

      
      IncarnationNumber _pd_incarnation;

    
    };

    typedef SpecifiedServiceTypes::_var_type SpecifiedServiceTypes_var;

    typedef SpecifiedServiceTypes& SpecifiedServiceTypes_out;

    static _dyn_attr const ::CORBA::TypeCode_ptr _tc_SpecifiedServiceTypes;

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

    

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

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

      ::CORBA::String_member base_if;

      ::CORBA::String_member derived_service;

      ::CORBA::String_member derived_if;

    

      inline InterfaceTypeMismatch() {
        pd_insertToAnyFn    = insertToAnyFn;
        pd_insertToAnyFnNCP = insertToAnyFnNCP;
      }
      InterfaceTypeMismatch(const InterfaceTypeMismatch&);
      InterfaceTypeMismatch(const char* i_base_service, const char* i_base_if, const char* i_derived_service, const char* i_derived_if);
      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 HasSubTypes : public ::CORBA::UserException {
    public:
      
      ::CORBA::String_member the_type;

      ::CORBA::String_member sub_type;

    

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

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

    

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

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

    

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

    class ValueTypeRedefinition : public ::CORBA::UserException {
    public:
      
      ::CORBA::String_member type_1;

      PropStruct definition_1;

      ::CORBA::String_member type_2;

      PropStruct definition_2;

    

      inline ValueTypeRedefinition() {
        pd_insertToAnyFn    = insertToAnyFn;
        pd_insertToAnyFnNCP = insertToAnyFnNCP;
      }
      ValueTypeRedefinition(const ValueTypeRedefinition&);
      ValueTypeRedefinition(const char* i_type_1, const PropStruct& i_definition_1, const char* i_type_2, const PropStruct& i_definition_2);
      ValueTypeRedefinition& operator=(const ValueTypeRedefinition&);
      virtual ~ValueTypeRedefinition();
      virtual void _raise() const;
      static ValueTypeRedefinition* _downcast(::CORBA::Exception*);
      static const ValueTypeRedefinition* _downcast(const ::CORBA::Exception*);
      static inline ValueTypeRedefinition* _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_ValueTypeRedefinition;

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

    

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

  
  };

  class _objref_ServiceTypeRepository :
    public virtual ::CORBA::Object,
    public virtual omniObjRef
  {
  public:
    ServiceTypeRepository::IncarnationNumber add_type(const char* name, const char* if_name, const ::CosTradingRepos::ServiceTypeRepository::PropStructSeq& props, const ::CosTradingRepos::ServiceTypeRepository::ServiceTypeNameSeq& super_types);
    void remove_type(const char* name);
    ServiceTypeRepository::ServiceTypeNameSeq* list_types(const ::CosTradingRepos::ServiceTypeRepository::SpecifiedServiceTypes& which_types);
    ServiceTypeRepository::TypeStruct* describe_type(const char* name);
    ServiceTypeRepository::TypeStruct* fully_describe_type(const char* name);
    void mask_type(const char* name);
    void unmask_type(const char* name);
    ServiceTypeRepository::IncarnationNumber incarnation();

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

  protected:
    virtual ~_objref_ServiceTypeRepository();

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

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

    friend class ServiceTypeRepository;
  };

  class _pof_ServiceTypeRepository : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_ServiceTypeRepository() : _OMNI_NS(proxyObjectFactory)(ServiceTypeRepository::_PD_repoId) {}
    virtual ~_pof_ServiceTypeRepository();

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

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

    virtual ServiceTypeRepository::IncarnationNumber add_type(const char* name, const char* if_name, const ::CosTradingRepos::ServiceTypeRepository::PropStructSeq& props, const ::CosTradingRepos::ServiceTypeRepository::ServiceTypeNameSeq& super_types) = 0;
    virtual void remove_type(const char* name) = 0;
    virtual ServiceTypeRepository::ServiceTypeNameSeq* list_types(const ::CosTradingRepos::ServiceTypeRepository::SpecifiedServiceTypes& which_types) = 0;
    virtual ServiceTypeRepository::TypeStruct* describe_type(const char* name) = 0;
    virtual ServiceTypeRepository::TypeStruct* fully_describe_type(const char* name) = 0;
    virtual void mask_type(const char* name) = 0;
    virtual void unmask_type(const char* name) = 0;
    virtual ServiceTypeRepository::IncarnationNumber incarnation() = 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_ServiceTypeRepository;

_CORBA_MODULE_END



_CORBA_MODULE POA_CosTradingRepos
_CORBA_MODULE_BEG

  class ServiceTypeRepository :
    public virtual CosTradingRepos::_impl_ServiceTypeRepository,
    public virtual ::PortableServer::ServantBase
  {
  public:
    virtual ~ServiceTypeRepository();

    inline ::CosTradingRepos::ServiceTypeRepository_ptr _this() {
      return (::CosTradingRepos::ServiceTypeRepository_ptr) _do_this(::CosTradingRepos::ServiceTypeRepository::_PD_repoId);
    }
  };

_CORBA_MODULE_END



_CORBA_MODULE OBV_CosTradingRepos
_CORBA_MODULE_BEG

_CORBA_MODULE_END





#undef _core_attr
#undef _dyn_attr

void operator<<=(::CORBA::Any& _a, const CosTradingRepos::ServiceTypeRepository::ServiceTypeNameSeq& _s);
void operator<<=(::CORBA::Any& _a, CosTradingRepos::ServiceTypeRepository::ServiceTypeNameSeq* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, CosTradingRepos::ServiceTypeRepository::ServiceTypeNameSeq*& _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const CosTradingRepos::ServiceTypeRepository::ServiceTypeNameSeq*& _sp);

inline void operator >>=(CosTradingRepos::ServiceTypeRepository::PropertyMode _e, cdrStream& s) {
  ::operator>>=((::CORBA::ULong)_e, s);
}

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

void operator<<=(::CORBA::Any& _a, CosTradingRepos::ServiceTypeRepository::PropertyMode _s);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, CosTradingRepos::ServiceTypeRepository::PropertyMode& _s);

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

void operator<<=(::CORBA::Any& _a, const CosTradingRepos::ServiceTypeRepository::PropStructSeq& _s);
void operator<<=(::CORBA::Any& _a, CosTradingRepos::ServiceTypeRepository::PropStructSeq* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, CosTradingRepos::ServiceTypeRepository::PropStructSeq*& _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const CosTradingRepos::ServiceTypeRepository::PropStructSeq*& _sp);

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

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

inline void operator >>=(CosTradingRepos::ServiceTypeRepository::ListOption _e, cdrStream& s) {
  ::operator>>=((::CORBA::ULong)_e, s);
}

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

void operator<<=(::CORBA::Any& _a, CosTradingRepos::ServiceTypeRepository::ListOption _s);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, CosTradingRepos::ServiceTypeRepository::ListOption& _s);

void operator<<=(::CORBA::Any& _a, const CosTradingRepos::ServiceTypeRepository::SpecifiedServiceTypes& _s);
void operator<<=(::CORBA::Any& _a, CosTradingRepos::ServiceTypeRepository::SpecifiedServiceTypes* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const CosTradingRepos::ServiceTypeRepository::SpecifiedServiceTypes*& _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, CosTradingRepos::ServiceTypeRepository::SpecifiedServiceTypes*& _sp);

void operator<<=(::CORBA::Any& _a, const CosTradingRepos::ServiceTypeRepository::ServiceTypeExists& _s);
void operator<<=(::CORBA::Any& _a, const CosTradingRepos::ServiceTypeRepository::ServiceTypeExists* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const CosTradingRepos::ServiceTypeRepository::ServiceTypeExists*& _sp);

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

void operator<<=(::CORBA::Any& _a, const CosTradingRepos::ServiceTypeRepository::HasSubTypes& _s);
void operator<<=(::CORBA::Any& _a, const CosTradingRepos::ServiceTypeRepository::HasSubTypes* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const CosTradingRepos::ServiceTypeRepository::HasSubTypes*& _sp);

void operator<<=(::CORBA::Any& _a, const CosTradingRepos::ServiceTypeRepository::AlreadyMasked& _s);
void operator<<=(::CORBA::Any& _a, const CosTradingRepos::ServiceTypeRepository::AlreadyMasked* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const CosTradingRepos::ServiceTypeRepository::AlreadyMasked*& _sp);

void operator<<=(::CORBA::Any& _a, const CosTradingRepos::ServiceTypeRepository::NotMasked& _s);
void operator<<=(::CORBA::Any& _a, const CosTradingRepos::ServiceTypeRepository::NotMasked* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const CosTradingRepos::ServiceTypeRepository::NotMasked*& _sp);

void operator<<=(::CORBA::Any& _a, const CosTradingRepos::ServiceTypeRepository::ValueTypeRedefinition& _s);
void operator<<=(::CORBA::Any& _a, const CosTradingRepos::ServiceTypeRepository::ValueTypeRedefinition* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const CosTradingRepos::ServiceTypeRepository::ValueTypeRedefinition*& _sp);

void operator<<=(::CORBA::Any& _a, const CosTradingRepos::ServiceTypeRepository::DuplicateServiceTypeName& _s);
void operator<<=(::CORBA::Any& _a, const CosTradingRepos::ServiceTypeRepository::DuplicateServiceTypeName* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const CosTradingRepos::ServiceTypeRepository::DuplicateServiceTypeName*& _sp);

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



inline void
CosTradingRepos::ServiceTypeRepository::_marshalObjRef(::CosTradingRepos::ServiceTypeRepository_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}




#ifdef   USE_stub_in_nt_dll_NOT_DEFINED_CosTradingRepos
# undef  USE_stub_in_nt_dll
# undef  USE_stub_in_nt_dll_NOT_DEFINED_CosTradingRepos
#endif
#ifdef   USE_core_stub_in_nt_dll_NOT_DEFINED_CosTradingRepos
# undef  USE_core_stub_in_nt_dll
# undef  USE_core_stub_in_nt_dll_NOT_DEFINED_CosTradingRepos
#endif
#ifdef   USE_dyn_stub_in_nt_dll_NOT_DEFINED_CosTradingRepos
# undef  USE_dyn_stub_in_nt_dll
# undef  USE_dyn_stub_in_nt_dll_NOT_DEFINED_CosTradingRepos
#endif

#endif  // __CosTradingRepos_hh__