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

// This file is generated by omniidl (C++ backend)- omniORB_4_1. Do not edit.
#ifndef __CosPropertyService_hh__
#define __CosPropertyService_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_CosPropertyService
#endif
#ifndef  USE_core_stub_in_nt_dll
# define USE_core_stub_in_nt_dll_NOT_DEFINED_CosPropertyService
#endif
#ifndef  USE_dyn_stub_in_nt_dll
# define USE_dyn_stub_in_nt_dll_NOT_DEFINED_CosPropertyService
#endif


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



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

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

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





_CORBA_MODULE CosPropertyService

_CORBA_MODULE_BEG

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

  struct Property {
    typedef _CORBA_ConstrType_Variable_Var<Property> _var_type;

    
    ::CORBA::String_member property_name;

    ::CORBA::Any property_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;

  enum PropertyModeType { normal, read_only, fixed_normal, fixed_readonly, undefined /*, __max_PropertyModeType=0xffffffff */ };
  typedef PropertyModeType& PropertyModeType_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_PropertyModeType;

  struct PropertyDef {
    typedef _CORBA_ConstrType_Variable_Var<PropertyDef> _var_type;

    
    ::CORBA::String_member property_name;

    ::CORBA::Any property_value;

    PropertyModeType property_mode;

  

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

  typedef PropertyDef::_var_type PropertyDef_var;

  typedef _CORBA_ConstrType_Variable_OUT_arg< PropertyDef,PropertyDef_var > PropertyDef_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_PropertyDef;

  struct PropertyMode {
    typedef _CORBA_ConstrType_Variable_Var<PropertyMode> _var_type;

    
    ::CORBA::String_member property_name;

    PropertyModeType property_mode;

  

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

  typedef PropertyMode::_var_type PropertyMode_var;

  typedef _CORBA_ConstrType_Variable_OUT_arg< PropertyMode,PropertyMode_var > PropertyMode_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_PropertyMode;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_PropertyNames;

  class PropertyNames_var;

  class PropertyNames : public _CORBA_Unbounded_Sequence_String {
  public:
    typedef PropertyNames_var _var_type;
    inline PropertyNames() {}
    inline PropertyNames(const PropertyNames& _s)
      : _CORBA_Unbounded_Sequence_String(_s) {}

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

  

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

  class PropertyNames_out;

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

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

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

  

    PropertyNames*& _data;

  private:
    PropertyNames_out();
    PropertyNames_out& operator=(const PropertyNames_var&);
  };

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_Properties;

  class Properties_var;

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

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

  

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

  class Properties_out;

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

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

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

  

    Properties*& _data;

  private:
    Properties_out();
    Properties_out& operator=(const Properties_var&);
  };

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_PropertyDefs;

  class PropertyDefs_var;

  class PropertyDefs : public _CORBA_Unbounded_Sequence< PropertyDef >  {
  public:
    typedef PropertyDefs_var _var_type;
    inline PropertyDefs() {}
    inline PropertyDefs(const PropertyDefs& _s)
      : _CORBA_Unbounded_Sequence< PropertyDef > (_s) {}

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

  

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

  class PropertyDefs_out;

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

  

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

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

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

  

    PropertyDefs*& _data;

  private:
    PropertyDefs_out();
    PropertyDefs_out& operator=(const PropertyDefs_var&);
  };

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_PropertyModes;

  class PropertyModes_var;

  class PropertyModes : public _CORBA_Unbounded_Sequence< PropertyMode >  {
  public:
    typedef PropertyModes_var _var_type;
    inline PropertyModes() {}
    inline PropertyModes(const PropertyModes& _s)
      : _CORBA_Unbounded_Sequence< PropertyMode > (_s) {}

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

  

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

  class PropertyModes_out;

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

  

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

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

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

  

    PropertyModes*& _data;

  private:
    PropertyModes_out();
    PropertyModes_out& operator=(const PropertyModes_var&);
  };

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_PropertyTypes;

  class PropertyTypes_var;

  class PropertyTypes : public _CORBA_Unbounded_Sequence< ::CORBA::TypeCode_member >  {
  public:
    typedef PropertyTypes_var _var_type;
    inline PropertyTypes() {}
    inline PropertyTypes(const PropertyTypes& _s)
      : _CORBA_Unbounded_Sequence< ::CORBA::TypeCode_member > (_s) {}

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

  

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

  class PropertyTypes_out;

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

  

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

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

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

  

    PropertyTypes*& _data;

  private:
    PropertyTypes_out();
    PropertyTypes_out& operator=(const PropertyTypes_var&);
  };

#ifndef __CosPropertyService_mPropertyNamesIterator__
#define __CosPropertyService_mPropertyNamesIterator__

  class PropertyNamesIterator;
  class _objref_PropertyNamesIterator;
  class _impl_PropertyNamesIterator;
  
  typedef _objref_PropertyNamesIterator* PropertyNamesIterator_ptr;
  typedef PropertyNamesIterator_ptr PropertyNamesIteratorRef;

  class PropertyNamesIterator_Helper {
  public:
    typedef PropertyNamesIterator_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_PropertyNamesIterator, PropertyNamesIterator_Helper> PropertyNamesIterator_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_PropertyNamesIterator,PropertyNamesIterator_Helper > PropertyNamesIterator_out;

#endif

#ifndef __CosPropertyService_mPropertiesIterator__
#define __CosPropertyService_mPropertiesIterator__

  class PropertiesIterator;
  class _objref_PropertiesIterator;
  class _impl_PropertiesIterator;
  
  typedef _objref_PropertiesIterator* PropertiesIterator_ptr;
  typedef PropertiesIterator_ptr PropertiesIteratorRef;

  class PropertiesIterator_Helper {
  public:
    typedef PropertiesIterator_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_PropertiesIterator, PropertiesIterator_Helper> PropertiesIterator_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_PropertiesIterator,PropertiesIterator_Helper > PropertiesIterator_out;

#endif

#ifndef __CosPropertyService_mPropertySetFactory__
#define __CosPropertyService_mPropertySetFactory__

  class PropertySetFactory;
  class _objref_PropertySetFactory;
  class _impl_PropertySetFactory;
  
  typedef _objref_PropertySetFactory* PropertySetFactory_ptr;
  typedef PropertySetFactory_ptr PropertySetFactoryRef;

  class PropertySetFactory_Helper {
  public:
    typedef PropertySetFactory_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_PropertySetFactory, PropertySetFactory_Helper> PropertySetFactory_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_PropertySetFactory,PropertySetFactory_Helper > PropertySetFactory_out;

#endif

#ifndef __CosPropertyService_mPropertySetDef__
#define __CosPropertyService_mPropertySetDef__

  class PropertySetDef;
  class _objref_PropertySetDef;
  class _impl_PropertySetDef;
  
  typedef _objref_PropertySetDef* PropertySetDef_ptr;
  typedef PropertySetDef_ptr PropertySetDefRef;

  class PropertySetDef_Helper {
  public:
    typedef PropertySetDef_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_PropertySetDef, PropertySetDef_Helper> PropertySetDef_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_PropertySetDef,PropertySetDef_Helper > PropertySetDef_out;

#endif

#ifndef __CosPropertyService_mPropertySet__
#define __CosPropertyService_mPropertySet__

  class PropertySet;
  class _objref_PropertySet;
  class _impl_PropertySet;
  
  typedef _objref_PropertySet* PropertySet_ptr;
  typedef PropertySet_ptr PropertySetRef;

  class PropertySet_Helper {
  public:
    typedef PropertySet_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_PropertySet, PropertySet_Helper> PropertySet_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_PropertySet,PropertySet_Helper > PropertySet_out;

#endif

  class ConstraintNotSupported : public ::CORBA::UserException {
  public:
    
    

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

  class InvalidPropertyName : public ::CORBA::UserException {
  public:
    
    

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

  class ConflictingProperty : public ::CORBA::UserException {
  public:
    
    

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

  class PropertyNotFound : public ::CORBA::UserException {
  public:
    
    

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

  class UnsupportedTypeCode : public ::CORBA::UserException {
  public:
    
    

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

  class UnsupportedProperty : public ::CORBA::UserException {
  public:
    
    

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

  class UnsupportedMode : public ::CORBA::UserException {
  public:
    
    

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

  class FixedProperty : public ::CORBA::UserException {
  public:
    
    

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

  class ReadOnlyProperty : public ::CORBA::UserException {
  public:
    
    

    inline ReadOnlyProperty() {
      pd_insertToAnyFn    = insertToAnyFn;
      pd_insertToAnyFnNCP = insertToAnyFnNCP;
    }
    ReadOnlyProperty(const ReadOnlyProperty&);
    
    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);
    }
    
    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_ReadOnlyProperty;

  enum ExceptionReason { invalid_property_name, conflicting_property, property_not_found, unsupported_type_code, unsupported_property, unsupported_mode, fixed_property, read_only_property /*, __max_ExceptionReason=0xffffffff */ };
  typedef ExceptionReason& ExceptionReason_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_ExceptionReason;

  struct PropertyException {
    typedef _CORBA_ConstrType_Variable_Var<PropertyException> _var_type;

    
    ExceptionReason reason;

    ::CORBA::String_member failing_property_name;

  

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

  typedef PropertyException::_var_type PropertyException_var;

  typedef _CORBA_ConstrType_Variable_OUT_arg< PropertyException,PropertyException_var > PropertyException_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_PropertyException;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_PropertyExceptions;

  class PropertyExceptions_var;

  class PropertyExceptions : public _CORBA_Unbounded_Sequence< PropertyException >  {
  public:
    typedef PropertyExceptions_var _var_type;
    inline PropertyExceptions() {}
    inline PropertyExceptions(const PropertyExceptions& _s)
      : _CORBA_Unbounded_Sequence< PropertyException > (_s) {}

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

  

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

  class PropertyExceptions_out;

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

  

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

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

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

  

    PropertyExceptions*& _data;

  private:
    PropertyExceptions_out();
    PropertyExceptions_out& operator=(const PropertyExceptions_var&);
  };

  class MultipleExceptions : public ::CORBA::UserException {
  public:
    
    PropertyExceptions exceptions;

  

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

#ifndef __CosPropertyService_mPropertySetFactory__
#define __CosPropertyService_mPropertySetFactory__

  class PropertySetFactory;
  class _objref_PropertySetFactory;
  class _impl_PropertySetFactory;
  
  typedef _objref_PropertySetFactory* PropertySetFactory_ptr;
  typedef PropertySetFactory_ptr PropertySetFactoryRef;

  class PropertySetFactory_Helper {
  public:
    typedef PropertySetFactory_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_PropertySetFactory, PropertySetFactory_Helper> PropertySetFactory_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_PropertySetFactory,PropertySetFactory_Helper > PropertySetFactory_out;

#endif

  // interface PropertySetFactory
  class PropertySetFactory {
  public:
    // Declarations for this interface type.
    typedef PropertySetFactory_ptr _ptr_type;
    typedef PropertySetFactory_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_PropertySetFactory :
    public virtual ::CORBA::Object,
    public virtual omniObjRef
  {
  public:
    PropertySet_ptr create_propertyset();
    PropertySet_ptr create_constrained_propertyset(const ::CosPropertyService::PropertyTypes& allowed_property_types, const ::CosPropertyService::Properties& allowed_properties);
    PropertySet_ptr create_initial_propertyset(const ::CosPropertyService::Properties& initial_properties);

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

  protected:
    virtual ~_objref_PropertySetFactory();

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

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

    friend class PropertySetFactory;
  };

  class _pof_PropertySetFactory : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_PropertySetFactory() : _OMNI_NS(proxyObjectFactory)(PropertySetFactory::_PD_repoId) {}
    virtual ~_pof_PropertySetFactory();

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

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

    virtual PropertySet_ptr create_propertyset() = 0;
    virtual PropertySet_ptr create_constrained_propertyset(const ::CosPropertyService::PropertyTypes& allowed_property_types, const ::CosPropertyService::Properties& allowed_properties) = 0;
    virtual PropertySet_ptr create_initial_propertyset(const ::CosPropertyService::Properties& initial_properties) = 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_PropertySetFactory;

#ifndef __CosPropertyService_mPropertySetDefFactory__
#define __CosPropertyService_mPropertySetDefFactory__

  class PropertySetDefFactory;
  class _objref_PropertySetDefFactory;
  class _impl_PropertySetDefFactory;
  
  typedef _objref_PropertySetDefFactory* PropertySetDefFactory_ptr;
  typedef PropertySetDefFactory_ptr PropertySetDefFactoryRef;

  class PropertySetDefFactory_Helper {
  public:
    typedef PropertySetDefFactory_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_PropertySetDefFactory, PropertySetDefFactory_Helper> PropertySetDefFactory_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_PropertySetDefFactory,PropertySetDefFactory_Helper > PropertySetDefFactory_out;

#endif

  // interface PropertySetDefFactory
  class PropertySetDefFactory {
  public:
    // Declarations for this interface type.
    typedef PropertySetDefFactory_ptr _ptr_type;
    typedef PropertySetDefFactory_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_PropertySetDefFactory :
    public virtual ::CORBA::Object,
    public virtual omniObjRef
  {
  public:
    PropertySetDef_ptr create_propertysetdef();
    PropertySetDef_ptr create_constrained_propertysetdef(const ::CosPropertyService::PropertyTypes& allowed_property_types, const ::CosPropertyService::PropertyDefs& allowed_property_defs);
    PropertySetDef_ptr create_initial_propertysetdef(const ::CosPropertyService::PropertyDefs& initial_property_defs);

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

  protected:
    virtual ~_objref_PropertySetDefFactory();

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

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

    friend class PropertySetDefFactory;
  };

  class _pof_PropertySetDefFactory : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_PropertySetDefFactory() : _OMNI_NS(proxyObjectFactory)(PropertySetDefFactory::_PD_repoId) {}
    virtual ~_pof_PropertySetDefFactory();

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

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

    virtual PropertySetDef_ptr create_propertysetdef() = 0;
    virtual PropertySetDef_ptr create_constrained_propertysetdef(const ::CosPropertyService::PropertyTypes& allowed_property_types, const ::CosPropertyService::PropertyDefs& allowed_property_defs) = 0;
    virtual PropertySetDef_ptr create_initial_propertysetdef(const ::CosPropertyService::PropertyDefs& initial_property_defs) = 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_PropertySetDefFactory;

#ifndef __CosPropertyService_mPropertySet__
#define __CosPropertyService_mPropertySet__

  class PropertySet;
  class _objref_PropertySet;
  class _impl_PropertySet;
  
  typedef _objref_PropertySet* PropertySet_ptr;
  typedef PropertySet_ptr PropertySetRef;

  class PropertySet_Helper {
  public:
    typedef PropertySet_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_PropertySet, PropertySet_Helper> PropertySet_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_PropertySet,PropertySet_Helper > PropertySet_out;

#endif

  // interface PropertySet
  class PropertySet {
  public:
    // Declarations for this interface type.
    typedef PropertySet_ptr _ptr_type;
    typedef PropertySet_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_PropertySet :
    public virtual ::CORBA::Object,
    public virtual omniObjRef
  {
  public:
    void define_property(const char* property_name, const ::CORBA::Any& property_value);
    void define_properties(const ::CosPropertyService::Properties& nproperties);
    ::CORBA::ULong get_number_of_properties();
    void get_all_property_names(::CORBA::ULong how_many, ::CosPropertyService::PropertyNames_out property_names, ::CosPropertyService::PropertyNamesIterator_out rest);
    ::CORBA::Any* get_property_value(const char* property_name);
    ::CORBA::Boolean get_properties(const ::CosPropertyService::PropertyNames& property_names, ::CosPropertyService::Properties_out nproperties);
    void get_all_properties(::CORBA::ULong how_many, ::CosPropertyService::Properties_out nproperties, ::CosPropertyService::PropertiesIterator_out rest);
    void delete_property(const char* property_name);
    void delete_properties(const ::CosPropertyService::PropertyNames& property_names);
    ::CORBA::Boolean delete_all_properties();
    ::CORBA::Boolean is_property_defined(const char* property_name);

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

  protected:
    virtual ~_objref_PropertySet();

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

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

    friend class PropertySet;
  };

  class _pof_PropertySet : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_PropertySet() : _OMNI_NS(proxyObjectFactory)(PropertySet::_PD_repoId) {}
    virtual ~_pof_PropertySet();

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

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

    virtual void define_property(const char* property_name, const ::CORBA::Any& property_value) = 0;
    virtual void define_properties(const ::CosPropertyService::Properties& nproperties) = 0;
    virtual ::CORBA::ULong get_number_of_properties() = 0;
    virtual void get_all_property_names(::CORBA::ULong how_many, ::CosPropertyService::PropertyNames_out property_names, ::CosPropertyService::PropertyNamesIterator_out rest) = 0;
    virtual ::CORBA::Any* get_property_value(const char* property_name) = 0;
    virtual ::CORBA::Boolean get_properties(const ::CosPropertyService::PropertyNames& property_names, ::CosPropertyService::Properties_out nproperties) = 0;
    virtual void get_all_properties(::CORBA::ULong how_many, ::CosPropertyService::Properties_out nproperties, ::CosPropertyService::PropertiesIterator_out rest) = 0;
    virtual void delete_property(const char* property_name) = 0;
    virtual void delete_properties(const ::CosPropertyService::PropertyNames& property_names) = 0;
    virtual ::CORBA::Boolean delete_all_properties() = 0;
    virtual ::CORBA::Boolean is_property_defined(const char* property_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_PropertySet;

#ifndef __CosPropertyService_mPropertySetDef__
#define __CosPropertyService_mPropertySetDef__

  class PropertySetDef;
  class _objref_PropertySetDef;
  class _impl_PropertySetDef;
  
  typedef _objref_PropertySetDef* PropertySetDef_ptr;
  typedef PropertySetDef_ptr PropertySetDefRef;

  class PropertySetDef_Helper {
  public:
    typedef PropertySetDef_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_PropertySetDef, PropertySetDef_Helper> PropertySetDef_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_PropertySetDef,PropertySetDef_Helper > PropertySetDef_out;

#endif

  // interface PropertySetDef
  class PropertySetDef {
  public:
    // Declarations for this interface type.
    typedef PropertySetDef_ptr _ptr_type;
    typedef PropertySetDef_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_PropertySetDef :
    public virtual _objref_PropertySet
  {
  public:
    void get_allowed_property_types(::CosPropertyService::PropertyTypes_out property_types);
    void get_allowed_properties(::CosPropertyService::PropertyDefs_out property_defs);
    void define_property_with_mode(const char* property_name, const ::CORBA::Any& property_value, ::CosPropertyService::PropertyModeType property_mode);
    void define_properties_with_modes(const ::CosPropertyService::PropertyDefs& property_defs);
    PropertyModeType get_property_mode(const char* property_name);
    ::CORBA::Boolean get_property_modes(const ::CosPropertyService::PropertyNames& property_names, ::CosPropertyService::PropertyModes_out property_modes);
    void set_property_mode(const char* property_name, ::CosPropertyService::PropertyModeType property_mode);
    void set_property_modes(const ::CosPropertyService::PropertyModes& property_modes);

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

  protected:
    virtual ~_objref_PropertySetDef();

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

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

    friend class PropertySetDef;
  };

  class _pof_PropertySetDef : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_PropertySetDef() : _OMNI_NS(proxyObjectFactory)(PropertySetDef::_PD_repoId) {}
    virtual ~_pof_PropertySetDef();

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

  class _impl_PropertySetDef :
    public virtual _impl_PropertySet
  {
  public:
    virtual ~_impl_PropertySetDef();

    virtual void get_allowed_property_types(::CosPropertyService::PropertyTypes_out property_types) = 0;
    virtual void get_allowed_properties(::CosPropertyService::PropertyDefs_out property_defs) = 0;
    virtual void define_property_with_mode(const char* property_name, const ::CORBA::Any& property_value, ::CosPropertyService::PropertyModeType property_mode) = 0;
    virtual void define_properties_with_modes(const ::CosPropertyService::PropertyDefs& property_defs) = 0;
    virtual PropertyModeType get_property_mode(const char* property_name) = 0;
    virtual ::CORBA::Boolean get_property_modes(const ::CosPropertyService::PropertyNames& property_names, ::CosPropertyService::PropertyModes_out property_modes) = 0;
    virtual void set_property_mode(const char* property_name, ::CosPropertyService::PropertyModeType property_mode) = 0;
    virtual void set_property_modes(const ::CosPropertyService::PropertyModes& property_modes) = 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_PropertySetDef;

#ifndef __CosPropertyService_mPropertyNamesIterator__
#define __CosPropertyService_mPropertyNamesIterator__

  class PropertyNamesIterator;
  class _objref_PropertyNamesIterator;
  class _impl_PropertyNamesIterator;
  
  typedef _objref_PropertyNamesIterator* PropertyNamesIterator_ptr;
  typedef PropertyNamesIterator_ptr PropertyNamesIteratorRef;

  class PropertyNamesIterator_Helper {
  public:
    typedef PropertyNamesIterator_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_PropertyNamesIterator, PropertyNamesIterator_Helper> PropertyNamesIterator_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_PropertyNamesIterator,PropertyNamesIterator_Helper > PropertyNamesIterator_out;

#endif

  // interface PropertyNamesIterator
  class PropertyNamesIterator {
  public:
    // Declarations for this interface type.
    typedef PropertyNamesIterator_ptr _ptr_type;
    typedef PropertyNamesIterator_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_PropertyNamesIterator :
    public virtual ::CORBA::Object,
    public virtual omniObjRef
  {
  public:
    void reset();
    ::CORBA::Boolean next_one(::CosPropertyService::PropertyName_out property_name);
    ::CORBA::Boolean next_n(::CORBA::ULong how_many, ::CosPropertyService::PropertyNames_out property_names);
    void destroy();

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

  protected:
    virtual ~_objref_PropertyNamesIterator();

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

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

    friend class PropertyNamesIterator;
  };

  class _pof_PropertyNamesIterator : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_PropertyNamesIterator() : _OMNI_NS(proxyObjectFactory)(PropertyNamesIterator::_PD_repoId) {}
    virtual ~_pof_PropertyNamesIterator();

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

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

    virtual void reset() = 0;
    virtual ::CORBA::Boolean next_one(::CosPropertyService::PropertyName_out property_name) = 0;
    virtual ::CORBA::Boolean next_n(::CORBA::ULong how_many, ::CosPropertyService::PropertyNames_out property_names) = 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_PropertyNamesIterator;

#ifndef __CosPropertyService_mPropertiesIterator__
#define __CosPropertyService_mPropertiesIterator__

  class PropertiesIterator;
  class _objref_PropertiesIterator;
  class _impl_PropertiesIterator;
  
  typedef _objref_PropertiesIterator* PropertiesIterator_ptr;
  typedef PropertiesIterator_ptr PropertiesIteratorRef;

  class PropertiesIterator_Helper {
  public:
    typedef PropertiesIterator_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_PropertiesIterator, PropertiesIterator_Helper> PropertiesIterator_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_PropertiesIterator,PropertiesIterator_Helper > PropertiesIterator_out;

#endif

  // interface PropertiesIterator
  class PropertiesIterator {
  public:
    // Declarations for this interface type.
    typedef PropertiesIterator_ptr _ptr_type;
    typedef PropertiesIterator_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_PropertiesIterator :
    public virtual ::CORBA::Object,
    public virtual omniObjRef
  {
  public:
    void reset();
    ::CORBA::Boolean next_one(::CosPropertyService::Property_out aproperty);
    ::CORBA::Boolean next_n(::CORBA::ULong how_many, ::CosPropertyService::Properties_out nproperties);
    void destroy();

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

  protected:
    virtual ~_objref_PropertiesIterator();

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

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

    friend class PropertiesIterator;
  };

  class _pof_PropertiesIterator : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_PropertiesIterator() : _OMNI_NS(proxyObjectFactory)(PropertiesIterator::_PD_repoId) {}
    virtual ~_pof_PropertiesIterator();

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

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

    virtual void reset() = 0;
    virtual ::CORBA::Boolean next_one(::CosPropertyService::Property_out aproperty) = 0;
    virtual ::CORBA::Boolean next_n(::CORBA::ULong how_many, ::CosPropertyService::Properties_out nproperties) = 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_PropertiesIterator;

_CORBA_MODULE_END



_CORBA_MODULE POA_CosPropertyService
_CORBA_MODULE_BEG

  class PropertySetFactory :
    public virtual CosPropertyService::_impl_PropertySetFactory,
    public virtual ::PortableServer::ServantBase
  {
  public:
    virtual ~PropertySetFactory();

    inline ::CosPropertyService::PropertySetFactory_ptr _this() {
      return (::CosPropertyService::PropertySetFactory_ptr) _do_this(::CosPropertyService::PropertySetFactory::_PD_repoId);
    }
  };

  class PropertySetDefFactory :
    public virtual CosPropertyService::_impl_PropertySetDefFactory,
    public virtual ::PortableServer::ServantBase
  {
  public:
    virtual ~PropertySetDefFactory();

    inline ::CosPropertyService::PropertySetDefFactory_ptr _this() {
      return (::CosPropertyService::PropertySetDefFactory_ptr) _do_this(::CosPropertyService::PropertySetDefFactory::_PD_repoId);
    }
  };

  class PropertySet :
    public virtual CosPropertyService::_impl_PropertySet,
    public virtual ::PortableServer::ServantBase
  {
  public:
    virtual ~PropertySet();

    inline ::CosPropertyService::PropertySet_ptr _this() {
      return (::CosPropertyService::PropertySet_ptr) _do_this(::CosPropertyService::PropertySet::_PD_repoId);
    }
  };

  class PropertySetDef :
    public virtual CosPropertyService::_impl_PropertySetDef,
    public virtual PropertySet
  {
  public:
    virtual ~PropertySetDef();

    inline ::CosPropertyService::PropertySetDef_ptr _this() {
      return (::CosPropertyService::PropertySetDef_ptr) _do_this(::CosPropertyService::PropertySetDef::_PD_repoId);
    }
  };

  class PropertyNamesIterator :
    public virtual CosPropertyService::_impl_PropertyNamesIterator,
    public virtual ::PortableServer::ServantBase
  {
  public:
    virtual ~PropertyNamesIterator();

    inline ::CosPropertyService::PropertyNamesIterator_ptr _this() {
      return (::CosPropertyService::PropertyNamesIterator_ptr) _do_this(::CosPropertyService::PropertyNamesIterator::_PD_repoId);
    }
  };

  class PropertiesIterator :
    public virtual CosPropertyService::_impl_PropertiesIterator,
    public virtual ::PortableServer::ServantBase
  {
  public:
    virtual ~PropertiesIterator();

    inline ::CosPropertyService::PropertiesIterator_ptr _this() {
      return (::CosPropertyService::PropertiesIterator_ptr) _do_this(::CosPropertyService::PropertiesIterator::_PD_repoId);
    }
  };

_CORBA_MODULE_END



_CORBA_MODULE OBV_CosPropertyService
_CORBA_MODULE_BEG

_CORBA_MODULE_END





#undef _core_attr
#undef _dyn_attr

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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



inline void
CosPropertyService::PropertySetFactory::_marshalObjRef(::CosPropertyService::PropertySetFactory_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosPropertyService::PropertySetDefFactory::_marshalObjRef(::CosPropertyService::PropertySetDefFactory_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosPropertyService::PropertySet::_marshalObjRef(::CosPropertyService::PropertySet_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosPropertyService::PropertySetDef::_marshalObjRef(::CosPropertyService::PropertySetDef_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosPropertyService::PropertyNamesIterator::_marshalObjRef(::CosPropertyService::PropertyNamesIterator_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosPropertyService::PropertiesIterator::_marshalObjRef(::CosPropertyService::PropertiesIterator_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}




#ifdef   USE_stub_in_nt_dll_NOT_DEFINED_CosPropertyService
# undef  USE_stub_in_nt_dll
# undef  USE_stub_in_nt_dll_NOT_DEFINED_CosPropertyService
#endif
#ifdef   USE_core_stub_in_nt_dll_NOT_DEFINED_CosPropertyService
# undef  USE_core_stub_in_nt_dll
# undef  USE_core_stub_in_nt_dll_NOT_DEFINED_CosPropertyService
#endif
#ifdef   USE_dyn_stub_in_nt_dll_NOT_DEFINED_CosPropertyService
# undef  USE_dyn_stub_in_nt_dll
# undef  USE_dyn_stub_in_nt_dll_NOT_DEFINED_CosPropertyService
#endif

#endif  // __CosPropertyService_hh__