// -*- C++ -*-
//
// $Id$

// ****  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

#include "PortableInterceptorC.h"

#include "tao/Stub.h"
#include "tao/Invocation.h"
#include "tao/PortableInterceptor.h"

#if TAO_HAS_INTERCEPTORS == 1
#include "tao/RequestInfo_Util.h"
#include "tao/ClientRequestInfo_i.h"
#include "tao/ClientInterceptorAdapter.h"
#endif  /* TAO_HAS_INTERCEPTORS == 1 */

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

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

int PortableInterceptor::Interceptor::_tao_class_id = 0;

PortableInterceptor::Interceptor_ptr
tao_PortableInterceptor_Interceptor_duplicate (
    PortableInterceptor::Interceptor_ptr p
  )
{
  return PortableInterceptor::Interceptor::_duplicate (p);
}

void
tao_PortableInterceptor_Interceptor_release (
    PortableInterceptor::Interceptor_ptr p
  )
{
  CORBA::release (p);
}

PortableInterceptor::Interceptor_ptr
tao_PortableInterceptor_Interceptor_nil (
    void
  )
{
  return PortableInterceptor::Interceptor::_nil ();
}

PortableInterceptor::Interceptor_ptr
tao_PortableInterceptor_Interceptor_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return PortableInterceptor::Interceptor::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
tao_PortableInterceptor_Interceptor_upcast (
    void *src
  )
{
  PortableInterceptor::Interceptor **tmp =
    ACE_static_cast (PortableInterceptor::Interceptor **, src);
  return *tmp;
}

// *************************************************************
// PortableInterceptor::Interceptor_var
// TAO_IDL - Generated from
// be/be_interface.cpp:654
// *************************************************************

PortableInterceptor::Interceptor_var::Interceptor_var (void) // default constructor
  : ptr_ (Interceptor::_nil ())
{}

::PortableInterceptor::Interceptor_ptr
PortableInterceptor::Interceptor_var::ptr (void) const
{
  return this->ptr_;
}

PortableInterceptor::Interceptor_var::Interceptor_var (const ::PortableInterceptor::Interceptor_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (Interceptor::_duplicate (p.ptr ()))
{}

PortableInterceptor::Interceptor_var::~Interceptor_var (void) // destructor
{
  CORBA::release (this->ptr_);
}

PortableInterceptor::Interceptor_var &
PortableInterceptor::Interceptor_var::operator= (Interceptor_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

PortableInterceptor::Interceptor_var &
PortableInterceptor::Interceptor_var::operator= (const ::PortableInterceptor::Interceptor_var &p)
{
  if (this != &p)
  {
    CORBA::release (this->ptr_);
    this->ptr_ = ::PortableInterceptor::Interceptor::_duplicate (p.ptr ());
  }
  return *this;
}

PortableInterceptor::Interceptor_var::operator const ::PortableInterceptor::Interceptor_ptr &() const // cast
{
  return this->ptr_;
}

PortableInterceptor::Interceptor_var::operator ::PortableInterceptor::Interceptor_ptr &() // cast
{
  return this->ptr_;
}

::PortableInterceptor::Interceptor_ptr
PortableInterceptor::Interceptor_var::operator-> (void) const
{
  return this->ptr_;
}

::PortableInterceptor::Interceptor_ptr
PortableInterceptor::Interceptor_var::in (void) const
{
  return this->ptr_;
}

::PortableInterceptor::Interceptor_ptr &
PortableInterceptor::Interceptor_var::inout (void)
{
  return this->ptr_;
}

::PortableInterceptor::Interceptor_ptr &
PortableInterceptor::Interceptor_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::PortableInterceptor::Interceptor::_nil ();
  return this->ptr_;
}

::PortableInterceptor::Interceptor_ptr
PortableInterceptor::Interceptor_var::_retn (void)
{
  // yield ownership of managed obj reference
  ::PortableInterceptor::Interceptor_ptr val = this->ptr_;
  this->ptr_ = ::PortableInterceptor::Interceptor::_nil ();
  return val;
}

::PortableInterceptor::Interceptor_ptr
PortableInterceptor::Interceptor_var::tao_duplicate (Interceptor_ptr p)
{
  return ::PortableInterceptor::Interceptor::_duplicate (p);
}

void
PortableInterceptor::Interceptor_var::tao_release (Interceptor_ptr p)
{
  CORBA::release (p);
}

::PortableInterceptor::Interceptor_ptr
PortableInterceptor::Interceptor_var::tao_nil (void)
{
  return ::PortableInterceptor::Interceptor::_nil ();
}

::PortableInterceptor::Interceptor_ptr
PortableInterceptor::Interceptor_var::tao_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return ::PortableInterceptor::Interceptor::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
PortableInterceptor::Interceptor_var::tao_upcast (void *src)
{
  Interceptor **tmp =
    ACE_static_cast (Interceptor **, src);
  return *tmp;
}

// *************************************************************
// PortableInterceptor::Interceptor_out
// TAO_IDL - Generated from
// be/be_interface.cpp:932
// *************************************************************

PortableInterceptor::Interceptor_out::Interceptor_out (Interceptor_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::PortableInterceptor::Interceptor::_nil ();
}

PortableInterceptor::Interceptor_out::Interceptor_out (Interceptor_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::PortableInterceptor::Interceptor::_nil ();
}

PortableInterceptor::Interceptor_out::Interceptor_out (const ::PortableInterceptor::Interceptor_out &p) // copy constructor
  : ptr_ (ACE_const_cast (Interceptor_out &, p).ptr_)
{}

::PortableInterceptor::Interceptor_out &
PortableInterceptor::Interceptor_out::operator= (const ::PortableInterceptor::Interceptor_out &p)
{
  this->ptr_ = ACE_const_cast (Interceptor_out&, p).ptr_;
  return *this;
}

PortableInterceptor::Interceptor_out &
PortableInterceptor::Interceptor_out::operator= (const ::PortableInterceptor::Interceptor_var &p)
{
  this->ptr_ = ::PortableInterceptor::Interceptor::_duplicate (p.ptr ());
  return *this;
}

PortableInterceptor::Interceptor_out &
PortableInterceptor::Interceptor_out::operator= (Interceptor_ptr p)
{
  this->ptr_ = p;
  return *this;
}

PortableInterceptor::Interceptor_out::operator ::PortableInterceptor::Interceptor_ptr &() // cast
{
  return this->ptr_;
}

::PortableInterceptor::Interceptor_ptr &
PortableInterceptor::Interceptor_out::ptr (void) // ptr
{
  return this->ptr_;
}

::PortableInterceptor::Interceptor_ptr
PortableInterceptor::Interceptor_out::operator-> (void)
{
  return this->ptr_;
}


// TAO_IDL - Generated from
// be/be_visitor_interface/interface_cs.cpp:209

PortableInterceptor::Interceptor::Interceptor (void)
{}

PortableInterceptor::Interceptor::~Interceptor (void)
{}

PortableInterceptor::Interceptor_ptr PortableInterceptor::Interceptor::_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL
  )
{
  return Interceptor::_unchecked_narrow (obj ACE_ENV_ARG_PARAMETER);
}

PortableInterceptor::Interceptor_ptr
PortableInterceptor::Interceptor::_unchecked_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  if (CORBA::is_nil (obj))
    return Interceptor::_nil ();
  return
      ACE_reinterpret_cast
        (
          Interceptor_ptr,
            obj->_tao_QueryInterface
              (
                ACE_reinterpret_cast
                  (
                    ptr_arith_t,
                    &Interceptor::_tao_class_id
                  )
              )
        );
}

PortableInterceptor::Interceptor_ptr
PortableInterceptor::Interceptor::_duplicate (Interceptor_ptr obj)
{
  if (!CORBA::is_nil (obj))
    obj->_add_ref ();
  return obj;
}

void *PortableInterceptor::Interceptor::_tao_QueryInterface (ptr_arith_t type)
{
  void *retv = 0;
  if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &ACE_NESTED_CLASS (::PortableInterceptor, Interceptor)::_tao_class_id))
    retv = ACE_reinterpret_cast (void*, this);
  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_tao_class_id))
    retv = ACE_reinterpret_cast (void *,
      ACE_static_cast (CORBA::Object_ptr, this));

  if (retv)
    this->_add_ref ();
  return retv;
}

const char* PortableInterceptor::Interceptor::_interface_repository_id (void) const
{
  return "IDL:PortableInterceptor/Interceptor:1.0";
}

// Default constructor.
PortableInterceptor::ForwardRequest::ForwardRequest (void)
  : CORBA_UserException (
        "IDL:PortableInterceptor/ForwardRequest:1.0",
        "ForwardRequest"
      )
{
}

// Destructor - all members are of self managing types.
PortableInterceptor::ForwardRequest::~ForwardRequest (void)
{
}

// Copy constructor.
PortableInterceptor::ForwardRequest::ForwardRequest (const ::PortableInterceptor::ForwardRequest &_tao_excp)
  : CORBA_UserException (
        _tao_excp._rep_id (),
        _tao_excp._name ()
      )
{
  this->forward = CORBA::Object::_duplicate (_tao_excp.forward.in ());
  this->permanent = _tao_excp.permanent;
}

// Assignment operator.
PortableInterceptor::ForwardRequest&
PortableInterceptor::ForwardRequest::operator= (const ::PortableInterceptor::ForwardRequest &_tao_excp)
{
  this->CORBA_UserException::operator= (_tao_excp);
  this->forward = CORBA::Object::_duplicate (_tao_excp.forward.in ());
  this->permanent = _tao_excp.permanent;
  return *this;
}

void PortableInterceptor::ForwardRequest::_tao_any_destructor (void *_tao_void_pointer)
{
  ForwardRequest *tmp = ACE_static_cast (ForwardRequest*, _tao_void_pointer);
  delete tmp;
}

PortableInterceptor::ForwardRequest *
PortableInterceptor::ForwardRequest::_downcast (CORBA::Exception *exc)
{
  if (!ACE_OS::strcmp ("IDL:PortableInterceptor/ForwardRequest:1.0", exc->_rep_id ()))
    {
      return ACE_dynamic_cast (ForwardRequest *, exc);
    }
  else
    {
      return 0;
    }
}

CORBA::Exception *PortableInterceptor::ForwardRequest::_alloc (void)
{
  CORBA::Exception *retval = 0;
  ACE_NEW_RETURN (retval, ::PortableInterceptor::ForwardRequest, 0);
  return retval;
}

CORBA::Exception *
PortableInterceptor::ForwardRequest::_tao_duplicate (void) const
{
  CORBA::Exception *result;
  ACE_NEW_RETURN (
      result,
      PortableInterceptor::ForwardRequest (*this),
      0
    );
  return result;
}

void PortableInterceptor::ForwardRequest::_raise ()
{
  TAO_RAISE (*this);
}

void PortableInterceptor::ForwardRequest::_tao_encode (
    TAO_OutputCDR &cdr
    ACE_ENV_ARG_DECL
  ) const
{
  if (cdr << *this)
    {
      return;
    }

  ACE_THROW (CORBA::MARSHAL ());
}

void PortableInterceptor::ForwardRequest::_tao_decode (
    TAO_InputCDR &cdr
    ACE_ENV_ARG_DECL
  )
{
  if (cdr >> *this)
    {
      return;
    }

  ACE_THROW (CORBA::MARSHAL ());
}

PortableInterceptor::ForwardRequest::ForwardRequest (
    const CORBA::Object_ptr  _tao_forward,
    CORBA::Boolean _tao_permanent
  )
  : CORBA_UserException (
        "IDL:PortableInterceptor/ForwardRequest:1.0",
        "ForwardRequest"
      )
{
  this->forward = CORBA::Object::_duplicate (_tao_forward);
  this->permanent = _tao_permanent;
}

static const CORBA::Long _oc_PortableInterceptor_ForwardRequest[] =
{
  TAO_ENCAP_BYTE_ORDER, // byte order
  43,
  ACE_NTOHL (0x49444c3a),
  ACE_NTOHL (0x506f7274),
  ACE_NTOHL (0x61626c65),
  ACE_NTOHL (0x496e7465),
  ACE_NTOHL (0x72636570),
  ACE_NTOHL (0x746f722f),
  ACE_NTOHL (0x466f7277),
  ACE_NTOHL (0x61726452),
  ACE_NTOHL (0x65717565),
  ACE_NTOHL (0x73743a31),
  ACE_NTOHL (0x2e300000),  // repository ID = IDL:PortableInterceptor/ForwardRequest:1.0
  15,
  ACE_NTOHL (0x466f7277),
  ACE_NTOHL (0x61726452),
  ACE_NTOHL (0x65717565),
  ACE_NTOHL (0x73740000),  // name = ForwardRequest
  2, // member count
  8,
  ACE_NTOHL (0x666f7277),
  ACE_NTOHL (0x61726400),  // name = forward
  CORBA::tk_objref,
  52, // encapsulation length
    TAO_ENCAP_BYTE_ORDER, // byte order
    29,
    ACE_NTOHL (0x49444c3a),
    ACE_NTOHL (0x6f6d672e),
    ACE_NTOHL (0x6f72672f),
    ACE_NTOHL (0x434f5242),
    ACE_NTOHL (0x412f4f62),
    ACE_NTOHL (0x6a656374),
    ACE_NTOHL (0x3a312e30),
    ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Object:1.0
    7,
    ACE_NTOHL (0x4f626a65),
    ACE_NTOHL (0x63740000),  // name = Object

  10,
  ACE_NTOHL (0x7065726d),
  ACE_NTOHL (0x616e656e),
  ACE_NTOHL (0x74000000),  // name = permanent
  CORBA::tk_boolean,

};

static CORBA::TypeCode _tc_TAO_tc_PortableInterceptor_ForwardRequest (
    CORBA::tk_except,
    sizeof (_oc_PortableInterceptor_ForwardRequest),
    (char *) &_oc_PortableInterceptor_ForwardRequest,
    0,
    sizeof (PortableInterceptor::ForwardRequest)
  );

TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
TAO_NAMESPACE_BEGIN (PortableInterceptor)
TAO_NAMESPACE_DEFINE (::CORBA::TypeCode_ptr, _tc_ForwardRequest, &_tc_TAO_tc_PortableInterceptor_ForwardRequest)
TAO_NAMESPACE_END


// TAO extension - the virtual _type method.
CORBA::TypeCode_ptr PortableInterceptor::ForwardRequest::_type (void) const
{
  return ::PortableInterceptor::_tc_ForwardRequest;
}

static const CORBA::Long _oc_PortableInterceptor_ReplyStatus[] =
{
  TAO_ENCAP_BYTE_ORDER, // byte order
  40,
  ACE_NTOHL (0x49444c3a),
  ACE_NTOHL (0x506f7274),
  ACE_NTOHL (0x61626c65),
  ACE_NTOHL (0x496e7465),
  ACE_NTOHL (0x72636570),
  ACE_NTOHL (0x746f722f),
  ACE_NTOHL (0x5265706c),
  ACE_NTOHL (0x79537461),
  ACE_NTOHL (0x7475733a),
  ACE_NTOHL (0x312e3000),  // repository ID = IDL:PortableInterceptor/ReplyStatus:1.0
  12,
  ACE_NTOHL (0x5265706c),
  ACE_NTOHL (0x79537461),
  ACE_NTOHL (0x74757300),  // name = ReplyStatus
  CORBA::tk_short,

};

static CORBA::TypeCode _tc_TAO_tc_PortableInterceptor_ReplyStatus (
    CORBA::tk_alias,
    sizeof (_oc_PortableInterceptor_ReplyStatus),
    (char *) &_oc_PortableInterceptor_ReplyStatus,
    0,
    sizeof (PortableInterceptor::ReplyStatus)
  );

TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
TAO_NAMESPACE_BEGIN (PortableInterceptor)
TAO_NAMESPACE_DEFINE (::CORBA::TypeCode_ptr, _tc_ReplyStatus, &_tc_TAO_tc_PortableInterceptor_ReplyStatus)
TAO_NAMESPACE_END

TAO_NAMESPACE_TYPE (const CORBA::Short)
TAO_NAMESPACE_BEGIN (PortableInterceptor)
TAO_NAMESPACE_DEFINE (const CORBA::Short, SUCCESSFUL, 0)
TAO_NAMESPACE_END
TAO_NAMESPACE_TYPE (const CORBA::Short)
TAO_NAMESPACE_BEGIN (PortableInterceptor)
TAO_NAMESPACE_DEFINE (const CORBA::Short, SYSTEM_EXCEPTION, 1)
TAO_NAMESPACE_END
TAO_NAMESPACE_TYPE (const CORBA::Short)
TAO_NAMESPACE_BEGIN (PortableInterceptor)
TAO_NAMESPACE_DEFINE (const CORBA::Short, USER_EXCEPTION, 2)
TAO_NAMESPACE_END
TAO_NAMESPACE_TYPE (const CORBA::Short)
TAO_NAMESPACE_BEGIN (PortableInterceptor)
TAO_NAMESPACE_DEFINE (const CORBA::Short, LOCATION_FORWARD, 3)
TAO_NAMESPACE_END
TAO_NAMESPACE_TYPE (const CORBA::Short)
TAO_NAMESPACE_BEGIN (PortableInterceptor)
TAO_NAMESPACE_DEFINE (const CORBA::Short, LOCATION_FORWARD_PERMANENT, 4)
TAO_NAMESPACE_END
TAO_NAMESPACE_TYPE (const CORBA::Short)
TAO_NAMESPACE_BEGIN (PortableInterceptor)
TAO_NAMESPACE_DEFINE (const CORBA::Short, TRANSPORT_RETRY, 5)
TAO_NAMESPACE_END
static const CORBA::Long _oc_PortableInterceptor_SlotId[] =
{
  TAO_ENCAP_BYTE_ORDER, // byte order
  35,
  ACE_NTOHL (0x49444c3a),
  ACE_NTOHL (0x506f7274),
  ACE_NTOHL (0x61626c65),
  ACE_NTOHL (0x496e7465),
  ACE_NTOHL (0x72636570),
  ACE_NTOHL (0x746f722f),
  ACE_NTOHL (0x536c6f74),
  ACE_NTOHL (0x49643a31),
  ACE_NTOHL (0x2e300000),  // repository ID = IDL:PortableInterceptor/SlotId:1.0
  7,
  ACE_NTOHL (0x536c6f74),
  ACE_NTOHL (0x49640000),  // name = SlotId
  CORBA::tk_ulong,

};

static CORBA::TypeCode _tc_TAO_tc_PortableInterceptor_SlotId (
    CORBA::tk_alias,
    sizeof (_oc_PortableInterceptor_SlotId),
    (char *) &_oc_PortableInterceptor_SlotId,
    0,
    sizeof (PortableInterceptor::SlotId)
  );

TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
TAO_NAMESPACE_BEGIN (PortableInterceptor)
TAO_NAMESPACE_DEFINE (::CORBA::TypeCode_ptr, _tc_SlotId, &_tc_TAO_tc_PortableInterceptor_SlotId)
TAO_NAMESPACE_END

// Default constructor.
PortableInterceptor::InvalidSlot::InvalidSlot (void)
  : CORBA_UserException (
        "IDL:PortableInterceptor/InvalidSlot:1.0",
        "InvalidSlot"
      )
{
}

// Destructor - all members are of self managing types.
PortableInterceptor::InvalidSlot::~InvalidSlot (void)
{
}

// Copy constructor.
PortableInterceptor::InvalidSlot::InvalidSlot (const ::PortableInterceptor::InvalidSlot &_tao_excp)
  : CORBA_UserException (
        _tao_excp._rep_id (),
        _tao_excp._name ()
      )
{
}

// Assignment operator.
PortableInterceptor::InvalidSlot&
PortableInterceptor::InvalidSlot::operator= (const ::PortableInterceptor::InvalidSlot &_tao_excp)
{
  this->CORBA_UserException::operator= (_tao_excp);
  return *this;
}

void PortableInterceptor::InvalidSlot::_tao_any_destructor (void *_tao_void_pointer)
{
  InvalidSlot *tmp = ACE_static_cast (InvalidSlot*, _tao_void_pointer);
  delete tmp;
}

PortableInterceptor::InvalidSlot *
PortableInterceptor::InvalidSlot::_downcast (CORBA::Exception *exc)
{
  if (!ACE_OS::strcmp ("IDL:PortableInterceptor/InvalidSlot:1.0", exc->_rep_id ()))
    {
      return ACE_dynamic_cast (InvalidSlot *, exc);
    }
  else
    {
      return 0;
    }
}

CORBA::Exception *PortableInterceptor::InvalidSlot::_alloc (void)
{
  CORBA::Exception *retval = 0;
  ACE_NEW_RETURN (retval, ::PortableInterceptor::InvalidSlot, 0);
  return retval;
}

CORBA::Exception *
PortableInterceptor::InvalidSlot::_tao_duplicate (void) const
{
  CORBA::Exception *result;
  ACE_NEW_RETURN (
      result,
      PortableInterceptor::InvalidSlot (*this),
      0
    );
  return result;
}

void PortableInterceptor::InvalidSlot::_raise ()
{
  TAO_RAISE (*this);
}

void PortableInterceptor::InvalidSlot::_tao_encode (
    TAO_OutputCDR &cdr
    ACE_ENV_ARG_DECL
  ) const
{
  if (cdr << *this)
    {
      return;
    }

  ACE_THROW (CORBA::MARSHAL ());
}

void PortableInterceptor::InvalidSlot::_tao_decode (
    TAO_InputCDR &cdr
    ACE_ENV_ARG_DECL
  )
{
  if (cdr >> *this)
    {
      return;
    }

  ACE_THROW (CORBA::MARSHAL ());
}

static const CORBA::Long _oc_PortableInterceptor_InvalidSlot[] =
{
  TAO_ENCAP_BYTE_ORDER, // byte order
  40,
  ACE_NTOHL (0x49444c3a),
  ACE_NTOHL (0x506f7274),
  ACE_NTOHL (0x61626c65),
  ACE_NTOHL (0x496e7465),
  ACE_NTOHL (0x72636570),
  ACE_NTOHL (0x746f722f),
  ACE_NTOHL (0x496e7661),
  ACE_NTOHL (0x6c696453),
  ACE_NTOHL (0x6c6f743a),
  ACE_NTOHL (0x312e3000),  // repository ID = IDL:PortableInterceptor/InvalidSlot:1.0
  12,
  ACE_NTOHL (0x496e7661),
  ACE_NTOHL (0x6c696453),
  ACE_NTOHL (0x6c6f7400),  // name = InvalidSlot
  0, // member count
};

static CORBA::TypeCode _tc_TAO_tc_PortableInterceptor_InvalidSlot (
    CORBA::tk_except,
    sizeof (_oc_PortableInterceptor_InvalidSlot),
    (char *) &_oc_PortableInterceptor_InvalidSlot,
    0,
    sizeof (PortableInterceptor::InvalidSlot)
  );

TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
TAO_NAMESPACE_BEGIN (PortableInterceptor)
TAO_NAMESPACE_DEFINE (::CORBA::TypeCode_ptr, _tc_InvalidSlot, &_tc_TAO_tc_PortableInterceptor_InvalidSlot)
TAO_NAMESPACE_END


// TAO extension - the virtual _type method.
CORBA::TypeCode_ptr PortableInterceptor::InvalidSlot::_type (void) const
{
  return ::PortableInterceptor::_tc_InvalidSlot;
}

int PortableInterceptor::Current::_tao_class_id = 0;

PortableInterceptor::Current_ptr
tao_PortableInterceptor_Current_duplicate (
    PortableInterceptor::Current_ptr p
  )
{
  return PortableInterceptor::Current::_duplicate (p);
}

void
tao_PortableInterceptor_Current_release (
    PortableInterceptor::Current_ptr p
  )
{
  CORBA::release (p);
}

PortableInterceptor::Current_ptr
tao_PortableInterceptor_Current_nil (
    void
  )
{
  return PortableInterceptor::Current::_nil ();
}

PortableInterceptor::Current_ptr
tao_PortableInterceptor_Current_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return PortableInterceptor::Current::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
tao_PortableInterceptor_Current_upcast (
    void *src
  )
{
  PortableInterceptor::Current **tmp =
    ACE_static_cast (PortableInterceptor::Current **, src);
  return *tmp;
}

// *************************************************************
// PortableInterceptor::Current_var
// TAO_IDL - Generated from
// be/be_interface.cpp:654
// *************************************************************

PortableInterceptor::Current_var::Current_var (void) // default constructor
  : ptr_ (Current::_nil ())
{}

::PortableInterceptor::Current_ptr
PortableInterceptor::Current_var::ptr (void) const
{
  return this->ptr_;
}

PortableInterceptor::Current_var::Current_var (const ::PortableInterceptor::Current_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (Current::_duplicate (p.ptr ()))
{}

PortableInterceptor::Current_var::~Current_var (void) // destructor
{
  CORBA::release (this->ptr_);
}

PortableInterceptor::Current_var &
PortableInterceptor::Current_var::operator= (Current_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

PortableInterceptor::Current_var &
PortableInterceptor::Current_var::operator= (const ::PortableInterceptor::Current_var &p)
{
  if (this != &p)
  {
    CORBA::release (this->ptr_);
    this->ptr_ = ::PortableInterceptor::Current::_duplicate (p.ptr ());
  }
  return *this;
}

PortableInterceptor::Current_var::operator const ::PortableInterceptor::Current_ptr &() const // cast
{
  return this->ptr_;
}

PortableInterceptor::Current_var::operator ::PortableInterceptor::Current_ptr &() // cast
{
  return this->ptr_;
}

::PortableInterceptor::Current_ptr
PortableInterceptor::Current_var::operator-> (void) const
{
  return this->ptr_;
}

::PortableInterceptor::Current_ptr
PortableInterceptor::Current_var::in (void) const
{
  return this->ptr_;
}

::PortableInterceptor::Current_ptr &
PortableInterceptor::Current_var::inout (void)
{
  return this->ptr_;
}

::PortableInterceptor::Current_ptr &
PortableInterceptor::Current_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::PortableInterceptor::Current::_nil ();
  return this->ptr_;
}

::PortableInterceptor::Current_ptr
PortableInterceptor::Current_var::_retn (void)
{
  // yield ownership of managed obj reference
  ::PortableInterceptor::Current_ptr val = this->ptr_;
  this->ptr_ = ::PortableInterceptor::Current::_nil ();
  return val;
}

::PortableInterceptor::Current_ptr
PortableInterceptor::Current_var::tao_duplicate (Current_ptr p)
{
  return ::PortableInterceptor::Current::_duplicate (p);
}

void
PortableInterceptor::Current_var::tao_release (Current_ptr p)
{
  CORBA::release (p);
}

::PortableInterceptor::Current_ptr
PortableInterceptor::Current_var::tao_nil (void)
{
  return ::PortableInterceptor::Current::_nil ();
}

::PortableInterceptor::Current_ptr
PortableInterceptor::Current_var::tao_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return ::PortableInterceptor::Current::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
PortableInterceptor::Current_var::tao_upcast (void *src)
{
  Current **tmp =
    ACE_static_cast (Current **, src);
  return *tmp;
}

// *************************************************************
// PortableInterceptor::Current_out
// TAO_IDL - Generated from
// be/be_interface.cpp:932
// *************************************************************

PortableInterceptor::Current_out::Current_out (Current_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::PortableInterceptor::Current::_nil ();
}

PortableInterceptor::Current_out::Current_out (Current_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::PortableInterceptor::Current::_nil ();
}

PortableInterceptor::Current_out::Current_out (const ::PortableInterceptor::Current_out &p) // copy constructor
  : ptr_ (ACE_const_cast (Current_out &, p).ptr_)
{}

::PortableInterceptor::Current_out &
PortableInterceptor::Current_out::operator= (const ::PortableInterceptor::Current_out &p)
{
  this->ptr_ = ACE_const_cast (Current_out&, p).ptr_;
  return *this;
}

PortableInterceptor::Current_out &
PortableInterceptor::Current_out::operator= (const ::PortableInterceptor::Current_var &p)
{
  this->ptr_ = ::PortableInterceptor::Current::_duplicate (p.ptr ());
  return *this;
}

PortableInterceptor::Current_out &
PortableInterceptor::Current_out::operator= (Current_ptr p)
{
  this->ptr_ = p;
  return *this;
}

PortableInterceptor::Current_out::operator ::PortableInterceptor::Current_ptr &() // cast
{
  return this->ptr_;
}

::PortableInterceptor::Current_ptr &
PortableInterceptor::Current_out::ptr (void) // ptr
{
  return this->ptr_;
}

::PortableInterceptor::Current_ptr
PortableInterceptor::Current_out::operator-> (void)
{
  return this->ptr_;
}


// TAO_IDL - Generated from
// be/be_visitor_interface/interface_cs.cpp:209

PortableInterceptor::Current::Current (void)
{}

PortableInterceptor::Current::~Current (void)
{}

PortableInterceptor::Current_ptr PortableInterceptor::Current::_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL
  )
{
  return Current::_unchecked_narrow (obj ACE_ENV_ARG_PARAMETER);
}

PortableInterceptor::Current_ptr
PortableInterceptor::Current::_unchecked_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  if (CORBA::is_nil (obj))
    return Current::_nil ();
  return
      ACE_reinterpret_cast
        (
          Current_ptr,
            obj->_tao_QueryInterface
              (
                ACE_reinterpret_cast
                  (
                    ptr_arith_t,
                    &Current::_tao_class_id
                  )
              )
        );
}

PortableInterceptor::Current_ptr
PortableInterceptor::Current::_duplicate (Current_ptr obj)
{
  if (!CORBA::is_nil (obj))
    obj->_add_ref ();
  return obj;
}

void *PortableInterceptor::Current::_tao_QueryInterface (ptr_arith_t type)
{
  void *retv = 0;
  if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &ACE_NESTED_CLASS (::PortableInterceptor, Current)::_tao_class_id))
    retv = ACE_reinterpret_cast (void*, this);
  else if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &::CORBA::Current::_tao_class_id))
    retv = ACE_reinterpret_cast
      (
        void *,
        ACE_static_cast
          (
            CORBA::Current_ptr,
            this
          )
      );
  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_tao_class_id))
    retv = ACE_reinterpret_cast (void *,
      ACE_static_cast (CORBA::Object_ptr, this));

  if (retv)
    this->_add_ref ();
  return retv;
}

const char* PortableInterceptor::Current::_interface_repository_id (void) const
{
  return "IDL:PortableInterceptor/Current:1.0";
}

int PortableInterceptor::RequestInfo::_tao_class_id = 0;

PortableInterceptor::RequestInfo_ptr
tao_PortableInterceptor_RequestInfo_duplicate (
    PortableInterceptor::RequestInfo_ptr p
  )
{
  return PortableInterceptor::RequestInfo::_duplicate (p);
}

void
tao_PortableInterceptor_RequestInfo_release (
    PortableInterceptor::RequestInfo_ptr p
  )
{
  CORBA::release (p);
}

PortableInterceptor::RequestInfo_ptr
tao_PortableInterceptor_RequestInfo_nil (
    void
  )
{
  return PortableInterceptor::RequestInfo::_nil ();
}

PortableInterceptor::RequestInfo_ptr
tao_PortableInterceptor_RequestInfo_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return PortableInterceptor::RequestInfo::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
tao_PortableInterceptor_RequestInfo_upcast (
    void *src
  )
{
  PortableInterceptor::RequestInfo **tmp =
    ACE_static_cast (PortableInterceptor::RequestInfo **, src);
  return *tmp;
}

// *************************************************************
// PortableInterceptor::RequestInfo_var
// TAO_IDL - Generated from
// be/be_interface.cpp:654
// *************************************************************

PortableInterceptor::RequestInfo_var::RequestInfo_var (void) // default constructor
  : ptr_ (RequestInfo::_nil ())
{}

::PortableInterceptor::RequestInfo_ptr
PortableInterceptor::RequestInfo_var::ptr (void) const
{
  return this->ptr_;
}

PortableInterceptor::RequestInfo_var::RequestInfo_var (const ::PortableInterceptor::RequestInfo_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (RequestInfo::_duplicate (p.ptr ()))
{}

PortableInterceptor::RequestInfo_var::~RequestInfo_var (void) // destructor
{
  CORBA::release (this->ptr_);
}

PortableInterceptor::RequestInfo_var &
PortableInterceptor::RequestInfo_var::operator= (RequestInfo_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

PortableInterceptor::RequestInfo_var &
PortableInterceptor::RequestInfo_var::operator= (const ::PortableInterceptor::RequestInfo_var &p)
{
  if (this != &p)
  {
    CORBA::release (this->ptr_);
    this->ptr_ = ::PortableInterceptor::RequestInfo::_duplicate (p.ptr ());
  }
  return *this;
}

PortableInterceptor::RequestInfo_var::operator const ::PortableInterceptor::RequestInfo_ptr &() const // cast
{
  return this->ptr_;
}

PortableInterceptor::RequestInfo_var::operator ::PortableInterceptor::RequestInfo_ptr &() // cast
{
  return this->ptr_;
}

::PortableInterceptor::RequestInfo_ptr
PortableInterceptor::RequestInfo_var::operator-> (void) const
{
  return this->ptr_;
}

::PortableInterceptor::RequestInfo_ptr
PortableInterceptor::RequestInfo_var::in (void) const
{
  return this->ptr_;
}

::PortableInterceptor::RequestInfo_ptr &
PortableInterceptor::RequestInfo_var::inout (void)
{
  return this->ptr_;
}

::PortableInterceptor::RequestInfo_ptr &
PortableInterceptor::RequestInfo_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::PortableInterceptor::RequestInfo::_nil ();
  return this->ptr_;
}

::PortableInterceptor::RequestInfo_ptr
PortableInterceptor::RequestInfo_var::_retn (void)
{
  // yield ownership of managed obj reference
  ::PortableInterceptor::RequestInfo_ptr val = this->ptr_;
  this->ptr_ = ::PortableInterceptor::RequestInfo::_nil ();
  return val;
}

::PortableInterceptor::RequestInfo_ptr
PortableInterceptor::RequestInfo_var::tao_duplicate (RequestInfo_ptr p)
{
  return ::PortableInterceptor::RequestInfo::_duplicate (p);
}

void
PortableInterceptor::RequestInfo_var::tao_release (RequestInfo_ptr p)
{
  CORBA::release (p);
}

::PortableInterceptor::RequestInfo_ptr
PortableInterceptor::RequestInfo_var::tao_nil (void)
{
  return ::PortableInterceptor::RequestInfo::_nil ();
}

::PortableInterceptor::RequestInfo_ptr
PortableInterceptor::RequestInfo_var::tao_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return ::PortableInterceptor::RequestInfo::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
PortableInterceptor::RequestInfo_var::tao_upcast (void *src)
{
  RequestInfo **tmp =
    ACE_static_cast (RequestInfo **, src);
  return *tmp;
}

// *************************************************************
// PortableInterceptor::RequestInfo_out
// TAO_IDL - Generated from
// be/be_interface.cpp:932
// *************************************************************

PortableInterceptor::RequestInfo_out::RequestInfo_out (RequestInfo_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::PortableInterceptor::RequestInfo::_nil ();
}

PortableInterceptor::RequestInfo_out::RequestInfo_out (RequestInfo_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::PortableInterceptor::RequestInfo::_nil ();
}

PortableInterceptor::RequestInfo_out::RequestInfo_out (const ::PortableInterceptor::RequestInfo_out &p) // copy constructor
  : ptr_ (ACE_const_cast (RequestInfo_out &, p).ptr_)
{}

::PortableInterceptor::RequestInfo_out &
PortableInterceptor::RequestInfo_out::operator= (const ::PortableInterceptor::RequestInfo_out &p)
{
  this->ptr_ = ACE_const_cast (RequestInfo_out&, p).ptr_;
  return *this;
}

PortableInterceptor::RequestInfo_out &
PortableInterceptor::RequestInfo_out::operator= (const ::PortableInterceptor::RequestInfo_var &p)
{
  this->ptr_ = ::PortableInterceptor::RequestInfo::_duplicate (p.ptr ());
  return *this;
}

PortableInterceptor::RequestInfo_out &
PortableInterceptor::RequestInfo_out::operator= (RequestInfo_ptr p)
{
  this->ptr_ = p;
  return *this;
}

PortableInterceptor::RequestInfo_out::operator ::PortableInterceptor::RequestInfo_ptr &() // cast
{
  return this->ptr_;
}

::PortableInterceptor::RequestInfo_ptr &
PortableInterceptor::RequestInfo_out::ptr (void) // ptr
{
  return this->ptr_;
}

::PortableInterceptor::RequestInfo_ptr
PortableInterceptor::RequestInfo_out::operator-> (void)
{
  return this->ptr_;
}


// TAO_IDL - Generated from
// be/be_visitor_interface/interface_cs.cpp:209

PortableInterceptor::RequestInfo::RequestInfo (void)
{}

PortableInterceptor::RequestInfo::~RequestInfo (void)
{}

PortableInterceptor::RequestInfo_ptr PortableInterceptor::RequestInfo::_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL
  )
{
  return RequestInfo::_unchecked_narrow (obj ACE_ENV_ARG_PARAMETER);
}

PortableInterceptor::RequestInfo_ptr
PortableInterceptor::RequestInfo::_unchecked_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  if (CORBA::is_nil (obj))
    return RequestInfo::_nil ();
  return
      ACE_reinterpret_cast
        (
          RequestInfo_ptr,
            obj->_tao_QueryInterface
              (
                ACE_reinterpret_cast
                  (
                    ptr_arith_t,
                    &RequestInfo::_tao_class_id
                  )
              )
        );
}

PortableInterceptor::RequestInfo_ptr
PortableInterceptor::RequestInfo::_duplicate (RequestInfo_ptr obj)
{
  if (!CORBA::is_nil (obj))
    obj->_add_ref ();
  return obj;
}

void *PortableInterceptor::RequestInfo::_tao_QueryInterface (ptr_arith_t type)
{
  void *retv = 0;
  if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &ACE_NESTED_CLASS (::PortableInterceptor, RequestInfo)::_tao_class_id))
    retv = ACE_reinterpret_cast (void*, this);
  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_tao_class_id))
    retv = ACE_reinterpret_cast (void *,
      ACE_static_cast (CORBA::Object_ptr, this));

  if (retv)
    this->_add_ref ();
  return retv;
}

const char* PortableInterceptor::RequestInfo::_interface_repository_id (void) const
{
  return "IDL:PortableInterceptor/RequestInfo:1.0";
}

int PortableInterceptor::ClientRequestInfo::_tao_class_id = 0;

PortableInterceptor::ClientRequestInfo_ptr
tao_PortableInterceptor_ClientRequestInfo_duplicate (
    PortableInterceptor::ClientRequestInfo_ptr p
  )
{
  return PortableInterceptor::ClientRequestInfo::_duplicate (p);
}

void
tao_PortableInterceptor_ClientRequestInfo_release (
    PortableInterceptor::ClientRequestInfo_ptr p
  )
{
  CORBA::release (p);
}

PortableInterceptor::ClientRequestInfo_ptr
tao_PortableInterceptor_ClientRequestInfo_nil (
    void
  )
{
  return PortableInterceptor::ClientRequestInfo::_nil ();
}

PortableInterceptor::ClientRequestInfo_ptr
tao_PortableInterceptor_ClientRequestInfo_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return PortableInterceptor::ClientRequestInfo::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
tao_PortableInterceptor_ClientRequestInfo_upcast (
    void *src
  )
{
  PortableInterceptor::ClientRequestInfo **tmp =
    ACE_static_cast (PortableInterceptor::ClientRequestInfo **, src);
  return *tmp;
}

// *************************************************************
// PortableInterceptor::ClientRequestInfo_var
// TAO_IDL - Generated from
// be/be_interface.cpp:654
// *************************************************************

PortableInterceptor::ClientRequestInfo_var::ClientRequestInfo_var (void) // default constructor
  : ptr_ (ClientRequestInfo::_nil ())
{}

::PortableInterceptor::ClientRequestInfo_ptr
PortableInterceptor::ClientRequestInfo_var::ptr (void) const
{
  return this->ptr_;
}

PortableInterceptor::ClientRequestInfo_var::ClientRequestInfo_var (const ::PortableInterceptor::ClientRequestInfo_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (ClientRequestInfo::_duplicate (p.ptr ()))
{}

PortableInterceptor::ClientRequestInfo_var::~ClientRequestInfo_var (void) // destructor
{
  CORBA::release (this->ptr_);
}

PortableInterceptor::ClientRequestInfo_var &
PortableInterceptor::ClientRequestInfo_var::operator= (ClientRequestInfo_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

PortableInterceptor::ClientRequestInfo_var &
PortableInterceptor::ClientRequestInfo_var::operator= (const ::PortableInterceptor::ClientRequestInfo_var &p)
{
  if (this != &p)
  {
    CORBA::release (this->ptr_);
    this->ptr_ = ::PortableInterceptor::ClientRequestInfo::_duplicate (p.ptr ());
  }
  return *this;
}

PortableInterceptor::ClientRequestInfo_var::operator const ::PortableInterceptor::ClientRequestInfo_ptr &() const // cast
{
  return this->ptr_;
}

PortableInterceptor::ClientRequestInfo_var::operator ::PortableInterceptor::ClientRequestInfo_ptr &() // cast
{
  return this->ptr_;
}

::PortableInterceptor::ClientRequestInfo_ptr
PortableInterceptor::ClientRequestInfo_var::operator-> (void) const
{
  return this->ptr_;
}

::PortableInterceptor::ClientRequestInfo_ptr
PortableInterceptor::ClientRequestInfo_var::in (void) const
{
  return this->ptr_;
}

::PortableInterceptor::ClientRequestInfo_ptr &
PortableInterceptor::ClientRequestInfo_var::inout (void)
{
  return this->ptr_;
}

::PortableInterceptor::ClientRequestInfo_ptr &
PortableInterceptor::ClientRequestInfo_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::PortableInterceptor::ClientRequestInfo::_nil ();
  return this->ptr_;
}

::PortableInterceptor::ClientRequestInfo_ptr
PortableInterceptor::ClientRequestInfo_var::_retn (void)
{
  // yield ownership of managed obj reference
  ::PortableInterceptor::ClientRequestInfo_ptr val = this->ptr_;
  this->ptr_ = ::PortableInterceptor::ClientRequestInfo::_nil ();
  return val;
}

::PortableInterceptor::ClientRequestInfo_ptr
PortableInterceptor::ClientRequestInfo_var::tao_duplicate (ClientRequestInfo_ptr p)
{
  return ::PortableInterceptor::ClientRequestInfo::_duplicate (p);
}

void
PortableInterceptor::ClientRequestInfo_var::tao_release (ClientRequestInfo_ptr p)
{
  CORBA::release (p);
}

::PortableInterceptor::ClientRequestInfo_ptr
PortableInterceptor::ClientRequestInfo_var::tao_nil (void)
{
  return ::PortableInterceptor::ClientRequestInfo::_nil ();
}

::PortableInterceptor::ClientRequestInfo_ptr
PortableInterceptor::ClientRequestInfo_var::tao_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return ::PortableInterceptor::ClientRequestInfo::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
PortableInterceptor::ClientRequestInfo_var::tao_upcast (void *src)
{
  ClientRequestInfo **tmp =
    ACE_static_cast (ClientRequestInfo **, src);
  return *tmp;
}

// *************************************************************
// PortableInterceptor::ClientRequestInfo_out
// TAO_IDL - Generated from
// be/be_interface.cpp:932
// *************************************************************

PortableInterceptor::ClientRequestInfo_out::ClientRequestInfo_out (ClientRequestInfo_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::PortableInterceptor::ClientRequestInfo::_nil ();
}

PortableInterceptor::ClientRequestInfo_out::ClientRequestInfo_out (ClientRequestInfo_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::PortableInterceptor::ClientRequestInfo::_nil ();
}

PortableInterceptor::ClientRequestInfo_out::ClientRequestInfo_out (const ::PortableInterceptor::ClientRequestInfo_out &p) // copy constructor
  : ptr_ (ACE_const_cast (ClientRequestInfo_out &, p).ptr_)
{}

::PortableInterceptor::ClientRequestInfo_out &
PortableInterceptor::ClientRequestInfo_out::operator= (const ::PortableInterceptor::ClientRequestInfo_out &p)
{
  this->ptr_ = ACE_const_cast (ClientRequestInfo_out&, p).ptr_;
  return *this;
}

PortableInterceptor::ClientRequestInfo_out &
PortableInterceptor::ClientRequestInfo_out::operator= (const ::PortableInterceptor::ClientRequestInfo_var &p)
{
  this->ptr_ = ::PortableInterceptor::ClientRequestInfo::_duplicate (p.ptr ());
  return *this;
}

PortableInterceptor::ClientRequestInfo_out &
PortableInterceptor::ClientRequestInfo_out::operator= (ClientRequestInfo_ptr p)
{
  this->ptr_ = p;
  return *this;
}

PortableInterceptor::ClientRequestInfo_out::operator ::PortableInterceptor::ClientRequestInfo_ptr &() // cast
{
  return this->ptr_;
}

::PortableInterceptor::ClientRequestInfo_ptr &
PortableInterceptor::ClientRequestInfo_out::ptr (void) // ptr
{
  return this->ptr_;
}

::PortableInterceptor::ClientRequestInfo_ptr
PortableInterceptor::ClientRequestInfo_out::operator-> (void)
{
  return this->ptr_;
}


// TAO_IDL - Generated from
// be/be_visitor_interface/interface_cs.cpp:209

PortableInterceptor::ClientRequestInfo::ClientRequestInfo (void)
{}

PortableInterceptor::ClientRequestInfo::~ClientRequestInfo (void)
{}

PortableInterceptor::ClientRequestInfo_ptr PortableInterceptor::ClientRequestInfo::_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL
  )
{
  return ClientRequestInfo::_unchecked_narrow (obj ACE_ENV_ARG_PARAMETER);
}

PortableInterceptor::ClientRequestInfo_ptr
PortableInterceptor::ClientRequestInfo::_unchecked_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  if (CORBA::is_nil (obj))
    return ClientRequestInfo::_nil ();
  return
      ACE_reinterpret_cast
        (
          ClientRequestInfo_ptr,
            obj->_tao_QueryInterface
              (
                ACE_reinterpret_cast
                  (
                    ptr_arith_t,
                    &ClientRequestInfo::_tao_class_id
                  )
              )
        );
}

PortableInterceptor::ClientRequestInfo_ptr
PortableInterceptor::ClientRequestInfo::_duplicate (ClientRequestInfo_ptr obj)
{
  if (!CORBA::is_nil (obj))
    obj->_add_ref ();
  return obj;
}

void *PortableInterceptor::ClientRequestInfo::_tao_QueryInterface (ptr_arith_t type)
{
  void *retv = 0;
  if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &ACE_NESTED_CLASS (::PortableInterceptor, ClientRequestInfo)::_tao_class_id))
    retv = ACE_reinterpret_cast (void*, this);
  else if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &ACE_NESTED_CLASS (::PortableInterceptor, RequestInfo)::_tao_class_id))
    retv = ACE_reinterpret_cast
      (
        void *,
        ACE_static_cast
          (
            PortableInterceptor::RequestInfo_ptr,
            this
          )
      );
  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_tao_class_id))
    retv = ACE_reinterpret_cast (void *,
      ACE_static_cast (CORBA::Object_ptr, this));

  if (retv)
    this->_add_ref ();
  return retv;
}

const char* PortableInterceptor::ClientRequestInfo::_interface_repository_id (void) const
{
  return "IDL:PortableInterceptor/ClientRequestInfo:1.0";
}

int PortableInterceptor::ServerRequestInfo::_tao_class_id = 0;

PortableInterceptor::ServerRequestInfo_ptr
tao_PortableInterceptor_ServerRequestInfo_duplicate (
    PortableInterceptor::ServerRequestInfo_ptr p
  )
{
  return PortableInterceptor::ServerRequestInfo::_duplicate (p);
}

void
tao_PortableInterceptor_ServerRequestInfo_release (
    PortableInterceptor::ServerRequestInfo_ptr p
  )
{
  CORBA::release (p);
}

PortableInterceptor::ServerRequestInfo_ptr
tao_PortableInterceptor_ServerRequestInfo_nil (
    void
  )
{
  return PortableInterceptor::ServerRequestInfo::_nil ();
}

PortableInterceptor::ServerRequestInfo_ptr
tao_PortableInterceptor_ServerRequestInfo_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return PortableInterceptor::ServerRequestInfo::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
tao_PortableInterceptor_ServerRequestInfo_upcast (
    void *src
  )
{
  PortableInterceptor::ServerRequestInfo **tmp =
    ACE_static_cast (PortableInterceptor::ServerRequestInfo **, src);
  return *tmp;
}

// *************************************************************
// PortableInterceptor::ServerRequestInfo_var
// TAO_IDL - Generated from
// be/be_interface.cpp:654
// *************************************************************

PortableInterceptor::ServerRequestInfo_var::ServerRequestInfo_var (void) // default constructor
  : ptr_ (ServerRequestInfo::_nil ())
{}

::PortableInterceptor::ServerRequestInfo_ptr
PortableInterceptor::ServerRequestInfo_var::ptr (void) const
{
  return this->ptr_;
}

PortableInterceptor::ServerRequestInfo_var::ServerRequestInfo_var (const ::PortableInterceptor::ServerRequestInfo_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (ServerRequestInfo::_duplicate (p.ptr ()))
{}

PortableInterceptor::ServerRequestInfo_var::~ServerRequestInfo_var (void) // destructor
{
  CORBA::release (this->ptr_);
}

PortableInterceptor::ServerRequestInfo_var &
PortableInterceptor::ServerRequestInfo_var::operator= (ServerRequestInfo_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

PortableInterceptor::ServerRequestInfo_var &
PortableInterceptor::ServerRequestInfo_var::operator= (const ::PortableInterceptor::ServerRequestInfo_var &p)
{
  if (this != &p)
  {
    CORBA::release (this->ptr_);
    this->ptr_ = ::PortableInterceptor::ServerRequestInfo::_duplicate (p.ptr ());
  }
  return *this;
}

PortableInterceptor::ServerRequestInfo_var::operator const ::PortableInterceptor::ServerRequestInfo_ptr &() const // cast
{
  return this->ptr_;
}

PortableInterceptor::ServerRequestInfo_var::operator ::PortableInterceptor::ServerRequestInfo_ptr &() // cast
{
  return this->ptr_;
}

::PortableInterceptor::ServerRequestInfo_ptr
PortableInterceptor::ServerRequestInfo_var::operator-> (void) const
{
  return this->ptr_;
}

::PortableInterceptor::ServerRequestInfo_ptr
PortableInterceptor::ServerRequestInfo_var::in (void) const
{
  return this->ptr_;
}

::PortableInterceptor::ServerRequestInfo_ptr &
PortableInterceptor::ServerRequestInfo_var::inout (void)
{
  return this->ptr_;
}

::PortableInterceptor::ServerRequestInfo_ptr &
PortableInterceptor::ServerRequestInfo_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::PortableInterceptor::ServerRequestInfo::_nil ();
  return this->ptr_;
}

::PortableInterceptor::ServerRequestInfo_ptr
PortableInterceptor::ServerRequestInfo_var::_retn (void)
{
  // yield ownership of managed obj reference
  ::PortableInterceptor::ServerRequestInfo_ptr val = this->ptr_;
  this->ptr_ = ::PortableInterceptor::ServerRequestInfo::_nil ();
  return val;
}

::PortableInterceptor::ServerRequestInfo_ptr
PortableInterceptor::ServerRequestInfo_var::tao_duplicate (ServerRequestInfo_ptr p)
{
  return ::PortableInterceptor::ServerRequestInfo::_duplicate (p);
}

void
PortableInterceptor::ServerRequestInfo_var::tao_release (ServerRequestInfo_ptr p)
{
  CORBA::release (p);
}

::PortableInterceptor::ServerRequestInfo_ptr
PortableInterceptor::ServerRequestInfo_var::tao_nil (void)
{
  return ::PortableInterceptor::ServerRequestInfo::_nil ();
}

::PortableInterceptor::ServerRequestInfo_ptr
PortableInterceptor::ServerRequestInfo_var::tao_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return ::PortableInterceptor::ServerRequestInfo::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
PortableInterceptor::ServerRequestInfo_var::tao_upcast (void *src)
{
  ServerRequestInfo **tmp =
    ACE_static_cast (ServerRequestInfo **, src);
  return *tmp;
}

// *************************************************************
// PortableInterceptor::ServerRequestInfo_out
// TAO_IDL - Generated from
// be/be_interface.cpp:932
// *************************************************************

PortableInterceptor::ServerRequestInfo_out::ServerRequestInfo_out (ServerRequestInfo_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::PortableInterceptor::ServerRequestInfo::_nil ();
}

PortableInterceptor::ServerRequestInfo_out::ServerRequestInfo_out (ServerRequestInfo_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::PortableInterceptor::ServerRequestInfo::_nil ();
}

PortableInterceptor::ServerRequestInfo_out::ServerRequestInfo_out (const ::PortableInterceptor::ServerRequestInfo_out &p) // copy constructor
  : ptr_ (ACE_const_cast (ServerRequestInfo_out &, p).ptr_)
{}

::PortableInterceptor::ServerRequestInfo_out &
PortableInterceptor::ServerRequestInfo_out::operator= (const ::PortableInterceptor::ServerRequestInfo_out &p)
{
  this->ptr_ = ACE_const_cast (ServerRequestInfo_out&, p).ptr_;
  return *this;
}

PortableInterceptor::ServerRequestInfo_out &
PortableInterceptor::ServerRequestInfo_out::operator= (const ::PortableInterceptor::ServerRequestInfo_var &p)
{
  this->ptr_ = ::PortableInterceptor::ServerRequestInfo::_duplicate (p.ptr ());
  return *this;
}

PortableInterceptor::ServerRequestInfo_out &
PortableInterceptor::ServerRequestInfo_out::operator= (ServerRequestInfo_ptr p)
{
  this->ptr_ = p;
  return *this;
}

PortableInterceptor::ServerRequestInfo_out::operator ::PortableInterceptor::ServerRequestInfo_ptr &() // cast
{
  return this->ptr_;
}

::PortableInterceptor::ServerRequestInfo_ptr &
PortableInterceptor::ServerRequestInfo_out::ptr (void) // ptr
{
  return this->ptr_;
}

::PortableInterceptor::ServerRequestInfo_ptr
PortableInterceptor::ServerRequestInfo_out::operator-> (void)
{
  return this->ptr_;
}


// TAO_IDL - Generated from
// be/be_visitor_interface/interface_cs.cpp:209

PortableInterceptor::ServerRequestInfo::ServerRequestInfo (void)
{}

PortableInterceptor::ServerRequestInfo::~ServerRequestInfo (void)
{}

PortableInterceptor::ServerRequestInfo_ptr PortableInterceptor::ServerRequestInfo::_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL
  )
{
  return ServerRequestInfo::_unchecked_narrow (obj ACE_ENV_ARG_PARAMETER);
}

PortableInterceptor::ServerRequestInfo_ptr
PortableInterceptor::ServerRequestInfo::_unchecked_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  if (CORBA::is_nil (obj))
    return ServerRequestInfo::_nil ();
  return
      ACE_reinterpret_cast
        (
          ServerRequestInfo_ptr,
            obj->_tao_QueryInterface
              (
                ACE_reinterpret_cast
                  (
                    ptr_arith_t,
                    &ServerRequestInfo::_tao_class_id
                  )
              )
        );
}

PortableInterceptor::ServerRequestInfo_ptr
PortableInterceptor::ServerRequestInfo::_duplicate (ServerRequestInfo_ptr obj)
{
  if (!CORBA::is_nil (obj))
    obj->_add_ref ();
  return obj;
}

void *PortableInterceptor::ServerRequestInfo::_tao_QueryInterface (ptr_arith_t type)
{
  void *retv = 0;
  if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &ACE_NESTED_CLASS (::PortableInterceptor, ServerRequestInfo)::_tao_class_id))
    retv = ACE_reinterpret_cast (void*, this);
  else if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &ACE_NESTED_CLASS (::PortableInterceptor, RequestInfo)::_tao_class_id))
    retv = ACE_reinterpret_cast
      (
        void *,
        ACE_static_cast
          (
            PortableInterceptor::RequestInfo_ptr,
            this
          )
      );
  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_tao_class_id))
    retv = ACE_reinterpret_cast (void *,
      ACE_static_cast (CORBA::Object_ptr, this));

  if (retv)
    this->_add_ref ();
  return retv;
}

const char* PortableInterceptor::ServerRequestInfo::_interface_repository_id (void) const
{
  return "IDL:PortableInterceptor/ServerRequestInfo:1.0";
}

int PortableInterceptor::ClientRequestInterceptor::_tao_class_id = 0;

PortableInterceptor::ClientRequestInterceptor_ptr
tao_PortableInterceptor_ClientRequestInterceptor_duplicate (
    PortableInterceptor::ClientRequestInterceptor_ptr p
  )
{
  return PortableInterceptor::ClientRequestInterceptor::_duplicate (p);
}

void
tao_PortableInterceptor_ClientRequestInterceptor_release (
    PortableInterceptor::ClientRequestInterceptor_ptr p
  )
{
  CORBA::release (p);
}

PortableInterceptor::ClientRequestInterceptor_ptr
tao_PortableInterceptor_ClientRequestInterceptor_nil (
    void
  )
{
  return PortableInterceptor::ClientRequestInterceptor::_nil ();
}

PortableInterceptor::ClientRequestInterceptor_ptr
tao_PortableInterceptor_ClientRequestInterceptor_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return PortableInterceptor::ClientRequestInterceptor::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
tao_PortableInterceptor_ClientRequestInterceptor_upcast (
    void *src
  )
{
  PortableInterceptor::ClientRequestInterceptor **tmp =
    ACE_static_cast (PortableInterceptor::ClientRequestInterceptor **, src);
  return *tmp;
}

// *************************************************************
// PortableInterceptor::ClientRequestInterceptor_var
// TAO_IDL - Generated from
// be/be_interface.cpp:654
// *************************************************************

PortableInterceptor::ClientRequestInterceptor_var::ClientRequestInterceptor_var (void) // default constructor
  : ptr_ (ClientRequestInterceptor::_nil ())
{}

::PortableInterceptor::ClientRequestInterceptor_ptr
PortableInterceptor::ClientRequestInterceptor_var::ptr (void) const
{
  return this->ptr_;
}

PortableInterceptor::ClientRequestInterceptor_var::ClientRequestInterceptor_var (const ::PortableInterceptor::ClientRequestInterceptor_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (ClientRequestInterceptor::_duplicate (p.ptr ()))
{}

PortableInterceptor::ClientRequestInterceptor_var::~ClientRequestInterceptor_var (void) // destructor
{
  CORBA::release (this->ptr_);
}

PortableInterceptor::ClientRequestInterceptor_var &
PortableInterceptor::ClientRequestInterceptor_var::operator= (ClientRequestInterceptor_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

PortableInterceptor::ClientRequestInterceptor_var &
PortableInterceptor::ClientRequestInterceptor_var::operator= (const ::PortableInterceptor::ClientRequestInterceptor_var &p)
{
  if (this != &p)
  {
    CORBA::release (this->ptr_);
    this->ptr_ = ::PortableInterceptor::ClientRequestInterceptor::_duplicate (p.ptr ());
  }
  return *this;
}

PortableInterceptor::ClientRequestInterceptor_var::operator const ::PortableInterceptor::ClientRequestInterceptor_ptr &() const // cast
{
  return this->ptr_;
}

PortableInterceptor::ClientRequestInterceptor_var::operator ::PortableInterceptor::ClientRequestInterceptor_ptr &() // cast
{
  return this->ptr_;
}

::PortableInterceptor::ClientRequestInterceptor_ptr
PortableInterceptor::ClientRequestInterceptor_var::operator-> (void) const
{
  return this->ptr_;
}

::PortableInterceptor::ClientRequestInterceptor_ptr
PortableInterceptor::ClientRequestInterceptor_var::in (void) const
{
  return this->ptr_;
}

::PortableInterceptor::ClientRequestInterceptor_ptr &
PortableInterceptor::ClientRequestInterceptor_var::inout (void)
{
  return this->ptr_;
}

::PortableInterceptor::ClientRequestInterceptor_ptr &
PortableInterceptor::ClientRequestInterceptor_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::PortableInterceptor::ClientRequestInterceptor::_nil ();
  return this->ptr_;
}

::PortableInterceptor::ClientRequestInterceptor_ptr
PortableInterceptor::ClientRequestInterceptor_var::_retn (void)
{
  // yield ownership of managed obj reference
  ::PortableInterceptor::ClientRequestInterceptor_ptr val = this->ptr_;
  this->ptr_ = ::PortableInterceptor::ClientRequestInterceptor::_nil ();
  return val;
}

::PortableInterceptor::ClientRequestInterceptor_ptr
PortableInterceptor::ClientRequestInterceptor_var::tao_duplicate (ClientRequestInterceptor_ptr p)
{
  return ::PortableInterceptor::ClientRequestInterceptor::_duplicate (p);
}

void
PortableInterceptor::ClientRequestInterceptor_var::tao_release (ClientRequestInterceptor_ptr p)
{
  CORBA::release (p);
}

::PortableInterceptor::ClientRequestInterceptor_ptr
PortableInterceptor::ClientRequestInterceptor_var::tao_nil (void)
{
  return ::PortableInterceptor::ClientRequestInterceptor::_nil ();
}

::PortableInterceptor::ClientRequestInterceptor_ptr
PortableInterceptor::ClientRequestInterceptor_var::tao_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return ::PortableInterceptor::ClientRequestInterceptor::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
PortableInterceptor::ClientRequestInterceptor_var::tao_upcast (void *src)
{
  ClientRequestInterceptor **tmp =
    ACE_static_cast (ClientRequestInterceptor **, src);
  return *tmp;
}

// *************************************************************
// PortableInterceptor::ClientRequestInterceptor_out
// TAO_IDL - Generated from
// be/be_interface.cpp:932
// *************************************************************

PortableInterceptor::ClientRequestInterceptor_out::ClientRequestInterceptor_out (ClientRequestInterceptor_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::PortableInterceptor::ClientRequestInterceptor::_nil ();
}

PortableInterceptor::ClientRequestInterceptor_out::ClientRequestInterceptor_out (ClientRequestInterceptor_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::PortableInterceptor::ClientRequestInterceptor::_nil ();
}

PortableInterceptor::ClientRequestInterceptor_out::ClientRequestInterceptor_out (const ::PortableInterceptor::ClientRequestInterceptor_out &p) // copy constructor
  : ptr_ (ACE_const_cast (ClientRequestInterceptor_out &, p).ptr_)
{}

::PortableInterceptor::ClientRequestInterceptor_out &
PortableInterceptor::ClientRequestInterceptor_out::operator= (const ::PortableInterceptor::ClientRequestInterceptor_out &p)
{
  this->ptr_ = ACE_const_cast (ClientRequestInterceptor_out&, p).ptr_;
  return *this;
}

PortableInterceptor::ClientRequestInterceptor_out &
PortableInterceptor::ClientRequestInterceptor_out::operator= (const ::PortableInterceptor::ClientRequestInterceptor_var &p)
{
  this->ptr_ = ::PortableInterceptor::ClientRequestInterceptor::_duplicate (p.ptr ());
  return *this;
}

PortableInterceptor::ClientRequestInterceptor_out &
PortableInterceptor::ClientRequestInterceptor_out::operator= (ClientRequestInterceptor_ptr p)
{
  this->ptr_ = p;
  return *this;
}

PortableInterceptor::ClientRequestInterceptor_out::operator ::PortableInterceptor::ClientRequestInterceptor_ptr &() // cast
{
  return this->ptr_;
}

::PortableInterceptor::ClientRequestInterceptor_ptr &
PortableInterceptor::ClientRequestInterceptor_out::ptr (void) // ptr
{
  return this->ptr_;
}

::PortableInterceptor::ClientRequestInterceptor_ptr
PortableInterceptor::ClientRequestInterceptor_out::operator-> (void)
{
  return this->ptr_;
}


// TAO_IDL - Generated from
// be/be_visitor_interface/interface_cs.cpp:209

PortableInterceptor::ClientRequestInterceptor::ClientRequestInterceptor (void)
{}

PortableInterceptor::ClientRequestInterceptor::~ClientRequestInterceptor (void)
{}

PortableInterceptor::ClientRequestInterceptor_ptr PortableInterceptor::ClientRequestInterceptor::_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL
  )
{
  return ClientRequestInterceptor::_unchecked_narrow (obj ACE_ENV_ARG_PARAMETER);
}

PortableInterceptor::ClientRequestInterceptor_ptr
PortableInterceptor::ClientRequestInterceptor::_unchecked_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  if (CORBA::is_nil (obj))
    return ClientRequestInterceptor::_nil ();
  return
      ACE_reinterpret_cast
        (
          ClientRequestInterceptor_ptr,
            obj->_tao_QueryInterface
              (
                ACE_reinterpret_cast
                  (
                    ptr_arith_t,
                    &ClientRequestInterceptor::_tao_class_id
                  )
              )
        );
}

PortableInterceptor::ClientRequestInterceptor_ptr
PortableInterceptor::ClientRequestInterceptor::_duplicate (ClientRequestInterceptor_ptr obj)
{
  if (!CORBA::is_nil (obj))
    obj->_add_ref ();
  return obj;
}

void *PortableInterceptor::ClientRequestInterceptor::_tao_QueryInterface (ptr_arith_t type)
{
  void *retv = 0;
  if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &ACE_NESTED_CLASS (::PortableInterceptor, ClientRequestInterceptor)::_tao_class_id))
    retv = ACE_reinterpret_cast (void*, this);
  else if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &ACE_NESTED_CLASS (::PortableInterceptor, Interceptor)::_tao_class_id))
    retv = ACE_reinterpret_cast
      (
        void *,
        ACE_static_cast
          (
            PortableInterceptor::Interceptor_ptr,
            this
          )
      );
  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_tao_class_id))
    retv = ACE_reinterpret_cast (void *,
      ACE_static_cast (CORBA::Object_ptr, this));

  if (retv)
    this->_add_ref ();
  return retv;
}

const char* PortableInterceptor::ClientRequestInterceptor::_interface_repository_id (void) const
{
  return "IDL:PortableInterceptor/ClientRequestInterceptor:1.0";
}

int PortableInterceptor::ServerRequestInterceptor::_tao_class_id = 0;

PortableInterceptor::ServerRequestInterceptor_ptr
tao_PortableInterceptor_ServerRequestInterceptor_duplicate (
    PortableInterceptor::ServerRequestInterceptor_ptr p
  )
{
  return PortableInterceptor::ServerRequestInterceptor::_duplicate (p);
}

void
tao_PortableInterceptor_ServerRequestInterceptor_release (
    PortableInterceptor::ServerRequestInterceptor_ptr p
  )
{
  CORBA::release (p);
}

PortableInterceptor::ServerRequestInterceptor_ptr
tao_PortableInterceptor_ServerRequestInterceptor_nil (
    void
  )
{
  return PortableInterceptor::ServerRequestInterceptor::_nil ();
}

PortableInterceptor::ServerRequestInterceptor_ptr
tao_PortableInterceptor_ServerRequestInterceptor_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return PortableInterceptor::ServerRequestInterceptor::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
tao_PortableInterceptor_ServerRequestInterceptor_upcast (
    void *src
  )
{
  PortableInterceptor::ServerRequestInterceptor **tmp =
    ACE_static_cast (PortableInterceptor::ServerRequestInterceptor **, src);
  return *tmp;
}

// *************************************************************
// PortableInterceptor::ServerRequestInterceptor_var
// TAO_IDL - Generated from
// be/be_interface.cpp:654
// *************************************************************

PortableInterceptor::ServerRequestInterceptor_var::ServerRequestInterceptor_var (void) // default constructor
  : ptr_ (ServerRequestInterceptor::_nil ())
{}

::PortableInterceptor::ServerRequestInterceptor_ptr
PortableInterceptor::ServerRequestInterceptor_var::ptr (void) const
{
  return this->ptr_;
}

PortableInterceptor::ServerRequestInterceptor_var::ServerRequestInterceptor_var (const ::PortableInterceptor::ServerRequestInterceptor_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (ServerRequestInterceptor::_duplicate (p.ptr ()))
{}

PortableInterceptor::ServerRequestInterceptor_var::~ServerRequestInterceptor_var (void) // destructor
{
  CORBA::release (this->ptr_);
}

PortableInterceptor::ServerRequestInterceptor_var &
PortableInterceptor::ServerRequestInterceptor_var::operator= (ServerRequestInterceptor_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

PortableInterceptor::ServerRequestInterceptor_var &
PortableInterceptor::ServerRequestInterceptor_var::operator= (const ::PortableInterceptor::ServerRequestInterceptor_var &p)
{
  if (this != &p)
  {
    CORBA::release (this->ptr_);
    this->ptr_ = ::PortableInterceptor::ServerRequestInterceptor::_duplicate (p.ptr ());
  }
  return *this;
}

PortableInterceptor::ServerRequestInterceptor_var::operator const ::PortableInterceptor::ServerRequestInterceptor_ptr &() const // cast
{
  return this->ptr_;
}

PortableInterceptor::ServerRequestInterceptor_var::operator ::PortableInterceptor::ServerRequestInterceptor_ptr &() // cast
{
  return this->ptr_;
}

::PortableInterceptor::ServerRequestInterceptor_ptr
PortableInterceptor::ServerRequestInterceptor_var::operator-> (void) const
{
  return this->ptr_;
}

::PortableInterceptor::ServerRequestInterceptor_ptr
PortableInterceptor::ServerRequestInterceptor_var::in (void) const
{
  return this->ptr_;
}

::PortableInterceptor::ServerRequestInterceptor_ptr &
PortableInterceptor::ServerRequestInterceptor_var::inout (void)
{
  return this->ptr_;
}

::PortableInterceptor::ServerRequestInterceptor_ptr &
PortableInterceptor::ServerRequestInterceptor_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::PortableInterceptor::ServerRequestInterceptor::_nil ();
  return this->ptr_;
}

::PortableInterceptor::ServerRequestInterceptor_ptr
PortableInterceptor::ServerRequestInterceptor_var::_retn (void)
{
  // yield ownership of managed obj reference
  ::PortableInterceptor::ServerRequestInterceptor_ptr val = this->ptr_;
  this->ptr_ = ::PortableInterceptor::ServerRequestInterceptor::_nil ();
  return val;
}

::PortableInterceptor::ServerRequestInterceptor_ptr
PortableInterceptor::ServerRequestInterceptor_var::tao_duplicate (ServerRequestInterceptor_ptr p)
{
  return ::PortableInterceptor::ServerRequestInterceptor::_duplicate (p);
}

void
PortableInterceptor::ServerRequestInterceptor_var::tao_release (ServerRequestInterceptor_ptr p)
{
  CORBA::release (p);
}

::PortableInterceptor::ServerRequestInterceptor_ptr
PortableInterceptor::ServerRequestInterceptor_var::tao_nil (void)
{
  return ::PortableInterceptor::ServerRequestInterceptor::_nil ();
}

::PortableInterceptor::ServerRequestInterceptor_ptr
PortableInterceptor::ServerRequestInterceptor_var::tao_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return ::PortableInterceptor::ServerRequestInterceptor::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
PortableInterceptor::ServerRequestInterceptor_var::tao_upcast (void *src)
{
  ServerRequestInterceptor **tmp =
    ACE_static_cast (ServerRequestInterceptor **, src);
  return *tmp;
}

// *************************************************************
// PortableInterceptor::ServerRequestInterceptor_out
// TAO_IDL - Generated from
// be/be_interface.cpp:932
// *************************************************************

PortableInterceptor::ServerRequestInterceptor_out::ServerRequestInterceptor_out (ServerRequestInterceptor_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::PortableInterceptor::ServerRequestInterceptor::_nil ();
}

PortableInterceptor::ServerRequestInterceptor_out::ServerRequestInterceptor_out (ServerRequestInterceptor_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::PortableInterceptor::ServerRequestInterceptor::_nil ();
}

PortableInterceptor::ServerRequestInterceptor_out::ServerRequestInterceptor_out (const ::PortableInterceptor::ServerRequestInterceptor_out &p) // copy constructor
  : ptr_ (ACE_const_cast (ServerRequestInterceptor_out &, p).ptr_)
{}

::PortableInterceptor::ServerRequestInterceptor_out &
PortableInterceptor::ServerRequestInterceptor_out::operator= (const ::PortableInterceptor::ServerRequestInterceptor_out &p)
{
  this->ptr_ = ACE_const_cast (ServerRequestInterceptor_out&, p).ptr_;
  return *this;
}

PortableInterceptor::ServerRequestInterceptor_out &
PortableInterceptor::ServerRequestInterceptor_out::operator= (const ::PortableInterceptor::ServerRequestInterceptor_var &p)
{
  this->ptr_ = ::PortableInterceptor::ServerRequestInterceptor::_duplicate (p.ptr ());
  return *this;
}

PortableInterceptor::ServerRequestInterceptor_out &
PortableInterceptor::ServerRequestInterceptor_out::operator= (ServerRequestInterceptor_ptr p)
{
  this->ptr_ = p;
  return *this;
}

PortableInterceptor::ServerRequestInterceptor_out::operator ::PortableInterceptor::ServerRequestInterceptor_ptr &() // cast
{
  return this->ptr_;
}

::PortableInterceptor::ServerRequestInterceptor_ptr &
PortableInterceptor::ServerRequestInterceptor_out::ptr (void) // ptr
{
  return this->ptr_;
}

::PortableInterceptor::ServerRequestInterceptor_ptr
PortableInterceptor::ServerRequestInterceptor_out::operator-> (void)
{
  return this->ptr_;
}


// TAO_IDL - Generated from
// be/be_visitor_interface/interface_cs.cpp:209

PortableInterceptor::ServerRequestInterceptor::ServerRequestInterceptor (void)
{}

PortableInterceptor::ServerRequestInterceptor::~ServerRequestInterceptor (void)
{}

PortableInterceptor::ServerRequestInterceptor_ptr PortableInterceptor::ServerRequestInterceptor::_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL
  )
{
  return ServerRequestInterceptor::_unchecked_narrow (obj ACE_ENV_ARG_PARAMETER);
}

PortableInterceptor::ServerRequestInterceptor_ptr
PortableInterceptor::ServerRequestInterceptor::_unchecked_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  if (CORBA::is_nil (obj))
    return ServerRequestInterceptor::_nil ();
  return
      ACE_reinterpret_cast
        (
          ServerRequestInterceptor_ptr,
            obj->_tao_QueryInterface
              (
                ACE_reinterpret_cast
                  (
                    ptr_arith_t,
                    &ServerRequestInterceptor::_tao_class_id
                  )
              )
        );
}

PortableInterceptor::ServerRequestInterceptor_ptr
PortableInterceptor::ServerRequestInterceptor::_duplicate (ServerRequestInterceptor_ptr obj)
{
  if (!CORBA::is_nil (obj))
    obj->_add_ref ();
  return obj;
}

void *PortableInterceptor::ServerRequestInterceptor::_tao_QueryInterface (ptr_arith_t type)
{
  void *retv = 0;
  if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &ACE_NESTED_CLASS (::PortableInterceptor, ServerRequestInterceptor)::_tao_class_id))
    retv = ACE_reinterpret_cast (void*, this);
  else if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &ACE_NESTED_CLASS (::PortableInterceptor, Interceptor)::_tao_class_id))
    retv = ACE_reinterpret_cast
      (
        void *,
        ACE_static_cast
          (
            PortableInterceptor::Interceptor_ptr,
            this
          )
      );
  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_tao_class_id))
    retv = ACE_reinterpret_cast (void *,
      ACE_static_cast (CORBA::Object_ptr, this));

  if (retv)
    this->_add_ref ();
  return retv;
}

const char* PortableInterceptor::ServerRequestInterceptor::_interface_repository_id (void) const
{
  return "IDL:PortableInterceptor/ServerRequestInterceptor:1.0";
}

int PortableInterceptor::IORInfo::_tao_class_id = 0;

PortableInterceptor::IORInfo_ptr
tao_PortableInterceptor_IORInfo_duplicate (
    PortableInterceptor::IORInfo_ptr p
  )
{
  return PortableInterceptor::IORInfo::_duplicate (p);
}

void
tao_PortableInterceptor_IORInfo_release (
    PortableInterceptor::IORInfo_ptr p
  )
{
  CORBA::release (p);
}

PortableInterceptor::IORInfo_ptr
tao_PortableInterceptor_IORInfo_nil (
    void
  )
{
  return PortableInterceptor::IORInfo::_nil ();
}

PortableInterceptor::IORInfo_ptr
tao_PortableInterceptor_IORInfo_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return PortableInterceptor::IORInfo::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
tao_PortableInterceptor_IORInfo_upcast (
    void *src
  )
{
  PortableInterceptor::IORInfo **tmp =
    ACE_static_cast (PortableInterceptor::IORInfo **, src);
  return *tmp;
}

// *************************************************************
// PortableInterceptor::IORInfo_var
// TAO_IDL - Generated from
// be/be_interface.cpp:654
// *************************************************************

PortableInterceptor::IORInfo_var::IORInfo_var (void) // default constructor
  : ptr_ (IORInfo::_nil ())
{}

::PortableInterceptor::IORInfo_ptr
PortableInterceptor::IORInfo_var::ptr (void) const
{
  return this->ptr_;
}

PortableInterceptor::IORInfo_var::IORInfo_var (const ::PortableInterceptor::IORInfo_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (IORInfo::_duplicate (p.ptr ()))
{}

PortableInterceptor::IORInfo_var::~IORInfo_var (void) // destructor
{
  CORBA::release (this->ptr_);
}

PortableInterceptor::IORInfo_var &
PortableInterceptor::IORInfo_var::operator= (IORInfo_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

PortableInterceptor::IORInfo_var &
PortableInterceptor::IORInfo_var::operator= (const ::PortableInterceptor::IORInfo_var &p)
{
  if (this != &p)
  {
    CORBA::release (this->ptr_);
    this->ptr_ = ::PortableInterceptor::IORInfo::_duplicate (p.ptr ());
  }
  return *this;
}

PortableInterceptor::IORInfo_var::operator const ::PortableInterceptor::IORInfo_ptr &() const // cast
{
  return this->ptr_;
}

PortableInterceptor::IORInfo_var::operator ::PortableInterceptor::IORInfo_ptr &() // cast
{
  return this->ptr_;
}

::PortableInterceptor::IORInfo_ptr
PortableInterceptor::IORInfo_var::operator-> (void) const
{
  return this->ptr_;
}

::PortableInterceptor::IORInfo_ptr
PortableInterceptor::IORInfo_var::in (void) const
{
  return this->ptr_;
}

::PortableInterceptor::IORInfo_ptr &
PortableInterceptor::IORInfo_var::inout (void)
{
  return this->ptr_;
}

::PortableInterceptor::IORInfo_ptr &
PortableInterceptor::IORInfo_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::PortableInterceptor::IORInfo::_nil ();
  return this->ptr_;
}

::PortableInterceptor::IORInfo_ptr
PortableInterceptor::IORInfo_var::_retn (void)
{
  // yield ownership of managed obj reference
  ::PortableInterceptor::IORInfo_ptr val = this->ptr_;
  this->ptr_ = ::PortableInterceptor::IORInfo::_nil ();
  return val;
}

::PortableInterceptor::IORInfo_ptr
PortableInterceptor::IORInfo_var::tao_duplicate (IORInfo_ptr p)
{
  return ::PortableInterceptor::IORInfo::_duplicate (p);
}

void
PortableInterceptor::IORInfo_var::tao_release (IORInfo_ptr p)
{
  CORBA::release (p);
}

::PortableInterceptor::IORInfo_ptr
PortableInterceptor::IORInfo_var::tao_nil (void)
{
  return ::PortableInterceptor::IORInfo::_nil ();
}

::PortableInterceptor::IORInfo_ptr
PortableInterceptor::IORInfo_var::tao_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return ::PortableInterceptor::IORInfo::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
PortableInterceptor::IORInfo_var::tao_upcast (void *src)
{
  IORInfo **tmp =
    ACE_static_cast (IORInfo **, src);
  return *tmp;
}

// *************************************************************
// PortableInterceptor::IORInfo_out
// TAO_IDL - Generated from
// be/be_interface.cpp:932
// *************************************************************

PortableInterceptor::IORInfo_out::IORInfo_out (IORInfo_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::PortableInterceptor::IORInfo::_nil ();
}

PortableInterceptor::IORInfo_out::IORInfo_out (IORInfo_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::PortableInterceptor::IORInfo::_nil ();
}

PortableInterceptor::IORInfo_out::IORInfo_out (const ::PortableInterceptor::IORInfo_out &p) // copy constructor
  : ptr_ (ACE_const_cast (IORInfo_out &, p).ptr_)
{}

::PortableInterceptor::IORInfo_out &
PortableInterceptor::IORInfo_out::operator= (const ::PortableInterceptor::IORInfo_out &p)
{
  this->ptr_ = ACE_const_cast (IORInfo_out&, p).ptr_;
  return *this;
}

PortableInterceptor::IORInfo_out &
PortableInterceptor::IORInfo_out::operator= (const ::PortableInterceptor::IORInfo_var &p)
{
  this->ptr_ = ::PortableInterceptor::IORInfo::_duplicate (p.ptr ());
  return *this;
}

PortableInterceptor::IORInfo_out &
PortableInterceptor::IORInfo_out::operator= (IORInfo_ptr p)
{
  this->ptr_ = p;
  return *this;
}

PortableInterceptor::IORInfo_out::operator ::PortableInterceptor::IORInfo_ptr &() // cast
{
  return this->ptr_;
}

::PortableInterceptor::IORInfo_ptr &
PortableInterceptor::IORInfo_out::ptr (void) // ptr
{
  return this->ptr_;
}

::PortableInterceptor::IORInfo_ptr
PortableInterceptor::IORInfo_out::operator-> (void)
{
  return this->ptr_;
}


// TAO_IDL - Generated from
// be/be_visitor_interface/interface_cs.cpp:209

PortableInterceptor::IORInfo::IORInfo (void)
{}

PortableInterceptor::IORInfo::~IORInfo (void)
{}

PortableInterceptor::IORInfo_ptr PortableInterceptor::IORInfo::_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL
  )
{
  return IORInfo::_unchecked_narrow (obj ACE_ENV_ARG_PARAMETER);
}

PortableInterceptor::IORInfo_ptr
PortableInterceptor::IORInfo::_unchecked_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  if (CORBA::is_nil (obj))
    return IORInfo::_nil ();
  return
      ACE_reinterpret_cast
        (
          IORInfo_ptr,
            obj->_tao_QueryInterface
              (
                ACE_reinterpret_cast
                  (
                    ptr_arith_t,
                    &IORInfo::_tao_class_id
                  )
              )
        );
}

PortableInterceptor::IORInfo_ptr
PortableInterceptor::IORInfo::_duplicate (IORInfo_ptr obj)
{
  if (!CORBA::is_nil (obj))
    obj->_add_ref ();
  return obj;
}

void *PortableInterceptor::IORInfo::_tao_QueryInterface (ptr_arith_t type)
{
  void *retv = 0;
  if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &ACE_NESTED_CLASS (::PortableInterceptor, IORInfo)::_tao_class_id))
    retv = ACE_reinterpret_cast (void*, this);
  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_tao_class_id))
    retv = ACE_reinterpret_cast (void *,
      ACE_static_cast (CORBA::Object_ptr, this));

  if (retv)
    this->_add_ref ();
  return retv;
}

const char* PortableInterceptor::IORInfo::_interface_repository_id (void) const
{
  return "IDL:PortableInterceptor/IORInfo:1.0";
}

int PortableInterceptor::IORInterceptor::_tao_class_id = 0;

PortableInterceptor::IORInterceptor_ptr
tao_PortableInterceptor_IORInterceptor_duplicate (
    PortableInterceptor::IORInterceptor_ptr p
  )
{
  return PortableInterceptor::IORInterceptor::_duplicate (p);
}

void
tao_PortableInterceptor_IORInterceptor_release (
    PortableInterceptor::IORInterceptor_ptr p
  )
{
  CORBA::release (p);
}

PortableInterceptor::IORInterceptor_ptr
tao_PortableInterceptor_IORInterceptor_nil (
    void
  )
{
  return PortableInterceptor::IORInterceptor::_nil ();
}

PortableInterceptor::IORInterceptor_ptr
tao_PortableInterceptor_IORInterceptor_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return PortableInterceptor::IORInterceptor::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
tao_PortableInterceptor_IORInterceptor_upcast (
    void *src
  )
{
  PortableInterceptor::IORInterceptor **tmp =
    ACE_static_cast (PortableInterceptor::IORInterceptor **, src);
  return *tmp;
}

// *************************************************************
// PortableInterceptor::IORInterceptor_var
// TAO_IDL - Generated from
// be/be_interface.cpp:654
// *************************************************************

PortableInterceptor::IORInterceptor_var::IORInterceptor_var (void) // default constructor
  : ptr_ (IORInterceptor::_nil ())
{}

::PortableInterceptor::IORInterceptor_ptr
PortableInterceptor::IORInterceptor_var::ptr (void) const
{
  return this->ptr_;
}

PortableInterceptor::IORInterceptor_var::IORInterceptor_var (const ::PortableInterceptor::IORInterceptor_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (IORInterceptor::_duplicate (p.ptr ()))
{}

PortableInterceptor::IORInterceptor_var::~IORInterceptor_var (void) // destructor
{
  CORBA::release (this->ptr_);
}

PortableInterceptor::IORInterceptor_var &
PortableInterceptor::IORInterceptor_var::operator= (IORInterceptor_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

PortableInterceptor::IORInterceptor_var &
PortableInterceptor::IORInterceptor_var::operator= (const ::PortableInterceptor::IORInterceptor_var &p)
{
  if (this != &p)
  {
    CORBA::release (this->ptr_);
    this->ptr_ = ::PortableInterceptor::IORInterceptor::_duplicate (p.ptr ());
  }
  return *this;
}

PortableInterceptor::IORInterceptor_var::operator const ::PortableInterceptor::IORInterceptor_ptr &() const // cast
{
  return this->ptr_;
}

PortableInterceptor::IORInterceptor_var::operator ::PortableInterceptor::IORInterceptor_ptr &() // cast
{
  return this->ptr_;
}

::PortableInterceptor::IORInterceptor_ptr
PortableInterceptor::IORInterceptor_var::operator-> (void) const
{
  return this->ptr_;
}

::PortableInterceptor::IORInterceptor_ptr
PortableInterceptor::IORInterceptor_var::in (void) const
{
  return this->ptr_;
}

::PortableInterceptor::IORInterceptor_ptr &
PortableInterceptor::IORInterceptor_var::inout (void)
{
  return this->ptr_;
}

::PortableInterceptor::IORInterceptor_ptr &
PortableInterceptor::IORInterceptor_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::PortableInterceptor::IORInterceptor::_nil ();
  return this->ptr_;
}

::PortableInterceptor::IORInterceptor_ptr
PortableInterceptor::IORInterceptor_var::_retn (void)
{
  // yield ownership of managed obj reference
  ::PortableInterceptor::IORInterceptor_ptr val = this->ptr_;
  this->ptr_ = ::PortableInterceptor::IORInterceptor::_nil ();
  return val;
}

::PortableInterceptor::IORInterceptor_ptr
PortableInterceptor::IORInterceptor_var::tao_duplicate (IORInterceptor_ptr p)
{
  return ::PortableInterceptor::IORInterceptor::_duplicate (p);
}

void
PortableInterceptor::IORInterceptor_var::tao_release (IORInterceptor_ptr p)
{
  CORBA::release (p);
}

::PortableInterceptor::IORInterceptor_ptr
PortableInterceptor::IORInterceptor_var::tao_nil (void)
{
  return ::PortableInterceptor::IORInterceptor::_nil ();
}

::PortableInterceptor::IORInterceptor_ptr
PortableInterceptor::IORInterceptor_var::tao_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return ::PortableInterceptor::IORInterceptor::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
PortableInterceptor::IORInterceptor_var::tao_upcast (void *src)
{
  IORInterceptor **tmp =
    ACE_static_cast (IORInterceptor **, src);
  return *tmp;
}

// *************************************************************
// PortableInterceptor::IORInterceptor_out
// TAO_IDL - Generated from
// be/be_interface.cpp:932
// *************************************************************

PortableInterceptor::IORInterceptor_out::IORInterceptor_out (IORInterceptor_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::PortableInterceptor::IORInterceptor::_nil ();
}

PortableInterceptor::IORInterceptor_out::IORInterceptor_out (IORInterceptor_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::PortableInterceptor::IORInterceptor::_nil ();
}

PortableInterceptor::IORInterceptor_out::IORInterceptor_out (const ::PortableInterceptor::IORInterceptor_out &p) // copy constructor
  : ptr_ (ACE_const_cast (IORInterceptor_out &, p).ptr_)
{}

::PortableInterceptor::IORInterceptor_out &
PortableInterceptor::IORInterceptor_out::operator= (const ::PortableInterceptor::IORInterceptor_out &p)
{
  this->ptr_ = ACE_const_cast (IORInterceptor_out&, p).ptr_;
  return *this;
}

PortableInterceptor::IORInterceptor_out &
PortableInterceptor::IORInterceptor_out::operator= (const ::PortableInterceptor::IORInterceptor_var &p)
{
  this->ptr_ = ::PortableInterceptor::IORInterceptor::_duplicate (p.ptr ());
  return *this;
}

PortableInterceptor::IORInterceptor_out &
PortableInterceptor::IORInterceptor_out::operator= (IORInterceptor_ptr p)
{
  this->ptr_ = p;
  return *this;
}

PortableInterceptor::IORInterceptor_out::operator ::PortableInterceptor::IORInterceptor_ptr &() // cast
{
  return this->ptr_;
}

::PortableInterceptor::IORInterceptor_ptr &
PortableInterceptor::IORInterceptor_out::ptr (void) // ptr
{
  return this->ptr_;
}

::PortableInterceptor::IORInterceptor_ptr
PortableInterceptor::IORInterceptor_out::operator-> (void)
{
  return this->ptr_;
}


// TAO_IDL - Generated from
// be/be_visitor_interface/interface_cs.cpp:209

PortableInterceptor::IORInterceptor::IORInterceptor (void)
{}

PortableInterceptor::IORInterceptor::~IORInterceptor (void)
{}

PortableInterceptor::IORInterceptor_ptr PortableInterceptor::IORInterceptor::_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL
  )
{
  return IORInterceptor::_unchecked_narrow (obj ACE_ENV_ARG_PARAMETER);
}

PortableInterceptor::IORInterceptor_ptr
PortableInterceptor::IORInterceptor::_unchecked_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  if (CORBA::is_nil (obj))
    return IORInterceptor::_nil ();
  return
      ACE_reinterpret_cast
        (
          IORInterceptor_ptr,
            obj->_tao_QueryInterface
              (
                ACE_reinterpret_cast
                  (
                    ptr_arith_t,
                    &IORInterceptor::_tao_class_id
                  )
              )
        );
}

PortableInterceptor::IORInterceptor_ptr
PortableInterceptor::IORInterceptor::_duplicate (IORInterceptor_ptr obj)
{
  if (!CORBA::is_nil (obj))
    obj->_add_ref ();
  return obj;
}

void *PortableInterceptor::IORInterceptor::_tao_QueryInterface (ptr_arith_t type)
{
  void *retv = 0;
  if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &ACE_NESTED_CLASS (::PortableInterceptor, IORInterceptor)::_tao_class_id))
    retv = ACE_reinterpret_cast (void*, this);
  else if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &ACE_NESTED_CLASS (::PortableInterceptor, Interceptor)::_tao_class_id))
    retv = ACE_reinterpret_cast
      (
        void *,
        ACE_static_cast
          (
            PortableInterceptor::Interceptor_ptr,
            this
          )
      );
  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_tao_class_id))
    retv = ACE_reinterpret_cast (void *,
      ACE_static_cast (CORBA::Object_ptr, this));

  if (retv)
    this->_add_ref ();
  return retv;
}

const char* PortableInterceptor::IORInterceptor::_interface_repository_id (void) const
{
  return "IDL:PortableInterceptor/IORInterceptor:1.0";
}

int PortableInterceptor::PolicyFactory::_tao_class_id = 0;

PortableInterceptor::PolicyFactory_ptr
tao_PortableInterceptor_PolicyFactory_duplicate (
    PortableInterceptor::PolicyFactory_ptr p
  )
{
  return PortableInterceptor::PolicyFactory::_duplicate (p);
}

void
tao_PortableInterceptor_PolicyFactory_release (
    PortableInterceptor::PolicyFactory_ptr p
  )
{
  CORBA::release (p);
}

PortableInterceptor::PolicyFactory_ptr
tao_PortableInterceptor_PolicyFactory_nil (
    void
  )
{
  return PortableInterceptor::PolicyFactory::_nil ();
}

PortableInterceptor::PolicyFactory_ptr
tao_PortableInterceptor_PolicyFactory_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return PortableInterceptor::PolicyFactory::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
tao_PortableInterceptor_PolicyFactory_upcast (
    void *src
  )
{
  PortableInterceptor::PolicyFactory **tmp =
    ACE_static_cast (PortableInterceptor::PolicyFactory **, src);
  return *tmp;
}

// *************************************************************
// PortableInterceptor::PolicyFactory_var
// TAO_IDL - Generated from
// be/be_interface.cpp:654
// *************************************************************

PortableInterceptor::PolicyFactory_var::PolicyFactory_var (void) // default constructor
  : ptr_ (PolicyFactory::_nil ())
{}

::PortableInterceptor::PolicyFactory_ptr
PortableInterceptor::PolicyFactory_var::ptr (void) const
{
  return this->ptr_;
}

PortableInterceptor::PolicyFactory_var::PolicyFactory_var (const ::PortableInterceptor::PolicyFactory_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (PolicyFactory::_duplicate (p.ptr ()))
{}

PortableInterceptor::PolicyFactory_var::~PolicyFactory_var (void) // destructor
{
  CORBA::release (this->ptr_);
}

PortableInterceptor::PolicyFactory_var &
PortableInterceptor::PolicyFactory_var::operator= (PolicyFactory_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

PortableInterceptor::PolicyFactory_var &
PortableInterceptor::PolicyFactory_var::operator= (const ::PortableInterceptor::PolicyFactory_var &p)
{
  if (this != &p)
  {
    CORBA::release (this->ptr_);
    this->ptr_ = ::PortableInterceptor::PolicyFactory::_duplicate (p.ptr ());
  }
  return *this;
}

PortableInterceptor::PolicyFactory_var::operator const ::PortableInterceptor::PolicyFactory_ptr &() const // cast
{
  return this->ptr_;
}

PortableInterceptor::PolicyFactory_var::operator ::PortableInterceptor::PolicyFactory_ptr &() // cast
{
  return this->ptr_;
}

::PortableInterceptor::PolicyFactory_ptr
PortableInterceptor::PolicyFactory_var::operator-> (void) const
{
  return this->ptr_;
}

::PortableInterceptor::PolicyFactory_ptr
PortableInterceptor::PolicyFactory_var::in (void) const
{
  return this->ptr_;
}

::PortableInterceptor::PolicyFactory_ptr &
PortableInterceptor::PolicyFactory_var::inout (void)
{
  return this->ptr_;
}

::PortableInterceptor::PolicyFactory_ptr &
PortableInterceptor::PolicyFactory_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::PortableInterceptor::PolicyFactory::_nil ();
  return this->ptr_;
}

::PortableInterceptor::PolicyFactory_ptr
PortableInterceptor::PolicyFactory_var::_retn (void)
{
  // yield ownership of managed obj reference
  ::PortableInterceptor::PolicyFactory_ptr val = this->ptr_;
  this->ptr_ = ::PortableInterceptor::PolicyFactory::_nil ();
  return val;
}

::PortableInterceptor::PolicyFactory_ptr
PortableInterceptor::PolicyFactory_var::tao_duplicate (PolicyFactory_ptr p)
{
  return ::PortableInterceptor::PolicyFactory::_duplicate (p);
}

void
PortableInterceptor::PolicyFactory_var::tao_release (PolicyFactory_ptr p)
{
  CORBA::release (p);
}

::PortableInterceptor::PolicyFactory_ptr
PortableInterceptor::PolicyFactory_var::tao_nil (void)
{
  return ::PortableInterceptor::PolicyFactory::_nil ();
}

::PortableInterceptor::PolicyFactory_ptr
PortableInterceptor::PolicyFactory_var::tao_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return ::PortableInterceptor::PolicyFactory::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
PortableInterceptor::PolicyFactory_var::tao_upcast (void *src)
{
  PolicyFactory **tmp =
    ACE_static_cast (PolicyFactory **, src);
  return *tmp;
}

// *************************************************************
// PortableInterceptor::PolicyFactory_out
// TAO_IDL - Generated from
// be/be_interface.cpp:932
// *************************************************************

PortableInterceptor::PolicyFactory_out::PolicyFactory_out (PolicyFactory_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::PortableInterceptor::PolicyFactory::_nil ();
}

PortableInterceptor::PolicyFactory_out::PolicyFactory_out (PolicyFactory_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::PortableInterceptor::PolicyFactory::_nil ();
}

PortableInterceptor::PolicyFactory_out::PolicyFactory_out (const ::PortableInterceptor::PolicyFactory_out &p) // copy constructor
  : ptr_ (ACE_const_cast (PolicyFactory_out &, p).ptr_)
{}

::PortableInterceptor::PolicyFactory_out &
PortableInterceptor::PolicyFactory_out::operator= (const ::PortableInterceptor::PolicyFactory_out &p)
{
  this->ptr_ = ACE_const_cast (PolicyFactory_out&, p).ptr_;
  return *this;
}

PortableInterceptor::PolicyFactory_out &
PortableInterceptor::PolicyFactory_out::operator= (const ::PortableInterceptor::PolicyFactory_var &p)
{
  this->ptr_ = ::PortableInterceptor::PolicyFactory::_duplicate (p.ptr ());
  return *this;
}

PortableInterceptor::PolicyFactory_out &
PortableInterceptor::PolicyFactory_out::operator= (PolicyFactory_ptr p)
{
  this->ptr_ = p;
  return *this;
}

PortableInterceptor::PolicyFactory_out::operator ::PortableInterceptor::PolicyFactory_ptr &() // cast
{
  return this->ptr_;
}

::PortableInterceptor::PolicyFactory_ptr &
PortableInterceptor::PolicyFactory_out::ptr (void) // ptr
{
  return this->ptr_;
}

::PortableInterceptor::PolicyFactory_ptr
PortableInterceptor::PolicyFactory_out::operator-> (void)
{
  return this->ptr_;
}


// TAO_IDL - Generated from
// be/be_visitor_interface/interface_cs.cpp:209

PortableInterceptor::PolicyFactory::PolicyFactory (void)
{}

PortableInterceptor::PolicyFactory::~PolicyFactory (void)
{}

PortableInterceptor::PolicyFactory_ptr PortableInterceptor::PolicyFactory::_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL
  )
{
  return PolicyFactory::_unchecked_narrow (obj ACE_ENV_ARG_PARAMETER);
}

PortableInterceptor::PolicyFactory_ptr
PortableInterceptor::PolicyFactory::_unchecked_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  if (CORBA::is_nil (obj))
    return PolicyFactory::_nil ();
  return
      ACE_reinterpret_cast
        (
          PolicyFactory_ptr,
            obj->_tao_QueryInterface
              (
                ACE_reinterpret_cast
                  (
                    ptr_arith_t,
                    &PolicyFactory::_tao_class_id
                  )
              )
        );
}

PortableInterceptor::PolicyFactory_ptr
PortableInterceptor::PolicyFactory::_duplicate (PolicyFactory_ptr obj)
{
  if (!CORBA::is_nil (obj))
    obj->_add_ref ();
  return obj;
}

::CORBA::Policy_ptr
PortableInterceptor::PolicyFactory::_create_policy (CORBA::PolicyType
                                                    ACE_ENV_ARG_DECL)
  ACE_THROW_SPEC ((CORBA::SystemException,
                   CORBA::PolicyError))
{
  ACE_THROW_RETURN (CORBA::PolicyError (CORBA::BAD_POLICY_TYPE),
                    CORBA::Policy::_nil ());
}

void *PortableInterceptor::PolicyFactory::_tao_QueryInterface (ptr_arith_t type)
{
  void *retv = 0;
  if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &ACE_NESTED_CLASS (::PortableInterceptor, PolicyFactory)::_tao_class_id))
    retv = ACE_reinterpret_cast (void*, this);
  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_tao_class_id))
    retv = ACE_reinterpret_cast (void *,
      ACE_static_cast (CORBA::Object_ptr, this));

  if (retv)
    this->_add_ref ();
  return retv;
}

const char* PortableInterceptor::PolicyFactory::_interface_repository_id (void) const
{
  return "IDL:PortableInterceptor/PolicyFactory:1.0";
}

int PortableInterceptor::ORBInitInfo::_tao_class_id = 0;

PortableInterceptor::ORBInitInfo_ptr
tao_PortableInterceptor_ORBInitInfo_duplicate (
    PortableInterceptor::ORBInitInfo_ptr p
  )
{
  return PortableInterceptor::ORBInitInfo::_duplicate (p);
}

void
tao_PortableInterceptor_ORBInitInfo_release (
    PortableInterceptor::ORBInitInfo_ptr p
  )
{
  CORBA::release (p);
}

PortableInterceptor::ORBInitInfo_ptr
tao_PortableInterceptor_ORBInitInfo_nil (
    void
  )
{
  return PortableInterceptor::ORBInitInfo::_nil ();
}

PortableInterceptor::ORBInitInfo_ptr
tao_PortableInterceptor_ORBInitInfo_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return PortableInterceptor::ORBInitInfo::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
tao_PortableInterceptor_ORBInitInfo_upcast (
    void *src
  )
{
  PortableInterceptor::ORBInitInfo **tmp =
    ACE_static_cast (PortableInterceptor::ORBInitInfo **, src);
  return *tmp;
}

// *************************************************************
// PortableInterceptor::ORBInitInfo_var
// TAO_IDL - Generated from
// be/be_interface.cpp:654
// *************************************************************

PortableInterceptor::ORBInitInfo_var::ORBInitInfo_var (void) // default constructor
  : ptr_ (ORBInitInfo::_nil ())
{}

::PortableInterceptor::ORBInitInfo_ptr
PortableInterceptor::ORBInitInfo_var::ptr (void) const
{
  return this->ptr_;
}

PortableInterceptor::ORBInitInfo_var::ORBInitInfo_var (const ::PortableInterceptor::ORBInitInfo_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (ORBInitInfo::_duplicate (p.ptr ()))
{}

PortableInterceptor::ORBInitInfo_var::~ORBInitInfo_var (void) // destructor
{
  CORBA::release (this->ptr_);
}

PortableInterceptor::ORBInitInfo_var &
PortableInterceptor::ORBInitInfo_var::operator= (ORBInitInfo_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

PortableInterceptor::ORBInitInfo_var &
PortableInterceptor::ORBInitInfo_var::operator= (const ::PortableInterceptor::ORBInitInfo_var &p)
{
  if (this != &p)
  {
    CORBA::release (this->ptr_);
    this->ptr_ = ::PortableInterceptor::ORBInitInfo::_duplicate (p.ptr ());
  }
  return *this;
}

PortableInterceptor::ORBInitInfo_var::operator const ::PortableInterceptor::ORBInitInfo_ptr &() const // cast
{
  return this->ptr_;
}

PortableInterceptor::ORBInitInfo_var::operator ::PortableInterceptor::ORBInitInfo_ptr &() // cast
{
  return this->ptr_;
}

::PortableInterceptor::ORBInitInfo_ptr
PortableInterceptor::ORBInitInfo_var::operator-> (void) const
{
  return this->ptr_;
}

::PortableInterceptor::ORBInitInfo_ptr
PortableInterceptor::ORBInitInfo_var::in (void) const
{
  return this->ptr_;
}

::PortableInterceptor::ORBInitInfo_ptr &
PortableInterceptor::ORBInitInfo_var::inout (void)
{
  return this->ptr_;
}

::PortableInterceptor::ORBInitInfo_ptr &
PortableInterceptor::ORBInitInfo_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::PortableInterceptor::ORBInitInfo::_nil ();
  return this->ptr_;
}

::PortableInterceptor::ORBInitInfo_ptr
PortableInterceptor::ORBInitInfo_var::_retn (void)
{
  // yield ownership of managed obj reference
  ::PortableInterceptor::ORBInitInfo_ptr val = this->ptr_;
  this->ptr_ = ::PortableInterceptor::ORBInitInfo::_nil ();
  return val;
}

::PortableInterceptor::ORBInitInfo_ptr
PortableInterceptor::ORBInitInfo_var::tao_duplicate (ORBInitInfo_ptr p)
{
  return ::PortableInterceptor::ORBInitInfo::_duplicate (p);
}

void
PortableInterceptor::ORBInitInfo_var::tao_release (ORBInitInfo_ptr p)
{
  CORBA::release (p);
}

::PortableInterceptor::ORBInitInfo_ptr
PortableInterceptor::ORBInitInfo_var::tao_nil (void)
{
  return ::PortableInterceptor::ORBInitInfo::_nil ();
}

::PortableInterceptor::ORBInitInfo_ptr
PortableInterceptor::ORBInitInfo_var::tao_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return ::PortableInterceptor::ORBInitInfo::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
PortableInterceptor::ORBInitInfo_var::tao_upcast (void *src)
{
  ORBInitInfo **tmp =
    ACE_static_cast (ORBInitInfo **, src);
  return *tmp;
}

// *************************************************************
// PortableInterceptor::ORBInitInfo_out
// TAO_IDL - Generated from
// be/be_interface.cpp:932
// *************************************************************

PortableInterceptor::ORBInitInfo_out::ORBInitInfo_out (ORBInitInfo_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::PortableInterceptor::ORBInitInfo::_nil ();
}

PortableInterceptor::ORBInitInfo_out::ORBInitInfo_out (ORBInitInfo_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::PortableInterceptor::ORBInitInfo::_nil ();
}

PortableInterceptor::ORBInitInfo_out::ORBInitInfo_out (const ::PortableInterceptor::ORBInitInfo_out &p) // copy constructor
  : ptr_ (ACE_const_cast (ORBInitInfo_out &, p).ptr_)
{}

::PortableInterceptor::ORBInitInfo_out &
PortableInterceptor::ORBInitInfo_out::operator= (const ::PortableInterceptor::ORBInitInfo_out &p)
{
  this->ptr_ = ACE_const_cast (ORBInitInfo_out&, p).ptr_;
  return *this;
}

PortableInterceptor::ORBInitInfo_out &
PortableInterceptor::ORBInitInfo_out::operator= (const ::PortableInterceptor::ORBInitInfo_var &p)
{
  this->ptr_ = ::PortableInterceptor::ORBInitInfo::_duplicate (p.ptr ());
  return *this;
}

PortableInterceptor::ORBInitInfo_out &
PortableInterceptor::ORBInitInfo_out::operator= (ORBInitInfo_ptr p)
{
  this->ptr_ = p;
  return *this;
}

PortableInterceptor::ORBInitInfo_out::operator ::PortableInterceptor::ORBInitInfo_ptr &() // cast
{
  return this->ptr_;
}

::PortableInterceptor::ORBInitInfo_ptr &
PortableInterceptor::ORBInitInfo_out::ptr (void) // ptr
{
  return this->ptr_;
}

::PortableInterceptor::ORBInitInfo_ptr
PortableInterceptor::ORBInitInfo_out::operator-> (void)
{
  return this->ptr_;
}


// TAO_IDL - Generated from
// be/be_visitor_interface/interface_cs.cpp:209

PortableInterceptor::ORBInitInfo::ORBInitInfo (void)
{}

PortableInterceptor::ORBInitInfo::~ORBInitInfo (void)
{}

PortableInterceptor::ORBInitInfo_ptr PortableInterceptor::ORBInitInfo::_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL
  )
{
  return ORBInitInfo::_unchecked_narrow (obj ACE_ENV_ARG_PARAMETER);
}

PortableInterceptor::ORBInitInfo_ptr
PortableInterceptor::ORBInitInfo::_unchecked_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  if (CORBA::is_nil (obj))
    return ORBInitInfo::_nil ();
  return
      ACE_reinterpret_cast
        (
          ORBInitInfo_ptr,
            obj->_tao_QueryInterface
              (
                ACE_reinterpret_cast
                  (
                    ptr_arith_t,
                    &ORBInitInfo::_tao_class_id
                  )
              )
        );
}

PortableInterceptor::ORBInitInfo_ptr
PortableInterceptor::ORBInitInfo::_duplicate (ORBInitInfo_ptr obj)
{
  if (!CORBA::is_nil (obj))
    obj->_add_ref ();
  return obj;
}

void *PortableInterceptor::ORBInitInfo::_tao_QueryInterface (ptr_arith_t type)
{
  void *retv = 0;
  if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &ACE_NESTED_CLASS (::PortableInterceptor, ORBInitInfo)::_tao_class_id))
    retv = ACE_reinterpret_cast (void*, this);
  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_tao_class_id))
    retv = ACE_reinterpret_cast (void *,
      ACE_static_cast (CORBA::Object_ptr, this));

  if (retv)
    this->_add_ref ();
  return retv;
}

const char* PortableInterceptor::ORBInitInfo::_interface_repository_id (void) const
{
  return "IDL:PortableInterceptor/ORBInitInfo:1.0";
}

// Default constructor.
PortableInterceptor::ORBInitInfo::DuplicateName::DuplicateName (void)
  : CORBA_UserException (
        "IDL:PortableInterceptor/ORBInitInfo/DuplicateName:1.0",
        "DuplicateName"
      )
{
}

// Destructor - all members are of self managing types.
PortableInterceptor::ORBInitInfo::DuplicateName::~DuplicateName (void)
{
}

// Copy constructor.
PortableInterceptor::ORBInitInfo::DuplicateName::DuplicateName (const ::PortableInterceptor::ORBInitInfo::DuplicateName &_tao_excp)
  : CORBA_UserException (
        _tao_excp._rep_id (),
        _tao_excp._name ()
      )
{
  this->name = CORBA::string_dup (_tao_excp.name.in ());
}

// Assignment operator.
PortableInterceptor::ORBInitInfo::DuplicateName&
PortableInterceptor::ORBInitInfo::DuplicateName::operator= (const ::PortableInterceptor::ORBInitInfo::DuplicateName &_tao_excp)
{
  this->CORBA_UserException::operator= (_tao_excp);
  this->name = CORBA::string_dup (_tao_excp.name.in ());
  return *this;
}

PortableInterceptor::ORBInitInfo::DuplicateName *
PortableInterceptor::ORBInitInfo::DuplicateName::_downcast (CORBA::Exception *exc)
{
  if (!ACE_OS::strcmp ("IDL:PortableInterceptor/ORBInitInfo/DuplicateName:1.0", exc->_rep_id ()))
    {
      return ACE_dynamic_cast (DuplicateName *, exc);
    }
  else
    {
      return 0;
    }
}

CORBA::Exception *PortableInterceptor::ORBInitInfo::DuplicateName::_alloc (void)
{
  CORBA::Exception *retval = 0;
  ACE_NEW_RETURN (retval, ::PortableInterceptor::ORBInitInfo::DuplicateName, 0);
  return retval;
}

CORBA::Exception *
PortableInterceptor::ORBInitInfo::DuplicateName::_tao_duplicate (void) const
{
  CORBA::Exception *result;
  ACE_NEW_RETURN (
      result,
      PortableInterceptor::ORBInitInfo::DuplicateName (*this),
      0
    );
  return result;
}

void PortableInterceptor::ORBInitInfo::DuplicateName::_raise ()
{
  TAO_RAISE (*this);
}

void PortableInterceptor::ORBInitInfo::DuplicateName::_tao_encode (
    TAO_OutputCDR &
    ACE_ENV_ARG_DECL
  ) const
{
  ACE_THROW (CORBA::MARSHAL ());
}

void PortableInterceptor::ORBInitInfo::DuplicateName::_tao_decode (
    TAO_InputCDR &
    ACE_ENV_ARG_DECL
  )
{
  ACE_THROW (CORBA::MARSHAL ());
}

PortableInterceptor::ORBInitInfo::DuplicateName::DuplicateName (
    const char * _tao_name
  )
  : CORBA_UserException (
        "IDL:PortableInterceptor/ORBInitInfo/DuplicateName:1.0",
        "DuplicateName"
      )
{
  this->name = CORBA::string_dup (_tao_name);
}

// Default constructor.
PortableInterceptor::ORBInitInfo::InvalidName::InvalidName (void)
  : CORBA_UserException (
        "IDL:PortableInterceptor/ORBInitInfo/InvalidName:1.0",
        "InvalidName"
      )
{
}

// Destructor - all members are of self managing types.
PortableInterceptor::ORBInitInfo::InvalidName::~InvalidName (void)
{
}

// Copy constructor.
PortableInterceptor::ORBInitInfo::InvalidName::InvalidName (const ::PortableInterceptor::ORBInitInfo::InvalidName &_tao_excp)
  : CORBA_UserException (
        _tao_excp._rep_id (),
        _tao_excp._name ()
      )
{
}

// Assignment operator.
PortableInterceptor::ORBInitInfo::InvalidName&
PortableInterceptor::ORBInitInfo::InvalidName::operator= (const ::PortableInterceptor::ORBInitInfo::InvalidName &_tao_excp)
{
  this->CORBA_UserException::operator= (_tao_excp);
  return *this;
}

PortableInterceptor::ORBInitInfo::InvalidName *
PortableInterceptor::ORBInitInfo::InvalidName::_downcast (CORBA::Exception *exc)
{
  if (!ACE_OS::strcmp ("IDL:PortableInterceptor/ORBInitInfo/InvalidName:1.0", exc->_rep_id ()))
    {
      return ACE_dynamic_cast (InvalidName *, exc);
    }
  else
    {
      return 0;
    }
}

CORBA::Exception *PortableInterceptor::ORBInitInfo::InvalidName::_alloc (void)
{
  CORBA::Exception *retval = 0;
  ACE_NEW_RETURN (retval, ::PortableInterceptor::ORBInitInfo::InvalidName, 0);
  return retval;
}

CORBA::Exception *
PortableInterceptor::ORBInitInfo::InvalidName::_tao_duplicate (void) const
{
  CORBA::Exception *result;
  ACE_NEW_RETURN (
      result,
      PortableInterceptor::ORBInitInfo::InvalidName (*this),
      0
    );
  return result;
}

void PortableInterceptor::ORBInitInfo::InvalidName::_raise ()
{
  TAO_RAISE (*this);
}

void PortableInterceptor::ORBInitInfo::InvalidName::_tao_encode (
    TAO_OutputCDR &
    ACE_ENV_ARG_DECL
  ) const
{
  ACE_THROW (CORBA::MARSHAL ());
}

void PortableInterceptor::ORBInitInfo::InvalidName::_tao_decode (
    TAO_InputCDR &
    ACE_ENV_ARG_DECL
  )
{
  ACE_THROW (CORBA::MARSHAL ());
}

int PortableInterceptor::ORBInitializer::_tao_class_id = 0;

PortableInterceptor::ORBInitializer_ptr
tao_PortableInterceptor_ORBInitializer_duplicate (
    PortableInterceptor::ORBInitializer_ptr p
  )
{
  return PortableInterceptor::ORBInitializer::_duplicate (p);
}

void
tao_PortableInterceptor_ORBInitializer_release (
    PortableInterceptor::ORBInitializer_ptr p
  )
{
  CORBA::release (p);
}

PortableInterceptor::ORBInitializer_ptr
tao_PortableInterceptor_ORBInitializer_nil (
    void
  )
{
  return PortableInterceptor::ORBInitializer::_nil ();
}

PortableInterceptor::ORBInitializer_ptr
tao_PortableInterceptor_ORBInitializer_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return PortableInterceptor::ORBInitializer::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
tao_PortableInterceptor_ORBInitializer_upcast (
    void *src
  )
{
  PortableInterceptor::ORBInitializer **tmp =
    ACE_static_cast (PortableInterceptor::ORBInitializer **, src);
  return *tmp;
}

// *************************************************************
// PortableInterceptor::ORBInitializer_var
// TAO_IDL - Generated from
// be/be_interface.cpp:654
// *************************************************************

PortableInterceptor::ORBInitializer_var::ORBInitializer_var (void) // default constructor
  : ptr_ (ORBInitializer::_nil ())
{}

::PortableInterceptor::ORBInitializer_ptr
PortableInterceptor::ORBInitializer_var::ptr (void) const
{
  return this->ptr_;
}

PortableInterceptor::ORBInitializer_var::ORBInitializer_var (const ::PortableInterceptor::ORBInitializer_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (ORBInitializer::_duplicate (p.ptr ()))
{}

PortableInterceptor::ORBInitializer_var::~ORBInitializer_var (void) // destructor
{
  CORBA::release (this->ptr_);
}

PortableInterceptor::ORBInitializer_var &
PortableInterceptor::ORBInitializer_var::operator= (ORBInitializer_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

PortableInterceptor::ORBInitializer_var &
PortableInterceptor::ORBInitializer_var::operator= (const ::PortableInterceptor::ORBInitializer_var &p)
{
  if (this != &p)
  {
    CORBA::release (this->ptr_);
    this->ptr_ = ::PortableInterceptor::ORBInitializer::_duplicate (p.ptr ());
  }
  return *this;
}

PortableInterceptor::ORBInitializer_var::operator const ::PortableInterceptor::ORBInitializer_ptr &() const // cast
{
  return this->ptr_;
}

PortableInterceptor::ORBInitializer_var::operator ::PortableInterceptor::ORBInitializer_ptr &() // cast
{
  return this->ptr_;
}

::PortableInterceptor::ORBInitializer_ptr
PortableInterceptor::ORBInitializer_var::operator-> (void) const
{
  return this->ptr_;
}

::PortableInterceptor::ORBInitializer_ptr
PortableInterceptor::ORBInitializer_var::in (void) const
{
  return this->ptr_;
}

::PortableInterceptor::ORBInitializer_ptr &
PortableInterceptor::ORBInitializer_var::inout (void)
{
  return this->ptr_;
}

::PortableInterceptor::ORBInitializer_ptr &
PortableInterceptor::ORBInitializer_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::PortableInterceptor::ORBInitializer::_nil ();
  return this->ptr_;
}

::PortableInterceptor::ORBInitializer_ptr
PortableInterceptor::ORBInitializer_var::_retn (void)
{
  // yield ownership of managed obj reference
  ::PortableInterceptor::ORBInitializer_ptr val = this->ptr_;
  this->ptr_ = ::PortableInterceptor::ORBInitializer::_nil ();
  return val;
}

::PortableInterceptor::ORBInitializer_ptr
PortableInterceptor::ORBInitializer_var::tao_duplicate (ORBInitializer_ptr p)
{
  return ::PortableInterceptor::ORBInitializer::_duplicate (p);
}

void
PortableInterceptor::ORBInitializer_var::tao_release (ORBInitializer_ptr p)
{
  CORBA::release (p);
}

::PortableInterceptor::ORBInitializer_ptr
PortableInterceptor::ORBInitializer_var::tao_nil (void)
{
  return ::PortableInterceptor::ORBInitializer::_nil ();
}

::PortableInterceptor::ORBInitializer_ptr
PortableInterceptor::ORBInitializer_var::tao_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return ::PortableInterceptor::ORBInitializer::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
PortableInterceptor::ORBInitializer_var::tao_upcast (void *src)
{
  ORBInitializer **tmp =
    ACE_static_cast (ORBInitializer **, src);
  return *tmp;
}

// *************************************************************
// PortableInterceptor::ORBInitializer_out
// TAO_IDL - Generated from
// be/be_interface.cpp:932
// *************************************************************

PortableInterceptor::ORBInitializer_out::ORBInitializer_out (ORBInitializer_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::PortableInterceptor::ORBInitializer::_nil ();
}

PortableInterceptor::ORBInitializer_out::ORBInitializer_out (ORBInitializer_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::PortableInterceptor::ORBInitializer::_nil ();
}

PortableInterceptor::ORBInitializer_out::ORBInitializer_out (const ::PortableInterceptor::ORBInitializer_out &p) // copy constructor
  : ptr_ (ACE_const_cast (ORBInitializer_out &, p).ptr_)
{}

::PortableInterceptor::ORBInitializer_out &
PortableInterceptor::ORBInitializer_out::operator= (const ::PortableInterceptor::ORBInitializer_out &p)
{
  this->ptr_ = ACE_const_cast (ORBInitializer_out&, p).ptr_;
  return *this;
}

PortableInterceptor::ORBInitializer_out &
PortableInterceptor::ORBInitializer_out::operator= (const ::PortableInterceptor::ORBInitializer_var &p)
{
  this->ptr_ = ::PortableInterceptor::ORBInitializer::_duplicate (p.ptr ());
  return *this;
}

PortableInterceptor::ORBInitializer_out &
PortableInterceptor::ORBInitializer_out::operator= (ORBInitializer_ptr p)
{
  this->ptr_ = p;
  return *this;
}

PortableInterceptor::ORBInitializer_out::operator ::PortableInterceptor::ORBInitializer_ptr &() // cast
{
  return this->ptr_;
}

::PortableInterceptor::ORBInitializer_ptr &
PortableInterceptor::ORBInitializer_out::ptr (void) // ptr
{
  return this->ptr_;
}

::PortableInterceptor::ORBInitializer_ptr
PortableInterceptor::ORBInitializer_out::operator-> (void)
{
  return this->ptr_;
}


// TAO_IDL - Generated from
// be/be_visitor_interface/interface_cs.cpp:209

PortableInterceptor::ORBInitializer::ORBInitializer (void)
{}

PortableInterceptor::ORBInitializer::~ORBInitializer (void)
{}

PortableInterceptor::ORBInitializer_ptr PortableInterceptor::ORBInitializer::_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL
  )
{
  return ORBInitializer::_unchecked_narrow (obj ACE_ENV_ARG_PARAMETER);
}

PortableInterceptor::ORBInitializer_ptr
PortableInterceptor::ORBInitializer::_unchecked_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  if (CORBA::is_nil (obj))
    return ORBInitializer::_nil ();
  return
      ACE_reinterpret_cast
        (
          ORBInitializer_ptr,
            obj->_tao_QueryInterface
              (
                ACE_reinterpret_cast
                  (
                    ptr_arith_t,
                    &ORBInitializer::_tao_class_id
                  )
              )
        );
}

PortableInterceptor::ORBInitializer_ptr
PortableInterceptor::ORBInitializer::_duplicate (ORBInitializer_ptr obj)
{
  if (!CORBA::is_nil (obj))
    obj->_add_ref ();
  return obj;
}

void *PortableInterceptor::ORBInitializer::_tao_QueryInterface (ptr_arith_t type)
{
  void *retv = 0;
  if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &ACE_NESTED_CLASS (::PortableInterceptor, ORBInitializer)::_tao_class_id))
    retv = ACE_reinterpret_cast (void*, this);
  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_tao_class_id))
    retv = ACE_reinterpret_cast (void *,
      ACE_static_cast (CORBA::Object_ptr, this));

  if (retv)
    this->_add_ref ();
  return retv;
}

const char* PortableInterceptor::ORBInitializer::_interface_repository_id (void) const
{
  return "IDL:PortableInterceptor/ORBInitializer:1.0";
}

#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
    defined (ACE_HAS_GNU_REPO)
    template class TAO_Object_Manager<PortableInterceptor::Interceptor,PortableInterceptor::Interceptor_var>;
  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
  #  pragma instantiate TAO_Object_Manager<PortableInterceptor::Interceptor,PortableInterceptor::Interceptor_var>
#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */

void operator<<= (CORBA::Any &_tao_any, const PortableInterceptor::ForwardRequest &_tao_elem) // copying
{
  TAO_OutputCDR stream;
  stream << _tao_elem;
  _tao_any._tao_replace (
      PortableInterceptor::_tc_ForwardRequest,
      TAO_ENCAP_BYTE_ORDER,
      stream.begin ()
    );
}

void operator<<= (CORBA::Any &_tao_any, PortableInterceptor::ForwardRequest *_tao_elem) // non copying
{
  TAO_OutputCDR stream;
  stream << *_tao_elem;
  _tao_any._tao_replace (
      PortableInterceptor::_tc_ForwardRequest,
      TAO_ENCAP_BYTE_ORDER,
      stream.begin (),
      1,
      _tao_elem,
      PortableInterceptor::ForwardRequest::_tao_any_destructor
    );
}

CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableInterceptor::ForwardRequest *&_tao_elem)
{
  return _tao_any >>= ACE_const_cast(
      const PortableInterceptor::ForwardRequest*&,
      _tao_elem
    );
}

CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableInterceptor::ForwardRequest *&_tao_elem)
{
  _tao_elem = 0;
  ACE_TRY_NEW_ENV
  {
    CORBA::TypeCode_var type = _tao_any.type ();

    CORBA::Boolean result = type->equivalent (PortableInterceptor::_tc_ForwardRequest ACE_ENV_ARG_PARAMETER);
    ACE_TRY_CHECK;

    if (!result)
      return 0; // not equivalent

    if (_tao_any.any_owns_data ())
    {
      _tao_elem = (PortableInterceptor::ForwardRequest *)_tao_any.value ();
      return 1;
    }
    else
    {
      PortableInterceptor::ForwardRequest *tmp;
      ACE_NEW_RETURN (tmp, PortableInterceptor::ForwardRequest, 0);
      TAO_InputCDR stream (
          _tao_any._tao_get_cdr (),
          _tao_any._tao_byte_order ()
        );
      CORBA::String_var interface_repository_id;
      if (!(stream >> interface_repository_id.out ()))
        return 0;
      if (ACE_OS::strcmp (
          interface_repository_id.in (),
          "IDL:PortableInterceptor/ForwardRequest:1.0"))
        return 0;
      if (stream >> *tmp)
      {
        ((CORBA::Any *)&_tao_any)->_tao_replace (
            PortableInterceptor::_tc_ForwardRequest,
            1,
            tmp,
            PortableInterceptor::ForwardRequest::_tao_any_destructor
          );
        _tao_elem = tmp;
        return 1;
      }
      else
      {
        delete tmp;
      }
    }
  }
  ACE_CATCHANY
  {
  }
  ACE_ENDTRY;
  return 0;
}

void operator<<= (CORBA::Any &_tao_any, const PortableInterceptor::InvalidSlot &_tao_elem) // copying
{
  TAO_OutputCDR stream;
  stream << _tao_elem;
  _tao_any._tao_replace (
      PortableInterceptor::_tc_InvalidSlot,
      TAO_ENCAP_BYTE_ORDER,
      stream.begin ()
    );
}

void operator<<= (CORBA::Any &_tao_any, PortableInterceptor::InvalidSlot *_tao_elem) // non copying
{
  TAO_OutputCDR stream;
  stream << *_tao_elem;
  _tao_any._tao_replace (
      PortableInterceptor::_tc_InvalidSlot,
      TAO_ENCAP_BYTE_ORDER,
      stream.begin (),
      1,
      _tao_elem,
      PortableInterceptor::InvalidSlot::_tao_any_destructor
    );
}

CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableInterceptor::InvalidSlot *&_tao_elem)
{
  return _tao_any >>= ACE_const_cast(
      const PortableInterceptor::InvalidSlot*&,
      _tao_elem
    );
}

CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableInterceptor::InvalidSlot *&_tao_elem)
{
  _tao_elem = 0;
  ACE_TRY_NEW_ENV
  {
    CORBA::TypeCode_var type = _tao_any.type ();

    CORBA::Boolean result = type->equivalent (PortableInterceptor::_tc_InvalidSlot ACE_ENV_ARG_PARAMETER);
    ACE_TRY_CHECK;

    if (!result)
      return 0; // not equivalent

    if (_tao_any.any_owns_data ())
    {
      _tao_elem = (PortableInterceptor::InvalidSlot *)_tao_any.value ();
      return 1;
    }
    else
    {
      PortableInterceptor::InvalidSlot *tmp;
      ACE_NEW_RETURN (tmp, PortableInterceptor::InvalidSlot, 0);
      TAO_InputCDR stream (
          _tao_any._tao_get_cdr (),
          _tao_any._tao_byte_order ()
        );
      CORBA::String_var interface_repository_id;
      if (!(stream >> interface_repository_id.out ()))
        return 0;
      if (ACE_OS::strcmp (
          interface_repository_id.in (),
          "IDL:PortableInterceptor/InvalidSlot:1.0"))
        return 0;
      if (stream >> *tmp)
      {
        ((CORBA::Any *)&_tao_any)->_tao_replace (
            PortableInterceptor::_tc_InvalidSlot,
            1,
            tmp,
            PortableInterceptor::InvalidSlot::_tao_any_destructor
          );
        _tao_elem = tmp;
        return 1;
      }
      else
      {
        delete tmp;
      }
    }
  }
  ACE_CATCHANY
  {
  }
  ACE_ENDTRY;
  return 0;
}

#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
    defined (ACE_HAS_GNU_REPO)
    template class TAO_Object_Manager<PortableInterceptor::Current,PortableInterceptor::Current_var>;
  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
  #  pragma instantiate TAO_Object_Manager<PortableInterceptor::Current,PortableInterceptor::Current_var>
#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */

#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
    defined (ACE_HAS_GNU_REPO)
    template class TAO_Object_Manager<PortableInterceptor::RequestInfo,PortableInterceptor::RequestInfo_var>;
  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
  #  pragma instantiate TAO_Object_Manager<PortableInterceptor::RequestInfo,PortableInterceptor::RequestInfo_var>
#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */

#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
    defined (ACE_HAS_GNU_REPO)
    template class TAO_Object_Manager<PortableInterceptor::ClientRequestInfo,PortableInterceptor::ClientRequestInfo_var>;
  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
  #  pragma instantiate TAO_Object_Manager<PortableInterceptor::ClientRequestInfo,PortableInterceptor::ClientRequestInfo_var>
#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */

#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
    defined (ACE_HAS_GNU_REPO)
    template class TAO_Object_Manager<PortableInterceptor::ServerRequestInfo,PortableInterceptor::ServerRequestInfo_var>;
  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
  #  pragma instantiate TAO_Object_Manager<PortableInterceptor::ServerRequestInfo,PortableInterceptor::ServerRequestInfo_var>
#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */

#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
    defined (ACE_HAS_GNU_REPO)
    template class TAO_Object_Manager<PortableInterceptor::ClientRequestInterceptor,PortableInterceptor::ClientRequestInterceptor_var>;
  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
  #  pragma instantiate TAO_Object_Manager<PortableInterceptor::ClientRequestInterceptor,PortableInterceptor::ClientRequestInterceptor_var>
#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */

#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
    defined (ACE_HAS_GNU_REPO)
    template class TAO_Object_Manager<PortableInterceptor::ServerRequestInterceptor,PortableInterceptor::ServerRequestInterceptor_var>;
  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
  #  pragma instantiate TAO_Object_Manager<PortableInterceptor::ServerRequestInterceptor,PortableInterceptor::ServerRequestInterceptor_var>
#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */

#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
    defined (ACE_HAS_GNU_REPO)
    template class TAO_Object_Manager<PortableInterceptor::IORInfo,PortableInterceptor::IORInfo_var>;
  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
  #  pragma instantiate TAO_Object_Manager<PortableInterceptor::IORInfo,PortableInterceptor::IORInfo_var>
#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */

#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
    defined (ACE_HAS_GNU_REPO)
    template class TAO_Object_Manager<PortableInterceptor::IORInterceptor,PortableInterceptor::IORInterceptor_var>;
  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
  #  pragma instantiate TAO_Object_Manager<PortableInterceptor::IORInterceptor,PortableInterceptor::IORInterceptor_var>
#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */

#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
    defined (ACE_HAS_GNU_REPO)
    template class TAO_Object_Manager<PortableInterceptor::PolicyFactory,PortableInterceptor::PolicyFactory_var>;
  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
  #  pragma instantiate TAO_Object_Manager<PortableInterceptor::PolicyFactory,PortableInterceptor::PolicyFactory_var>
#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */

#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
    defined (ACE_HAS_GNU_REPO)
    template class TAO_Object_Manager<PortableInterceptor::ORBInitInfo,PortableInterceptor::ORBInitInfo_var>;
  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
  #  pragma instantiate TAO_Object_Manager<PortableInterceptor::ORBInitInfo,PortableInterceptor::ORBInitInfo_var>
#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */

#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
    defined (ACE_HAS_GNU_REPO)
    template class TAO_Object_Manager<PortableInterceptor::ORBInitializer,PortableInterceptor::ORBInitializer_var>;
  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
  #  pragma instantiate TAO_Object_Manager<PortableInterceptor::ORBInitializer,PortableInterceptor::ORBInitializer_var>
#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */