// -*- C++ -*-
//
// PortableInterceptorC.h,v 1.30 2002/09/03 23:28:57 irfan Exp

// ****  Code generated by the The ACE ORB (TAO) IDL Compiler ****
// TAO and the TAO IDL Compiler have been developed by:
//       Center for Distributed Object Computing
//       Washington University
//       St. Louis, MO
//       USA
//       http://www.cs.wustl.edu/~schmidt/doc-center.html
// and
//       Distributed Object Computing Laboratory
//       University of California at Irvine
//       Irvine, CA
//       USA
//       http://doc.ece.uci.edu/
//
// Information about TAO is available at:
//     http://www.cs.wustl.edu/~schmidt/TAO.html

#ifndef _TAO_IDL_ORIG_PORTABLEINTERCEPTORC_H_
#define _TAO_IDL_ORIG_PORTABLEINTERCEPTORC_H_

#include "ace/pre.h"
#include "tao/corbafwd.h"

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

#include "TAO_Export.h"
#include "CurrentC.h"
#include "DynamicC.h"
#include "ObjectReferenceTemplateC.h"
#include "Messaging_SyncScopeC.h"
#include "IOPC.h"
#include "PolicyC.h"

#if defined (TAO_EXPORT_MACRO)
#undef TAO_EXPORT_MACRO
#endif
#define TAO_EXPORT_MACRO TAO_Export

#if defined (TAO_EXPORT_NESTED_CLASSES)
#  if defined (TAO_EXPORT_NESTED_MACRO)
#    undef TAO_EXPORT_NESTED_MACRO
#  endif /* defined (TAO_EXPORT_NESTED_MACRO) */
#  define TAO_EXPORT_NESTED_MACRO TAO_Export
#endif /* TAO_EXPORT_NESTED_CLASSES */

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

#if defined (__BORLANDC__)
#pragma option push -w-rvl -w-rch -w-ccc -w-inl
#endif /* __BORLANDC__ */

TAO_NAMESPACE  PortableInterceptor
{

#if !defined (_PORTABLEINTERCEPTOR_INTERCEPTOR___PTR_CH_)
#define _PORTABLEINTERCEPTOR_INTERCEPTOR___PTR_CH_

  class Interceptor;
  typedef Interceptor *Interceptor_ptr;

#endif /* end #if !defined */


#if !defined (_PORTABLEINTERCEPTOR_INTERCEPTOR___VAR_CH_)
#define _PORTABLEINTERCEPTOR_INTERCEPTOR___VAR_CH_

  class TAO_Export Interceptor_var : public TAO_Base_var
  {
  public:
    Interceptor_var (void); // default constructor
    Interceptor_var (Interceptor_ptr p) : ptr_ (p) {}
    Interceptor_var (const Interceptor_var &); // copy constructor
    ~Interceptor_var (void); // destructor

    Interceptor_var &operator= (Interceptor_ptr);
    Interceptor_var &operator= (const Interceptor_var &);
    Interceptor_ptr operator-> (void) const;

    operator const Interceptor_ptr &() const;
    operator Interceptor_ptr &();
    // in, inout, out, _retn
    Interceptor_ptr in (void) const;
    Interceptor_ptr &inout (void);
    Interceptor_ptr &out (void);
    Interceptor_ptr _retn (void);
    Interceptor_ptr ptr (void) const;

    // Hooks used by template sequence and object manager classes
    // for non-defined forward declared interfaces.
    static Interceptor_ptr tao_duplicate (Interceptor_ptr);
    static void tao_release (Interceptor_ptr);
    static Interceptor_ptr tao_nil (void);
    static Interceptor_ptr tao_narrow (
        CORBA::Object *
        ACE_ENV_ARG_DECL_NOT_USED
      );
    static CORBA::Object * tao_upcast (void *);

  private:
    Interceptor_ptr ptr_;
    // Unimplemented - prevents widening assignment.
    Interceptor_var (const TAO_Base_var &rhs);
    Interceptor_var &operator= (const TAO_Base_var &rhs);
  };


#endif /* end #if !defined */


#if !defined (_PORTABLEINTERCEPTOR_INTERCEPTOR___OUT_CH_)
#define _PORTABLEINTERCEPTOR_INTERCEPTOR___OUT_CH_

  class TAO_Export Interceptor_out
  {
  public:
    Interceptor_out (Interceptor_ptr &);
    Interceptor_out (Interceptor_var &);
    Interceptor_out (const Interceptor_out &);
    Interceptor_out &operator= (const Interceptor_out &);
    Interceptor_out &operator= (const Interceptor_var &);
    Interceptor_out &operator= (Interceptor_ptr);
    operator Interceptor_ptr &();
    Interceptor_ptr &ptr (void);
    Interceptor_ptr operator-> (void);

  private:
    Interceptor_ptr &ptr_;
  };


#endif /* end #if !defined */


#if !defined (_PORTABLEINTERCEPTOR_INTERCEPTOR_CH_)
#define _PORTABLEINTERCEPTOR_INTERCEPTOR_CH_

  class TAO_Export Interceptor
    : public virtual CORBA_Object
  {
  public:
  #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
    typedef Interceptor_ptr _ptr_type;
    typedef Interceptor_var _var_type;
  #endif /* ! __GNUC__ || g++ >= 2.8 */

    static int _tao_class_id;

    // The static operations.
    static Interceptor_ptr _duplicate (Interceptor_ptr obj);

    static Interceptor_ptr _narrow (
        CORBA::Object_ptr obj
        ACE_ENV_ARG_DECL_WITH_DEFAULTS
      );

    static Interceptor_ptr _unchecked_narrow (
        CORBA::Object_ptr obj
        ACE_ENV_ARG_DECL_WITH_DEFAULTS
      );

    static Interceptor_ptr _nil (void)
      {
        return (Interceptor_ptr)0;
      }

    virtual char * name (

        ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
      )
      ACE_THROW_SPEC ((
        CORBA::SystemException
      )) = 0;

    virtual void destroy (

        ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
      )
      ACE_THROW_SPEC ((
        CORBA::SystemException
      )) = 0;

    virtual void *_tao_QueryInterface (ptr_arith_t type);

    virtual const char* _interface_repository_id (void) const;

  protected:
    Interceptor (void);

    virtual ~Interceptor (void);

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


#endif /* end #if !defined */


#if !defined (_PORTABLEINTERCEPTOR_FORWARDREQUEST_CH_)
#define _PORTABLEINTERCEPTOR_FORWARDREQUEST_CH_

  class TAO_Export ForwardRequest : public CORBA::UserException
  {
  public:
    CORBA::Object_var forward;
    CORBA::Boolean permanent;

    ForwardRequest (void);
    ForwardRequest (const ForwardRequest &);
    ~ForwardRequest (void);

    ForwardRequest &operator= (const ForwardRequest &);

    static void _tao_any_destructor (void*);

    static ForwardRequest *_downcast (CORBA::Exception *);
    static CORBA::Exception *_alloc (void);

    virtual CORBA::Exception *_tao_duplicate (void) const;

    virtual void _raise (void);

    virtual void _tao_encode (
        TAO_OutputCDR &
        ACE_ENV_ARG_DECL_NOT_USED
      ) const;

    virtual void _tao_decode (
        TAO_InputCDR &
        ACE_ENV_ARG_DECL_NOT_USED
      );

        ForwardRequest (
        const CORBA::Object_ptr  _tao_forward,
        CORBA::Boolean _tao_permanent
      );

    virtual CORBA::TypeCode_ptr _type (void) const;
  };

TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_ForwardRequest;


#endif /* end #if !defined */

  typedef CORBA::Short ReplyStatus;
  typedef CORBA::Short_out ReplyStatus_out;
  TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_ReplyStatus;

  TAO_NAMESPACE_STORAGE_CLASS const CORBA::Short SUCCESSFUL;

  TAO_NAMESPACE_STORAGE_CLASS const CORBA::Short SYSTEM_EXCEPTION;

  TAO_NAMESPACE_STORAGE_CLASS const CORBA::Short USER_EXCEPTION;

  TAO_NAMESPACE_STORAGE_CLASS const CORBA::Short LOCATION_FORWARD;

  TAO_NAMESPACE_STORAGE_CLASS const CORBA::Short LOCATION_FORWARD_PERMANENT;

  TAO_NAMESPACE_STORAGE_CLASS const CORBA::Short TRANSPORT_RETRY;

  typedef CORBA::ULong SlotId;
  typedef CORBA::ULong_out SlotId_out;
  TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_SlotId;


#if !defined (_PORTABLEINTERCEPTOR_INVALIDSLOT_CH_)
#define _PORTABLEINTERCEPTOR_INVALIDSLOT_CH_

  class TAO_Export InvalidSlot : public CORBA::UserException
  {
  public:

    InvalidSlot (void);
    InvalidSlot (const InvalidSlot &);
    ~InvalidSlot (void);

    InvalidSlot &operator= (const InvalidSlot &);

    static void _tao_any_destructor (void*);

    static InvalidSlot *_downcast (CORBA::Exception *);
    static CORBA::Exception *_alloc (void);

    virtual CORBA::Exception *_tao_duplicate (void) const;

    virtual void _raise (void);

    virtual void _tao_encode (
        TAO_OutputCDR &
        ACE_ENV_ARG_DECL_NOT_USED
      ) const;

    virtual void _tao_decode (
        TAO_InputCDR &
        ACE_ENV_ARG_DECL_NOT_USED
      );


    virtual CORBA::TypeCode_ptr _type (void) const;
  };

TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_InvalidSlot;


#endif /* end #if !defined */


#if !defined (_PORTABLEINTERCEPTOR_CURRENT___PTR_CH_)
#define _PORTABLEINTERCEPTOR_CURRENT___PTR_CH_

  class Current;
  typedef Current *Current_ptr;

#endif /* end #if !defined */


#if !defined (_PORTABLEINTERCEPTOR_CURRENT___VAR_CH_)
#define _PORTABLEINTERCEPTOR_CURRENT___VAR_CH_

  class TAO_Export Current_var : public TAO_Base_var
  {
  public:
    Current_var (void); // default constructor
    Current_var (Current_ptr p) : ptr_ (p) {}
    Current_var (const Current_var &); // copy constructor
    ~Current_var (void); // destructor

    Current_var &operator= (Current_ptr);
    Current_var &operator= (const Current_var &);
    Current_ptr operator-> (void) const;

    operator const Current_ptr &() const;
    operator Current_ptr &();
    // in, inout, out, _retn
    Current_ptr in (void) const;
    Current_ptr &inout (void);
    Current_ptr &out (void);
    Current_ptr _retn (void);
    Current_ptr ptr (void) const;

    // Hooks used by template sequence and object manager classes
    // for non-defined forward declared interfaces.
    static Current_ptr tao_duplicate (Current_ptr);
    static void tao_release (Current_ptr);
    static Current_ptr tao_nil (void);
    static Current_ptr tao_narrow (
        CORBA::Object *
        ACE_ENV_ARG_DECL_NOT_USED
      );
    static CORBA::Object * tao_upcast (void *);

  private:
    Current_ptr ptr_;
    // Unimplemented - prevents widening assignment.
    Current_var (const TAO_Base_var &rhs);
    Current_var &operator= (const TAO_Base_var &rhs);
  };


#endif /* end #if !defined */


#if !defined (_PORTABLEINTERCEPTOR_CURRENT___OUT_CH_)
#define _PORTABLEINTERCEPTOR_CURRENT___OUT_CH_

  class TAO_Export Current_out
  {
  public:
    Current_out (Current_ptr &);
    Current_out (Current_var &);
    Current_out (const Current_out &);
    Current_out &operator= (const Current_out &);
    Current_out &operator= (const Current_var &);
    Current_out &operator= (Current_ptr);
    operator Current_ptr &();
    Current_ptr &ptr (void);
    Current_ptr operator-> (void);

  private:
    Current_ptr &ptr_;
  };


#endif /* end #if !defined */


#if !defined (_PORTABLEINTERCEPTOR_CURRENT_CH_)
#define _PORTABLEINTERCEPTOR_CURRENT_CH_

  class TAO_Export Current
    : public virtual CORBA::Current
  {
  public:
  #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
    typedef Current_ptr _ptr_type;
    typedef Current_var _var_type;
  #endif /* ! __GNUC__ || g++ >= 2.8 */

    static int _tao_class_id;

    // The static operations.
    static Current_ptr _duplicate (Current_ptr obj);

    static Current_ptr _narrow (
        CORBA::Object_ptr obj
        ACE_ENV_ARG_DECL_WITH_DEFAULTS
      );

    static Current_ptr _unchecked_narrow (
        CORBA::Object_ptr obj
        ACE_ENV_ARG_DECL_WITH_DEFAULTS
      );

    static Current_ptr _nil (void)
      {
        return (Current_ptr)0;
      }

    virtual CORBA::Any * get_slot (
        PortableInterceptor::SlotId id
        ACE_ENV_ARG_DECL_WITH_DEFAULTS
      )
      ACE_THROW_SPEC ((
        CORBA::SystemException
        , PortableInterceptor::InvalidSlot
      )) = 0;

    virtual void set_slot (
        PortableInterceptor::SlotId id,
        const CORBA::Any & data
        ACE_ENV_ARG_DECL_WITH_DEFAULTS
      )
      ACE_THROW_SPEC ((
        CORBA::SystemException
        , PortableInterceptor::InvalidSlot
      )) = 0;

    virtual void *_tao_QueryInterface (ptr_arith_t type);

    virtual const char* _interface_repository_id (void) const;

  protected:
    Current (void);

    virtual ~Current (void);

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


#endif /* end #if !defined */


#if !defined (_PORTABLEINTERCEPTOR_REQUESTINFO___PTR_CH_)
#define _PORTABLEINTERCEPTOR_REQUESTINFO___PTR_CH_

  class RequestInfo;
  typedef RequestInfo *RequestInfo_ptr;

#endif /* end #if !defined */


#if !defined (_PORTABLEINTERCEPTOR_REQUESTINFO___VAR_CH_)
#define _PORTABLEINTERCEPTOR_REQUESTINFO___VAR_CH_

  class TAO_Export RequestInfo_var : public TAO_Base_var
  {
  public:
    RequestInfo_var (void); // default constructor
    RequestInfo_var (RequestInfo_ptr p) : ptr_ (p) {}
    RequestInfo_var (const RequestInfo_var &); // copy constructor
    ~RequestInfo_var (void); // destructor

    RequestInfo_var &operator= (RequestInfo_ptr);
    RequestInfo_var &operator= (const RequestInfo_var &);
    RequestInfo_ptr operator-> (void) const;

    operator const RequestInfo_ptr &() const;
    operator RequestInfo_ptr &();
    // in, inout, out, _retn
    RequestInfo_ptr in (void) const;
    RequestInfo_ptr &inout (void);
    RequestInfo_ptr &out (void);
    RequestInfo_ptr _retn (void);
    RequestInfo_ptr ptr (void) const;

    // Hooks used by template sequence and object manager classes
    // for non-defined forward declared interfaces.
    static RequestInfo_ptr tao_duplicate (RequestInfo_ptr);
    static void tao_release (RequestInfo_ptr);
    static RequestInfo_ptr tao_nil (void);
    static RequestInfo_ptr tao_narrow (
        CORBA::Object *
        ACE_ENV_ARG_DECL_NOT_USED
      );
    static CORBA::Object * tao_upcast (void *);

  private:
    RequestInfo_ptr ptr_;
    // Unimplemented - prevents widening assignment.
    RequestInfo_var (const TAO_Base_var &rhs);
    RequestInfo_var &operator= (const TAO_Base_var &rhs);
  };


#endif /* end #if !defined */


#if !defined (_PORTABLEINTERCEPTOR_REQUESTINFO___OUT_CH_)
#define _PORTABLEINTERCEPTOR_REQUESTINFO___OUT_CH_

  class TAO_Export RequestInfo_out
  {
  public:
    RequestInfo_out (RequestInfo_ptr &);
    RequestInfo_out (RequestInfo_var &);
    RequestInfo_out (const RequestInfo_out &);
    RequestInfo_out &operator= (const RequestInfo_out &);
    RequestInfo_out &operator= (const RequestInfo_var &);
    RequestInfo_out &operator= (RequestInfo_ptr);
    operator RequestInfo_ptr &();
    RequestInfo_ptr &ptr (void);
    RequestInfo_ptr operator-> (void);

  private:
    RequestInfo_ptr &ptr_;
  };


#endif /* end #if !defined */


#if !defined (_PORTABLEINTERCEPTOR_REQUESTINFO_CH_)
#define _PORTABLEINTERCEPTOR_REQUESTINFO_CH_

  class TAO_Export RequestInfo
    : public virtual CORBA_Object
  {
  public:
  #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
    typedef RequestInfo_ptr _ptr_type;
    typedef RequestInfo_var _var_type;
  #endif /* ! __GNUC__ || g++ >= 2.8 */

    static int _tao_class_id;

    // The static operations.
    static RequestInfo_ptr _duplicate (RequestInfo_ptr obj);

    static RequestInfo_ptr _narrow (
        CORBA::Object_ptr obj
        ACE_ENV_ARG_DECL_WITH_DEFAULTS
      );

    static RequestInfo_ptr _unchecked_narrow (
        CORBA::Object_ptr obj
        ACE_ENV_ARG_DECL_WITH_DEFAULTS
      );

    static RequestInfo_ptr _nil (void)
      {
        return (RequestInfo_ptr)0;
      }

    virtual CORBA::ULong request_id (

        ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
      )
      ACE_THROW_SPEC ((
        CORBA::SystemException
      )) = 0;

    virtual char * operation (

        ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
      )
      ACE_THROW_SPEC ((
        CORBA::SystemException
      )) = 0;

    virtual ::Dynamic::ParameterList * arguments (

        ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
      )
      ACE_THROW_SPEC ((
        CORBA::SystemException
      )) = 0;

    virtual ::Dynamic::ExceptionList * exceptions (

        ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
      )
      ACE_THROW_SPEC ((
        CORBA::SystemException
      )) = 0;

    virtual ::Dynamic::ContextList * contexts (

        ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
      )
      ACE_THROW_SPEC ((
        CORBA::SystemException
      )) = 0;

    virtual ::Dynamic::RequestContext * operation_context (

        ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
      )
      ACE_THROW_SPEC ((
        CORBA::SystemException
      )) = 0;

    virtual CORBA::Any * result (

        ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
      )
      ACE_THROW_SPEC ((
        CORBA::SystemException
      )) = 0;

    virtual CORBA::Boolean response_expected (

        ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
      )
      ACE_THROW_SPEC ((
        CORBA::SystemException
      )) = 0;

#if TAO_HAS_CORBA_MESSAGING == 1
    virtual Messaging::SyncScope sync_scope (

        ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
      )
      ACE_THROW_SPEC ((
        CORBA::SystemException
      )) = 0;
#endif /* TAO_HAS_CORBA_MESSAGING == 1 */

    virtual PortableInterceptor::ReplyStatus reply_status (

        ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
      )
      ACE_THROW_SPEC ((
        CORBA::SystemException
      )) = 0;

    virtual CORBA::Object_ptr forward_reference (

        ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
      )
      ACE_THROW_SPEC ((
        CORBA::SystemException
      )) = 0;

    virtual CORBA::Any * get_slot (
        PortableInterceptor::SlotId id
        ACE_ENV_ARG_DECL_WITH_DEFAULTS
      )
      ACE_THROW_SPEC ((
        CORBA::SystemException
        , PortableInterceptor::InvalidSlot
      )) = 0;

    virtual ::IOP::ServiceContext * get_request_service_context (
        IOP::ServiceId id
        ACE_ENV_ARG_DECL_WITH_DEFAULTS
      )
      ACE_THROW_SPEC ((
        CORBA::SystemException
      )) = 0;

    virtual ::IOP::ServiceContext * get_reply_service_context (
        IOP::ServiceId id
        ACE_ENV_ARG_DECL_WITH_DEFAULTS
      )
      ACE_THROW_SPEC ((
        CORBA::SystemException
      )) = 0;

    virtual void *_tao_QueryInterface (ptr_arith_t type);

    virtual const char* _interface_repository_id (void) const;

  protected:
    RequestInfo (void);

    virtual ~RequestInfo (void);

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


#endif /* end #if !defined */


#if !defined (_PORTABLEINTERCEPTOR_CLIENTREQUESTINFO___PTR_CH_)
#define _PORTABLEINTERCEPTOR_CLIENTREQUESTINFO___PTR_CH_

  class ClientRequestInfo;
  typedef ClientRequestInfo *ClientRequestInfo_ptr;

#endif /* end #if !defined */


#if !defined (_PORTABLEINTERCEPTOR_CLIENTREQUESTINFO___VAR_CH_)
#define _PORTABLEINTERCEPTOR_CLIENTREQUESTINFO___VAR_CH_

  class TAO_Export ClientRequestInfo_var : public TAO_Base_var
  {
  public:
    ClientRequestInfo_var (void); // default constructor
    ClientRequestInfo_var (ClientRequestInfo_ptr p) : ptr_ (p) {}
    ClientRequestInfo_var (const ClientRequestInfo_var &); // copy constructor
    ~ClientRequestInfo_var (void); // destructor

    ClientRequestInfo_var &operator= (ClientRequestInfo_ptr);
    ClientRequestInfo_var &operator= (const ClientRequestInfo_var &);
    ClientRequestInfo_ptr operator-> (void) const;

    operator const ClientRequestInfo_ptr &() const;
    operator ClientRequestInfo_ptr &();
    // in, inout, out, _retn
    ClientRequestInfo_ptr in (void) const;
    ClientRequestInfo_ptr &inout (void);
    ClientRequestInfo_ptr &out (void);
    ClientRequestInfo_ptr _retn (void);
    ClientRequestInfo_ptr ptr (void) const;

    // Hooks used by template sequence and object manager classes
    // for non-defined forward declared interfaces.
    static ClientRequestInfo_ptr tao_duplicate (ClientRequestInfo_ptr);
    static void tao_release (ClientRequestInfo_ptr);
    static ClientRequestInfo_ptr tao_nil (void);
    static ClientRequestInfo_ptr tao_narrow (
        CORBA::Object *
        ACE_ENV_ARG_DECL_NOT_USED
      );
    static CORBA::Object * tao_upcast (void *);

  private:
    ClientRequestInfo_ptr ptr_;
    // Unimplemented - prevents widening assignment.
    ClientRequestInfo_var (const TAO_Base_var &rhs);
    ClientRequestInfo_var &operator= (const TAO_Base_var &rhs);
  };


#endif /* end #if !defined */


#if !defined (_PORTABLEINTERCEPTOR_CLIENTREQUESTINFO___OUT_CH_)
#define _PORTABLEINTERCEPTOR_CLIENTREQUESTINFO___OUT_CH_

  class TAO_Export ClientRequestInfo_out
  {
  public:
    ClientRequestInfo_out (ClientRequestInfo_ptr &);
    ClientRequestInfo_out (ClientRequestInfo_var &);
    ClientRequestInfo_out (const ClientRequestInfo_out &);
    ClientRequestInfo_out &operator= (const ClientRequestInfo_out &);
    ClientRequestInfo_out &operator= (const ClientRequestInfo_var &);
    ClientRequestInfo_out &operator= (ClientRequestInfo_ptr);
    operator ClientRequestInfo_ptr &();
    ClientRequestInfo_ptr &ptr (void);
    ClientRequestInfo_ptr operator-> (void);

  private:
    ClientRequestInfo_ptr &ptr_;
  };


#endif /* end #if !defined */


#if !defined (_PORTABLEINTERCEPTOR_CLIENTREQUESTINFO_CH_)
#define _PORTABLEINTERCEPTOR_CLIENTREQUESTINFO_CH_

  class TAO_Export ClientRequestInfo
    : public virtual PortableInterceptor::RequestInfo
  {
  public:
  #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
    typedef ClientRequestInfo_ptr _ptr_type;
    typedef ClientRequestInfo_var _var_type;
  #endif /* ! __GNUC__ || g++ >= 2.8 */

    static int _tao_class_id;

    // The static operations.
    static ClientRequestInfo_ptr _duplicate (ClientRequestInfo_ptr obj);

    static ClientRequestInfo_ptr _narrow (
        CORBA::Object_ptr obj
        ACE_ENV_ARG_DECL_WITH_DEFAULTS
      );

    static ClientRequestInfo_ptr _unchecked_narrow (
        CORBA::Object_ptr obj
        ACE_ENV_ARG_DECL_WITH_DEFAULTS
      );

    static ClientRequestInfo_ptr _nil (void)
      {
        return (ClientRequestInfo_ptr)0;
      }

    virtual CORBA::Object_ptr target (

        ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
      )
      ACE_THROW_SPEC ((
        CORBA::SystemException
      )) = 0;

    virtual CORBA::Object_ptr effective_target (

        ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
      )
      ACE_THROW_SPEC ((
        CORBA::SystemException
      )) = 0;

    virtual ::IOP::TaggedProfile * effective_profile (

        ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
      )
      ACE_THROW_SPEC ((
        CORBA::SystemException
      )) = 0;

    virtual CORBA::Any * received_exception (

        ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
      )
      ACE_THROW_SPEC ((
        CORBA::SystemException
      )) = 0;

    virtual char * received_exception_id (

        ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
      )
      ACE_THROW_SPEC ((
        CORBA::SystemException
      )) = 0;

    virtual ::IOP::TaggedComponent * get_effective_component (
        IOP::ComponentId id
        ACE_ENV_ARG_DECL_WITH_DEFAULTS
      )
      ACE_THROW_SPEC ((
        CORBA::SystemException
      )) = 0;

    virtual ::IOP::TaggedComponentSeq * get_effective_components (
        IOP::ComponentId id
        ACE_ENV_ARG_DECL_WITH_DEFAULTS
      )
      ACE_THROW_SPEC ((
        CORBA::SystemException
      )) = 0;

    virtual ::CORBA::Policy_ptr get_request_policy (
        CORBA::PolicyType type
        ACE_ENV_ARG_DECL_WITH_DEFAULTS
      )
      ACE_THROW_SPEC ((
        CORBA::SystemException
      )) = 0;

    virtual void add_request_service_context (
        const IOP::ServiceContext & service_context,
        CORBA::Boolean replace
        ACE_ENV_ARG_DECL_WITH_DEFAULTS
      )
      ACE_THROW_SPEC ((
        CORBA::SystemException
      )) = 0;

    virtual void *_tao_QueryInterface (ptr_arith_t type);

    virtual const char* _interface_repository_id (void) const;

  protected:
    ClientRequestInfo (void);

    virtual ~ClientRequestInfo (void);

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


#endif /* end #if !defined */


#if !defined (_PORTABLEINTERCEPTOR_SERVERREQUESTINFO___PTR_CH_)
#define _PORTABLEINTERCEPTOR_SERVERREQUESTINFO___PTR_CH_

  class ServerRequestInfo;
  typedef ServerRequestInfo *ServerRequestInfo_ptr;

#endif /* end #if !defined */


#if !defined (_PORTABLEINTERCEPTOR_SERVERREQUESTINFO___VAR_CH_)
#define _PORTABLEINTERCEPTOR_SERVERREQUESTINFO___VAR_CH_

  class TAO_Export ServerRequestInfo_var : public TAO_Base_var
  {
  public:
    ServerRequestInfo_var (void); // default constructor
    ServerRequestInfo_var (ServerRequestInfo_ptr p) : ptr_ (p) {}
    ServerRequestInfo_var (const ServerRequestInfo_var &); // copy constructor
    ~ServerRequestInfo_var (void); // destructor

    ServerRequestInfo_var &operator= (ServerRequestInfo_ptr);
    ServerRequestInfo_var &operator= (const ServerRequestInfo_var &);
    ServerRequestInfo_ptr operator-> (void) const;

    operator const ServerRequestInfo_ptr &() const;
    operator ServerRequestInfo_ptr &();
    // in, inout, out, _retn
    ServerRequestInfo_ptr in (void) const;
    ServerRequestInfo_ptr &inout (void);
    ServerRequestInfo_ptr &out (void);
    ServerRequestInfo_ptr _retn (void);
    ServerRequestInfo_ptr ptr (void) const;

    // Hooks used by template sequence and object manager classes
    // for non-defined forward declared interfaces.
    static ServerRequestInfo_ptr tao_duplicate (ServerRequestInfo_ptr);
    static void tao_release (ServerRequestInfo_ptr);
    static ServerRequestInfo_ptr tao_nil (void);
    static ServerRequestInfo_ptr tao_narrow (
        CORBA::Object *
        ACE_ENV_ARG_DECL_NOT_USED
      );
    static CORBA::Object * tao_upcast (void *);

  private:
    ServerRequestInfo_ptr ptr_;
    // Unimplemented - prevents widening assignment.
    ServerRequestInfo_var (const TAO_Base_var &rhs);
    ServerRequestInfo_var &operator= (const TAO_Base_var &rhs);
  };


#endif /* end #if !defined */


#if !defined (_PORTABLEINTERCEPTOR_SERVERREQUESTINFO___OUT_CH_)
#define _PORTABLEINTERCEPTOR_SERVERREQUESTINFO___OUT_CH_

  class TAO_Export ServerRequestInfo_out
  {
  public:
    ServerRequestInfo_out (ServerRequestInfo_ptr &);
    ServerRequestInfo_out (ServerRequestInfo_var &);
    ServerRequestInfo_out (const ServerRequestInfo_out &);
    ServerRequestInfo_out &operator= (const ServerRequestInfo_out &);
    ServerRequestInfo_out &operator= (const ServerRequestInfo_var &);
    ServerRequestInfo_out &operator= (ServerRequestInfo_ptr);
    operator ServerRequestInfo_ptr &();
    ServerRequestInfo_ptr &ptr (void);
    ServerRequestInfo_ptr operator-> (void);

  private:
    ServerRequestInfo_ptr &ptr_;
  };


#endif /* end #if !defined */


#if !defined (_PORTABLEINTERCEPTOR_SERVERREQUESTINFO_CH_)
#define _PORTABLEINTERCEPTOR_SERVERREQUESTINFO_CH_

  class TAO_Export ServerRequestInfo
    : public virtual PortableInterceptor::RequestInfo
  {
  public:
  #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
    typedef ServerRequestInfo_ptr _ptr_type;
    typedef ServerRequestInfo_var _var_type;
  #endif /* ! __GNUC__ || g++ >= 2.8 */

    static int _tao_class_id;

    // The static operations.
    static ServerRequestInfo_ptr _duplicate (ServerRequestInfo_ptr obj);

    static ServerRequestInfo_ptr _narrow (
        CORBA::Object_ptr obj
        ACE_ENV_ARG_DECL_WITH_DEFAULTS
      );

    static ServerRequestInfo_ptr _unchecked_narrow (
        CORBA::Object_ptr obj
        ACE_ENV_ARG_DECL_WITH_DEFAULTS
      );

    static ServerRequestInfo_ptr _nil (void)
      {
        return (ServerRequestInfo_ptr)0;
      }

    virtual CORBA::Any * sending_exception (

        ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
      )
      ACE_THROW_SPEC ((
        CORBA::SystemException
      )) = 0;

    virtual char * server_id (

        ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
      )
      ACE_THROW_SPEC ((
        CORBA::SystemException
      )) = 0;

    virtual char * orb_id (

        ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
      )
      ACE_THROW_SPEC ((
        CORBA::SystemException
      )) = 0;

    virtual ::PortableInterceptor::AdapterName * adapter_name (

        ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
      )
      ACE_THROW_SPEC ((
        CORBA::SystemException
      )) = 0;

    virtual ::CORBA::OctetSeq * object_id (

        ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
      )
      ACE_THROW_SPEC ((
        CORBA::SystemException
      )) = 0;

    virtual ::CORBA::OctetSeq * adapter_id (

        ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
      )
      ACE_THROW_SPEC ((
        CORBA::SystemException
      )) = 0;

    virtual char * target_most_derived_interface (

        ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
      )
      ACE_THROW_SPEC ((
        CORBA::SystemException
      )) = 0;

    virtual ::CORBA::Policy_ptr get_server_policy (
        CORBA::PolicyType type
        ACE_ENV_ARG_DECL_WITH_DEFAULTS
      )
      ACE_THROW_SPEC ((
        CORBA::SystemException
      )) = 0;

    virtual void set_slot (
        PortableInterceptor::SlotId id,
        const CORBA::Any & data
        ACE_ENV_ARG_DECL_WITH_DEFAULTS
      )
      ACE_THROW_SPEC ((
        CORBA::SystemException
        , PortableInterceptor::InvalidSlot
      )) = 0;

    virtual CORBA::Boolean target_is_a (
        const char * id
        ACE_ENV_ARG_DECL_WITH_DEFAULTS
      )
      ACE_THROW_SPEC ((
        CORBA::SystemException
      )) = 0;

    virtual void add_reply_service_context (
        const IOP::ServiceContext & service_context,
        CORBA::Boolean replace
        ACE_ENV_ARG_DECL_WITH_DEFAULTS
      )
      ACE_THROW_SPEC ((
        CORBA::SystemException
      )) = 0;

    virtual void *_tao_QueryInterface (ptr_arith_t type);

    virtual const char* _interface_repository_id (void) const;

  protected:
    ServerRequestInfo (void);

    virtual ~ServerRequestInfo (void);

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


#endif /* end #if !defined */


#if !defined (_PORTABLEINTERCEPTOR_CLIENTREQUESTINTERCEPTOR___PTR_CH_)
#define _PORTABLEINTERCEPTOR_CLIENTREQUESTINTERCEPTOR___PTR_CH_

  class ClientRequestInterceptor;
  typedef ClientRequestInterceptor *ClientRequestInterceptor_ptr;

#endif /* end #if !defined */


#if !defined (_PORTABLEINTERCEPTOR_CLIENTREQUESTINTERCEPTOR___VAR_CH_)
#define _PORTABLEINTERCEPTOR_CLIENTREQUESTINTERCEPTOR___VAR_CH_

  class TAO_Export ClientRequestInterceptor_var : public TAO_Base_var
  {
  public:
    ClientRequestInterceptor_var (void); // default constructor
    ClientRequestInterceptor_var (ClientRequestInterceptor_ptr p) : ptr_ (p) {}
    ClientRequestInterceptor_var (const ClientRequestInterceptor_var &); // copy constructor
    ~ClientRequestInterceptor_var (void); // destructor

    ClientRequestInterceptor_var &operator= (ClientRequestInterceptor_ptr);
    ClientRequestInterceptor_var &operator= (const ClientRequestInterceptor_var &);
    ClientRequestInterceptor_ptr operator-> (void) const;

    operator const ClientRequestInterceptor_ptr &() const;
    operator ClientRequestInterceptor_ptr &();
    // in, inout, out, _retn
    ClientRequestInterceptor_ptr in (void) const;
    ClientRequestInterceptor_ptr &inout (void);
    ClientRequestInterceptor_ptr &out (void);
    ClientRequestInterceptor_ptr _retn (void);
    ClientRequestInterceptor_ptr ptr (void) const;

    // Hooks used by template sequence and object manager classes
    // for non-defined forward declared interfaces.
    static ClientRequestInterceptor_ptr tao_duplicate (ClientRequestInterceptor_ptr);
    static void tao_release (ClientRequestInterceptor_ptr);
    static ClientRequestInterceptor_ptr tao_nil (void);
    static ClientRequestInterceptor_ptr tao_narrow (
        CORBA::Object *
        ACE_ENV_ARG_DECL_NOT_USED
      );
    static CORBA::Object * tao_upcast (void *);

  private:
    ClientRequestInterceptor_ptr ptr_;
    // Unimplemented - prevents widening assignment.
    ClientRequestInterceptor_var (const TAO_Base_var &rhs);
    ClientRequestInterceptor_var &operator= (const TAO_Base_var &rhs);
  };


#endif /* end #if !defined */


#if !defined (_PORTABLEINTERCEPTOR_CLIENTREQUESTINTERCEPTOR___OUT_CH_)
#define _PORTABLEINTERCEPTOR_CLIENTREQUESTINTERCEPTOR___OUT_CH_

  class TAO_Export ClientRequestInterceptor_out
  {
  public:
    ClientRequestInterceptor_out (ClientRequestInterceptor_ptr &);
    ClientRequestInterceptor_out (ClientRequestInterceptor_var &);
    ClientRequestInterceptor_out (const ClientRequestInterceptor_out &);
    ClientRequestInterceptor_out &operator= (const ClientRequestInterceptor_out &);
    ClientRequestInterceptor_out &operator= (const ClientRequestInterceptor_var &);
    ClientRequestInterceptor_out &operator= (ClientRequestInterceptor_ptr);
    operator ClientRequestInterceptor_ptr &();
    ClientRequestInterceptor_ptr &ptr (void);
    ClientRequestInterceptor_ptr operator-> (void);

  private:
    ClientRequestInterceptor_ptr &ptr_;
  };


#endif /* end #if !defined */


#if !defined (_PORTABLEINTERCEPTOR_CLIENTREQUESTINTERCEPTOR_CH_)
#define _PORTABLEINTERCEPTOR_CLIENTREQUESTINTERCEPTOR_CH_

  class TAO_Export ClientRequestInterceptor
    : public virtual PortableInterceptor::Interceptor
  {
  public:
  #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
    typedef ClientRequestInterceptor_ptr _ptr_type;
    typedef ClientRequestInterceptor_var _var_type;
  #endif /* ! __GNUC__ || g++ >= 2.8 */

    static int _tao_class_id;

    // The static operations.
    static ClientRequestInterceptor_ptr _duplicate (ClientRequestInterceptor_ptr obj);

    static ClientRequestInterceptor_ptr _narrow (
        CORBA::Object_ptr obj
        ACE_ENV_ARG_DECL_WITH_DEFAULTS
      );

    static ClientRequestInterceptor_ptr _unchecked_narrow (
        CORBA::Object_ptr obj
        ACE_ENV_ARG_DECL_WITH_DEFAULTS
      );

    static ClientRequestInterceptor_ptr _nil (void)
      {
        return (ClientRequestInterceptor_ptr)0;
      }

    virtual void send_request (
        PortableInterceptor::ClientRequestInfo_ptr ri
        ACE_ENV_ARG_DECL_WITH_DEFAULTS
      )
      ACE_THROW_SPEC ((
        CORBA::SystemException
        , PortableInterceptor::ForwardRequest
      )) = 0;

    virtual void send_poll (
        PortableInterceptor::ClientRequestInfo_ptr ri
        ACE_ENV_ARG_DECL_WITH_DEFAULTS
      )
      ACE_THROW_SPEC ((
        CORBA::SystemException
      )) = 0;

    virtual void receive_reply (
        PortableInterceptor::ClientRequestInfo_ptr ri
        ACE_ENV_ARG_DECL_WITH_DEFAULTS
      )
      ACE_THROW_SPEC ((
        CORBA::SystemException
      )) = 0;

    virtual void receive_exception (
        PortableInterceptor::ClientRequestInfo_ptr ri
        ACE_ENV_ARG_DECL_WITH_DEFAULTS
      )
      ACE_THROW_SPEC ((
        CORBA::SystemException
        , PortableInterceptor::ForwardRequest
      )) = 0;

    virtual void receive_other (
        PortableInterceptor::ClientRequestInfo_ptr ri
        ACE_ENV_ARG_DECL_WITH_DEFAULTS
      )
      ACE_THROW_SPEC ((
        CORBA::SystemException
        , PortableInterceptor::ForwardRequest
      )) = 0;

    virtual void *_tao_QueryInterface (ptr_arith_t type);

    virtual const char* _interface_repository_id (void) const;

  protected:
    ClientRequestInterceptor (void);

    virtual ~ClientRequestInterceptor (void);

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


#endif /* end #if !defined */


#if !defined (_PORTABLEINTERCEPTOR_SERVERREQUESTINTERCEPTOR___PTR_CH_)
#define _PORTABLEINTERCEPTOR_SERVERREQUESTINTERCEPTOR___PTR_CH_

  class ServerRequestInterceptor;
  typedef ServerRequestInterceptor *ServerRequestInterceptor_ptr;

#endif /* end #if !defined */


#if !defined (_PORTABLEINTERCEPTOR_SERVERREQUESTINTERCEPTOR___VAR_CH_)
#define _PORTABLEINTERCEPTOR_SERVERREQUESTINTERCEPTOR___VAR_CH_

  class TAO_Export ServerRequestInterceptor_var : public TAO_Base_var
  {
  public:
    ServerRequestInterceptor_var (void); // default constructor
    ServerRequestInterceptor_var (ServerRequestInterceptor_ptr p) : ptr_ (p) {}
    ServerRequestInterceptor_var (const ServerRequestInterceptor_var &); // copy constructor
    ~ServerRequestInterceptor_var (void); // destructor

    ServerRequestInterceptor_var &operator= (ServerRequestInterceptor_ptr);
    ServerRequestInterceptor_var &operator= (const ServerRequestInterceptor_var &);
    ServerRequestInterceptor_ptr operator-> (void) const;

    operator const ServerRequestInterceptor_ptr &() const;
    operator ServerRequestInterceptor_ptr &();
    // in, inout, out, _retn
    ServerRequestInterceptor_ptr in (void) const;
    ServerRequestInterceptor_ptr &inout (void);
    ServerRequestInterceptor_ptr &out (void);
    ServerRequestInterceptor_ptr _retn (void);
    ServerRequestInterceptor_ptr ptr (void) const;

    // Hooks used by template sequence and object manager classes
    // for non-defined forward declared interfaces.
    static ServerRequestInterceptor_ptr tao_duplicate (ServerRequestInterceptor_ptr);
    static void tao_release (ServerRequestInterceptor_ptr);
    static ServerRequestInterceptor_ptr tao_nil (void);
    static ServerRequestInterceptor_ptr tao_narrow (
        CORBA::Object *
        ACE_ENV_ARG_DECL_NOT_USED
      );
    static CORBA::Object * tao_upcast (void *);

  private:
    ServerRequestInterceptor_ptr ptr_;
    // Unimplemented - prevents widening assignment.
    ServerRequestInterceptor_var (const TAO_Base_var &rhs);
    ServerRequestInterceptor_var &operator= (const TAO_Base_var &rhs);
  };


#endif /* end #if !defined */


#if !defined (_PORTABLEINTERCEPTOR_SERVERREQUESTINTERCEPTOR___OUT_CH_)
#define _PORTABLEINTERCEPTOR_SERVERREQUESTINTERCEPTOR___OUT_CH_

  class TAO_Export ServerRequestInterceptor_out
  {
  public:
    ServerRequestInterceptor_out (ServerRequestInterceptor_ptr &);
    ServerRequestInterceptor_out (ServerRequestInterceptor_var &);
    ServerRequestInterceptor_out (const ServerRequestInterceptor_out &);
    ServerRequestInterceptor_out &operator= (const ServerRequestInterceptor_out &);
    ServerRequestInterceptor_out &operator= (const ServerRequestInterceptor_var &);
    ServerRequestInterceptor_out &operator= (ServerRequestInterceptor_ptr);
    operator ServerRequestInterceptor_ptr &();
    ServerRequestInterceptor_ptr &ptr (void);
    ServerRequestInterceptor_ptr operator-> (void);

  private:
    ServerRequestInterceptor_ptr &ptr_;
  };


#endif /* end #if !defined */


#if !defined (_PORTABLEINTERCEPTOR_SERVERREQUESTINTERCEPTOR_CH_)
#define _PORTABLEINTERCEPTOR_SERVERREQUESTINTERCEPTOR_CH_

  class TAO_Export ServerRequestInterceptor
    : public virtual PortableInterceptor::Interceptor
  {
  public:
  #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
    typedef ServerRequestInterceptor_ptr _ptr_type;
    typedef ServerRequestInterceptor_var _var_type;
  #endif /* ! __GNUC__ || g++ >= 2.8 */

    static int _tao_class_id;

    // The static operations.
    static ServerRequestInterceptor_ptr _duplicate (ServerRequestInterceptor_ptr obj);

    static ServerRequestInterceptor_ptr _narrow (
        CORBA::Object_ptr obj
        ACE_ENV_ARG_DECL_WITH_DEFAULTS
      );

    static ServerRequestInterceptor_ptr _unchecked_narrow (
        CORBA::Object_ptr obj
        ACE_ENV_ARG_DECL_WITH_DEFAULTS
      );

    static ServerRequestInterceptor_ptr _nil (void)
      {
        return (ServerRequestInterceptor_ptr)0;
      }

    virtual void receive_request_service_contexts (
        PortableInterceptor::ServerRequestInfo_ptr ri
        ACE_ENV_ARG_DECL_WITH_DEFAULTS
      )
      ACE_THROW_SPEC ((
        CORBA::SystemException
        , PortableInterceptor::ForwardRequest
      )) = 0;

    virtual void receive_request (
        PortableInterceptor::ServerRequestInfo_ptr ri
        ACE_ENV_ARG_DECL_WITH_DEFAULTS
      )
      ACE_THROW_SPEC ((
        CORBA::SystemException
        , PortableInterceptor::ForwardRequest
      )) = 0;

    virtual void send_reply (
        PortableInterceptor::ServerRequestInfo_ptr ri
        ACE_ENV_ARG_DECL_WITH_DEFAULTS
      )
      ACE_THROW_SPEC ((
        CORBA::SystemException
      )) = 0;

    virtual void send_exception (
        PortableInterceptor::ServerRequestInfo_ptr ri
        ACE_ENV_ARG_DECL_WITH_DEFAULTS
      )
      ACE_THROW_SPEC ((
        CORBA::SystemException
        , PortableInterceptor::ForwardRequest
      )) = 0;

    virtual void send_other (
        PortableInterceptor::ServerRequestInfo_ptr ri
        ACE_ENV_ARG_DECL_WITH_DEFAULTS
      )
      ACE_THROW_SPEC ((
        CORBA::SystemException
        , PortableInterceptor::ForwardRequest
      )) = 0;

    virtual void *_tao_QueryInterface (ptr_arith_t type);

    virtual const char* _interface_repository_id (void) const;

  protected:
    ServerRequestInterceptor (void);

    virtual ~ServerRequestInterceptor (void);

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


#endif /* end #if !defined */


#if !defined (_PORTABLEINTERCEPTOR_IORINFO___PTR_CH_)
#define _PORTABLEINTERCEPTOR_IORINFO___PTR_CH_

  class IORInfo;
  typedef IORInfo *IORInfo_ptr;

#endif /* end #if !defined */


#if !defined (_PORTABLEINTERCEPTOR_IORINFO___VAR_CH_)
#define _PORTABLEINTERCEPTOR_IORINFO___VAR_CH_

  class TAO_Export IORInfo_var : public TAO_Base_var
  {
  public:
    IORInfo_var (void); // default constructor
    IORInfo_var (IORInfo_ptr p) : ptr_ (p) {}
    IORInfo_var (const IORInfo_var &); // copy constructor
    ~IORInfo_var (void); // destructor

    IORInfo_var &operator= (IORInfo_ptr);
    IORInfo_var &operator= (const IORInfo_var &);
    IORInfo_ptr operator-> (void) const;

    operator const IORInfo_ptr &() const;
    operator IORInfo_ptr &();
    // in, inout, out, _retn
    IORInfo_ptr in (void) const;
    IORInfo_ptr &inout (void);
    IORInfo_ptr &out (void);
    IORInfo_ptr _retn (void);
    IORInfo_ptr ptr (void) const;

    // Hooks used by template sequence and object manager classes
    // for non-defined forward declared interfaces.
    static IORInfo_ptr tao_duplicate (IORInfo_ptr);
    static void tao_release (IORInfo_ptr);
    static IORInfo_ptr tao_nil (void);
    static IORInfo_ptr tao_narrow (
        CORBA::Object *
        ACE_ENV_ARG_DECL_NOT_USED
      );
    static CORBA::Object * tao_upcast (void *);

  private:
    IORInfo_ptr ptr_;
    // Unimplemented - prevents widening assignment.
    IORInfo_var (const TAO_Base_var &rhs);
    IORInfo_var &operator= (const TAO_Base_var &rhs);
  };


#endif /* end #if !defined */


#if !defined (_PORTABLEINTERCEPTOR_IORINFO___OUT_CH_)
#define _PORTABLEINTERCEPTOR_IORINFO___OUT_CH_

  class TAO_Export IORInfo_out
  {
  public:
    IORInfo_out (IORInfo_ptr &);
    IORInfo_out (IORInfo_var &);
    IORInfo_out (const IORInfo_out &);
    IORInfo_out &operator= (const IORInfo_out &);
    IORInfo_out &operator= (const IORInfo_var &);
    IORInfo_out &operator= (IORInfo_ptr);
    operator IORInfo_ptr &();
    IORInfo_ptr &ptr (void);
    IORInfo_ptr operator-> (void);

  private:
    IORInfo_ptr &ptr_;
  };


#endif /* end #if !defined */


#if !defined (_PORTABLEINTERCEPTOR_IORINFO_CH_)
#define _PORTABLEINTERCEPTOR_IORINFO_CH_

  class TAO_Export IORInfo
    : public virtual CORBA_Object
  {
  public:
  #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
    typedef IORInfo_ptr _ptr_type;
    typedef IORInfo_var _var_type;
  #endif /* ! __GNUC__ || g++ >= 2.8 */

    static int _tao_class_id;

    // The static operations.
    static IORInfo_ptr _duplicate (IORInfo_ptr obj);

    static IORInfo_ptr _narrow (
        CORBA::Object_ptr obj
        ACE_ENV_ARG_DECL_WITH_DEFAULTS
      );

    static IORInfo_ptr _unchecked_narrow (
        CORBA::Object_ptr obj
        ACE_ENV_ARG_DECL_WITH_DEFAULTS
      );

    static IORInfo_ptr _nil (void)
      {
        return (IORInfo_ptr)0;
      }

    virtual ::CORBA::Policy_ptr get_effective_policy (
        CORBA::PolicyType type
        ACE_ENV_ARG_DECL_WITH_DEFAULTS
      )
      ACE_THROW_SPEC ((
        CORBA::SystemException
      )) = 0;

    virtual void add_ior_component (
        const IOP::TaggedComponent & component
        ACE_ENV_ARG_DECL_WITH_DEFAULTS
      )
      ACE_THROW_SPEC ((
        CORBA::SystemException
      )) = 0;

    virtual void add_ior_component_to_profile (
        const IOP::TaggedComponent & component,
        IOP::ProfileId profile_id
        ACE_ENV_ARG_DECL_WITH_DEFAULTS
      )
      ACE_THROW_SPEC ((
        CORBA::SystemException
      )) = 0;

    virtual PortableInterceptor::AdapterManagerId manager_id (

        ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
      )
      ACE_THROW_SPEC ((
        CORBA::SystemException
      )) = 0;

    virtual PortableInterceptor::AdapterState state (

        ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
      )
      ACE_THROW_SPEC ((
        CORBA::SystemException
      )) = 0;

    virtual ::PortableInterceptor::ObjectReferenceTemplate * adapter_template (

        ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
      )
      ACE_THROW_SPEC ((
        CORBA::SystemException
      )) = 0;

    virtual ::PortableInterceptor::ObjectReferenceFactory * current_factory (

        ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
      )
      ACE_THROW_SPEC ((
        CORBA::SystemException
      )) = 0;

    virtual void current_factory (
        PortableInterceptor::ObjectReferenceFactory * current_factory
        ACE_ENV_ARG_DECL_WITH_DEFAULTS
      )
      ACE_THROW_SPEC ((
        CORBA::SystemException
      )) = 0;

    virtual void *_tao_QueryInterface (ptr_arith_t type);

    virtual const char* _interface_repository_id (void) const;

  protected:
    IORInfo (void);

    virtual ~IORInfo (void);

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


#endif /* end #if !defined */


#if !defined (_PORTABLEINTERCEPTOR_IORINTERCEPTOR___PTR_CH_)
#define _PORTABLEINTERCEPTOR_IORINTERCEPTOR___PTR_CH_

  class IORInterceptor;
  typedef IORInterceptor *IORInterceptor_ptr;

#endif /* end #if !defined */


#if !defined (_PORTABLEINTERCEPTOR_IORINTERCEPTOR___VAR_CH_)
#define _PORTABLEINTERCEPTOR_IORINTERCEPTOR___VAR_CH_

  class TAO_Export IORInterceptor_var : public TAO_Base_var
  {
  public:
    IORInterceptor_var (void); // default constructor
    IORInterceptor_var (IORInterceptor_ptr p) : ptr_ (p) {}
    IORInterceptor_var (const IORInterceptor_var &); // copy constructor
    ~IORInterceptor_var (void); // destructor

    IORInterceptor_var &operator= (IORInterceptor_ptr);
    IORInterceptor_var &operator= (const IORInterceptor_var &);
    IORInterceptor_ptr operator-> (void) const;

    operator const IORInterceptor_ptr &() const;
    operator IORInterceptor_ptr &();
    // in, inout, out, _retn
    IORInterceptor_ptr in (void) const;
    IORInterceptor_ptr &inout (void);
    IORInterceptor_ptr &out (void);
    IORInterceptor_ptr _retn (void);
    IORInterceptor_ptr ptr (void) const;

    // Hooks used by template sequence and object manager classes
    // for non-defined forward declared interfaces.
    static IORInterceptor_ptr tao_duplicate (IORInterceptor_ptr);
    static void tao_release (IORInterceptor_ptr);
    static IORInterceptor_ptr tao_nil (void);
    static IORInterceptor_ptr tao_narrow (
        CORBA::Object *
        ACE_ENV_ARG_DECL_NOT_USED
      );
    static CORBA::Object * tao_upcast (void *);

  private:
    IORInterceptor_ptr ptr_;
    // Unimplemented - prevents widening assignment.
    IORInterceptor_var (const TAO_Base_var &rhs);
    IORInterceptor_var &operator= (const TAO_Base_var &rhs);
  };


#endif /* end #if !defined */


#if !defined (_PORTABLEINTERCEPTOR_IORINTERCEPTOR___OUT_CH_)
#define _PORTABLEINTERCEPTOR_IORINTERCEPTOR___OUT_CH_

  class TAO_Export IORInterceptor_out
  {
  public:
    IORInterceptor_out (IORInterceptor_ptr &);
    IORInterceptor_out (IORInterceptor_var &);
    IORInterceptor_out (const IORInterceptor_out &);
    IORInterceptor_out &operator= (const IORInterceptor_out &);
    IORInterceptor_out &operator= (const IORInterceptor_var &);
    IORInterceptor_out &operator= (IORInterceptor_ptr);
    operator IORInterceptor_ptr &();
    IORInterceptor_ptr &ptr (void);
    IORInterceptor_ptr operator-> (void);

  private:
    IORInterceptor_ptr &ptr_;
  };


#endif /* end #if !defined */


#if !defined (_PORTABLEINTERCEPTOR_IORINTERCEPTOR_CH_)
#define _PORTABLEINTERCEPTOR_IORINTERCEPTOR_CH_

  class TAO_Export IORInterceptor
    : public virtual PortableInterceptor::Interceptor
  {
  public:
  #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
    typedef IORInterceptor_ptr _ptr_type;
    typedef IORInterceptor_var _var_type;
  #endif /* ! __GNUC__ || g++ >= 2.8 */

    static int _tao_class_id;

    // The static operations.
    static IORInterceptor_ptr _duplicate (IORInterceptor_ptr obj);

    static IORInterceptor_ptr _narrow (
        CORBA::Object_ptr obj
        ACE_ENV_ARG_DECL_WITH_DEFAULTS
      );

    static IORInterceptor_ptr _unchecked_narrow (
        CORBA::Object_ptr obj
        ACE_ENV_ARG_DECL_WITH_DEFAULTS
      );

    static IORInterceptor_ptr _nil (void)
      {
        return (IORInterceptor_ptr)0;
      }

    virtual void establish_components (
        PortableInterceptor::IORInfo_ptr info
        ACE_ENV_ARG_DECL_WITH_DEFAULTS
      )
      ACE_THROW_SPEC ((
        CORBA::SystemException
      )) = 0;

    virtual void components_established (
        PortableInterceptor::IORInfo_ptr info
        ACE_ENV_ARG_DECL_WITH_DEFAULTS
      )
      ACE_THROW_SPEC ((
        CORBA::SystemException
      )) = 0;

    virtual void adapter_manager_state_changed (
        PortableInterceptor::AdapterManagerId id,
        PortableInterceptor::AdapterState state
        ACE_ENV_ARG_DECL_WITH_DEFAULTS
      )
      ACE_THROW_SPEC ((
        CORBA::SystemException
      )) = 0;

    virtual void adapter_state_changed (
        const PortableInterceptor::ObjectReferenceTemplateSeq & templates,
        PortableInterceptor::AdapterState state
        ACE_ENV_ARG_DECL_WITH_DEFAULTS
      )
      ACE_THROW_SPEC ((
        CORBA::SystemException
      )) = 0;

    virtual void *_tao_QueryInterface (ptr_arith_t type);

    virtual const char* _interface_repository_id (void) const;

  protected:
    IORInterceptor (void);

    virtual ~IORInterceptor (void);

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


#endif /* end #if !defined */


#if !defined (_PORTABLEINTERCEPTOR_POLICYFACTORY___PTR_CH_)
#define _PORTABLEINTERCEPTOR_POLICYFACTORY___PTR_CH_

  class PolicyFactory;
  typedef PolicyFactory *PolicyFactory_ptr;

#endif /* end #if !defined */


#if !defined (_PORTABLEINTERCEPTOR_POLICYFACTORY___VAR_CH_)
#define _PORTABLEINTERCEPTOR_POLICYFACTORY___VAR_CH_

  class TAO_Export PolicyFactory_var : public TAO_Base_var
  {
  public:
    PolicyFactory_var (void); // default constructor
    PolicyFactory_var (PolicyFactory_ptr p) : ptr_ (p) {}
    PolicyFactory_var (const PolicyFactory_var &); // copy constructor
    ~PolicyFactory_var (void); // destructor

    PolicyFactory_var &operator= (PolicyFactory_ptr);
    PolicyFactory_var &operator= (const PolicyFactory_var &);
    PolicyFactory_ptr operator-> (void) const;

    operator const PolicyFactory_ptr &() const;
    operator PolicyFactory_ptr &();
    // in, inout, out, _retn
    PolicyFactory_ptr in (void) const;
    PolicyFactory_ptr &inout (void);
    PolicyFactory_ptr &out (void);
    PolicyFactory_ptr _retn (void);
    PolicyFactory_ptr ptr (void) const;

    // Hooks used by template sequence and object manager classes
    // for non-defined forward declared interfaces.
    static PolicyFactory_ptr tao_duplicate (PolicyFactory_ptr);
    static void tao_release (PolicyFactory_ptr);
    static PolicyFactory_ptr tao_nil (void);
    static PolicyFactory_ptr tao_narrow (
        CORBA::Object *
        ACE_ENV_ARG_DECL_NOT_USED
      );
    static CORBA::Object * tao_upcast (void *);

  private:
    PolicyFactory_ptr ptr_;
    // Unimplemented - prevents widening assignment.
    PolicyFactory_var (const TAO_Base_var &rhs);
    PolicyFactory_var &operator= (const TAO_Base_var &rhs);
  };


#endif /* end #if !defined */


#if !defined (_PORTABLEINTERCEPTOR_POLICYFACTORY___OUT_CH_)
#define _PORTABLEINTERCEPTOR_POLICYFACTORY___OUT_CH_

  class TAO_Export PolicyFactory_out
  {
  public:
    PolicyFactory_out (PolicyFactory_ptr &);
    PolicyFactory_out (PolicyFactory_var &);
    PolicyFactory_out (const PolicyFactory_out &);
    PolicyFactory_out &operator= (const PolicyFactory_out &);
    PolicyFactory_out &operator= (const PolicyFactory_var &);
    PolicyFactory_out &operator= (PolicyFactory_ptr);
    operator PolicyFactory_ptr &();
    PolicyFactory_ptr &ptr (void);
    PolicyFactory_ptr operator-> (void);

  private:
    PolicyFactory_ptr &ptr_;
  };


#endif /* end #if !defined */


#if !defined (_PORTABLEINTERCEPTOR_POLICYFACTORY_CH_)
#define _PORTABLEINTERCEPTOR_POLICYFACTORY_CH_

  class TAO_Export PolicyFactory
    : public virtual CORBA_Object
  {
  public:
  #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
    typedef PolicyFactory_ptr _ptr_type;
    typedef PolicyFactory_var _var_type;
  #endif /* ! __GNUC__ || g++ >= 2.8 */

    static int _tao_class_id;

    // The static operations.
    static PolicyFactory_ptr _duplicate (PolicyFactory_ptr obj);

    static PolicyFactory_ptr _narrow (
        CORBA::Object_ptr obj
        ACE_ENV_ARG_DECL_WITH_DEFAULTS
      );

    static PolicyFactory_ptr _unchecked_narrow (
        CORBA::Object_ptr obj
        ACE_ENV_ARG_DECL_WITH_DEFAULTS
      );

    static PolicyFactory_ptr _nil (void)
      {
        return (PolicyFactory_ptr)0;
      }

    virtual ::CORBA::Policy_ptr create_policy (
        CORBA::PolicyType type,
        const CORBA::Any & value
        ACE_ENV_ARG_DECL_WITH_DEFAULTS
      )
      ACE_THROW_SPEC ((
        CORBA::SystemException
        , CORBA::PolicyError
      )) = 0;

    virtual ::CORBA::Policy_ptr _create_policy (
        CORBA::PolicyType type
        ACE_ENV_ARG_DECL_WITH_DEFAULTS
      )
      ACE_THROW_SPEC ((
        CORBA::SystemException
        , CORBA::PolicyError
      ));

    virtual void *_tao_QueryInterface (ptr_arith_t type);

    virtual const char* _interface_repository_id (void) const;

  protected:
    PolicyFactory (void);

    virtual ~PolicyFactory (void);

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


#endif /* end #if !defined */


#if !defined (_PORTABLEINTERCEPTOR_ORBINITINFO___PTR_CH_)
#define _PORTABLEINTERCEPTOR_ORBINITINFO___PTR_CH_

  class ORBInitInfo;
  typedef ORBInitInfo *ORBInitInfo_ptr;

#endif /* end #if !defined */


#if !defined (_PORTABLEINTERCEPTOR_ORBINITINFO___VAR_CH_)
#define _PORTABLEINTERCEPTOR_ORBINITINFO___VAR_CH_

  class TAO_Export ORBInitInfo_var : public TAO_Base_var
  {
  public:
    ORBInitInfo_var (void); // default constructor
    ORBInitInfo_var (ORBInitInfo_ptr p) : ptr_ (p) {}
    ORBInitInfo_var (const ORBInitInfo_var &); // copy constructor
    ~ORBInitInfo_var (void); // destructor

    ORBInitInfo_var &operator= (ORBInitInfo_ptr);
    ORBInitInfo_var &operator= (const ORBInitInfo_var &);
    ORBInitInfo_ptr operator-> (void) const;

    operator const ORBInitInfo_ptr &() const;
    operator ORBInitInfo_ptr &();
    // in, inout, out, _retn
    ORBInitInfo_ptr in (void) const;
    ORBInitInfo_ptr &inout (void);
    ORBInitInfo_ptr &out (void);
    ORBInitInfo_ptr _retn (void);
    ORBInitInfo_ptr ptr (void) const;

    // Hooks used by template sequence and object manager classes
    // for non-defined forward declared interfaces.
    static ORBInitInfo_ptr tao_duplicate (ORBInitInfo_ptr);
    static void tao_release (ORBInitInfo_ptr);
    static ORBInitInfo_ptr tao_nil (void);
    static ORBInitInfo_ptr tao_narrow (
        CORBA::Object *
        ACE_ENV_ARG_DECL_NOT_USED
      );
    static CORBA::Object * tao_upcast (void *);

  private:
    ORBInitInfo_ptr ptr_;
    // Unimplemented - prevents widening assignment.
    ORBInitInfo_var (const TAO_Base_var &rhs);
    ORBInitInfo_var &operator= (const TAO_Base_var &rhs);
  };


#endif /* end #if !defined */


#if !defined (_PORTABLEINTERCEPTOR_ORBINITINFO___OUT_CH_)
#define _PORTABLEINTERCEPTOR_ORBINITINFO___OUT_CH_

  class TAO_Export ORBInitInfo_out
  {
  public:
    ORBInitInfo_out (ORBInitInfo_ptr &);
    ORBInitInfo_out (ORBInitInfo_var &);
    ORBInitInfo_out (const ORBInitInfo_out &);
    ORBInitInfo_out &operator= (const ORBInitInfo_out &);
    ORBInitInfo_out &operator= (const ORBInitInfo_var &);
    ORBInitInfo_out &operator= (ORBInitInfo_ptr);
    operator ORBInitInfo_ptr &();
    ORBInitInfo_ptr &ptr (void);
    ORBInitInfo_ptr operator-> (void);

  private:
    ORBInitInfo_ptr &ptr_;
  };


#endif /* end #if !defined */


#if !defined (_PORTABLEINTERCEPTOR_ORBINITINFO_CH_)
#define _PORTABLEINTERCEPTOR_ORBINITINFO_CH_

  class TAO_Export ORBInitInfo
    : public virtual CORBA_Object
  {
  public:
  #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
    typedef ORBInitInfo_ptr _ptr_type;
    typedef ORBInitInfo_var _var_type;
  #endif /* ! __GNUC__ || g++ >= 2.8 */

    static int _tao_class_id;

    // The static operations.
    static ORBInitInfo_ptr _duplicate (ORBInitInfo_ptr obj);

    static ORBInitInfo_ptr _narrow (
        CORBA::Object_ptr obj
        ACE_ENV_ARG_DECL_WITH_DEFAULTS
      );

    static ORBInitInfo_ptr _unchecked_narrow (
        CORBA::Object_ptr obj
        ACE_ENV_ARG_DECL_WITH_DEFAULTS
      );

    static ORBInitInfo_ptr _nil (void)
      {
        return (ORBInitInfo_ptr)0;
      }

    typedef char * ObjectId;
    typedef CORBA::String_var ObjectId_var;
    typedef CORBA::String_out ObjectId_out;

#if !defined (_PORTABLEINTERCEPTOR_ORBINITINFO_DUPLICATENAME_CH_)
#define _PORTABLEINTERCEPTOR_ORBINITINFO_DUPLICATENAME_CH_

    class TAO_Export DuplicateName : public CORBA::UserException
    {
    public:
      TAO_String_Manager name;

      DuplicateName (void);
      DuplicateName (const DuplicateName &);
      ~DuplicateName (void);

      DuplicateName &operator= (const DuplicateName &);

      static DuplicateName *_downcast (CORBA::Exception *);
      static CORBA::Exception *_alloc (void);

      virtual CORBA::Exception *_tao_duplicate (void) const;

      virtual void _raise (void);

      virtual void _tao_encode (
          TAO_OutputCDR &
          ACE_ENV_ARG_DECL_NOT_USED
        ) const;

      virtual void _tao_decode (
          TAO_InputCDR &
          ACE_ENV_ARG_DECL_NOT_USED
        );

            DuplicateName (
          const char * _tao_name
        );

    };


#endif /* end #if !defined */


#if !defined (_PORTABLEINTERCEPTOR_ORBINITINFO_INVALIDNAME_CH_)
#define _PORTABLEINTERCEPTOR_ORBINITINFO_INVALIDNAME_CH_

    class TAO_Export InvalidName : public CORBA::UserException
    {
    public:

      InvalidName (void);
      InvalidName (const InvalidName &);
      ~InvalidName (void);

      InvalidName &operator= (const InvalidName &);

      static InvalidName *_downcast (CORBA::Exception *);
      static CORBA::Exception *_alloc (void);

      virtual CORBA::Exception *_tao_duplicate (void) const;

      virtual void _raise (void);

      virtual void _tao_encode (
          TAO_OutputCDR &
          ACE_ENV_ARG_DECL_NOT_USED
        ) const;

      virtual void _tao_decode (
          TAO_InputCDR &
          ACE_ENV_ARG_DECL_NOT_USED
        );


    };


#endif /* end #if !defined */

    virtual ::CORBA::StringSeq * arguments (

        ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
      )
      ACE_THROW_SPEC ((
        CORBA::SystemException
      )) = 0;

    virtual char * orb_id (

        ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
      )
      ACE_THROW_SPEC ((
        CORBA::SystemException
      )) = 0;

    virtual ::IOP::CodecFactory_ptr codec_factory (

        ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
      )
      ACE_THROW_SPEC ((
        CORBA::SystemException
      )) = 0;

    virtual void register_initial_reference (
        const char * id,
        CORBA::Object_ptr obj
        ACE_ENV_ARG_DECL_WITH_DEFAULTS
      )
      ACE_THROW_SPEC ((
        CORBA::SystemException
        , PortableInterceptor::ORBInitInfo::InvalidName
      )) = 0;

    virtual CORBA::Object_ptr resolve_initial_references (
        const char * id
        ACE_ENV_ARG_DECL_WITH_DEFAULTS
      )
      ACE_THROW_SPEC ((
        CORBA::SystemException
        , PortableInterceptor::ORBInitInfo::InvalidName
      )) = 0;

    virtual void add_client_request_interceptor (
        PortableInterceptor::ClientRequestInterceptor_ptr interceptor
        ACE_ENV_ARG_DECL_WITH_DEFAULTS
      )
      ACE_THROW_SPEC ((
        CORBA::SystemException
        , PortableInterceptor::ORBInitInfo::DuplicateName
      )) = 0;

    virtual void add_server_request_interceptor (
        PortableInterceptor::ServerRequestInterceptor_ptr interceptor
        ACE_ENV_ARG_DECL_WITH_DEFAULTS
      )
      ACE_THROW_SPEC ((
        CORBA::SystemException
        , PortableInterceptor::ORBInitInfo::DuplicateName
      )) = 0;

    virtual void add_ior_interceptor (
        PortableInterceptor::IORInterceptor_ptr interceptor
        ACE_ENV_ARG_DECL_WITH_DEFAULTS
      )
      ACE_THROW_SPEC ((
        CORBA::SystemException
        , PortableInterceptor::ORBInitInfo::DuplicateName
      )) = 0;

    virtual PortableInterceptor::SlotId allocate_slot_id (

        ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
      )
      ACE_THROW_SPEC ((
        CORBA::SystemException
      )) = 0;

    virtual void register_policy_factory (
        CORBA::PolicyType type,
        PortableInterceptor::PolicyFactory_ptr policy_factory
        ACE_ENV_ARG_DECL_WITH_DEFAULTS
      )
      ACE_THROW_SPEC ((
        CORBA::SystemException
      )) = 0;

    virtual void *_tao_QueryInterface (ptr_arith_t type);

    virtual const char* _interface_repository_id (void) const;

  protected:
    ORBInitInfo (void);

    virtual ~ORBInitInfo (void);

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


#endif /* end #if !defined */


#if !defined (_PORTABLEINTERCEPTOR_ORBINITIALIZER___PTR_CH_)
#define _PORTABLEINTERCEPTOR_ORBINITIALIZER___PTR_CH_

  class ORBInitializer;
  typedef ORBInitializer *ORBInitializer_ptr;

  /// Register an ORBInitializer with the global ORBInitializer
  /// table.
  TAO_NAMESPACE_STORAGE_CLASS void register_orb_initializer (
      ORBInitializer_ptr init
      TAO_ENV_ARG_DECL_WITH_DEFAULTS);

#endif /* end #if !defined */


#if !defined (_PORTABLEINTERCEPTOR_ORBINITIALIZER___VAR_CH_)
#define _PORTABLEINTERCEPTOR_ORBINITIALIZER___VAR_CH_

  class TAO_Export ORBInitializer_var : public TAO_Base_var
  {
  public:
    ORBInitializer_var (void); // default constructor
    ORBInitializer_var (ORBInitializer_ptr p) : ptr_ (p) {}
    ORBInitializer_var (const ORBInitializer_var &); // copy constructor
    ~ORBInitializer_var (void); // destructor

    ORBInitializer_var &operator= (ORBInitializer_ptr);
    ORBInitializer_var &operator= (const ORBInitializer_var &);
    ORBInitializer_ptr operator-> (void) const;

    operator const ORBInitializer_ptr &() const;
    operator ORBInitializer_ptr &();
    // in, inout, out, _retn
    ORBInitializer_ptr in (void) const;
    ORBInitializer_ptr &inout (void);
    ORBInitializer_ptr &out (void);
    ORBInitializer_ptr _retn (void);
    ORBInitializer_ptr ptr (void) const;

    // Hooks used by template sequence and object manager classes
    // for non-defined forward declared interfaces.
    static ORBInitializer_ptr tao_duplicate (ORBInitializer_ptr);
    static void tao_release (ORBInitializer_ptr);
    static ORBInitializer_ptr tao_nil (void);
    static ORBInitializer_ptr tao_narrow (
        CORBA::Object *
        ACE_ENV_ARG_DECL_NOT_USED
      );
    static CORBA::Object * tao_upcast (void *);

  private:
    ORBInitializer_ptr ptr_;
    // Unimplemented - prevents widening assignment.
    ORBInitializer_var (const TAO_Base_var &rhs);
    ORBInitializer_var &operator= (const TAO_Base_var &rhs);
  };


#endif /* end #if !defined */


#if !defined (_PORTABLEINTERCEPTOR_ORBINITIALIZER___OUT_CH_)
#define _PORTABLEINTERCEPTOR_ORBINITIALIZER___OUT_CH_

  class TAO_Export ORBInitializer_out
  {
  public:
    ORBInitializer_out (ORBInitializer_ptr &);
    ORBInitializer_out (ORBInitializer_var &);
    ORBInitializer_out (const ORBInitializer_out &);
    ORBInitializer_out &operator= (const ORBInitializer_out &);
    ORBInitializer_out &operator= (const ORBInitializer_var &);
    ORBInitializer_out &operator= (ORBInitializer_ptr);
    operator ORBInitializer_ptr &();
    ORBInitializer_ptr &ptr (void);
    ORBInitializer_ptr operator-> (void);

  private:
    ORBInitializer_ptr &ptr_;
  };


#endif /* end #if !defined */


#if !defined (_PORTABLEINTERCEPTOR_ORBINITIALIZER_CH_)
#define _PORTABLEINTERCEPTOR_ORBINITIALIZER_CH_

  class TAO_Export ORBInitializer
    : public virtual CORBA_Object
  {
  public:
  #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
    typedef ORBInitializer_ptr _ptr_type;
    typedef ORBInitializer_var _var_type;
  #endif /* ! __GNUC__ || g++ >= 2.8 */

    static int _tao_class_id;

    // The static operations.
    static ORBInitializer_ptr _duplicate (ORBInitializer_ptr obj);

    static ORBInitializer_ptr _narrow (
        CORBA::Object_ptr obj
        ACE_ENV_ARG_DECL_WITH_DEFAULTS
      );

    static ORBInitializer_ptr _unchecked_narrow (
        CORBA::Object_ptr obj
        ACE_ENV_ARG_DECL_WITH_DEFAULTS
      );

    static ORBInitializer_ptr _nil (void)
      {
        return (ORBInitializer_ptr)0;
      }

    virtual void pre_init (
        PortableInterceptor::ORBInitInfo_ptr info
        ACE_ENV_ARG_DECL_WITH_DEFAULTS
      )
      ACE_THROW_SPEC ((
        CORBA::SystemException
      )) = 0;

    virtual void post_init (
        PortableInterceptor::ORBInitInfo_ptr info
        ACE_ENV_ARG_DECL_WITH_DEFAULTS
      )
      ACE_THROW_SPEC ((
        CORBA::SystemException
      )) = 0;

    virtual void *_tao_QueryInterface (ptr_arith_t type);

    virtual const char* _interface_repository_id (void) const;

  protected:
    ORBInitializer (void);

    virtual ~ORBInitializer (void);

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


#endif /* end #if !defined */


}
TAO_NAMESPACE_CLOSE // module PortableInterceptor

TAO_NAMESPACE  OBV_PortableInterceptor
{
}
TAO_NAMESPACE_CLOSE

TAO_NAMESPACE  OBV_Messaging
{
}
TAO_NAMESPACE_CLOSE

TAO_Export void operator<<= (CORBA::Any &, const PortableInterceptor::ForwardRequest &); // copying version
TAO_Export void operator<<= (CORBA::Any &, PortableInterceptor::ForwardRequest*); // noncopying version
TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableInterceptor::ForwardRequest *&); // deprecated
TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const PortableInterceptor::ForwardRequest *&);
TAO_Export void operator<<= (CORBA::Any &, const PortableInterceptor::InvalidSlot &); // copying version
TAO_Export void operator<<= (CORBA::Any &, PortableInterceptor::InvalidSlot*); // noncopying version
TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableInterceptor::InvalidSlot *&); // deprecated
TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const PortableInterceptor::InvalidSlot *&);

#ifndef __ACE_INLINE__

TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableInterceptor::ForwardRequest &);
TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableInterceptor::ForwardRequest &);

TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableInterceptor::InvalidSlot &);
TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableInterceptor::InvalidSlot &);


#endif /* __ACE_INLINE__ */


#if defined (__ACE_INLINE__)
#include "PortableInterceptorC.i"
#endif /* defined INLINE */

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

#if defined (__BORLANDC__)
#pragma option pop
#endif /* __BORLANDC__ */

#include "ace/post.h"
#endif /* ifndef */
