// POAS.h,v 1.28 2000/01/07 04:44:06 irfan Exp
//
// ============================================================================
//
// = LIBRARY
//    TAO
//
// = FILENAME
//    POAC.h
//
// = DESCRIPTION
//
//    POA skels. This code generated by the The ACE ORB (TAO) IDL
//    Compiler and is not meant to be read.
//
// ============================================================================

#ifndef TAO_IDL_POAS_H
#define TAO_IDL_POAS_H

#include "tao/POAC.h"

#if !defined (ACE_LACKS_PRAGMA_ONCE)
# pragma once
#endif /* ACE_LACKS_PRAGMA_ONCE */

#include "tao/Servant_Base.h"
#include "tao/POA_CORBA.h"

#if defined (TAO_EXPORT_MACRO)
#undef TAO_EXPORT_MACRO
#endif
#define TAO_EXPORT_MACRO TAO_Export
#if defined(_MSC_VER)
#if (_MSC_VER >= 1200)
#pragma warning(push)
#endif /* _MSC_VER >= 1200 */
#pragma warning(disable:4250)
#endif /* _MSC_VER */

TAO_NAMESPACE POA_PortableServer
{

#if (TAO_HAS_MINIMUM_POA == 0)

  class ThreadPolicy;
  typedef ThreadPolicy *ThreadPolicy_ptr;
  class TAO_Export ThreadPolicy : public virtual POA_CORBA::Policy
  {
  protected:
    ThreadPolicy (void);
  public:
    virtual ~ThreadPolicy (void);
    virtual CORBA::Boolean _is_a (
                                  const char* logical_type_id,
                                  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());
    virtual void* _downcast (
                             const char* logical_type_id
                             );
    virtual PortableServer::ThreadPolicyValue value (CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()) = 0;
#if !defined (TAO_HAS_LOCALITY_CONSTRAINT_POLICIES)
    static void _get_value_skel (CORBA::ServerRequest &req, void *obj, void *context, CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());

    static void _is_a_skel (CORBA::ServerRequest &req, void *obj, void *context, CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());

    static void _non_existent_skel (CORBA::ServerRequest &req, void *obj, void *context, CORBA::Environment &ACE_TRY_ENV = CORBA::Environment::default_environment ());

    static void copy_skel (CORBA::ServerRequest &req, void *obj, void *context, CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());

    static void destroy_skel (CORBA::ServerRequest &req, void *obj, void *context, CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());

    static void _get_policy_type_skel (
                                       CORBA::ServerRequest &_tao_req,
                                       void *_tao_obj,
                                       void *_tao_context,
                                       CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                                       );

    virtual void _dispatch (CORBA::ServerRequest &req, void *context, CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());
#endif /* !TAO_HAS_LOCALITY_CONSTRAINT_POLICIES */

    PortableServer::ThreadPolicy *_this (CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());
    virtual const char* _interface_repository_id (void) const;
  };


#if !defined (_PORTABLESERVER_THREADPOLICY___COLLOCATED_SH_)
#define _PORTABLESERVER_THREADPOLICY___COLLOCATED_SH_

  class TAO_Export _tao_collocated_ThreadPolicy    : public virtual PortableServer::ThreadPolicy,
                                                     public virtual POA_CORBA::_tao_collocated_Policy
  {
  public:
    _tao_collocated_ThreadPolicy (
                                  ThreadPolicy_ptr  servant,
                                  TAO_Stub *stub
                                  );
    ThreadPolicy_ptr _get_servant (void) const;
    virtual CORBA::Boolean _is_a (
                                  const char *logical_type_id,
                                  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                                  );
    virtual PortableServer::ThreadPolicyValue value (
                                                     CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                                                     );
    virtual CORBA::Policy_ptr copy (
                                    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                                    );
    virtual void destroy (
                          CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                          );
    virtual CORBA::PolicyType policy_type (
                                           CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                                           );
  private:
    ThreadPolicy_ptr servant_;
  };


#endif // end #if !defined

#endif /* TAO_HAS_MINIMUM_POA == 0 */

  class LifespanPolicy;
  typedef LifespanPolicy *LifespanPolicy_ptr;
  class TAO_Export LifespanPolicy : public virtual POA_CORBA::Policy
  {
  protected:
    LifespanPolicy (void);
  public:
    virtual ~LifespanPolicy (void);
    virtual CORBA::Boolean _is_a (
                                  const char* logical_type_id,
                                  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());
    virtual void* _downcast (
                             const char* logical_type_id
                             );
    virtual PortableServer::LifespanPolicyValue value (CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()) = 0;

#if !defined (TAO_HAS_LOCALITY_CONSTRAINT_POLICIES)
    static void _get_value_skel (CORBA::ServerRequest &req, void *obj, void *context, CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());

    static void _is_a_skel (CORBA::ServerRequest &req, void *obj, void *context, CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());

    static void _non_existent_skel (CORBA::ServerRequest &req, void *obj, void *context, CORBA::Environment &ACE_TRY_ENV = CORBA::Environment::default_environment ());

    static void copy_skel (CORBA::ServerRequest &req, void *obj, void *context, CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());

    static void destroy_skel (CORBA::ServerRequest &req, void *obj, void *context, CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());

    static void _get_policy_type_skel (
                                       CORBA::ServerRequest &_tao_req,
                                       void *_tao_obj,
                                       void *_tao_context,
                                       CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                                       );

    virtual void _dispatch (CORBA::ServerRequest &req, void *context, CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());
#endif /* !TAO_HAS_LOCALITY_CONSTRAINT_POLICIES */

    PortableServer::LifespanPolicy *_this (CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());
    virtual const char* _interface_repository_id (void) const;
  };


#if !defined (_PORTABLESERVER_LIFESPANPOLICY___COLLOCATED_SH_)
#define _PORTABLESERVER_LIFESPANPOLICY___COLLOCATED_SH_

  class TAO_Export _tao_collocated_LifespanPolicy    : public virtual PortableServer::LifespanPolicy,
                                                       public virtual POA_CORBA::_tao_collocated_Policy
  {
  public:
    _tao_collocated_LifespanPolicy (
                                    LifespanPolicy_ptr  servant,
                                    TAO_Stub *stub
                                    );
    LifespanPolicy_ptr _get_servant (void) const;
    virtual CORBA::Boolean _is_a (
                                  const char *logical_type_id,
                                  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                                  );
    virtual PortableServer::LifespanPolicyValue value (
                                                       CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                                                       );
    virtual CORBA::Policy_ptr copy (
                                    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                                    );
    virtual void destroy (
                          CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                          );
    virtual CORBA::PolicyType policy_type (
                                           CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                                           );

  private:
    LifespanPolicy_ptr servant_;
  };


#endif // end #if !defined


  class IdUniquenessPolicy;
  typedef IdUniquenessPolicy *IdUniquenessPolicy_ptr;
  class TAO_Export IdUniquenessPolicy : public virtual POA_CORBA::Policy
  {
  protected:
    IdUniquenessPolicy (void);
  public:
    virtual ~IdUniquenessPolicy (void);
    virtual CORBA::Boolean _is_a (
                                  const char* logical_type_id,
                                  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());
    virtual void* _downcast (
                             const char* logical_type_id
                             );
    virtual PortableServer::IdUniquenessPolicyValue value (CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()) = 0;

#if !defined (TAO_HAS_LOCALITY_CONSTRAINT_POLICIES)
    static void _get_value_skel (CORBA::ServerRequest &req, void *obj, void *context, CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());

    static void _is_a_skel (CORBA::ServerRequest &req, void *obj, void *context, CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());

    static void _non_existent_skel (CORBA::ServerRequest &req, void *obj, void *context, CORBA::Environment &ACE_TRY_ENV = CORBA::Environment::default_environment ());

    static void copy_skel (CORBA::ServerRequest &req, void *obj, void *context, CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());

    static void destroy_skel (CORBA::ServerRequest &req, void *obj, void *context, CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());

    static void _get_policy_type_skel (
                                       CORBA::ServerRequest &_tao_req,
                                       void *_tao_obj,
                                       void *_tao_context,
                                       CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                                       );

    virtual void _dispatch (CORBA::ServerRequest &req, void *context, CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());
#endif /* !TAO_HAS_LOCALITY_CONSTRAINT_POLICIES */

    PortableServer::IdUniquenessPolicy *_this (CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());
    virtual const char* _interface_repository_id (void) const;
  };


#if !defined (_PORTABLESERVER_IDUNIQUENESSPOLICY___COLLOCATED_SH_)
#define _PORTABLESERVER_IDUNIQUENESSPOLICY___COLLOCATED_SH_

  class TAO_Export _tao_collocated_IdUniquenessPolicy    : public virtual PortableServer::IdUniquenessPolicy,
                                                           public virtual POA_CORBA::_tao_collocated_Policy
  {
  public:
    _tao_collocated_IdUniquenessPolicy (
                                        IdUniquenessPolicy_ptr  servant,
                                        TAO_Stub *stub
                                        );
    IdUniquenessPolicy_ptr _get_servant (void) const;
    virtual CORBA::Boolean _is_a (
                                  const char *logical_type_id,
                                  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                                  );
    virtual PortableServer::IdUniquenessPolicyValue value (
                                                           CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                                                           );
    virtual CORBA::Policy_ptr copy (
                                    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                                    );
    virtual void destroy (
                          CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                          );
    virtual CORBA::PolicyType policy_type (
                                           CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                                           );

  private:
    IdUniquenessPolicy_ptr servant_;
  };


#endif // end #if !defined


  class IdAssignmentPolicy;
  typedef IdAssignmentPolicy *IdAssignmentPolicy_ptr;
  class TAO_Export IdAssignmentPolicy : public virtual POA_CORBA::Policy
  {
  protected:
    IdAssignmentPolicy (void);
  public:
    virtual ~IdAssignmentPolicy (void);
    virtual CORBA::Boolean _is_a (
                                  const char* logical_type_id,
                                  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());
    virtual void* _downcast (
                             const char* logical_type_id
                             );
    virtual PortableServer::IdAssignmentPolicyValue value (CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()) = 0;

#if !defined (TAO_HAS_LOCALITY_CONSTRAINT_POLICIES)
    static void _get_value_skel (CORBA::ServerRequest &req, void *obj, void *context, CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());

    static void _is_a_skel (CORBA::ServerRequest &req, void *obj, void *context, CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());

    static void _non_existent_skel (CORBA::ServerRequest &req, void *obj, void *context, CORBA::Environment &ACE_TRY_ENV = CORBA::Environment::default_environment ());

    static void copy_skel (CORBA::ServerRequest &req, void *obj, void *context, CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());

    static void destroy_skel (CORBA::ServerRequest &req, void *obj, void *context, CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());

    static void _get_policy_type_skel (
                                       CORBA::ServerRequest &_tao_req,
                                       void *_tao_obj,
                                       void *_tao_context,
                                       CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                                       );

    virtual void _dispatch (CORBA::ServerRequest &req, void *context, CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());
#endif /* !TAO_HAS_LOCALITY_CONSTRAINT_POLICIES */

    PortableServer::IdAssignmentPolicy *_this (CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());
    virtual const char* _interface_repository_id (void) const;
  };


#if !defined (_PORTABLESERVER_IDASSIGNMENTPOLICY___COLLOCATED_SH_)
#define _PORTABLESERVER_IDASSIGNMENTPOLICY___COLLOCATED_SH_

  class TAO_Export _tao_collocated_IdAssignmentPolicy    : public virtual PortableServer::IdAssignmentPolicy,
                                                           public virtual POA_CORBA::_tao_collocated_Policy
  {
  public:
    _tao_collocated_IdAssignmentPolicy (
                                        IdAssignmentPolicy_ptr  servant,
                                        TAO_Stub *stub
                                        );
    IdAssignmentPolicy_ptr _get_servant (void) const;
    virtual CORBA::Boolean _is_a (
                                  const char *logical_type_id,
                                  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                                  );
    virtual PortableServer::IdAssignmentPolicyValue value (
                                                           CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                                                           );
    virtual CORBA::Policy_ptr copy (
                                    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                                    );
    virtual void destroy (
                          CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                          );
    virtual CORBA::PolicyType policy_type (
                                           CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                                           );

  private:
    IdAssignmentPolicy_ptr servant_;
  };


#endif // end #if !defined


#if (TAO_HAS_MINIMUM_POA == 0)

  class ImplicitActivationPolicy;
  typedef ImplicitActivationPolicy *ImplicitActivationPolicy_ptr;
  class TAO_Export ImplicitActivationPolicy : public virtual POA_CORBA::Policy
  {
  protected:
    ImplicitActivationPolicy (void);
  public:
    virtual ~ImplicitActivationPolicy (void);
    virtual CORBA::Boolean _is_a (
                                  const char* logical_type_id,
                                  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());
    virtual void* _downcast (
                             const char* logical_type_id
                             );
    virtual PortableServer::ImplicitActivationPolicyValue value (CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()) = 0;

#if !defined (TAO_HAS_LOCALITY_CONSTRAINT_POLICIES)
    static void _get_value_skel (CORBA::ServerRequest &req, void *obj, void *context, CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());

    static void _is_a_skel (CORBA::ServerRequest &req, void *obj, void *context, CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());

    static void _non_existent_skel (CORBA::ServerRequest &req, void *obj, void *context, CORBA::Environment &ACE_TRY_ENV = CORBA::Environment::default_environment ());

    static void copy_skel (CORBA::ServerRequest &req, void *obj, void *context, CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());

    static void destroy_skel (CORBA::ServerRequest &req, void *obj, void *context, CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());

    static void _get_policy_type_skel (
                                       CORBA::ServerRequest &_tao_req,
                                       void *_tao_obj,
                                       void *_tao_context,
                                       CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                                       );

    virtual void _dispatch (CORBA::ServerRequest &req, void *context, CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());
#endif /* !TAO_HAS_LOCALITY_CONSTRAINT_POLICIES */

    PortableServer::ImplicitActivationPolicy *_this (CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());
    virtual const char* _interface_repository_id (void) const;
  };


#if !defined (_PORTABLESERVER_IMPLICITACTIVATIONPOLICY___COLLOCATED_SH_)
#define _PORTABLESERVER_IMPLICITACTIVATIONPOLICY___COLLOCATED_SH_

  class TAO_Export _tao_collocated_ImplicitActivationPolicy    : public virtual PortableServer::ImplicitActivationPolicy,
                                                                 public virtual POA_CORBA::_tao_collocated_Policy
  {
  public:
    _tao_collocated_ImplicitActivationPolicy (
                                              ImplicitActivationPolicy_ptr  servant,
                                              TAO_Stub *stub
                                              );
    ImplicitActivationPolicy_ptr _get_servant (void) const;
    virtual CORBA::Boolean _is_a (
                                  const char *logical_type_id,
                                  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                                  );
    virtual PortableServer::ImplicitActivationPolicyValue value (
                                                                 CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                                                                 );
    virtual CORBA::Policy_ptr copy (
                                    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                                    );
    virtual void destroy (
                          CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                          );
    virtual CORBA::PolicyType policy_type (
                                           CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                                           );

  private:
    ImplicitActivationPolicy_ptr servant_;
  };


#endif // end #if !defined


  class ServantRetentionPolicy;
  typedef ServantRetentionPolicy *ServantRetentionPolicy_ptr;
  class TAO_Export ServantRetentionPolicy : public virtual POA_CORBA::Policy
  {
  protected:
    ServantRetentionPolicy (void);
  public:
    virtual ~ServantRetentionPolicy (void);
    virtual CORBA::Boolean _is_a (
                                  const char* logical_type_id,
                                  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());
    virtual void* _downcast (
                             const char* logical_type_id
                             );
    virtual PortableServer::ServantRetentionPolicyValue value (CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()) = 0;

#if !defined (TAO_HAS_LOCALITY_CONSTRAINT_POLICIES)
    static void _get_value_skel (CORBA::ServerRequest &req, void *obj, void *context, CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());

    static void _is_a_skel (CORBA::ServerRequest &req, void *obj, void *context, CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());

    static void _non_existent_skel (CORBA::ServerRequest &req, void *obj, void *context, CORBA::Environment &ACE_TRY_ENV = CORBA::Environment::default_environment ());

    static void copy_skel (CORBA::ServerRequest &req, void *obj, void *context, CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());

    static void destroy_skel (CORBA::ServerRequest &req, void *obj, void *context, CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());

    static void _get_policy_type_skel (
                                       CORBA::ServerRequest &_tao_req,
                                       void *_tao_obj,
                                       void *_tao_context,
                                       CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                                       );

    virtual void _dispatch (CORBA::ServerRequest &req, void *context, CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());
#endif /* !TAO_HAS_LOCALITY_CONSTRAINT_POLICIES */

    PortableServer::ServantRetentionPolicy *_this (CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());
    virtual const char* _interface_repository_id (void) const;
  };


#if !defined (_PORTABLESERVER_SERVANTRETENTIONPOLICY___COLLOCATED_SH_)
#define _PORTABLESERVER_SERVANTRETENTIONPOLICY___COLLOCATED_SH_

  class TAO_Export _tao_collocated_ServantRetentionPolicy    : public virtual PortableServer::ServantRetentionPolicy,
                                                               public virtual POA_CORBA::_tao_collocated_Policy
  {
  public:
    _tao_collocated_ServantRetentionPolicy (
                                            ServantRetentionPolicy_ptr  servant,
                                            TAO_Stub *stub
                                            );
    ServantRetentionPolicy_ptr _get_servant (void) const;
    virtual CORBA::Boolean _is_a (
                                  const char *logical_type_id,
                                  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                                  );
    virtual PortableServer::ServantRetentionPolicyValue value (
                                                               CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                                                               );
    virtual CORBA::Policy_ptr copy (
                                    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                                    );
    virtual void destroy (
                          CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                          );
    virtual CORBA::PolicyType policy_type (
                                           CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                                           );

  private:
    ServantRetentionPolicy_ptr servant_;
  };


#endif // end #if !defined


  class RequestProcessingPolicy;
  typedef RequestProcessingPolicy *RequestProcessingPolicy_ptr;
  class TAO_Export RequestProcessingPolicy : public virtual POA_CORBA::Policy
  {
  protected:
    RequestProcessingPolicy (void);
  public:
    virtual ~RequestProcessingPolicy (void);
    virtual CORBA::Boolean _is_a (
                                  const char* logical_type_id,
                                  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());
    virtual void* _downcast (
                             const char* logical_type_id
                             );
    virtual PortableServer::RequestProcessingPolicyValue value (CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()) = 0;

#if !defined (TAO_HAS_LOCALITY_CONSTRAINT_POLICIES)
    static void _get_value_skel (CORBA::ServerRequest &req, void *obj, void *context, CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());

    static void _is_a_skel (CORBA::ServerRequest &req, void *obj, void *context, CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());

    static void _non_existent_skel (CORBA::ServerRequest &req, void *obj, void *context, CORBA::Environment &ACE_TRY_ENV = CORBA::Environment::default_environment ());

    static void copy_skel (CORBA::ServerRequest &req, void *obj, void *context, CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());

    static void destroy_skel (CORBA::ServerRequest &req, void *obj, void *context, CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());

    static void _get_policy_type_skel (
                                       CORBA::ServerRequest &_tao_req,
                                       void *_tao_obj,
                                       void *_tao_context,
                                       CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                                       );

    virtual void _dispatch (CORBA::ServerRequest &req, void *context, CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());
#endif /* !TAO_HAS_LOCALITY_CONSTRAINT_POLICIES */

    PortableServer::RequestProcessingPolicy *_this (CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());
    virtual const char* _interface_repository_id (void) const;
  };


#if !defined (_PORTABLESERVER_REQUESTPROCESSINGPOLICY___COLLOCATED_SH_)
#define _PORTABLESERVER_REQUESTPROCESSINGPOLICY___COLLOCATED_SH_

  class TAO_Export _tao_collocated_RequestProcessingPolicy    : public virtual PortableServer::RequestProcessingPolicy,
                                                                public virtual POA_CORBA::_tao_collocated_Policy
  {
  public:
    _tao_collocated_RequestProcessingPolicy (
                                             RequestProcessingPolicy_ptr  servant,
                                             TAO_Stub *stub
                                             );
    RequestProcessingPolicy_ptr _get_servant (void) const;
    virtual CORBA::Boolean _is_a (
                                  const char *logical_type_id,
                                  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                                  );
    virtual PortableServer::RequestProcessingPolicyValue value (
                                                                CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                                                                );
    virtual CORBA::Policy_ptr copy (
                                    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                                    );
    virtual void destroy (
                          CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                          );
    virtual CORBA::PolicyType policy_type (
                                           CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                                           );

  private:
    RequestProcessingPolicy_ptr servant_;
  };


#endif // end #if !defined

#endif /* TAO_HAS_MINIMUM_POA == 0 */


  class POAManager;
  typedef POAManager *POAManager_ptr;
  class TAO_Export POAManager :  public virtual TAO_Local_ServantBase
  {
  protected:
    POAManager (void);
  public:
    virtual ~POAManager (void);
    virtual CORBA::Boolean _is_a (
                                  const char* logical_type_id,
                                  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());
    virtual void* _downcast (
                             const char* logical_type_id
                             );
    virtual void activate ( CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()) = 0; // pure virtual

#if (TAO_HAS_MINIMUM_POA == 0)

    virtual void hold_requests (CORBA::Boolean wait_for_completion,  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()) = 0; // pure virtual

    virtual void discard_requests (CORBA::Boolean wait_for_completion,  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()) = 0; // pure virtual

    virtual void deactivate (CORBA::Boolean etherealize_objects, CORBA::Boolean wait_for_completion,  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()) = 0; // pure virtual

#endif /* TAO_HAS_MINIMUM_POA == 0 */

    virtual PortableServer::POAManager::State get_state (CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()) = 0; // pure virtual

    PortableServer::POAManager *_this (CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());
    virtual const char* _interface_repository_id (void) const;
  };


#if !defined (_PORTABLESERVER_POAMANAGER___COLLOCATED_SH_)
#define _PORTABLESERVER_POAMANAGER___COLLOCATED_SH_

  class TAO_Export _tao_collocated_POAManager    : public virtual PortableServer::POAManager
  {
  public:
    _tao_collocated_POAManager (
                                POAManager_ptr  servant,
                                TAO_Stub *stub
                                );
    POAManager_ptr _get_servant (void) const;
    virtual CORBA::Boolean _is_a (
                                  const char *logical_type_id,
                                  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                                  );
    virtual void activate (
                           CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                           );

#if (TAO_HAS_MINIMUM_POA == 0)

    virtual void hold_requests (
                                CORBA::Boolean wait_for_completion,
                                CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                                );
    virtual void discard_requests (
                                   CORBA::Boolean wait_for_completion,
                                   CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                                   );
    virtual void deactivate (
                             CORBA::Boolean etherealize_objects,
                             CORBA::Boolean wait_for_completion,
                             CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                             );

#endif /* TAO_HAS_MINIMUM_POA == 0 */

    virtual PortableServer::POAManager::State get_state (CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());

  private:
    POAManager_ptr servant_;
  };


#endif // end #if !defined


#if (TAO_HAS_MINIMUM_POA == 0)

  class AdapterActivator;
  typedef AdapterActivator *AdapterActivator_ptr;
  class TAO_Export AdapterActivator :  public virtual TAO_Local_ServantBase
  {
  protected:
    AdapterActivator (void);
  public:
    virtual ~AdapterActivator (void);
    virtual CORBA::Boolean _is_a (
                                  const char* logical_type_id,
                                  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());
    virtual void* _downcast (
                             const char* logical_type_id
                             );
    virtual CORBA::Boolean unknown_adapter (PortableServer::POA_ptr parent, const char *name,  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()) = 0; // pure virtual

    PortableServer::AdapterActivator *_this (CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());
    virtual const char* _interface_repository_id (void) const;
  };


#if !defined (_PORTABLESERVER_ADAPTERACTIVATOR___COLLOCATED_SH_)
#define _PORTABLESERVER_ADAPTERACTIVATOR___COLLOCATED_SH_

  class TAO_Export _tao_collocated_AdapterActivator    : public virtual PortableServer::AdapterActivator
  {
  public:
    _tao_collocated_AdapterActivator (
                                      AdapterActivator_ptr  servant,
                                      TAO_Stub *stub
                                      );
    AdapterActivator_ptr _get_servant (void) const;
    virtual CORBA::Boolean _is_a (
                                  const char *logical_type_id,
                                  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                                  );
    virtual CORBA::Boolean unknown_adapter (
                                            PortableServer::POA_ptr  parent,
                                            const char* name,
                                            CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                                            );

  private:
    AdapterActivator_ptr servant_;
  };


#endif // end #if !defined


  class ServantManager;
  typedef ServantManager *ServantManager_ptr;
  class TAO_Export ServantManager :  public virtual TAO_Local_ServantBase
  {
  protected:
    ServantManager (void);
  public:
    virtual ~ServantManager (void);
    virtual CORBA::Boolean _is_a (
                                  const char* logical_type_id,
                                  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());
    virtual void* _downcast (
                             const char* logical_type_id
                             );

    PortableServer::ServantManager *_this (CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());
    virtual const char* _interface_repository_id (void) const;
  };


#if !defined (_PORTABLESERVER_SERVANTMANAGER___COLLOCATED_SH_)
#define _PORTABLESERVER_SERVANTMANAGER___COLLOCATED_SH_

  class TAO_Export _tao_collocated_ServantManager    : public virtual PortableServer::ServantManager
  {
  public:
    _tao_collocated_ServantManager (
                                    ServantManager_ptr  servant,
                                    TAO_Stub *stub
                                    );
    ServantManager_ptr _get_servant (void) const;
    virtual CORBA::Boolean _is_a (
                                  const char *logical_type_id,
                                  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                                  );

  private:
    ServantManager_ptr servant_;
  };


#endif // end #if !defined


  class ServantActivator;
  typedef ServantActivator *ServantActivator_ptr;
  class TAO_Export ServantActivator : public virtual ServantManager
  {
  protected:
    ServantActivator (void);
  public:
    virtual ~ServantActivator (void);
    virtual CORBA::Boolean _is_a (
                                  const char* logical_type_id,
                                  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());
    virtual void* _downcast (
                             const char* logical_type_id
                             );
    virtual PortableServer::Servant incarnate (const PortableServer::ObjectId &oid, PortableServer::POA_ptr adapter,  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()) = 0; // pure virtual

    virtual void etherealize (const PortableServer::ObjectId &oid, PortableServer::POA_ptr adapter, PortableServer::Servant serv, CORBA::Boolean cleanup_in_progress, CORBA::Boolean remaining_activations,  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()) = 0; // pure virtual

    PortableServer::ServantActivator *_this (CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());
    virtual const char* _interface_repository_id (void) const;
  };


#if !defined (_PORTABLESERVER_SERVANTACTIVATOR___COLLOCATED_SH_)
#define _PORTABLESERVER_SERVANTACTIVATOR___COLLOCATED_SH_

  class TAO_Export _tao_collocated_ServantActivator    : public virtual PortableServer::ServantActivator,
                                                         public virtual _tao_collocated_ServantManager
  {
  public:
    _tao_collocated_ServantActivator (
                                      ServantActivator_ptr  servant,
                                      TAO_Stub *stub
                                      );
    ServantActivator_ptr _get_servant (void) const;
    virtual CORBA::Boolean _is_a (
                                  const char *logical_type_id,
                                  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                                  );
    virtual PortableServer::Servant incarnate (
                                               const PortableServer::ObjectId & oid,
                                               PortableServer::POA_ptr  adapter,
                                               CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                                               );
    virtual void etherealize (
                              const PortableServer::ObjectId & oid,
                              PortableServer::POA_ptr  adapter,
                              PortableServer::Servant serv,
                              CORBA::Boolean cleanup_in_progress,
                              CORBA::Boolean remaining_activations,
                              CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                              );

  private:
    ServantActivator_ptr servant_;
  };


#endif // end #if !defined


  class ServantLocator;
  typedef ServantLocator *ServantLocator_ptr;
  class TAO_Export ServantLocator : public virtual ServantManager
  {
  protected:
    ServantLocator (void);
  public:
    virtual ~ServantLocator (void);
    virtual CORBA::Boolean _is_a (
                                  const char* logical_type_id,
                                  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());
    virtual void* _downcast (
                             const char* logical_type_id
                             );
    virtual PortableServer::Servant preinvoke (const PortableServer::ObjectId &oid,
                                               PortableServer::POA_ptr adapter,
                                               const char *operation,
                                               PortableServer::ServantLocator::Cookie & the_cookie,
                                               CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()) = 0; // pure virtual

    virtual void postinvoke (const PortableServer::ObjectId &oid, PortableServer::POA_ptr adapter, const char *operation, PortableServer::ServantLocator::Cookie the_cookie, PortableServer::Servant the_servant,  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()) = 0; // pure virtual

    PortableServer::ServantLocator *_this (CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());
    virtual const char* _interface_repository_id (void) const;
  };


#if !defined (_PORTABLESERVER_SERVANTLOCATOR___COLLOCATED_SH_)
#define _PORTABLESERVER_SERVANTLOCATOR___COLLOCATED_SH_

  class TAO_Export _tao_collocated_ServantLocator    : public virtual PortableServer::ServantLocator,
                                                       public virtual _tao_collocated_ServantManager
  {
  public:
    _tao_collocated_ServantLocator (
                                    ServantLocator_ptr  servant,
                                    TAO_Stub *stub
                                    );
    ServantLocator_ptr _get_servant (void) const;
    virtual CORBA::Boolean _is_a (
                                  const char *logical_type_id,
                                  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                                  );
    virtual PortableServer::Servant preinvoke (
                                               const PortableServer::ObjectId & oid,
                                               PortableServer::POA_ptr  adapter,
                                               const char * operation,
                                               PortableServer::ServantLocator::Cookie & the_cookie,
                                               CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                                               );
    virtual void postinvoke (
                             const PortableServer::ObjectId & oid,
                             PortableServer::POA_ptr  adapter,
                             const char * operation,
                             PortableServer::ServantLocator::Cookie the_cookie,
                             PortableServer::Servant the_servant,
                             CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                             );

  private:
    ServantLocator_ptr servant_;
  };


#endif // end #if !defined

#endif /* TAO_HAS_MINIMUM_POA == 0 */

  class POA;
  typedef POA *POA_ptr;
  class TAO_Export POA :  public virtual TAO_Local_ServantBase
  {
  protected:
    POA (void);
  public:
    virtual ~POA (void);
    virtual CORBA::Boolean _is_a (
                                  const char* logical_type_id,
                                  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());
    virtual void* _downcast (
                             const char* logical_type_id
                             );
    virtual PortableServer::POA_ptr  create_POA (const char *adapter_name, PortableServer::POAManager_ptr a_POAManager, const CORBA::PolicyList &policies,  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()) = 0; // pure virtual

    virtual PortableServer::POA_ptr  find_POA (const char *adapter_name, CORBA::Boolean activate_it,  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()) = 0; // pure virtual

    virtual void destroy (CORBA::Boolean etherealize_objects, CORBA::Boolean wait_for_completion,  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()) = 0; // pure virtual

#if (TAO_HAS_MINIMUM_POA == 0)

    virtual PortableServer::ThreadPolicy_ptr  create_thread_policy (PortableServer::ThreadPolicyValue value,  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()) = 0; // pure virtual

#endif /* TAO_HAS_MINIMUM_POA == 0 */

    virtual PortableServer::LifespanPolicy_ptr  create_lifespan_policy (PortableServer::LifespanPolicyValue value,  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()) = 0; // pure virtual

    virtual PortableServer::IdUniquenessPolicy_ptr  create_id_uniqueness_policy (PortableServer::IdUniquenessPolicyValue value,  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()) = 0; // pure virtual

    virtual PortableServer::IdAssignmentPolicy_ptr  create_id_assignment_policy (PortableServer::IdAssignmentPolicyValue value,  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()) = 0; // pure virtual

#if (TAO_HAS_MINIMUM_POA == 0)

    virtual PortableServer::ImplicitActivationPolicy_ptr  create_implicit_activation_policy (PortableServer::ImplicitActivationPolicyValue value,  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()) = 0; // pure virtual

    virtual PortableServer::ServantRetentionPolicy_ptr  create_servant_retention_policy (PortableServer::ServantRetentionPolicyValue value,  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()) = 0; // pure virtual

    virtual PortableServer::RequestProcessingPolicy_ptr  create_request_processing_policy (PortableServer::RequestProcessingPolicyValue value,  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()) = 0; // pure virtual

#endif /* TAO_HAS_MINIMUM_POA == 0 */

    virtual char * the_name (CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()) = 0;

    virtual PortableServer::POA_ptr  the_parent (CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()) = 0;

    virtual PortableServer::POAManager_ptr  the_POAManager (CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()) = 0;

#if (TAO_HAS_MINIMUM_POA == 0)

    virtual PortableServer::AdapterActivator_ptr  the_activator (CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()) = 0;

    virtual void the_activator(PortableServer::AdapterActivator_ptr the_activator, CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()) = 0;

    virtual PortableServer::ServantManager_ptr  get_servant_manager ( CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()) = 0; // pure virtual

    virtual void set_servant_manager (PortableServer::ServantManager_ptr imgr,  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()) = 0; // pure virtual

    virtual PortableServer::Servant get_servant ( CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()) = 0; // pure virtual

    virtual void set_servant (PortableServer::Servant p_servant,  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()) = 0; // pure virtual

#endif /* TAO_HAS_MINIMUM_POA == 0 */

    virtual PortableServer::ObjectId * activate_object (PortableServer::Servant p_servant,  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()) = 0; // pure virtual

    virtual void activate_object_with_id (const PortableServer::ObjectId &id, PortableServer::Servant p_servant,  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()) = 0; // pure virtual

    virtual void deactivate_object (const PortableServer::ObjectId &oid,  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()) = 0; // pure virtual

    virtual CORBA::Object_ptr create_reference (const char *intf,  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()) = 0; // pure virtual

    virtual CORBA::Object_ptr create_reference_with_id (const PortableServer::ObjectId &oid, const char *intf,  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()) = 0; // pure virtual

    virtual PortableServer::ObjectId * servant_to_id (PortableServer::Servant p_servant,  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()) = 0; // pure virtual

    virtual CORBA::Object_ptr servant_to_reference (PortableServer::Servant p_servant,  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()) = 0; // pure virtual

    virtual PortableServer::Servant reference_to_servant (CORBA::Object_ptr reference,  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()) = 0; // pure virtual

    virtual PortableServer::ObjectId * reference_to_id (CORBA::Object_ptr reference,  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()) = 0; // pure virtual

    virtual PortableServer::Servant id_to_servant (const PortableServer::ObjectId &oid,  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()) = 0; // pure virtual

    virtual CORBA::Object_ptr id_to_reference (const PortableServer::ObjectId &oid,  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()) = 0; // pure virtual

    PortableServer::POA *_this (CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());
    virtual const char* _interface_repository_id (void) const;
  };


#if !defined (_PORTABLESERVER_POA___COLLOCATED_SH_)
#define _PORTABLESERVER_POA___COLLOCATED_SH_

  class TAO_Export _tao_collocated_POA    : public virtual PortableServer::POA
  {
  public:
    _tao_collocated_POA (
                         POA_ptr  servant,
                         TAO_Stub *stub
                         );
    POA_ptr _get_servant (void) const;
    virtual CORBA::Boolean _is_a (
                                  const char *logical_type_id,
                                  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                                  );
    virtual PortableServer::POA_ptr create_POA (
                                                const char* adapter_name,
                                                PortableServer::POAManager_ptr  a_POAManager,
                                                const CORBA::PolicyList & policies,
                                                CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                                                );
    virtual PortableServer::POA_ptr find_POA (
                                              const char* adapter_name,
                                              CORBA::Boolean activate_it,
                                              CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                                              );
    virtual void destroy (
                          CORBA::Boolean etherealize_objects,
                          CORBA::Boolean wait_for_completion,
                          CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                          );

#if (TAO_HAS_MINIMUM_POA == 0)

    virtual PortableServer::ThreadPolicy_ptr create_thread_policy (
                                                                   PortableServer::ThreadPolicyValue value,
                                                                   CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                                                                   );

#endif /* TAO_HAS_MINIMUM_POA == 0 */

    virtual PortableServer::LifespanPolicy_ptr create_lifespan_policy (
                                                                       PortableServer::LifespanPolicyValue value,
                                                                       CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                                                                       );
    virtual PortableServer::IdUniquenessPolicy_ptr create_id_uniqueness_policy (
                                                                                PortableServer::IdUniquenessPolicyValue value,
                                                                                CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                                                                                );
    virtual PortableServer::IdAssignmentPolicy_ptr create_id_assignment_policy (
                                                                                PortableServer::IdAssignmentPolicyValue value,
                                                                                CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                                                                                );
#if (TAO_HAS_MINIMUM_POA == 0)

    virtual PortableServer::ImplicitActivationPolicy_ptr create_implicit_activation_policy (
                                                                                            PortableServer::ImplicitActivationPolicyValue value,
                                                                                            CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                                                                                            );
    virtual PortableServer::ServantRetentionPolicy_ptr create_servant_retention_policy (
                                                                                        PortableServer::ServantRetentionPolicyValue value,
                                                                                        CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                                                                                        );
    virtual PortableServer::RequestProcessingPolicy_ptr create_request_processing_policy (
                                                                                          PortableServer::RequestProcessingPolicyValue value,
                                                                                          CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                                                                                          );
#endif /* TAO_HAS_MINIMUM_POA == 0 */


    virtual char*  the_name (
                             CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                             );
    virtual PortableServer::POA_ptr the_parent (
                                                CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                                                );
    virtual PortableServer::POAManager_ptr the_POAManager (
                                                           CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                                                           );
#if (TAO_HAS_MINIMUM_POA == 0)

    virtual PortableServer::AdapterActivator_ptr the_activator (
                                                                CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                                                                );
    virtual void the_activator (PortableServer::AdapterActivator_ptr  _tao_value,
                                CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                                );
    virtual PortableServer::ServantManager_ptr get_servant_manager (
                                                                    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                                                                    );
    virtual void set_servant_manager (
                                      PortableServer::ServantManager_ptr  imgr,
                                      CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                                      );
    virtual PortableServer::Servant get_servant (
                                                 CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                                                 );
    virtual void set_servant (
                              PortableServer::Servant p_servant,
                              CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                              );

#endif /* TAO_HAS_MINIMUM_POA == 0 */

    virtual PortableServer::ObjectId * activate_object (
                                                        PortableServer::Servant p_servant,
                                                        CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                                                        );
    virtual void activate_object_with_id (
                                          const PortableServer::ObjectId & id,
                                          PortableServer::Servant p_servant,
                                          CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                                          );
    virtual void deactivate_object (
                                    const PortableServer::ObjectId & oid,
                                    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                                    );
    virtual CORBA::Object_ptr create_reference (
                                                const char *intf,
                                                CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                                                );
    virtual CORBA::Object_ptr create_reference_with_id (
                                                        const PortableServer::ObjectId & oid,
                                                        const char *intf,
                                                        CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                                                        );
    virtual PortableServer::ObjectId * servant_to_id (
                                                      PortableServer::Servant p_servant,
                                                      CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                                                      );
    virtual CORBA::Object_ptr servant_to_reference (
                                                    PortableServer::Servant p_servant,
                                                    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                                                    );
    virtual PortableServer::Servant reference_to_servant (
                                                          CORBA::Object_ptr  reference,
                                                          CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                                                          );
    virtual PortableServer::ObjectId * reference_to_id (
                                                        CORBA::Object_ptr  reference,
                                                        CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                                                        );
    virtual PortableServer::Servant id_to_servant (
                                                   const PortableServer::ObjectId & oid,
                                                   CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                                                   );
    virtual CORBA::Object_ptr id_to_reference (
                                               const PortableServer::ObjectId & oid,
                                               CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                                               );

  private:
    POA_ptr servant_;
  };


#endif // end #if !defined


  class Current;
  typedef Current *Current_ptr;
  class TAO_Export Current : public virtual POA_CORBA::Current
  {
  protected:
    Current (void);
  public:
    virtual ~Current (void);
    virtual CORBA::Boolean _is_a (
                                  const char* logical_type_id,
                                  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());
    virtual void* _downcast (
                             const char* logical_type_id
                             );
    virtual PortableServer::POA_ptr  get_POA ( CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()) = 0; // pure virtual

    virtual PortableServer::ObjectId * get_object_id ( CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()) = 0; // pure virtual

    PortableServer::Current *_this (CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());
    virtual const char* _interface_repository_id (void) const;
  };


#if !defined (_PORTABLESERVER_CURRENT___COLLOCATED_SH_)
#define _PORTABLESERVER_CURRENT___COLLOCATED_SH_

  class TAO_Export _tao_collocated_Current    : public virtual PortableServer::Current,
                                                public virtual POA_CORBA::_tao_collocated_Current
  {
  public:
    _tao_collocated_Current (
                             Current_ptr  servant,
                             TAO_Stub *stub
                             );
    Current_ptr _get_servant (void) const;
    virtual CORBA::Boolean _is_a (
                                  const char *logical_type_id,
                                  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                                  );
    virtual PortableServer::POA_ptr get_POA (
                                             CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                                             );
    virtual PortableServer::ObjectId * get_object_id (
                                                      CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
                                                      );

  private:
    Current_ptr servant_;
  };


#endif // end #if !defined


}
TAO_NAMESPACE_CLOSE

#if defined (__ACE_INLINE__)
#include "tao/POAS.i"
#endif // defined INLINE

#if defined(_MSC_VER) && (_MSC_VER >= 1200)
#pragma warning(pop)
#endif /* _MSC_VER */

#endif /* TAO_IDL_POAS_H */
