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

// This file is generated by omniidl (C++ backend)- omniORB_4_1. Do not edit.
#ifndef __LifeCycleService_hh__
#define __LifeCycleService_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_LifeCycleService
#endif
#ifndef  USE_core_stub_in_nt_dll
# define USE_core_stub_in_nt_dll_NOT_DEFINED_LifeCycleService
#endif
#ifndef  USE_dyn_stub_in_nt_dll
# define USE_dyn_stub_in_nt_dll_NOT_DEFINED_LifeCycleService
#endif


#include "COS_sysdep.h"
#ifndef __CosNaming_hh_EXTERNAL_GUARD__
#define __CosNaming_hh_EXTERNAL_GUARD__
#include "CosNaming.hh"
#endif
#ifndef __CosLifeCycle_hh_EXTERNAL_GUARD__
#define __CosLifeCycle_hh_EXTERNAL_GUARD__
#include "CosLifeCycle.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 LifeCycleService

_CORBA_MODULE_BEG

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_PolicyList;

  class PolicyList_var;

  class PolicyList : public _CORBA_Unbounded_Sequence< CosLifeCycle::NameValuePair >  {
  public:
    typedef PolicyList_var _var_type;
    inline PolicyList() {}
    inline PolicyList(const PolicyList& _s)
      : _CORBA_Unbounded_Sequence< CosLifeCycle::NameValuePair > (_s) {}

    inline PolicyList(_CORBA_ULong _max)
      : _CORBA_Unbounded_Sequence< CosLifeCycle::NameValuePair > (_max) {}
    inline PolicyList(_CORBA_ULong _max, _CORBA_ULong _len, CosLifeCycle::NameValuePair* _val, _CORBA_Boolean _rel=0)
      : _CORBA_Unbounded_Sequence< CosLifeCycle::NameValuePair > (_max, _len, _val, _rel) {}

  

    inline PolicyList& operator = (const PolicyList& _s) {
      _CORBA_Unbounded_Sequence< CosLifeCycle::NameValuePair > ::operator=(_s);
      return *this;
    }
  };

  class PolicyList_out;

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

  

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

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

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

  

    PolicyList*& _data;

  private:
    PolicyList_out();
    PolicyList_out& operator=(const PolicyList_var&);
  };

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_Keys;

  class Keys_var;

  class Keys : public _CORBA_Unbounded_Sequence< CosLifeCycle::Key >  {
  public:
    typedef Keys_var _var_type;
    inline Keys() {}
    inline Keys(const Keys& _s)
      : _CORBA_Unbounded_Sequence< CosLifeCycle::Key > (_s) {}

    inline Keys(_CORBA_ULong _max)
      : _CORBA_Unbounded_Sequence< CosLifeCycle::Key > (_max) {}
    inline Keys(_CORBA_ULong _max, _CORBA_ULong _len, CosLifeCycle::Key* _val, _CORBA_Boolean _rel=0)
      : _CORBA_Unbounded_Sequence< CosLifeCycle::Key > (_max, _len, _val, _rel) {}

  

    inline Keys& operator = (const Keys& _s) {
      _CORBA_Unbounded_Sequence< CosLifeCycle::Key > ::operator=(_s);
      return *this;
    }
  };

  class Keys_out;

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

  

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

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

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

  

    Keys*& _data;

  private:
    Keys_out();
    Keys_out& operator=(const Keys_var&);
  };

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_PropertyList;

  class PropertyList_var;

  class PropertyList : public _CORBA_Unbounded_Sequence< CosLifeCycle::NameValuePair >  {
  public:
    typedef PropertyList_var _var_type;
    inline PropertyList() {}
    inline PropertyList(const PropertyList& _s)
      : _CORBA_Unbounded_Sequence< CosLifeCycle::NameValuePair > (_s) {}

    inline PropertyList(_CORBA_ULong _max)
      : _CORBA_Unbounded_Sequence< CosLifeCycle::NameValuePair > (_max) {}
    inline PropertyList(_CORBA_ULong _max, _CORBA_ULong _len, CosLifeCycle::NameValuePair* _val, _CORBA_Boolean _rel=0)
      : _CORBA_Unbounded_Sequence< CosLifeCycle::NameValuePair > (_max, _len, _val, _rel) {}

  

    inline PropertyList& operator = (const PropertyList& _s) {
      _CORBA_Unbounded_Sequence< CosLifeCycle::NameValuePair > ::operator=(_s);
      return *this;
    }
  };

  class PropertyList_out;

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

  

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

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

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

  

    PropertyList*& _data;

  private:
    PropertyList_out();
    PropertyList_out& operator=(const PropertyList_var&);
  };

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_NameComponents;

  class NameComponents_var;

  class NameComponents : public _CORBA_Unbounded_Sequence< CosNaming::NameComponent >  {
  public:
    typedef NameComponents_var _var_type;
    inline NameComponents() {}
    inline NameComponents(const NameComponents& _s)
      : _CORBA_Unbounded_Sequence< CosNaming::NameComponent > (_s) {}

    inline NameComponents(_CORBA_ULong _max)
      : _CORBA_Unbounded_Sequence< CosNaming::NameComponent > (_max) {}
    inline NameComponents(_CORBA_ULong _max, _CORBA_ULong _len, CosNaming::NameComponent* _val, _CORBA_Boolean _rel=0)
      : _CORBA_Unbounded_Sequence< CosNaming::NameComponent > (_max, _len, _val, _rel) {}

  

    inline NameComponents& operator = (const NameComponents& _s) {
      _CORBA_Unbounded_Sequence< CosNaming::NameComponent > ::operator=(_s);
      return *this;
    }
  };

  class NameComponents_out;

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

  

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

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

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

  

    NameComponents*& _data;

  private:
    NameComponents_out();
    NameComponents_out& operator=(const NameComponents_var&);
  };

#ifndef __LifeCycleService_mLifeCycleServiceAdmin__
#define __LifeCycleService_mLifeCycleServiceAdmin__

  class LifeCycleServiceAdmin;
  class _objref_LifeCycleServiceAdmin;
  class _impl_LifeCycleServiceAdmin;
  
  typedef _objref_LifeCycleServiceAdmin* LifeCycleServiceAdmin_ptr;
  typedef LifeCycleServiceAdmin_ptr LifeCycleServiceAdminRef;

  class LifeCycleServiceAdmin_Helper {
  public:
    typedef LifeCycleServiceAdmin_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_LifeCycleServiceAdmin, LifeCycleServiceAdmin_Helper> LifeCycleServiceAdmin_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_LifeCycleServiceAdmin,LifeCycleServiceAdmin_Helper > LifeCycleServiceAdmin_out;

#endif

  // interface LifeCycleServiceAdmin
  class LifeCycleServiceAdmin {
  public:
    // Declarations for this interface type.
    typedef LifeCycleServiceAdmin_ptr _ptr_type;
    typedef LifeCycleServiceAdmin_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_LifeCycleServiceAdmin :
    public virtual ::CORBA::Object,
    public virtual omniObjRef
  {
  public:
    void bind_generic_factory(::CosLifeCycle::GenericFactory_ptr gf, const ::CosNaming::NameComponent& name, const ::LifeCycleService::Keys& key_set, const ::LifeCycleService::PropertyList& other_properties);
    void unbind_generic_factory(const ::CosNaming::NameComponent& name);
    CosLifeCycle::GenericFactory_ptr resolve_generic_factory(const ::CosNaming::NameComponent& name);
    NameComponents* list_generic_factories();
    ::CORBA::Boolean match_service(::CosLifeCycle::GenericFactory_ptr f);
    char* get_hint();
    void get_link_properties(const ::CosNaming::NameComponent& name, ::LifeCycleService::Keys_out key_set, ::LifeCycleService::PropertyList_out other_properties);
    PolicyList* policies();
    void policies(const ::LifeCycleService::PolicyList& _v);

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

  protected:
    virtual ~_objref_LifeCycleServiceAdmin();

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

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

    friend class LifeCycleServiceAdmin;
  };

  class _pof_LifeCycleServiceAdmin : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_LifeCycleServiceAdmin() : _OMNI_NS(proxyObjectFactory)(LifeCycleServiceAdmin::_PD_repoId) {}
    virtual ~_pof_LifeCycleServiceAdmin();

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

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

    virtual void bind_generic_factory(::CosLifeCycle::GenericFactory_ptr gf, const ::CosNaming::NameComponent& name, const ::LifeCycleService::Keys& key_set, const ::LifeCycleService::PropertyList& other_properties) = 0;
    virtual void unbind_generic_factory(const ::CosNaming::NameComponent& name) = 0;
    virtual CosLifeCycle::GenericFactory_ptr resolve_generic_factory(const ::CosNaming::NameComponent& name) = 0;
    virtual NameComponents* list_generic_factories() = 0;
    virtual ::CORBA::Boolean match_service(::CosLifeCycle::GenericFactory_ptr f) = 0;
    virtual char* get_hint() = 0;
    virtual void get_link_properties(const ::CosNaming::NameComponent& name, ::LifeCycleService::Keys_out key_set, ::LifeCycleService::PropertyList_out other_properties) = 0;
    virtual PolicyList* policies() = 0;
    virtual void policies(const ::LifeCycleService::PolicyList& _v) = 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_LifeCycleServiceAdmin;

_CORBA_MODULE_END



_CORBA_MODULE POA_LifeCycleService
_CORBA_MODULE_BEG

  class LifeCycleServiceAdmin :
    public virtual LifeCycleService::_impl_LifeCycleServiceAdmin,
    public virtual ::PortableServer::ServantBase
  {
  public:
    virtual ~LifeCycleServiceAdmin();

    inline ::LifeCycleService::LifeCycleServiceAdmin_ptr _this() {
      return (::LifeCycleService::LifeCycleServiceAdmin_ptr) _do_this(::LifeCycleService::LifeCycleServiceAdmin::_PD_repoId);
    }
  };

_CORBA_MODULE_END



_CORBA_MODULE OBV_LifeCycleService
_CORBA_MODULE_BEG

_CORBA_MODULE_END





#undef _core_attr
#undef _dyn_attr

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

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

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

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

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



inline void
LifeCycleService::LifeCycleServiceAdmin::_marshalObjRef(::LifeCycleService::LifeCycleServiceAdmin_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}




#ifdef   USE_stub_in_nt_dll_NOT_DEFINED_LifeCycleService
# undef  USE_stub_in_nt_dll
# undef  USE_stub_in_nt_dll_NOT_DEFINED_LifeCycleService
#endif
#ifdef   USE_core_stub_in_nt_dll_NOT_DEFINED_LifeCycleService
# undef  USE_core_stub_in_nt_dll
# undef  USE_core_stub_in_nt_dll_NOT_DEFINED_LifeCycleService
#endif
#ifdef   USE_dyn_stub_in_nt_dll_NOT_DEFINED_LifeCycleService
# undef  USE_dyn_stub_in_nt_dll
# undef  USE_dyn_stub_in_nt_dll_NOT_DEFINED_LifeCycleService
#endif

#endif  // __LifeCycleService_hh__