/*
 *  MICO --- an Open Source CORBA implementation
 *  Copyright (c) 1997-2001 by The Mico Team
 *
 *  This file was automatically generated. DO NOT EDIT!
 */

#include <CORBA.h>
#include <mico/throw.h>

#ifndef __PROPERTYSERVICE_H__
#define __PROPERTYSERVICE_H__





namespace PropertyService {


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

MICO_EXPORT_TYPEVAR_DECL CORBA::TypeCodeConst _tc_PropertyName;

struct Property;
typedef TVarVar<Property> Property_var;
typedef TVarOut<Property> Property_out;


struct Property {
  #ifdef HAVE_TYPEDEF_OVERLOAD
  typedef Property_var _var_type;
  #endif
  #ifdef HAVE_EXPLICIT_STRUCT_OPS
  Property();
  ~Property();
  Property( const Property& s );
  Property& operator=( const Property& s );
  #endif //HAVE_EXPLICIT_STRUCT_OPS

  PropertyName_var property_name;
  CORBA::Any property_value;
};

MICO_EXPORT_TYPEVAR_DECL CORBA::TypeCodeConst _tc_Property;

enum PropertyModeType {
  normal = 0,
  read_only,
  fixed_normal,
  fixed_readonly,
  undefined
};

typedef PropertyModeType& PropertyModeType_out;

MICO_EXPORT_TYPEVAR_DECL CORBA::TypeCodeConst _tc_PropertyModeType;

struct PropertyDef;
typedef TVarVar<PropertyDef> PropertyDef_var;
typedef TVarOut<PropertyDef> PropertyDef_out;


struct PropertyDef {
  #ifdef HAVE_TYPEDEF_OVERLOAD
  typedef PropertyDef_var _var_type;
  #endif
  #ifdef HAVE_EXPLICIT_STRUCT_OPS
  PropertyDef();
  ~PropertyDef();
  PropertyDef( const PropertyDef& s );
  PropertyDef& operator=( const PropertyDef& s );
  #endif //HAVE_EXPLICIT_STRUCT_OPS

  PropertyName_var property_name;
  CORBA::Any property_value;
  PropertyModeType property_mode;
};

MICO_EXPORT_TYPEVAR_DECL CORBA::TypeCodeConst _tc_PropertyDef;

struct PropertyMode;
typedef TVarVar<PropertyMode> PropertyMode_var;
typedef TVarOut<PropertyMode> PropertyMode_out;


struct PropertyMode {
  #ifdef HAVE_TYPEDEF_OVERLOAD
  typedef PropertyMode_var _var_type;
  #endif
  #ifdef HAVE_EXPLICIT_STRUCT_OPS
  PropertyMode();
  ~PropertyMode();
  PropertyMode( const PropertyMode& s );
  PropertyMode& operator=( const PropertyMode& s );
  #endif //HAVE_EXPLICIT_STRUCT_OPS

  PropertyName_var property_name;
  PropertyModeType property_mode;
};

MICO_EXPORT_TYPEVAR_DECL CORBA::TypeCodeConst _tc_PropertyMode;

typedef StringSequenceTmpl<CORBA::String_var> PropertyNames;
#ifdef _WINDOWS
static PropertyNames _dummy_PropertyNames;
#endif
typedef TSeqVar<StringSequenceTmpl<CORBA::String_var> > PropertyNames_var;
typedef TSeqOut<StringSequenceTmpl<CORBA::String_var> > PropertyNames_out;

MICO_EXPORT_TYPEVAR_DECL CORBA::TypeCodeConst _tc_PropertyNames;

typedef SequenceTmpl<Property,MICO_TID_DEF> Properties;
#ifdef _WINDOWS
static Properties _dummy_Properties;
#endif
typedef TSeqVar<SequenceTmpl<Property,MICO_TID_DEF> > Properties_var;
typedef TSeqOut<SequenceTmpl<Property,MICO_TID_DEF> > Properties_out;

MICO_EXPORT_TYPEVAR_DECL CORBA::TypeCodeConst _tc_Properties;

typedef SequenceTmpl<PropertyDef,MICO_TID_DEF> PropertyDefs;
#ifdef _WINDOWS
static PropertyDefs _dummy_PropertyDefs;
#endif
typedef TSeqVar<SequenceTmpl<PropertyDef,MICO_TID_DEF> > PropertyDefs_var;
typedef TSeqOut<SequenceTmpl<PropertyDef,MICO_TID_DEF> > PropertyDefs_out;

MICO_EXPORT_TYPEVAR_DECL CORBA::TypeCodeConst _tc_PropertyDefs;

typedef SequenceTmpl<PropertyMode,MICO_TID_DEF> PropertyModes;
#ifdef _WINDOWS
static PropertyModes _dummy_PropertyModes;
#endif
typedef TSeqVar<SequenceTmpl<PropertyMode,MICO_TID_DEF> > PropertyModes_var;
typedef TSeqOut<SequenceTmpl<PropertyMode,MICO_TID_DEF> > PropertyModes_out;

MICO_EXPORT_TYPEVAR_DECL CORBA::TypeCodeConst _tc_PropertyModes;

typedef SequenceTmpl<CORBA::TypeCode_var,MICO_TID_DEF> PropertyTypes;
#ifdef _WINDOWS
static PropertyTypes _dummy_PropertyTypes;
#endif
typedef TSeqVar<SequenceTmpl<CORBA::TypeCode_var,MICO_TID_DEF> > PropertyTypes_var;
typedef TSeqOut<SequenceTmpl<CORBA::TypeCode_var,MICO_TID_DEF> > PropertyTypes_out;

MICO_EXPORT_TYPEVAR_DECL CORBA::TypeCodeConst _tc_PropertyTypes;

class PropertyNamesIterator;
typedef PropertyNamesIterator *PropertyNamesIterator_ptr;
typedef PropertyNamesIterator_ptr PropertyNamesIteratorRef;
typedef ObjVar<PropertyNamesIterator> PropertyNamesIterator_var;
typedef ObjOut<PropertyNamesIterator> PropertyNamesIterator_out;


/*
 * Base class and common definitions for interface PropertyNamesIterator
 */

class PropertyNamesIterator : 
  virtual public CORBA::Object
{
  public:
    virtual ~PropertyNamesIterator();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef PropertyNamesIterator_ptr _ptr_type;
    typedef PropertyNamesIterator_var _var_type;
    #endif

    static PropertyNamesIterator_ptr _narrow( CORBA::Object_ptr obj );
    static PropertyNamesIterator_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static PropertyNamesIterator_ptr _duplicate( PropertyNamesIterator_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static PropertyNamesIterator_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual void reset() = 0;
    virtual CORBA::Boolean next_one( CORBA::String_out propery_name ) = 0;
    virtual CORBA::Boolean next_n( CORBA::ULong how_many, PropertyNames_out property_names ) = 0;
    virtual void destroy() = 0;

  protected:
    PropertyNamesIterator() {};
  private:
    PropertyNamesIterator( const PropertyNamesIterator& );
    void operator=( const PropertyNamesIterator& );
};

MICO_EXPORT_TYPEVAR_DECL CORBA::TypeCodeConst _tc_PropertyNamesIterator;

// Stub for interface PropertyNamesIterator
class PropertyNamesIterator_stub:
  virtual public PropertyNamesIterator
{
  public:
    virtual ~PropertyNamesIterator_stub();
    void reset();
    CORBA::Boolean next_one( CORBA::String_out propery_name );
    CORBA::Boolean next_n( CORBA::ULong how_many, PropertyNames_out property_names );
    void destroy();

  private:
    void operator=( const PropertyNamesIterator_stub& );
};

class PropertyNamesIterator_skel :
  virtual public StaticMethodDispatcher,
  virtual public PropertyNamesIterator
{
  public:
    PropertyNamesIterator_skel( const CORBA::BOA::ReferenceData & = CORBA::BOA::ReferenceData() );
    virtual ~PropertyNamesIterator_skel();
    PropertyNamesIterator_skel( CORBA::Object_ptr obj );
    virtual bool dispatch( CORBA::StaticServerRequest_ptr __req, CORBA::Environment &_env );
    PropertyNamesIterator_ptr _this();

};

class PropertiesIterator;
typedef PropertiesIterator *PropertiesIterator_ptr;
typedef PropertiesIterator_ptr PropertiesIteratorRef;
typedef ObjVar<PropertiesIterator> PropertiesIterator_var;
typedef ObjOut<PropertiesIterator> PropertiesIterator_out;


/*
 * Base class and common definitions for interface PropertiesIterator
 */

class PropertiesIterator : 
  virtual public CORBA::Object
{
  public:
    virtual ~PropertiesIterator();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef PropertiesIterator_ptr _ptr_type;
    typedef PropertiesIterator_var _var_type;
    #endif

    static PropertiesIterator_ptr _narrow( CORBA::Object_ptr obj );
    static PropertiesIterator_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static PropertiesIterator_ptr _duplicate( PropertiesIterator_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static PropertiesIterator_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual void reset() = 0;
    virtual CORBA::Boolean next_one( Property_out aproperty ) = 0;
    virtual CORBA::Boolean next_n( CORBA::ULong how_many, Properties_out nproperties ) = 0;
    virtual void destroy() = 0;

  protected:
    PropertiesIterator() {};
  private:
    PropertiesIterator( const PropertiesIterator& );
    void operator=( const PropertiesIterator& );
};

MICO_EXPORT_TYPEVAR_DECL CORBA::TypeCodeConst _tc_PropertiesIterator;

// Stub for interface PropertiesIterator
class PropertiesIterator_stub:
  virtual public PropertiesIterator
{
  public:
    virtual ~PropertiesIterator_stub();
    void reset();
    CORBA::Boolean next_one( Property_out aproperty );
    CORBA::Boolean next_n( CORBA::ULong how_many, Properties_out nproperties );
    void destroy();

  private:
    void operator=( const PropertiesIterator_stub& );
};

class PropertiesIterator_skel :
  virtual public StaticMethodDispatcher,
  virtual public PropertiesIterator
{
  public:
    PropertiesIterator_skel( const CORBA::BOA::ReferenceData & = CORBA::BOA::ReferenceData() );
    virtual ~PropertiesIterator_skel();
    PropertiesIterator_skel( CORBA::Object_ptr obj );
    virtual bool dispatch( CORBA::StaticServerRequest_ptr __req, CORBA::Environment &_env );
    PropertiesIterator_ptr _this();

};

class PropertySet;
typedef PropertySet *PropertySet_ptr;
typedef PropertySet_ptr PropertySetRef;
typedef ObjVar<PropertySet> PropertySet_var;
typedef ObjOut<PropertySet> PropertySet_out;

struct ConstraintNotSupported : public CORBA::UserException {
  #ifdef HAVE_EXPLICIT_STRUCT_OPS
  ConstraintNotSupported();
  ~ConstraintNotSupported();
  ConstraintNotSupported( const ConstraintNotSupported& s );
  ConstraintNotSupported& operator=( const ConstraintNotSupported& s );
  #endif //HAVE_EXPLICIT_STRUCT_OPS


  #ifdef HAVE_STD_EH
  ConstraintNotSupported *operator->() { return this; }
  ConstraintNotSupported& operator*() { return *this; }
  operator ConstraintNotSupported*() { return this; }
  #endif // HAVE_STD_EH

  void _throwit() const;
  const char *_repoid() const;
  void _encode( CORBA::DataEncoder &en ) const;
  void _encode_any( CORBA::Any &a ) const;
  CORBA::Exception *_clone() const;
  static ConstraintNotSupported *_downcast( CORBA::Exception *ex );
  static const ConstraintNotSupported *_downcast( const CORBA::Exception *ex );
};

#ifdef HAVE_STD_EH
typedef ConstraintNotSupported ConstraintNotSupported_catch;
#else
typedef ExceptVar<ConstraintNotSupported> ConstraintNotSupported_var;
typedef TVarOut<ConstraintNotSupported> ConstraintNotSupported_out;
typedef ConstraintNotSupported_var ConstraintNotSupported_catch;
#endif // HAVE_STD_EH

MICO_EXPORT_TYPEVAR_DECL CORBA::TypeCodeConst _tc_ConstraintNotSupported;

struct PropertyException;
typedef TVarVar<PropertyException> PropertyException_var;
typedef TVarOut<PropertyException> PropertyException_out;


typedef SequenceTmpl<PropertyException,MICO_TID_DEF> PropertyExceptions;
#ifdef _WINDOWS
static PropertyExceptions _dummy_PropertyExceptions;
#endif
typedef TSeqVar<SequenceTmpl<PropertyException,MICO_TID_DEF> > PropertyExceptions_var;
typedef TSeqOut<SequenceTmpl<PropertyException,MICO_TID_DEF> > PropertyExceptions_out;

MICO_EXPORT_TYPEVAR_DECL CORBA::TypeCodeConst _tc_PropertyExceptions;

struct MultipleExceptions : public CORBA::UserException {
  #ifdef HAVE_EXPLICIT_STRUCT_OPS
  MultipleExceptions();
  ~MultipleExceptions();
  MultipleExceptions( const MultipleExceptions& s );
  MultipleExceptions& operator=( const MultipleExceptions& s );
  #endif //HAVE_EXPLICIT_STRUCT_OPS

  #ifndef HAVE_EXPLICIT_STRUCT_OPS
  MultipleExceptions();
  #endif //HAVE_EXPLICIT_STRUCT_OPS
  MultipleExceptions( const PropertyExceptions& _m0 );

  #ifdef HAVE_STD_EH
  MultipleExceptions *operator->() { return this; }
  MultipleExceptions& operator*() { return *this; }
  operator MultipleExceptions*() { return this; }
  #endif // HAVE_STD_EH

  void _throwit() const;
  const char *_repoid() const;
  void _encode( CORBA::DataEncoder &en ) const;
  void _encode_any( CORBA::Any &a ) const;
  CORBA::Exception *_clone() const;
  static MultipleExceptions *_downcast( CORBA::Exception *ex );
  static const MultipleExceptions *_downcast( const CORBA::Exception *ex );
  PropertyExceptions exceptions;
};

#ifdef HAVE_STD_EH
typedef MultipleExceptions MultipleExceptions_catch;
#else
typedef ExceptVar<MultipleExceptions> MultipleExceptions_var;
typedef TVarOut<MultipleExceptions> MultipleExceptions_out;
typedef MultipleExceptions_var MultipleExceptions_catch;
#endif // HAVE_STD_EH

MICO_EXPORT_TYPEVAR_DECL CORBA::TypeCodeConst _tc_MultipleExceptions;

class PropertySetFactory;
typedef PropertySetFactory *PropertySetFactory_ptr;
typedef PropertySetFactory_ptr PropertySetFactoryRef;
typedef ObjVar<PropertySetFactory> PropertySetFactory_var;
typedef ObjOut<PropertySetFactory> PropertySetFactory_out;


/*
 * Base class and common definitions for interface PropertySetFactory
 */

class PropertySetFactory : 
  virtual public CORBA::Object
{
  public:
    virtual ~PropertySetFactory();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef PropertySetFactory_ptr _ptr_type;
    typedef PropertySetFactory_var _var_type;
    #endif

    static PropertySetFactory_ptr _narrow( CORBA::Object_ptr obj );
    static PropertySetFactory_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static PropertySetFactory_ptr _duplicate( PropertySetFactory_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static PropertySetFactory_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual PropertySet_ptr create_propertyset() = 0;
    virtual PropertySet_ptr create_constrained_propertyset( const PropertyTypes& allowed_property_types, const Properties& allowed_properties ) = 0;
    virtual PropertySet_ptr create_initial_propertyset( const Properties& initial_properties ) = 0;

  protected:
    PropertySetFactory() {};
  private:
    PropertySetFactory( const PropertySetFactory& );
    void operator=( const PropertySetFactory& );
};

MICO_EXPORT_TYPEVAR_DECL CORBA::TypeCodeConst _tc_PropertySetFactory;

// Stub for interface PropertySetFactory
class PropertySetFactory_stub:
  virtual public PropertySetFactory
{
  public:
    virtual ~PropertySetFactory_stub();
    PropertySet_ptr create_propertyset();
    PropertySet_ptr create_constrained_propertyset( const PropertyTypes& allowed_property_types, const Properties& allowed_properties );
    PropertySet_ptr create_initial_propertyset( const Properties& initial_properties );

  private:
    void operator=( const PropertySetFactory_stub& );
};

class PropertySetFactory_skel :
  virtual public StaticMethodDispatcher,
  virtual public PropertySetFactory
{
  public:
    PropertySetFactory_skel( const CORBA::BOA::ReferenceData & = CORBA::BOA::ReferenceData() );
    virtual ~PropertySetFactory_skel();
    PropertySetFactory_skel( CORBA::Object_ptr obj );
    virtual bool dispatch( CORBA::StaticServerRequest_ptr __req, CORBA::Environment &_env );
    PropertySetFactory_ptr _this();

};

struct InvalidPropertyName : public CORBA::UserException {
  #ifdef HAVE_EXPLICIT_STRUCT_OPS
  InvalidPropertyName();
  ~InvalidPropertyName();
  InvalidPropertyName( const InvalidPropertyName& s );
  InvalidPropertyName& operator=( const InvalidPropertyName& s );
  #endif //HAVE_EXPLICIT_STRUCT_OPS


  #ifdef HAVE_STD_EH
  InvalidPropertyName *operator->() { return this; }
  InvalidPropertyName& operator*() { return *this; }
  operator InvalidPropertyName*() { return this; }
  #endif // HAVE_STD_EH

  void _throwit() const;
  const char *_repoid() const;
  void _encode( CORBA::DataEncoder &en ) const;
  void _encode_any( CORBA::Any &a ) const;
  CORBA::Exception *_clone() const;
  static InvalidPropertyName *_downcast( CORBA::Exception *ex );
  static const InvalidPropertyName *_downcast( const CORBA::Exception *ex );
};

#ifdef HAVE_STD_EH
typedef InvalidPropertyName InvalidPropertyName_catch;
#else
typedef ExceptVar<InvalidPropertyName> InvalidPropertyName_var;
typedef TVarOut<InvalidPropertyName> InvalidPropertyName_out;
typedef InvalidPropertyName_var InvalidPropertyName_catch;
#endif // HAVE_STD_EH

MICO_EXPORT_TYPEVAR_DECL CORBA::TypeCodeConst _tc_InvalidPropertyName;

struct ConflictingProperty : public CORBA::UserException {
  #ifdef HAVE_EXPLICIT_STRUCT_OPS
  ConflictingProperty();
  ~ConflictingProperty();
  ConflictingProperty( const ConflictingProperty& s );
  ConflictingProperty& operator=( const ConflictingProperty& s );
  #endif //HAVE_EXPLICIT_STRUCT_OPS


  #ifdef HAVE_STD_EH
  ConflictingProperty *operator->() { return this; }
  ConflictingProperty& operator*() { return *this; }
  operator ConflictingProperty*() { return this; }
  #endif // HAVE_STD_EH

  void _throwit() const;
  const char *_repoid() const;
  void _encode( CORBA::DataEncoder &en ) const;
  void _encode_any( CORBA::Any &a ) const;
  CORBA::Exception *_clone() const;
  static ConflictingProperty *_downcast( CORBA::Exception *ex );
  static const ConflictingProperty *_downcast( const CORBA::Exception *ex );
};

#ifdef HAVE_STD_EH
typedef ConflictingProperty ConflictingProperty_catch;
#else
typedef ExceptVar<ConflictingProperty> ConflictingProperty_var;
typedef TVarOut<ConflictingProperty> ConflictingProperty_out;
typedef ConflictingProperty_var ConflictingProperty_catch;
#endif // HAVE_STD_EH

MICO_EXPORT_TYPEVAR_DECL CORBA::TypeCodeConst _tc_ConflictingProperty;

struct UnsupportedTypeCode : public CORBA::UserException {
  #ifdef HAVE_EXPLICIT_STRUCT_OPS
  UnsupportedTypeCode();
  ~UnsupportedTypeCode();
  UnsupportedTypeCode( const UnsupportedTypeCode& s );
  UnsupportedTypeCode& operator=( const UnsupportedTypeCode& s );
  #endif //HAVE_EXPLICIT_STRUCT_OPS


  #ifdef HAVE_STD_EH
  UnsupportedTypeCode *operator->() { return this; }
  UnsupportedTypeCode& operator*() { return *this; }
  operator UnsupportedTypeCode*() { return this; }
  #endif // HAVE_STD_EH

  void _throwit() const;
  const char *_repoid() const;
  void _encode( CORBA::DataEncoder &en ) const;
  void _encode_any( CORBA::Any &a ) const;
  CORBA::Exception *_clone() const;
  static UnsupportedTypeCode *_downcast( CORBA::Exception *ex );
  static const UnsupportedTypeCode *_downcast( const CORBA::Exception *ex );
};

#ifdef HAVE_STD_EH
typedef UnsupportedTypeCode UnsupportedTypeCode_catch;
#else
typedef ExceptVar<UnsupportedTypeCode> UnsupportedTypeCode_var;
typedef TVarOut<UnsupportedTypeCode> UnsupportedTypeCode_out;
typedef UnsupportedTypeCode_var UnsupportedTypeCode_catch;
#endif // HAVE_STD_EH

MICO_EXPORT_TYPEVAR_DECL CORBA::TypeCodeConst _tc_UnsupportedTypeCode;

struct UnsupportedProperty : public CORBA::UserException {
  #ifdef HAVE_EXPLICIT_STRUCT_OPS
  UnsupportedProperty();
  ~UnsupportedProperty();
  UnsupportedProperty( const UnsupportedProperty& s );
  UnsupportedProperty& operator=( const UnsupportedProperty& s );
  #endif //HAVE_EXPLICIT_STRUCT_OPS


  #ifdef HAVE_STD_EH
  UnsupportedProperty *operator->() { return this; }
  UnsupportedProperty& operator*() { return *this; }
  operator UnsupportedProperty*() { return this; }
  #endif // HAVE_STD_EH

  void _throwit() const;
  const char *_repoid() const;
  void _encode( CORBA::DataEncoder &en ) const;
  void _encode_any( CORBA::Any &a ) const;
  CORBA::Exception *_clone() const;
  static UnsupportedProperty *_downcast( CORBA::Exception *ex );
  static const UnsupportedProperty *_downcast( const CORBA::Exception *ex );
};

#ifdef HAVE_STD_EH
typedef UnsupportedProperty UnsupportedProperty_catch;
#else
typedef ExceptVar<UnsupportedProperty> UnsupportedProperty_var;
typedef TVarOut<UnsupportedProperty> UnsupportedProperty_out;
typedef UnsupportedProperty_var UnsupportedProperty_catch;
#endif // HAVE_STD_EH

MICO_EXPORT_TYPEVAR_DECL CORBA::TypeCodeConst _tc_UnsupportedProperty;

struct ReadOnlyProperty : public CORBA::UserException {
  #ifdef HAVE_EXPLICIT_STRUCT_OPS
  ReadOnlyProperty();
  ~ReadOnlyProperty();
  ReadOnlyProperty( const ReadOnlyProperty& s );
  ReadOnlyProperty& operator=( const ReadOnlyProperty& s );
  #endif //HAVE_EXPLICIT_STRUCT_OPS


  #ifdef HAVE_STD_EH
  ReadOnlyProperty *operator->() { return this; }
  ReadOnlyProperty& operator*() { return *this; }
  operator ReadOnlyProperty*() { return this; }
  #endif // HAVE_STD_EH

  void _throwit() const;
  const char *_repoid() const;
  void _encode( CORBA::DataEncoder &en ) const;
  void _encode_any( CORBA::Any &a ) const;
  CORBA::Exception *_clone() const;
  static ReadOnlyProperty *_downcast( CORBA::Exception *ex );
  static const ReadOnlyProperty *_downcast( const CORBA::Exception *ex );
};

#ifdef HAVE_STD_EH
typedef ReadOnlyProperty ReadOnlyProperty_catch;
#else
typedef ExceptVar<ReadOnlyProperty> ReadOnlyProperty_var;
typedef TVarOut<ReadOnlyProperty> ReadOnlyProperty_out;
typedef ReadOnlyProperty_var ReadOnlyProperty_catch;
#endif // HAVE_STD_EH

MICO_EXPORT_TYPEVAR_DECL CORBA::TypeCodeConst _tc_ReadOnlyProperty;

struct PropertyNotFound : public CORBA::UserException {
  #ifdef HAVE_EXPLICIT_STRUCT_OPS
  PropertyNotFound();
  ~PropertyNotFound();
  PropertyNotFound( const PropertyNotFound& s );
  PropertyNotFound& operator=( const PropertyNotFound& s );
  #endif //HAVE_EXPLICIT_STRUCT_OPS


  #ifdef HAVE_STD_EH
  PropertyNotFound *operator->() { return this; }
  PropertyNotFound& operator*() { return *this; }
  operator PropertyNotFound*() { return this; }
  #endif // HAVE_STD_EH

  void _throwit() const;
  const char *_repoid() const;
  void _encode( CORBA::DataEncoder &en ) const;
  void _encode_any( CORBA::Any &a ) const;
  CORBA::Exception *_clone() const;
  static PropertyNotFound *_downcast( CORBA::Exception *ex );
  static const PropertyNotFound *_downcast( const CORBA::Exception *ex );
};

#ifdef HAVE_STD_EH
typedef PropertyNotFound PropertyNotFound_catch;
#else
typedef ExceptVar<PropertyNotFound> PropertyNotFound_var;
typedef TVarOut<PropertyNotFound> PropertyNotFound_out;
typedef PropertyNotFound_var PropertyNotFound_catch;
#endif // HAVE_STD_EH

MICO_EXPORT_TYPEVAR_DECL CORBA::TypeCodeConst _tc_PropertyNotFound;

struct FixedProperty : public CORBA::UserException {
  #ifdef HAVE_EXPLICIT_STRUCT_OPS
  FixedProperty();
  ~FixedProperty();
  FixedProperty( const FixedProperty& s );
  FixedProperty& operator=( const FixedProperty& s );
  #endif //HAVE_EXPLICIT_STRUCT_OPS


  #ifdef HAVE_STD_EH
  FixedProperty *operator->() { return this; }
  FixedProperty& operator*() { return *this; }
  operator FixedProperty*() { return this; }
  #endif // HAVE_STD_EH

  void _throwit() const;
  const char *_repoid() const;
  void _encode( CORBA::DataEncoder &en ) const;
  void _encode_any( CORBA::Any &a ) const;
  CORBA::Exception *_clone() const;
  static FixedProperty *_downcast( CORBA::Exception *ex );
  static const FixedProperty *_downcast( const CORBA::Exception *ex );
};

#ifdef HAVE_STD_EH
typedef FixedProperty FixedProperty_catch;
#else
typedef ExceptVar<FixedProperty> FixedProperty_var;
typedef TVarOut<FixedProperty> FixedProperty_out;
typedef FixedProperty_var FixedProperty_catch;
#endif // HAVE_STD_EH

MICO_EXPORT_TYPEVAR_DECL CORBA::TypeCodeConst _tc_FixedProperty;


/*
 * Base class and common definitions for interface PropertySet
 */

class PropertySet : 
  virtual public CORBA::Object
{
  public:
    virtual ~PropertySet();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef PropertySet_ptr _ptr_type;
    typedef PropertySet_var _var_type;
    #endif

    static PropertySet_ptr _narrow( CORBA::Object_ptr obj );
    static PropertySet_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static PropertySet_ptr _duplicate( PropertySet_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static PropertySet_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual void define_property( const char* property_name, const CORBA::Any& property_value ) = 0;
    virtual void define_properties( const Properties& nproperties ) = 0;
    virtual CORBA::ULong get_number_of_properties() = 0;
    virtual void get_all_property_names( CORBA::ULong how_many, PropertyNames_out property_names, PropertyNamesIterator_out rest ) = 0;
    virtual CORBA::Any* get_property_value( const char* property_name ) = 0;
    virtual CORBA::Boolean get_properties( const PropertyNames& property_names, Properties_out nproperties ) = 0;
    virtual void get_all_properties( CORBA::ULong how_many, Properties_out nproperties, PropertiesIterator_out rest ) = 0;
    virtual void delete_property( const char* property_name ) = 0;
    virtual void delete_properties( const PropertyNames& property_names ) = 0;
    virtual CORBA::Boolean delete_all_properties() = 0;
    virtual CORBA::Boolean is_property_defined( const char* property_name ) = 0;

  protected:
    PropertySet() {};
  private:
    PropertySet( const PropertySet& );
    void operator=( const PropertySet& );
};

MICO_EXPORT_TYPEVAR_DECL CORBA::TypeCodeConst _tc_PropertySet;

// Stub for interface PropertySet
class PropertySet_stub:
  virtual public PropertySet
{
  public:
    virtual ~PropertySet_stub();
    void define_property( const char* property_name, const CORBA::Any& property_value );
    void define_properties( const Properties& nproperties );
    CORBA::ULong get_number_of_properties();
    void get_all_property_names( CORBA::ULong how_many, PropertyNames_out property_names, PropertyNamesIterator_out rest );
    CORBA::Any* get_property_value( const char* property_name );
    CORBA::Boolean get_properties( const PropertyNames& property_names, Properties_out nproperties );
    void get_all_properties( CORBA::ULong how_many, Properties_out nproperties, PropertiesIterator_out rest );
    void delete_property( const char* property_name );
    void delete_properties( const PropertyNames& property_names );
    CORBA::Boolean delete_all_properties();
    CORBA::Boolean is_property_defined( const char* property_name );

  private:
    void operator=( const PropertySet_stub& );
};

class PropertySet_skel :
  virtual public StaticMethodDispatcher,
  virtual public PropertySet
{
  public:
    PropertySet_skel( const CORBA::BOA::ReferenceData & = CORBA::BOA::ReferenceData() );
    virtual ~PropertySet_skel();
    PropertySet_skel( CORBA::Object_ptr obj );
    virtual bool dispatch( CORBA::StaticServerRequest_ptr __req, CORBA::Environment &_env );
    PropertySet_ptr _this();

};

struct UnsupportedMode : public CORBA::UserException {
  #ifdef HAVE_EXPLICIT_STRUCT_OPS
  UnsupportedMode();
  ~UnsupportedMode();
  UnsupportedMode( const UnsupportedMode& s );
  UnsupportedMode& operator=( const UnsupportedMode& s );
  #endif //HAVE_EXPLICIT_STRUCT_OPS


  #ifdef HAVE_STD_EH
  UnsupportedMode *operator->() { return this; }
  UnsupportedMode& operator*() { return *this; }
  operator UnsupportedMode*() { return this; }
  #endif // HAVE_STD_EH

  void _throwit() const;
  const char *_repoid() const;
  void _encode( CORBA::DataEncoder &en ) const;
  void _encode_any( CORBA::Any &a ) const;
  CORBA::Exception *_clone() const;
  static UnsupportedMode *_downcast( CORBA::Exception *ex );
  static const UnsupportedMode *_downcast( const CORBA::Exception *ex );
};

#ifdef HAVE_STD_EH
typedef UnsupportedMode UnsupportedMode_catch;
#else
typedef ExceptVar<UnsupportedMode> UnsupportedMode_var;
typedef TVarOut<UnsupportedMode> UnsupportedMode_out;
typedef UnsupportedMode_var UnsupportedMode_catch;
#endif // HAVE_STD_EH

MICO_EXPORT_TYPEVAR_DECL CORBA::TypeCodeConst _tc_UnsupportedMode;

class PropertySetDef;
typedef PropertySetDef *PropertySetDef_ptr;
typedef PropertySetDef_ptr PropertySetDefRef;
typedef ObjVar<PropertySetDef> PropertySetDef_var;
typedef ObjOut<PropertySetDef> PropertySetDef_out;


/*
 * Base class and common definitions for interface PropertySetDef
 */

class PropertySetDef : 
  virtual public ::PropertyService::PropertySet
{
  public:
    typedef ::PropertyService::PropertySet _VCHACK__PropertyService__PropertySet;
    virtual ~PropertySetDef();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef PropertySetDef_ptr _ptr_type;
    typedef PropertySetDef_var _var_type;
    #endif

    static PropertySetDef_ptr _narrow( CORBA::Object_ptr obj );
    static PropertySetDef_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static PropertySetDef_ptr _duplicate( PropertySetDef_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static PropertySetDef_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual void get_allowed_property_types( PropertyTypes_out property_types ) = 0;
    virtual void get_allowed_properties( PropertyDefs_out property_defs ) = 0;
    virtual void define_property_with_mode( const char* property_name, const CORBA::Any& property_value, PropertyModeType property_mode ) = 0;
    virtual void define_properties_with_modes( const PropertyDefs& property_defs ) = 0;
    virtual PropertyModeType get_property_mode( const char* property_name ) = 0;
    virtual CORBA::Boolean get_property_modes( const PropertyNames& property_names, PropertyModes_out property_modes ) = 0;
    virtual void set_property_mode( const char* property_name, PropertyModeType property_mode ) = 0;
    virtual void set_property_modes( const PropertyModes& property_modes ) = 0;

  protected:
    PropertySetDef() {};
  private:
    PropertySetDef( const PropertySetDef& );
    void operator=( const PropertySetDef& );
};

MICO_EXPORT_TYPEVAR_DECL CORBA::TypeCodeConst _tc_PropertySetDef;

// Stub for interface PropertySetDef
class PropertySetDef_stub:
  virtual public PropertySetDef,
  virtual public ::PropertyService::PropertySet_stub
{
  public:
    virtual ~PropertySetDef_stub();
    void get_allowed_property_types( PropertyTypes_out property_types );
    void get_allowed_properties( PropertyDefs_out property_defs );
    void define_property_with_mode( const char* property_name, const CORBA::Any& property_value, PropertyModeType property_mode );
    void define_properties_with_modes( const PropertyDefs& property_defs );
    PropertyModeType get_property_mode( const char* property_name );
    CORBA::Boolean get_property_modes( const PropertyNames& property_names, PropertyModes_out property_modes );
    void set_property_mode( const char* property_name, PropertyModeType property_mode );
    void set_property_modes( const PropertyModes& property_modes );

  private:
    void operator=( const PropertySetDef_stub& );
};

class PropertySetDef_skel :
  virtual public StaticMethodDispatcher,
  virtual public PropertySetDef
{
  public:
    PropertySetDef_skel( const CORBA::BOA::ReferenceData & = CORBA::BOA::ReferenceData() );
    virtual ~PropertySetDef_skel();
    PropertySetDef_skel( CORBA::Object_ptr obj );
    virtual bool dispatch( CORBA::StaticServerRequest_ptr __req, CORBA::Environment &_env );
    PropertySetDef_ptr _this();

};

enum ExceptionReason {
  invalid_property_name = 0,
  conflicting_property,
  property_not_found,
  unsupported_type_code,
  unsupported_property,
  unsupported_mode,
  fixed_property,
  read_only_property
};

typedef ExceptionReason& ExceptionReason_out;

MICO_EXPORT_TYPEVAR_DECL CORBA::TypeCodeConst _tc_ExceptionReason;

struct PropertyException {
  #ifdef HAVE_TYPEDEF_OVERLOAD
  typedef PropertyException_var _var_type;
  #endif
  #ifdef HAVE_EXPLICIT_STRUCT_OPS
  PropertyException();
  ~PropertyException();
  PropertyException( const PropertyException& s );
  PropertyException& operator=( const PropertyException& s );
  #endif //HAVE_EXPLICIT_STRUCT_OPS

  ExceptionReason reason;
  PropertyName_var failing_property_name;
};

MICO_EXPORT_TYPEVAR_DECL CORBA::TypeCodeConst _tc_PropertyException;

class PropertySetDefFactory;
typedef PropertySetDefFactory *PropertySetDefFactory_ptr;
typedef PropertySetDefFactory_ptr PropertySetDefFactoryRef;
typedef ObjVar<PropertySetDefFactory> PropertySetDefFactory_var;
typedef ObjOut<PropertySetDefFactory> PropertySetDefFactory_out;


/*
 * Base class and common definitions for interface PropertySetDefFactory
 */

class PropertySetDefFactory : 
  virtual public CORBA::Object
{
  public:
    virtual ~PropertySetDefFactory();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef PropertySetDefFactory_ptr _ptr_type;
    typedef PropertySetDefFactory_var _var_type;
    #endif

    static PropertySetDefFactory_ptr _narrow( CORBA::Object_ptr obj );
    static PropertySetDefFactory_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static PropertySetDefFactory_ptr _duplicate( PropertySetDefFactory_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static PropertySetDefFactory_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual PropertySetDef_ptr create_propertysetdef() = 0;
    virtual PropertySetDef_ptr create_constrained_propertysetdef( const PropertyTypes& allowed_property_types, const PropertyDefs& allowed_property_defs ) = 0;
    virtual PropertySetDef_ptr create_initial_propertysetdef( const PropertyDefs& initial_property_defs ) = 0;

  protected:
    PropertySetDefFactory() {};
  private:
    PropertySetDefFactory( const PropertySetDefFactory& );
    void operator=( const PropertySetDefFactory& );
};

MICO_EXPORT_TYPEVAR_DECL CORBA::TypeCodeConst _tc_PropertySetDefFactory;

// Stub for interface PropertySetDefFactory
class PropertySetDefFactory_stub:
  virtual public PropertySetDefFactory
{
  public:
    virtual ~PropertySetDefFactory_stub();
    PropertySetDef_ptr create_propertysetdef();
    PropertySetDef_ptr create_constrained_propertysetdef( const PropertyTypes& allowed_property_types, const PropertyDefs& allowed_property_defs );
    PropertySetDef_ptr create_initial_propertysetdef( const PropertyDefs& initial_property_defs );

  private:
    void operator=( const PropertySetDefFactory_stub& );
};

class PropertySetDefFactory_skel :
  virtual public StaticMethodDispatcher,
  virtual public PropertySetDefFactory
{
  public:
    PropertySetDefFactory_skel( const CORBA::BOA::ReferenceData & = CORBA::BOA::ReferenceData() );
    virtual ~PropertySetDefFactory_skel();
    PropertySetDefFactory_skel( CORBA::Object_ptr obj );
    virtual bool dispatch( CORBA::StaticServerRequest_ptr __req, CORBA::Environment &_env );
    PropertySetDefFactory_ptr _this();

};

}


#ifndef MICO_CONF_NO_POA

#endif // MICO_CONF_NO_POA

void operator<<=( CORBA::Any &_a, const ::PropertyService::Property &_s );
void operator<<=( CORBA::Any &_a, ::PropertyService::Property *_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, ::PropertyService::Property &_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, const ::PropertyService::Property *&_s );

extern CORBA::StaticTypeInfo *_marshaller_PropertyService_Property;

void operator<<=( CORBA::Any &a, const ::PropertyService::PropertyModeType &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, ::PropertyService::PropertyModeType &e );

extern CORBA::StaticTypeInfo *_marshaller_PropertyService_PropertyModeType;

void operator<<=( CORBA::Any &_a, const ::PropertyService::PropertyDef &_s );
void operator<<=( CORBA::Any &_a, ::PropertyService::PropertyDef *_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, ::PropertyService::PropertyDef &_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, const ::PropertyService::PropertyDef *&_s );

extern CORBA::StaticTypeInfo *_marshaller_PropertyService_PropertyDef;

void operator<<=( CORBA::Any &_a, const ::PropertyService::PropertyMode &_s );
void operator<<=( CORBA::Any &_a, ::PropertyService::PropertyMode *_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, ::PropertyService::PropertyMode &_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, const ::PropertyService::PropertyMode *&_s );

extern CORBA::StaticTypeInfo *_marshaller_PropertyService_PropertyMode;

void operator<<=( CORBA::Any &a, const PropertyService::PropertyNamesIterator_ptr obj );
void operator<<=( CORBA::Any &a, PropertyService::PropertyNamesIterator_ptr* obj_ptr );
CORBA::Boolean operator>>=( const CORBA::Any &a, PropertyService::PropertyNamesIterator_ptr &obj );

extern CORBA::StaticTypeInfo *_marshaller_PropertyService_PropertyNamesIterator;

void operator<<=( CORBA::Any &a, const PropertyService::PropertiesIterator_ptr obj );
void operator<<=( CORBA::Any &a, PropertyService::PropertiesIterator_ptr* obj_ptr );
CORBA::Boolean operator>>=( const CORBA::Any &a, PropertyService::PropertiesIterator_ptr &obj );

extern CORBA::StaticTypeInfo *_marshaller_PropertyService_PropertiesIterator;

void operator<<=( CORBA::Any &a, const ::PropertyService::ConstraintNotSupported &e );
void operator<<=( CORBA::Any &a, ::PropertyService::ConstraintNotSupported *e );
CORBA::Boolean operator>>=( const CORBA::Any &a, ::PropertyService::ConstraintNotSupported &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, const ::PropertyService::ConstraintNotSupported *&e );

extern CORBA::StaticTypeInfo *_marshaller_PropertyService_ConstraintNotSupported;

void operator<<=( CORBA::Any &a, const ::PropertyService::MultipleExceptions &e );
void operator<<=( CORBA::Any &a, ::PropertyService::MultipleExceptions *e );
CORBA::Boolean operator>>=( const CORBA::Any &a, ::PropertyService::MultipleExceptions &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, const ::PropertyService::MultipleExceptions *&e );

extern CORBA::StaticTypeInfo *_marshaller_PropertyService_MultipleExceptions;

void operator<<=( CORBA::Any &a, const PropertyService::PropertySetFactory_ptr obj );
void operator<<=( CORBA::Any &a, PropertyService::PropertySetFactory_ptr* obj_ptr );
CORBA::Boolean operator>>=( const CORBA::Any &a, PropertyService::PropertySetFactory_ptr &obj );

extern CORBA::StaticTypeInfo *_marshaller_PropertyService_PropertySetFactory;

void operator<<=( CORBA::Any &a, const ::PropertyService::InvalidPropertyName &e );
void operator<<=( CORBA::Any &a, ::PropertyService::InvalidPropertyName *e );
CORBA::Boolean operator>>=( const CORBA::Any &a, ::PropertyService::InvalidPropertyName &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, const ::PropertyService::InvalidPropertyName *&e );

extern CORBA::StaticTypeInfo *_marshaller_PropertyService_InvalidPropertyName;

void operator<<=( CORBA::Any &a, const ::PropertyService::ConflictingProperty &e );
void operator<<=( CORBA::Any &a, ::PropertyService::ConflictingProperty *e );
CORBA::Boolean operator>>=( const CORBA::Any &a, ::PropertyService::ConflictingProperty &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, const ::PropertyService::ConflictingProperty *&e );

extern CORBA::StaticTypeInfo *_marshaller_PropertyService_ConflictingProperty;

void operator<<=( CORBA::Any &a, const ::PropertyService::UnsupportedTypeCode &e );
void operator<<=( CORBA::Any &a, ::PropertyService::UnsupportedTypeCode *e );
CORBA::Boolean operator>>=( const CORBA::Any &a, ::PropertyService::UnsupportedTypeCode &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, const ::PropertyService::UnsupportedTypeCode *&e );

extern CORBA::StaticTypeInfo *_marshaller_PropertyService_UnsupportedTypeCode;

void operator<<=( CORBA::Any &a, const ::PropertyService::UnsupportedProperty &e );
void operator<<=( CORBA::Any &a, ::PropertyService::UnsupportedProperty *e );
CORBA::Boolean operator>>=( const CORBA::Any &a, ::PropertyService::UnsupportedProperty &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, const ::PropertyService::UnsupportedProperty *&e );

extern CORBA::StaticTypeInfo *_marshaller_PropertyService_UnsupportedProperty;

void operator<<=( CORBA::Any &a, const ::PropertyService::ReadOnlyProperty &e );
void operator<<=( CORBA::Any &a, ::PropertyService::ReadOnlyProperty *e );
CORBA::Boolean operator>>=( const CORBA::Any &a, ::PropertyService::ReadOnlyProperty &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, const ::PropertyService::ReadOnlyProperty *&e );

extern CORBA::StaticTypeInfo *_marshaller_PropertyService_ReadOnlyProperty;

void operator<<=( CORBA::Any &a, const ::PropertyService::PropertyNotFound &e );
void operator<<=( CORBA::Any &a, ::PropertyService::PropertyNotFound *e );
CORBA::Boolean operator>>=( const CORBA::Any &a, ::PropertyService::PropertyNotFound &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, const ::PropertyService::PropertyNotFound *&e );

extern CORBA::StaticTypeInfo *_marshaller_PropertyService_PropertyNotFound;

void operator<<=( CORBA::Any &a, const ::PropertyService::FixedProperty &e );
void operator<<=( CORBA::Any &a, ::PropertyService::FixedProperty *e );
CORBA::Boolean operator>>=( const CORBA::Any &a, ::PropertyService::FixedProperty &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, const ::PropertyService::FixedProperty *&e );

extern CORBA::StaticTypeInfo *_marshaller_PropertyService_FixedProperty;

void operator<<=( CORBA::Any &a, const PropertyService::PropertySet_ptr obj );
void operator<<=( CORBA::Any &a, PropertyService::PropertySet_ptr* obj_ptr );
CORBA::Boolean operator>>=( const CORBA::Any &a, PropertyService::PropertySet_ptr &obj );

extern CORBA::StaticTypeInfo *_marshaller_PropertyService_PropertySet;

void operator<<=( CORBA::Any &a, const ::PropertyService::UnsupportedMode &e );
void operator<<=( CORBA::Any &a, ::PropertyService::UnsupportedMode *e );
CORBA::Boolean operator>>=( const CORBA::Any &a, ::PropertyService::UnsupportedMode &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, const ::PropertyService::UnsupportedMode *&e );

extern CORBA::StaticTypeInfo *_marshaller_PropertyService_UnsupportedMode;

void operator<<=( CORBA::Any &a, const PropertyService::PropertySetDef_ptr obj );
void operator<<=( CORBA::Any &a, PropertyService::PropertySetDef_ptr* obj_ptr );
CORBA::Boolean operator>>=( const CORBA::Any &a, PropertyService::PropertySetDef_ptr &obj );

extern CORBA::StaticTypeInfo *_marshaller_PropertyService_PropertySetDef;

void operator<<=( CORBA::Any &a, const ::PropertyService::ExceptionReason &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, ::PropertyService::ExceptionReason &e );

extern CORBA::StaticTypeInfo *_marshaller_PropertyService_ExceptionReason;

void operator<<=( CORBA::Any &_a, const ::PropertyService::PropertyException &_s );
void operator<<=( CORBA::Any &_a, ::PropertyService::PropertyException *_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, ::PropertyService::PropertyException &_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, const ::PropertyService::PropertyException *&_s );

extern CORBA::StaticTypeInfo *_marshaller_PropertyService_PropertyException;

void operator<<=( CORBA::Any &a, const PropertyService::PropertySetDefFactory_ptr obj );
void operator<<=( CORBA::Any &a, PropertyService::PropertySetDefFactory_ptr* obj_ptr );
CORBA::Boolean operator>>=( const CORBA::Any &a, PropertyService::PropertySetDefFactory_ptr &obj );

extern CORBA::StaticTypeInfo *_marshaller_PropertyService_PropertySetDefFactory;

void operator<<=( CORBA::Any &_a, const StringSequenceTmpl<CORBA::String_var> &_s );
void operator<<=( CORBA::Any &_a, StringSequenceTmpl<CORBA::String_var> *_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, StringSequenceTmpl<CORBA::String_var> &_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, const StringSequenceTmpl<CORBA::String_var> *&_s );

void operator<<=( CORBA::Any &_a, const SequenceTmpl<PropertyService::Property,MICO_TID_DEF> &_s );
void operator<<=( CORBA::Any &_a, SequenceTmpl<PropertyService::Property,MICO_TID_DEF> *_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, SequenceTmpl<PropertyService::Property,MICO_TID_DEF> &_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, const SequenceTmpl<PropertyService::Property,MICO_TID_DEF> *&_s );

extern CORBA::StaticTypeInfo *_marshaller__seq_PropertyService_Property;

void operator<<=( CORBA::Any &_a, const SequenceTmpl<PropertyService::PropertyDef,MICO_TID_DEF> &_s );
void operator<<=( CORBA::Any &_a, SequenceTmpl<PropertyService::PropertyDef,MICO_TID_DEF> *_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, SequenceTmpl<PropertyService::PropertyDef,MICO_TID_DEF> &_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, const SequenceTmpl<PropertyService::PropertyDef,MICO_TID_DEF> *&_s );

extern CORBA::StaticTypeInfo *_marshaller__seq_PropertyService_PropertyDef;

void operator<<=( CORBA::Any &_a, const SequenceTmpl<PropertyService::PropertyMode,MICO_TID_DEF> &_s );
void operator<<=( CORBA::Any &_a, SequenceTmpl<PropertyService::PropertyMode,MICO_TID_DEF> *_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, SequenceTmpl<PropertyService::PropertyMode,MICO_TID_DEF> &_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, const SequenceTmpl<PropertyService::PropertyMode,MICO_TID_DEF> *&_s );

extern CORBA::StaticTypeInfo *_marshaller__seq_PropertyService_PropertyMode;

void operator<<=( CORBA::Any &_a, const SequenceTmpl<CORBA::TypeCode_var,MICO_TID_DEF> &_s );
void operator<<=( CORBA::Any &_a, SequenceTmpl<CORBA::TypeCode_var,MICO_TID_DEF> *_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, SequenceTmpl<CORBA::TypeCode_var,MICO_TID_DEF> &_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, const SequenceTmpl<CORBA::TypeCode_var,MICO_TID_DEF> *&_s );

extern CORBA::StaticTypeInfo *_marshaller__seq_TypeCode;

void operator<<=( CORBA::Any &_a, const SequenceTmpl<PropertyService::PropertyException,MICO_TID_DEF> &_s );
void operator<<=( CORBA::Any &_a, SequenceTmpl<PropertyService::PropertyException,MICO_TID_DEF> *_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, SequenceTmpl<PropertyService::PropertyException,MICO_TID_DEF> &_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, const SequenceTmpl<PropertyService::PropertyException,MICO_TID_DEF> *&_s );

extern CORBA::StaticTypeInfo *_marshaller__seq_PropertyService_PropertyException;

#endif
