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

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

#ifndef __COSLIFECYCLE_H__
#define __COSLIFECYCLE_H__






namespace CosLifeCycle
{

class FactoryFinder;
typedef FactoryFinder *FactoryFinder_ptr;
typedef FactoryFinder_ptr FactoryFinderRef;
typedef ObjVar< FactoryFinder > FactoryFinder_var;
typedef ObjOut< FactoryFinder > FactoryFinder_out;

class LifeCycleObject;
typedef LifeCycleObject *LifeCycleObject_ptr;
typedef LifeCycleObject_ptr LifeCycleObjectRef;
typedef ObjVar< LifeCycleObject > LifeCycleObject_var;
typedef ObjOut< LifeCycleObject > LifeCycleObject_out;

class GenericFactory;
typedef GenericFactory *GenericFactory_ptr;
typedef GenericFactory_ptr GenericFactoryRef;
typedef ObjVar< GenericFactory > GenericFactory_var;
typedef ObjOut< GenericFactory > GenericFactory_out;

}



#include <coss/CosNaming.h>



namespace CosLifeCycle
{

typedef ::CosNaming::Name Key;
typedef TSeqVar< ::CosNaming::Name > Key_var;
typedef TSeqOut< ::CosNaming::Name > Key_out;

extern CORBA::TypeCodeConst _tc_Key;

typedef CORBA::Object Factory_;
typedef CORBA::Object_ptr Factory__ptr;
typedef CORBA::ObjectRef Factory_Ref;
typedef CORBA::Object_var Factory__var;
typedef CORBA::Object_out Factory__out;

extern CORBA::TypeCodeConst _tc_Factory_;

typedef IfaceSequenceTmpl< Factory__var,Factory__ptr> Factories;
typedef TSeqVar< IfaceSequenceTmpl< Factory__var,Factory__ptr> > Factories_var;
typedef TSeqOut< IfaceSequenceTmpl< Factory__var,Factory__ptr> > Factories_out;

extern CORBA::TypeCodeConst _tc_Factories;

struct NVP;
typedef TVarVar< NVP > NVP_var;
typedef TVarOut< NVP > NVP_out;


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

  ::CosNaming::Istring_var name;
  CORBA::Any value;
};

extern CORBA::TypeCodeConst _tc_NVP;

typedef NVP NameValuePair;
typedef NVP_var NameValuePair_var;
typedef NVP_out NameValuePair_out;

extern CORBA::TypeCodeConst _tc_NameValuePair;

typedef SequenceTmpl< NameValuePair,MICO_TID_DEF> Criteria;
typedef TSeqVar< SequenceTmpl< NameValuePair,MICO_TID_DEF> > Criteria_var;
typedef TSeqOut< SequenceTmpl< NameValuePair,MICO_TID_DEF> > Criteria_out;

extern CORBA::TypeCodeConst _tc_Criteria;

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

  #ifndef HAVE_EXPLICIT_STRUCT_OPS
  NoFactory();
  #endif //HAVE_EXPLICIT_STRUCT_OPS
  NoFactory( const ::CosLifeCycle::Key& _m0 );

  #ifdef HAVE_STD_EH
  NoFactory *operator->() { return this; }
  NoFactory& operator*() { return *this; }
  operator NoFactory*() { 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 NoFactory *_downcast( CORBA::Exception *ex );
  static const NoFactory *_downcast( const CORBA::Exception *ex );
  Key search_key;
};

#ifdef HAVE_STD_EH
typedef NoFactory NoFactory_catch;
#else
typedef ExceptVar< NoFactory > NoFactory_var;
typedef TVarOut< NoFactory > NoFactory_out;
typedef NoFactory_var NoFactory_catch;
#endif // HAVE_STD_EH

extern CORBA::TypeCodeConst _tc_NoFactory;

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

  #ifndef HAVE_EXPLICIT_STRUCT_OPS
  NotCopyable();
  #endif //HAVE_EXPLICIT_STRUCT_OPS
  NotCopyable( const char* _m0 );

  #ifdef HAVE_STD_EH
  NotCopyable *operator->() { return this; }
  NotCopyable& operator*() { return *this; }
  operator NotCopyable*() { 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 NotCopyable *_downcast( CORBA::Exception *ex );
  static const NotCopyable *_downcast( const CORBA::Exception *ex );
  CORBA::String_var reason;
};

#ifdef HAVE_STD_EH
typedef NotCopyable NotCopyable_catch;
#else
typedef ExceptVar< NotCopyable > NotCopyable_var;
typedef TVarOut< NotCopyable > NotCopyable_out;
typedef NotCopyable_var NotCopyable_catch;
#endif // HAVE_STD_EH

extern CORBA::TypeCodeConst _tc_NotCopyable;

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

  #ifndef HAVE_EXPLICIT_STRUCT_OPS
  NotMovable();
  #endif //HAVE_EXPLICIT_STRUCT_OPS
  NotMovable( const char* _m0 );

  #ifdef HAVE_STD_EH
  NotMovable *operator->() { return this; }
  NotMovable& operator*() { return *this; }
  operator NotMovable*() { 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 NotMovable *_downcast( CORBA::Exception *ex );
  static const NotMovable *_downcast( const CORBA::Exception *ex );
  CORBA::String_var reason;
};

#ifdef HAVE_STD_EH
typedef NotMovable NotMovable_catch;
#else
typedef ExceptVar< NotMovable > NotMovable_var;
typedef TVarOut< NotMovable > NotMovable_out;
typedef NotMovable_var NotMovable_catch;
#endif // HAVE_STD_EH

extern CORBA::TypeCodeConst _tc_NotMovable;

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

  #ifndef HAVE_EXPLICIT_STRUCT_OPS
  NotRemovable();
  #endif //HAVE_EXPLICIT_STRUCT_OPS
  NotRemovable( const char* _m0 );

  #ifdef HAVE_STD_EH
  NotRemovable *operator->() { return this; }
  NotRemovable& operator*() { return *this; }
  operator NotRemovable*() { 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 NotRemovable *_downcast( CORBA::Exception *ex );
  static const NotRemovable *_downcast( const CORBA::Exception *ex );
  CORBA::String_var reason;
};

#ifdef HAVE_STD_EH
typedef NotRemovable NotRemovable_catch;
#else
typedef ExceptVar< NotRemovable > NotRemovable_var;
typedef TVarOut< NotRemovable > NotRemovable_out;
typedef NotRemovable_var NotRemovable_catch;
#endif // HAVE_STD_EH

extern CORBA::TypeCodeConst _tc_NotRemovable;

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

  #ifndef HAVE_EXPLICIT_STRUCT_OPS
  InvalidCriteria();
  #endif //HAVE_EXPLICIT_STRUCT_OPS
  InvalidCriteria( const ::CosLifeCycle::Criteria& _m0 );

  #ifdef HAVE_STD_EH
  InvalidCriteria *operator->() { return this; }
  InvalidCriteria& operator*() { return *this; }
  operator InvalidCriteria*() { 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 InvalidCriteria *_downcast( CORBA::Exception *ex );
  static const InvalidCriteria *_downcast( const CORBA::Exception *ex );
  Criteria invalid_criteria;
};

#ifdef HAVE_STD_EH
typedef InvalidCriteria InvalidCriteria_catch;
#else
typedef ExceptVar< InvalidCriteria > InvalidCriteria_var;
typedef TVarOut< InvalidCriteria > InvalidCriteria_out;
typedef InvalidCriteria_var InvalidCriteria_catch;
#endif // HAVE_STD_EH

extern CORBA::TypeCodeConst _tc_InvalidCriteria;

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

  #ifndef HAVE_EXPLICIT_STRUCT_OPS
  CannotMeetCriteria();
  #endif //HAVE_EXPLICIT_STRUCT_OPS
  CannotMeetCriteria( const ::CosLifeCycle::Criteria& _m0 );

  #ifdef HAVE_STD_EH
  CannotMeetCriteria *operator->() { return this; }
  CannotMeetCriteria& operator*() { return *this; }
  operator CannotMeetCriteria*() { 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 CannotMeetCriteria *_downcast( CORBA::Exception *ex );
  static const CannotMeetCriteria *_downcast( const CORBA::Exception *ex );
  Criteria unmet_criteria;
};

#ifdef HAVE_STD_EH
typedef CannotMeetCriteria CannotMeetCriteria_catch;
#else
typedef ExceptVar< CannotMeetCriteria > CannotMeetCriteria_var;
typedef TVarOut< CannotMeetCriteria > CannotMeetCriteria_out;
typedef CannotMeetCriteria_var CannotMeetCriteria_catch;
#endif // HAVE_STD_EH

extern CORBA::TypeCodeConst _tc_CannotMeetCriteria;


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

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

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef FactoryFinder_ptr _ptr_type;
    typedef FactoryFinder_var _var_type;
    #endif

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

    static FactoryFinder_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual Factories* find_factories( const Key& factory_key ) = 0;

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

extern CORBA::TypeCodeConst _tc_FactoryFinder;

// Stub for interface FactoryFinder
class FactoryFinder_stub:
  virtual public FactoryFinder
{
  public:
    virtual ~FactoryFinder_stub();
    Factories* find_factories( const Key& factory_key );

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

#ifndef MICO_CONF_NO_POA

class FactoryFinder_stub_clp :
  virtual public FactoryFinder_stub,
  virtual public PortableServer::StubBase
{
  public:
    FactoryFinder_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~FactoryFinder_stub_clp ();
    Factories* find_factories( const Key& factory_key );

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

#endif // MICO_CONF_NO_POA


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

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

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef LifeCycleObject_ptr _ptr_type;
    typedef LifeCycleObject_var _var_type;
    #endif

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

    static LifeCycleObject_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual LifeCycleObject_ptr copy( FactoryFinder_ptr there, const Criteria& the_criteria ) = 0;
    virtual void move( FactoryFinder_ptr there, const Criteria& the_criteria ) = 0;
    virtual void remove() = 0;

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

extern CORBA::TypeCodeConst _tc_LifeCycleObject;

// Stub for interface LifeCycleObject
class LifeCycleObject_stub:
  virtual public LifeCycleObject
{
  public:
    virtual ~LifeCycleObject_stub();
    LifeCycleObject_ptr copy( FactoryFinder_ptr there, const Criteria& the_criteria );
    void move( FactoryFinder_ptr there, const Criteria& the_criteria );
    void remove();

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

#ifndef MICO_CONF_NO_POA

class LifeCycleObject_stub_clp :
  virtual public LifeCycleObject_stub,
  virtual public PortableServer::StubBase
{
  public:
    LifeCycleObject_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~LifeCycleObject_stub_clp ();
    LifeCycleObject_ptr copy( FactoryFinder_ptr there, const Criteria& the_criteria );
    void move( FactoryFinder_ptr there, const Criteria& the_criteria );
    void remove();

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

#endif // MICO_CONF_NO_POA


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

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

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef GenericFactory_ptr _ptr_type;
    typedef GenericFactory_var _var_type;
    #endif

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

    static GenericFactory_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual CORBA::Boolean support( const Key& k ) = 0;
    virtual CORBA::Object_ptr create_object( const Key& k, const Criteria& the_criteria ) = 0;

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

extern CORBA::TypeCodeConst _tc_GenericFactory;

// Stub for interface GenericFactory
class GenericFactory_stub:
  virtual public GenericFactory
{
  public:
    virtual ~GenericFactory_stub();
    CORBA::Boolean support( const Key& k );
    CORBA::Object_ptr create_object( const Key& k, const Criteria& the_criteria );

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

#ifndef MICO_CONF_NO_POA

class GenericFactory_stub_clp :
  virtual public GenericFactory_stub,
  virtual public PortableServer::StubBase
{
  public:
    GenericFactory_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~GenericFactory_stub_clp ();
    CORBA::Boolean support( const Key& k );
    CORBA::Object_ptr create_object( const Key& k, const Criteria& the_criteria );

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

#endif // MICO_CONF_NO_POA

}


#ifndef MICO_CONF_NO_POA



namespace POA_CosLifeCycle
{

class FactoryFinder : virtual public PortableServer::StaticImplementation
{
  public:
    virtual ~FactoryFinder ();
    CosLifeCycle::FactoryFinder_ptr _this ();
    bool dispatch (CORBA::StaticServerRequest_ptr);
    virtual void invoke (CORBA::StaticServerRequest_ptr);
    virtual CORBA::Boolean _is_a (const char *);
    virtual CORBA::InterfaceDef_ptr _get_interface ();
    virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);

    virtual void * _narrow_helper (const char *);
    static FactoryFinder * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

    virtual ::CosLifeCycle::Factories* find_factories( const ::CosLifeCycle::Key& factory_key ) = 0;

  protected:
    FactoryFinder () {};

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

class LifeCycleObject : virtual public PortableServer::StaticImplementation
{
  public:
    virtual ~LifeCycleObject ();
    CosLifeCycle::LifeCycleObject_ptr _this ();
    bool dispatch (CORBA::StaticServerRequest_ptr);
    virtual void invoke (CORBA::StaticServerRequest_ptr);
    virtual CORBA::Boolean _is_a (const char *);
    virtual CORBA::InterfaceDef_ptr _get_interface ();
    virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);

    virtual void * _narrow_helper (const char *);
    static LifeCycleObject * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

    virtual ::CosLifeCycle::LifeCycleObject_ptr copy( ::CosLifeCycle::FactoryFinder_ptr there, const ::CosLifeCycle::Criteria& the_criteria ) = 0;
    virtual void move( ::CosLifeCycle::FactoryFinder_ptr there, const ::CosLifeCycle::Criteria& the_criteria ) = 0;
    virtual void remove() = 0;

  protected:
    LifeCycleObject () {};

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

class GenericFactory : virtual public PortableServer::StaticImplementation
{
  public:
    virtual ~GenericFactory ();
    CosLifeCycle::GenericFactory_ptr _this ();
    bool dispatch (CORBA::StaticServerRequest_ptr);
    virtual void invoke (CORBA::StaticServerRequest_ptr);
    virtual CORBA::Boolean _is_a (const char *);
    virtual CORBA::InterfaceDef_ptr _get_interface ();
    virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);

    virtual void * _narrow_helper (const char *);
    static GenericFactory * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

    virtual CORBA::Boolean support( const ::CosLifeCycle::Key& k ) = 0;
    virtual CORBA::Object_ptr create_object( const ::CosLifeCycle::Key& k, const ::CosLifeCycle::Criteria& the_criteria ) = 0;

  protected:
    GenericFactory () {};

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

}


#endif // MICO_CONF_NO_POA

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

extern CORBA::StaticTypeInfo *_marshaller_CosLifeCycle_NVP;

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

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

extern CORBA::StaticTypeInfo *_marshaller_CosLifeCycle_NoFactory;

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

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

extern CORBA::StaticTypeInfo *_marshaller_CosLifeCycle_NotCopyable;

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

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

extern CORBA::StaticTypeInfo *_marshaller_CosLifeCycle_NotMovable;

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

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

extern CORBA::StaticTypeInfo *_marshaller_CosLifeCycle_NotRemovable;

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

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

extern CORBA::StaticTypeInfo *_marshaller_CosLifeCycle_InvalidCriteria;

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

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

extern CORBA::StaticTypeInfo *_marshaller_CosLifeCycle_CannotMeetCriteria;

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

extern CORBA::StaticTypeInfo *_marshaller_CosLifeCycle_FactoryFinder;

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

extern CORBA::StaticTypeInfo *_marshaller_CosLifeCycle_LifeCycleObject;

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

extern CORBA::StaticTypeInfo *_marshaller_CosLifeCycle_GenericFactory;

void operator<<=( CORBA::Any &_a, const IfaceSequenceTmpl< CosLifeCycle::Factory__var,CosLifeCycle::Factory__ptr> &_s );
void operator<<=( CORBA::Any &_a, IfaceSequenceTmpl< CosLifeCycle::Factory__var,CosLifeCycle::Factory__ptr> *_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, IfaceSequenceTmpl< CosLifeCycle::Factory__var,CosLifeCycle::Factory__ptr> &_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, const IfaceSequenceTmpl< CosLifeCycle::Factory__var,CosLifeCycle::Factory__ptr> *&_s );

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

extern CORBA::StaticTypeInfo *_marshaller__seq_CosLifeCycle_NVP;

#endif
