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

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

#include "tao/CORBA_String.h"

// default constructor
PortableInterceptor::Interceptor::Interceptor (void)
{}

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

PortableInterceptor::Interceptor_ptr PortableInterceptor::Interceptor::_narrow (
    CORBA::Object_ptr obj,
    CORBA::Environment &ACE_TRY_ENV
  )
{
  return Interceptor::_unchecked_narrow (obj, ACE_TRY_ENV);
}

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

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)::_narrow))
    retv = ACE_reinterpret_cast (void*, this);
  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
    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")
{
}

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

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

// Copy constructor.
PortableInterceptor::ForwardRequest::ForwardRequest (const ::PortableInterceptor::ForwardRequest &_tao_excp)
  : CORBA_UserException (_tao_excp._id ())
{
  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;
}

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

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

void PortableInterceptor::ForwardRequest::_tao_encode (
    TAO_OutputCDR &cdr,
    CORBA::Environment &ACE_TRY_ENV
  ) const
{
  if (cdr << *this)
    {
      return;
    }

  ACE_THROW (CORBA::MARSHAL ());
}

void PortableInterceptor::ForwardRequest::_tao_decode (
    TAO_InputCDR &cdr,
    CORBA::Environment &ACE_TRY_ENV
  )
{
  if (cdr >> *this)
    {
      return;
    }

  ACE_THROW (CORBA::MARSHAL ());
}

// TAO extension - the _alloc method.
CORBA::Exception *PortableInterceptor::ForwardRequest::_alloc (void)
{
  CORBA::Exception *retval = 0;
  ACE_NEW_RETURN (retval, ::PortableInterceptor::ForwardRequest, 0);
  return retval;
}

PortableInterceptor::ForwardRequest::ForwardRequest (
    const CORBA::Object_ptr  _tao_forward,
    CORBA::Boolean _tao_permanent
  )
  : CORBA_UserException ("IDL:PortableInterceptor/ForwardRequest:1.0")
{
  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")
{
}

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

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

// Copy constructor.
PortableInterceptor::InvalidSlot::InvalidSlot (const ::PortableInterceptor::InvalidSlot &_tao_excp)
  : CORBA_UserException (_tao_excp._id ())
{
}

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

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

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

void PortableInterceptor::InvalidSlot::_tao_encode (
    TAO_OutputCDR &cdr,
    CORBA::Environment &ACE_TRY_ENV
  ) const
{
  if (cdr << *this)
    {
      return;
    }

  ACE_THROW (CORBA::MARSHAL ());
}

void PortableInterceptor::InvalidSlot::_tao_decode (
    TAO_InputCDR &cdr,
    CORBA::Environment &ACE_TRY_ENV
  )
{
  if (cdr >> *this)
    {
      return;
    }

  ACE_THROW (CORBA::MARSHAL ());
}

// TAO extension - the _alloc method.
CORBA::Exception *PortableInterceptor::InvalidSlot::_alloc (void)
{
  CORBA::Exception *retval = 0;
  ACE_NEW_RETURN (retval, ::PortableInterceptor::InvalidSlot, 0);
  return retval;
}

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;
}


// default constructor
PortableInterceptor::Current::Current (void)
{}

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

PortableInterceptor::Current_ptr PortableInterceptor::Current::_narrow (
    CORBA::Object_ptr obj,
    CORBA::Environment &ACE_TRY_ENV
  )
{
  return Current::_unchecked_narrow (obj, ACE_TRY_ENV);
}

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

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)::_narrow))
    retv = ACE_reinterpret_cast (void*, this);
  else if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &::CORBA::Current::_narrow))
    retv = ACE_reinterpret_cast
      (
        void *,
        ACE_static_cast
          (
            CORBA::Current_ptr,
            this
          )
      );
  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
    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";
}


// default constructor
PortableInterceptor::RequestInfo::RequestInfo (void)
{}

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

PortableInterceptor::RequestInfo_ptr PortableInterceptor::RequestInfo::_narrow (
    CORBA::Object_ptr obj,
    CORBA::Environment &ACE_TRY_ENV
  )
{
  return RequestInfo::_unchecked_narrow (obj, ACE_TRY_ENV);
}

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

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)::_narrow))
    retv = ACE_reinterpret_cast (void*, this);
  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
    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";
}


// default constructor
PortableInterceptor::ClientRequestInfo::ClientRequestInfo (void)
{}

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

PortableInterceptor::ClientRequestInfo_ptr PortableInterceptor::ClientRequestInfo::_narrow (
    CORBA::Object_ptr obj,
    CORBA::Environment &ACE_TRY_ENV
  )
{
  return ClientRequestInfo::_unchecked_narrow (obj, ACE_TRY_ENV);
}

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

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)::_narrow))
    retv = ACE_reinterpret_cast (void*, this);
  else if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &ACE_NESTED_CLASS (::PortableInterceptor, RequestInfo)::_narrow))
    retv = ACE_reinterpret_cast
      (
        void *,
        ACE_static_cast
          (
            PortableInterceptor::RequestInfo_ptr,
            this
          )
      );
  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
    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";
}


// default constructor
PortableInterceptor::ServerRequestInfo::ServerRequestInfo (void)
{}

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

PortableInterceptor::ServerRequestInfo_ptr PortableInterceptor::ServerRequestInfo::_narrow (
    CORBA::Object_ptr obj,
    CORBA::Environment &ACE_TRY_ENV
  )
{
  return ServerRequestInfo::_unchecked_narrow (obj, ACE_TRY_ENV);
}

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

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)::_narrow))
    retv = ACE_reinterpret_cast (void*, this);
  else if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &ACE_NESTED_CLASS (::PortableInterceptor, RequestInfo)::_narrow))
    retv = ACE_reinterpret_cast
      (
        void *,
        ACE_static_cast
          (
            PortableInterceptor::RequestInfo_ptr,
            this
          )
      );
  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
    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";
}


// default constructor
PortableInterceptor::ClientRequestInterceptor::ClientRequestInterceptor (void)
{}

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

PortableInterceptor::ClientRequestInterceptor_ptr PortableInterceptor::ClientRequestInterceptor::_narrow (
    CORBA::Object_ptr obj,
    CORBA::Environment &ACE_TRY_ENV
  )
{
  return ClientRequestInterceptor::_unchecked_narrow (obj, ACE_TRY_ENV);
}

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

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)::_narrow))
    retv = ACE_reinterpret_cast (void*, this);
  else if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &ACE_NESTED_CLASS (::PortableInterceptor, Interceptor)::_narrow))
    retv = ACE_reinterpret_cast
      (
        void *,
        ACE_static_cast
          (
            PortableInterceptor::Interceptor_ptr,
            this
          )
      );
  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
    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";
}


// default constructor
PortableInterceptor::ServerRequestInterceptor::ServerRequestInterceptor (void)
{}

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

PortableInterceptor::ServerRequestInterceptor_ptr PortableInterceptor::ServerRequestInterceptor::_narrow (
    CORBA::Object_ptr obj,
    CORBA::Environment &ACE_TRY_ENV
  )
{
  return ServerRequestInterceptor::_unchecked_narrow (obj, ACE_TRY_ENV);
}

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

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)::_narrow))
    retv = ACE_reinterpret_cast (void*, this);
  else if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &ACE_NESTED_CLASS (::PortableInterceptor, Interceptor)::_narrow))
    retv = ACE_reinterpret_cast
      (
        void *,
        ACE_static_cast
          (
            PortableInterceptor::Interceptor_ptr,
            this
          )
      );
  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
    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";
}


// default constructor
PortableInterceptor::IORInfo::IORInfo (void)
{}

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

PortableInterceptor::IORInfo_ptr PortableInterceptor::IORInfo::_narrow (
    CORBA::Object_ptr obj,
    CORBA::Environment &ACE_TRY_ENV
  )
{
  return IORInfo::_unchecked_narrow (obj, ACE_TRY_ENV);
}

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

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)::_narrow))
    retv = ACE_reinterpret_cast (void*, this);
  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
    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";
}


// default constructor
PortableInterceptor::IORInterceptor::IORInterceptor (void)
{}

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

PortableInterceptor::IORInterceptor_ptr PortableInterceptor::IORInterceptor::_narrow (
    CORBA::Object_ptr obj,
    CORBA::Environment &ACE_TRY_ENV
  )
{
  return IORInterceptor::_unchecked_narrow (obj, ACE_TRY_ENV);
}

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

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)::_narrow))
    retv = ACE_reinterpret_cast (void*, this);
  else if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &ACE_NESTED_CLASS (::PortableInterceptor, Interceptor)::_narrow))
    retv = ACE_reinterpret_cast
      (
        void *,
        ACE_static_cast
          (
            PortableInterceptor::Interceptor_ptr,
            this
          )
      );
  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
    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";
}


// default constructor
PortableInterceptor::PolicyFactory::PolicyFactory (void)
{}

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

PortableInterceptor::PolicyFactory_ptr PortableInterceptor::PolicyFactory::_narrow (
    CORBA::Object_ptr obj,
    CORBA::Environment &ACE_TRY_ENV
  )
{
  return PolicyFactory::_unchecked_narrow (obj, ACE_TRY_ENV);
}

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

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

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)::_narrow))
    retv = ACE_reinterpret_cast (void*, this);
  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
    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";
}


// default constructor
PortableInterceptor::ORBInitInfo::ORBInitInfo (void)
{}

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

PortableInterceptor::ORBInitInfo_ptr PortableInterceptor::ORBInitInfo::_narrow (
    CORBA::Object_ptr obj,
    CORBA::Environment &ACE_TRY_ENV
  )
{
  return ORBInitInfo::_unchecked_narrow (obj, ACE_TRY_ENV);
}

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

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)::_narrow))
    retv = ACE_reinterpret_cast (void*, this);
  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
    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")
{
}

// 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._id ())
{
  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;
}

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

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

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

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

// TAO extension - the _alloc method.
CORBA::Exception *PortableInterceptor::ORBInitInfo::DuplicateName::_alloc (void)
{
  CORBA::Exception *retval = 0;
  ACE_NEW_RETURN (retval, ::PortableInterceptor::ORBInitInfo::DuplicateName, 0);
  return retval;
}

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

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

// 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._id ())
{
}

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

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

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

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

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

// TAO extension - the _alloc method.
CORBA::Exception *PortableInterceptor::ORBInitInfo::InvalidName::_alloc (void)
{
  CORBA::Exception *retval = 0;
  ACE_NEW_RETURN (retval, ::PortableInterceptor::ORBInitInfo::InvalidName, 0);
  return retval;
}


// default constructor
PortableInterceptor::ORBInitializer::ORBInitializer (void)
{}

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

PortableInterceptor::ORBInitializer_ptr PortableInterceptor::ORBInitializer::_narrow (
    CORBA::Object_ptr obj,
    CORBA::Environment &ACE_TRY_ENV
  )
{
  return ORBInitializer::_unchecked_narrow (obj, ACE_TRY_ENV);
}

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

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)::_narrow))
    retv = ACE_reinterpret_cast (void*, this);
  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
    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 ();
    if (!type->equivalent (PortableInterceptor::_tc_ForwardRequest, ACE_TRY_ENV)) // not equal
      {
        return 0;
      }
    ACE_TRY_CHECK;
    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 ();
    if (!type->equivalent (PortableInterceptor::_tc_InvalidSlot, ACE_TRY_ENV)) // not equal
      {
        return 0;
      }
    ACE_TRY_CHECK;
    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 */