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

// ******  Code generated by the The ACE ORB (TAO) IDL Compiler *******
// TAO and the TAO IDL Compiler have been developed by the Center for
// Distributed Object Computing at Washington University, St. Louis.
//
// Information about TAO is available at:
//                 http://www.cs.wustl.edu/~schmidt/TAO.html


#if !defined (_PORTABLESERVER_POA___VAR_CI_)
#define _PORTABLESERVER_POA___VAR_CI_

// *************************************************************
// Inline operations for class PortableServer::POA_var
// *************************************************************

ACE_INLINE
PortableServer::POA_var::POA_var (void) // default constructor
  : ptr_ (PortableServer::POA::_nil ())
{}

ACE_INLINE PortableServer::POA_ptr
PortableServer::POA_var::ptr (void) const
{
  return this->ptr_;
}

ACE_INLINE
PortableServer::POA_var::POA_var (const PortableServer::POA_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (POA::_duplicate (p.ptr ()))
{}

ACE_INLINE
PortableServer::POA_var::~POA_var (void) // destructor
{
  CORBA::release (this->ptr_);
}

ACE_INLINE PortableServer::POA_var &
PortableServer::POA_var::operator= (PortableServer::POA_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

ACE_INLINE PortableServer::POA_var &
PortableServer::POA_var::operator= (const PortableServer::POA_var &p)
{
  if (this != &p)
  {
    CORBA::release (this->ptr_);
    this->ptr_ = PortableServer::POA::_duplicate (p.ptr ());
  }
  return *this;
}

ACE_INLINE
PortableServer::POA_var::operator const PortableServer::POA_ptr &() const // cast
{
  return this->ptr_;
}

ACE_INLINE
PortableServer::POA_var::operator PortableServer::POA_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE PortableServer::POA_ptr
PortableServer::POA_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE PortableServer::POA_ptr
PortableServer::POA_var::in (void) const
{
  return this->ptr_;
}

ACE_INLINE PortableServer::POA_ptr &
PortableServer::POA_var::inout (void)
{
  return this->ptr_;
}

ACE_INLINE PortableServer::POA_ptr &
PortableServer::POA_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = PortableServer::POA::_nil ();
  return this->ptr_;
}

ACE_INLINE PortableServer::POA_ptr
PortableServer::POA_var::_retn (void)
{
  // yield ownership of managed obj reference
  PortableServer::POA_ptr val = this->ptr_;
  this->ptr_ = PortableServer::POA::_nil ();
  return val;
}


#endif /* end #if !defined */


#if !defined (_PORTABLESERVER_POA___OUT_CI_)
#define _PORTABLESERVER_POA___OUT_CI_

// *************************************************************
// Inline operations for class PortableServer::POA_out
// *************************************************************

ACE_INLINE
PortableServer::POA_out::POA_out (PortableServer::POA_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = PortableServer::POA::_nil ();
}

ACE_INLINE
PortableServer::POA_out::POA_out (PortableServer::POA_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = PortableServer::POA::_nil ();
}

ACE_INLINE
PortableServer::POA_out::POA_out (const PortableServer::POA_out &p) // copy constructor
  : ptr_ (ACE_const_cast (PortableServer::POA_out&,p).ptr_)
{}

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

ACE_INLINE PortableServer::POA_out &
PortableServer::POA_out::operator= (const PortableServer::POA_var &p)
{
  this->ptr_ = PortableServer::POA::_duplicate (p.ptr ());
  return *this;
}

ACE_INLINE PortableServer::POA_out &
PortableServer::POA_out::operator= (PortableServer::POA_ptr p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE
PortableServer::POA_out::operator PortableServer::POA_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE PortableServer::POA_ptr &
PortableServer::POA_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE PortableServer::POA_ptr
PortableServer::POA_out::operator-> (void)
{
  return this->ptr_;
}


#endif /* end #if !defined */


#if !defined (TAO_USE_SEQUENCE_TEMPLATES)

#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_PORTABLESERVER_POALIST_CI_)
#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_PORTABLESERVER_POALIST_CI_

  ACE_INLINE PortableServer::POA **
  PortableServer::_TAO_Unbounded_Object_Sequence_PortableServer_POAList::allocbuf (CORBA::ULong nelems)
  {
    PortableServer::POA **buf = 0;

    ACE_NEW_RETURN (buf, PortableServer::POA*[nelems], 0);

    for (CORBA::ULong i = 0; i < nelems; i++)
      buf[i] = PortableServer::POA::_nil ();

    return buf;
  }

  ACE_INLINE void
  PortableServer::_TAO_Unbounded_Object_Sequence_PortableServer_POAList::freebuf (PortableServer::POA **buffer)
  {
    if (buffer == 0)
      return;
    delete[] buffer;
  }

  ACE_INLINE
  PortableServer::_TAO_Unbounded_Object_Sequence_PortableServer_POAList::_TAO_Unbounded_Object_Sequence_PortableServer_POAList (void)
  {
  }

  ACE_INLINE
  PortableServer::_TAO_Unbounded_Object_Sequence_PortableServer_POAList::_TAO_Unbounded_Object_Sequence_PortableServer_POAList (CORBA::ULong maximum)
    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Object_Sequence_PortableServer_POAList::allocbuf (maximum))
  {
  }

  ACE_INLINE
  PortableServer::_TAO_Unbounded_Object_Sequence_PortableServer_POAList::_TAO_Unbounded_Object_Sequence_PortableServer_POAList (CORBA::ULong maximum,
    CORBA::ULong length,
    PortableServer::POA* *value,
    CORBA::Boolean release)
  : TAO_Unbounded_Base_Sequence (maximum, length, value, release)
  {
  }

  ACE_INLINE
  PortableServer::_TAO_Unbounded_Object_Sequence_PortableServer_POAList::_TAO_Unbounded_Object_Sequence_PortableServer_POAList(const _TAO_Unbounded_Object_Sequence_PortableServer_POAList &rhs)
    : TAO_Unbounded_Base_Sequence (rhs)
  {
    if (rhs.buffer_ != 0)
    {
      PortableServer::POA **tmp1 = _TAO_Unbounded_Object_Sequence_PortableServer_POAList::allocbuf (this->maximum_);
      PortableServer::POA ** const tmp2 = ACE_reinterpret_cast (PortableServer::POA ** ACE_CAST_CONST, rhs.buffer_);

      for (CORBA::ULong i = 0; i < rhs.length_; ++i)
        tmp1[i] = PortableServer::POA::_duplicate (tmp2[i]);

      this->buffer_ = tmp1;
    }
    else
    {
      this->buffer_ = 0;
    }
  }

  ACE_INLINE PortableServer::_TAO_Unbounded_Object_Sequence_PortableServer_POAList &
  PortableServer::_TAO_Unbounded_Object_Sequence_PortableServer_POAList::operator= (const _TAO_Unbounded_Object_Sequence_PortableServer_POAList &rhs)
  {
    if (this == &rhs)
      return *this;

    if (this->release_)
    {
      PortableServer::POA **tmp = ACE_reinterpret_cast (PortableServer::POA **, this->buffer_);

      for (CORBA::ULong i = 0; i < this->length_; ++i)
      {
        CORBA::release (tmp[i]);
        tmp[i] = PortableServer::POA::_nil ();
      }
      if (this->maximum_ < rhs.maximum_)
      {
        _TAO_Unbounded_Object_Sequence_PortableServer_POAList::freebuf (tmp);
        this->buffer_ = _TAO_Unbounded_Object_Sequence_PortableServer_POAList::allocbuf (rhs.maximum_);
      }
    }
    else
      this->buffer_ = _TAO_Unbounded_Object_Sequence_PortableServer_POAList::allocbuf (rhs.maximum_);

    TAO_Unbounded_Base_Sequence::operator= (rhs);

    PortableServer::POA **tmp1 = ACE_reinterpret_cast (PortableServer::POA **, this->buffer_);
    PortableServer::POA ** const tmp2 = ACE_reinterpret_cast (PortableServer::POA ** ACE_CAST_CONST, rhs.buffer_);

    for (CORBA::ULong i = 0; i < rhs.length_; ++i)
      tmp1[i] = PortableServer::POA::_duplicate (tmp2[i]);

    return *this;
  }

  ACE_INLINE TAO_Object_Manager<PortableServer::POA,PortableServer::POA_var>
  PortableServer::_TAO_Unbounded_Object_Sequence_PortableServer_POAList::operator[] (CORBA::ULong index) const
  // read-write accessor
  {
    ACE_ASSERT (index < this->maximum_);
    PortableServer::POA ** const tmp = ACE_reinterpret_cast (PortableServer::POA ** ACE_CAST_CONST, this->buffer_);
    return TAO_Object_Manager<PortableServer::POA,PortableServer::POA_var> (tmp + index, this->release_);
  }

  ACE_INLINE PortableServer::POA* *
  PortableServer::_TAO_Unbounded_Object_Sequence_PortableServer_POAList::get_buffer (CORBA::Boolean orphan)
  {
    PortableServer::POA **result = 0;
    if (orphan == 0)
    {
      // We retain ownership.
      if (this->buffer_ == 0)
      {
        result = _TAO_Unbounded_Object_Sequence_PortableServer_POAList::allocbuf (this->maximum_);
        this->buffer_ = result;
        this->release_ = 1;
      }
      else
      {
        result = ACE_reinterpret_cast (PortableServer::POA**, this->buffer_);
      }
    }
    else // if (orphan == 1)
    {
      if (this->release_ != 0)
      {
        // We set the state back to default and relinquish
        // ownership.
        result = ACE_reinterpret_cast(PortableServer::POA**,this->buffer_);
        this->maximum_ = 0;
        this->length_ = 0;
        this->buffer_ = 0;
        this->release_ = 0;
      }
    }
    return result;
  }

  ACE_INLINE const PortableServer::POA* *
  PortableServer::_TAO_Unbounded_Object_Sequence_PortableServer_POAList::get_buffer (void) const
  {
    return ACE_reinterpret_cast(const PortableServer::POA ** ACE_CAST_CONST, this->buffer_);
  }


#endif /* end #if !defined */


#endif /* !TAO_USE_SEQUENCE_TEMPLATES */

#if !defined (_PORTABLESERVER_POALIST_CI_)
#define _PORTABLESERVER_POALIST_CI_

// *************************************************************
// Inline operations for class PortableServer::POAList_var
// *************************************************************

ACE_INLINE
PortableServer::POAList_var::POAList_var (void) // default constructor
  : ptr_ (0)
{}

ACE_INLINE
PortableServer::POAList_var::POAList_var (POAList *p)
  : ptr_ (p)
{}

ACE_INLINE
PortableServer::POAList_var::POAList_var (const ::PortableServer::POAList_var &p) // copy constructor
{
  if (p.ptr_)
    ACE_NEW (this->ptr_, ::PortableServer::POAList (*p.ptr_));
  else
    this->ptr_ = 0;
}

ACE_INLINE
PortableServer::POAList_var::~POAList_var (void) // destructor
{
  delete this->ptr_;
}

ACE_INLINE PortableServer::POAList_var &
PortableServer::POAList_var::operator= (POAList *p)
{
  delete this->ptr_;
  this->ptr_ = p;
  return *this;
}

ACE_INLINE PortableServer::POAList_var &
PortableServer::POAList_var::operator= (const ::PortableServer::POAList_var &p) // deep copy
{
  if (this != &p)
    {
      if (p.ptr_ == 0)
        {
          delete this->ptr_;
          this->ptr_ = 0;
        }
      else
        {
          PortableServer::POAList *deep_copy = 
            new PortableServer::POAList (*p.ptr_);
          
          if (deep_copy != 0)
            {
              PortableServer::POAList *tmp = deep_copy;
              deep_copy = this->ptr_;
              this->ptr_ = tmp;
              delete deep_copy;
            }
        }
    }
  
  return *this;
}

ACE_INLINE const ::PortableServer::POAList *
PortableServer::POAList_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE ::PortableServer::POAList *
PortableServer::POAList_var::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE
PortableServer::POAList_var::operator const ::PortableServer::POAList &() const // cast
{
  return *this->ptr_;
}

ACE_INLINE
PortableServer::POAList_var::operator ::PortableServer::POAList &() // cast
{
  return *this->ptr_;
}

ACE_INLINE
PortableServer::POAList_var::operator ::PortableServer::POAList &() const // cast
{
  return *this->ptr_;
}

// variable-size types only
ACE_INLINE
PortableServer::POAList_var::operator ::PortableServer::POAList *&() // cast
{
  return this->ptr_;
}

ACE_INLINE TAO_Object_Manager<PortableServer::POA, PortableServer::POA_var>
PortableServer::POAList_var::operator[] (CORBA::ULong index)
{
  return this->ptr_->operator[] (index);
}

ACE_INLINE const ::PortableServer::POAList &
PortableServer::POAList_var::in (void) const
{
  return *this->ptr_;
}

ACE_INLINE ::PortableServer::POAList &
PortableServer::POAList_var::inout (void)
{
  return *this->ptr_;
}

// mapping for variable size
ACE_INLINE ::PortableServer::POAList *&
PortableServer::POAList_var::out (void)
{
  delete this->ptr_;
  this->ptr_ = 0;
  return this->ptr_;
}

ACE_INLINE ::PortableServer::POAList *
PortableServer::POAList_var::_retn (void)
{
  ::PortableServer::POAList *tmp = this->ptr_;
  this->ptr_ = 0;
  return tmp;
}

ACE_INLINE ::PortableServer::POAList *
PortableServer::POAList_var::ptr (void) const
{
  return this->ptr_;
}

// *************************************************************
// Inline operations for class PortableServer::POAList_out
// *************************************************************

ACE_INLINE
PortableServer::POAList_out::POAList_out (POAList *&p)
  : ptr_ (p)
{
  this->ptr_ = 0;
}

ACE_INLINE
PortableServer::POAList_out::POAList_out (POAList_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  delete this->ptr_;
  this->ptr_ = 0;
}

ACE_INLINE
PortableServer::POAList_out::POAList_out (const ::PortableServer::POAList_out &p) // copy constructor
  : ptr_ (ACE_const_cast (POAList_out&, p).ptr_)
{}

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

ACE_INLINE ::PortableServer::POAList_out &
PortableServer::POAList_out::operator= (POAList *p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE
PortableServer::POAList_out::operator ::PortableServer::POAList *&() // cast
{
  return this->ptr_;
}

ACE_INLINE ::PortableServer::POAList *&
PortableServer::POAList_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE ::PortableServer::POAList *
PortableServer::POAList_out::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE TAO_Object_Manager<PortableServer::POA, PortableServer::POA_var>
PortableServer::POAList_out::operator[] (CORBA::ULong index)
{
  return this->ptr_->operator[] (index);
}


#endif /* end #if !defined */


#if !defined (_PORTABLESERVER_OBJECTID_CI_)
#define _PORTABLESERVER_OBJECTID_CI_

// *************************************************************
// Inline operations for class PortableServer::ObjectId_var
// *************************************************************

ACE_INLINE
PortableServer::ObjectId_var::ObjectId_var (void) // default constructor
  : ptr_ (0)
{}

ACE_INLINE
PortableServer::ObjectId_var::ObjectId_var (ObjectId *p)
  : ptr_ (p)
{}

ACE_INLINE
PortableServer::ObjectId_var::ObjectId_var (const ::PortableServer::ObjectId_var &p) // copy constructor
{
  if (p.ptr_)
    ACE_NEW (this->ptr_, ::PortableServer::ObjectId (*p.ptr_));
  else
    this->ptr_ = 0;
}

// fixed-size base types only
ACE_INLINE
PortableServer::ObjectId_var::ObjectId_var (const ::PortableServer::ObjectId &p)
{
  ACE_NEW (this->ptr_, ::PortableServer::ObjectId (p));
}

ACE_INLINE
PortableServer::ObjectId_var::~ObjectId_var (void) // destructor
{
  delete this->ptr_;
}

ACE_INLINE PortableServer::ObjectId_var &
PortableServer::ObjectId_var::operator= (ObjectId *p)
{
  delete this->ptr_;
  this->ptr_ = p;
  return *this;
}

ACE_INLINE PortableServer::ObjectId_var &
PortableServer::ObjectId_var::operator= (const ::PortableServer::ObjectId_var &p) // deep copy
{
  if (this != &p)
    {
      if (p.ptr_ == 0)
        {
          delete this->ptr_;
          this->ptr_ = 0;
        }
      else
        {
          PortableServer::ObjectId *deep_copy = 
            new PortableServer::ObjectId (*p.ptr_);
          
          if (deep_copy != 0)
            {
              PortableServer::ObjectId *tmp = deep_copy;
              deep_copy = this->ptr_;
              this->ptr_ = tmp;
              delete deep_copy;
            }
        }
    }
  
  return *this;
}

// fixed-size types only
ACE_INLINE ::PortableServer::ObjectId_var &
PortableServer::ObjectId_var::operator= (const ::PortableServer::ObjectId &p)
{
  if (this->ptr_ != &p)
  {
    delete this->ptr_;
    ACE_NEW_RETURN (this->ptr_, ::PortableServer::ObjectId (p), *this);
  }
  return *this;
}

ACE_INLINE const ::PortableServer::ObjectId *
PortableServer::ObjectId_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE ::PortableServer::ObjectId *
PortableServer::ObjectId_var::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE
PortableServer::ObjectId_var::operator const ::PortableServer::ObjectId &() const // cast
{
  return *this->ptr_;
}

ACE_INLINE
PortableServer::ObjectId_var::operator ::PortableServer::ObjectId &() // cast
{
  return *this->ptr_;
}

ACE_INLINE
PortableServer::ObjectId_var::operator ::PortableServer::ObjectId &() const // cast
{
  return *this->ptr_;
}

ACE_INLINE CORBA::Octet &
PortableServer::ObjectId_var::operator[] (CORBA::ULong index)
{
  return this->ptr_->operator[] (index);
}

ACE_INLINE const ::PortableServer::ObjectId &
PortableServer::ObjectId_var::in (void) const
{
  return *this->ptr_;
}

ACE_INLINE ::PortableServer::ObjectId &
PortableServer::ObjectId_var::inout (void)
{
  return *this->ptr_;
}

// mapping for variable size
ACE_INLINE ::PortableServer::ObjectId *&
PortableServer::ObjectId_var::out (void)
{
  delete this->ptr_;
  this->ptr_ = 0;
  return this->ptr_;
}

ACE_INLINE ::PortableServer::ObjectId *
PortableServer::ObjectId_var::_retn (void)
{
  ::PortableServer::ObjectId *tmp = this->ptr_;
  this->ptr_ = 0;
  return tmp;
}

ACE_INLINE ::PortableServer::ObjectId *
PortableServer::ObjectId_var::ptr (void) const
{
  return this->ptr_;
}

// *************************************************************
// Inline operations for class PortableServer::ObjectId_out
// *************************************************************

ACE_INLINE
PortableServer::ObjectId_out::ObjectId_out (ObjectId *&p)
  : ptr_ (p)
{
  this->ptr_ = 0;
}

ACE_INLINE
PortableServer::ObjectId_out::ObjectId_out (ObjectId_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  delete this->ptr_;
  this->ptr_ = 0;
}

ACE_INLINE
PortableServer::ObjectId_out::ObjectId_out (const ::PortableServer::ObjectId_out &p) // copy constructor
  : ptr_ (ACE_const_cast (ObjectId_out&, p).ptr_)
{}

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

ACE_INLINE ::PortableServer::ObjectId_out &
PortableServer::ObjectId_out::operator= (ObjectId *p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE
PortableServer::ObjectId_out::operator ::PortableServer::ObjectId *&() // cast
{
  return this->ptr_;
}

ACE_INLINE ::PortableServer::ObjectId *&
PortableServer::ObjectId_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE ::PortableServer::ObjectId *
PortableServer::ObjectId_out::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE CORBA::Octet &
PortableServer::ObjectId_out::operator[] (CORBA::ULong index)
{
  return this->ptr_->operator[] (index);
}


#endif /* end #if !defined */

// *************************************************************
// Inline operations for exception PortableServer::ForwardRequest
// *************************************************************


#if (TAO_HAS_MINIMUM_POA == 0)

#if !defined (_PORTABLESERVER_THREADPOLICY___VAR_CI_)
#define _PORTABLESERVER_THREADPOLICY___VAR_CI_

// *************************************************************
// Inline operations for class PortableServer::ThreadPolicy_var
// *************************************************************

ACE_INLINE
PortableServer::ThreadPolicy_var::ThreadPolicy_var (void) // default constructor
  : ptr_ (ThreadPolicy::_nil ())
{}

ACE_INLINE ::PortableServer::ThreadPolicy_ptr
PortableServer::ThreadPolicy_var::ptr (void) const
{
  return this->ptr_;
}

ACE_INLINE
PortableServer::ThreadPolicy_var::ThreadPolicy_var (const ::PortableServer::ThreadPolicy_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (ThreadPolicy::_duplicate (p.ptr ()))
{}

ACE_INLINE
PortableServer::ThreadPolicy_var::~ThreadPolicy_var (void) // destructor
{
  CORBA::release (this->ptr_);
}

ACE_INLINE PortableServer::ThreadPolicy_var &
PortableServer::ThreadPolicy_var::operator= (ThreadPolicy_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

ACE_INLINE PortableServer::ThreadPolicy_var &
PortableServer::ThreadPolicy_var::operator= (const ::PortableServer::ThreadPolicy_var &p)
{
  if (this != &p)
  {
    CORBA::release (this->ptr_);
    this->ptr_ = ::PortableServer::ThreadPolicy::_duplicate (p.ptr ());
  }
  return *this;
}

ACE_INLINE
PortableServer::ThreadPolicy_var::operator const ::PortableServer::ThreadPolicy_ptr &() const // cast
{
  return this->ptr_;
}

ACE_INLINE
PortableServer::ThreadPolicy_var::operator ::PortableServer::ThreadPolicy_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE ::PortableServer::ThreadPolicy_ptr
PortableServer::ThreadPolicy_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE ::PortableServer::ThreadPolicy_ptr
PortableServer::ThreadPolicy_var::in (void) const
{
  return this->ptr_;
}

ACE_INLINE ::PortableServer::ThreadPolicy_ptr &
PortableServer::ThreadPolicy_var::inout (void)
{
  return this->ptr_;
}

ACE_INLINE ::PortableServer::ThreadPolicy_ptr &
PortableServer::ThreadPolicy_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::PortableServer::ThreadPolicy::_nil ();
  return this->ptr_;
}

ACE_INLINE ::PortableServer::ThreadPolicy_ptr
PortableServer::ThreadPolicy_var::_retn (void)
{
  // yield ownership of managed obj reference
  ::PortableServer::ThreadPolicy_ptr val = this->ptr_;
  this->ptr_ = ::PortableServer::ThreadPolicy::_nil ();
  return val;
}


#endif /* end #if !defined */


#if !defined (_PORTABLESERVER_THREADPOLICY___OUT_CI_)
#define _PORTABLESERVER_THREADPOLICY___OUT_CI_

// *************************************************************
// Inline operations for class PortableServer::ThreadPolicy_out
// *************************************************************

ACE_INLINE
PortableServer::ThreadPolicy_out::ThreadPolicy_out (ThreadPolicy_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::PortableServer::ThreadPolicy::_nil ();
}

ACE_INLINE
PortableServer::ThreadPolicy_out::ThreadPolicy_out (ThreadPolicy_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::PortableServer::ThreadPolicy::_nil ();
}

ACE_INLINE
PortableServer::ThreadPolicy_out::ThreadPolicy_out (const ::PortableServer::ThreadPolicy_out &p) // copy constructor
  : ptr_ (ACE_const_cast (ThreadPolicy_out &, p).ptr_)
{}

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

ACE_INLINE PortableServer::ThreadPolicy_out &
PortableServer::ThreadPolicy_out::operator= (const ::PortableServer::ThreadPolicy_var &p)
{
  this->ptr_ = ::PortableServer::ThreadPolicy::_duplicate (p.ptr ());
  return *this;
}

ACE_INLINE PortableServer::ThreadPolicy_out &
PortableServer::ThreadPolicy_out::operator= (ThreadPolicy_ptr p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE
PortableServer::ThreadPolicy_out::operator ::PortableServer::ThreadPolicy_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE ::PortableServer::ThreadPolicy_ptr &
PortableServer::ThreadPolicy_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE ::PortableServer::ThreadPolicy_ptr
PortableServer::ThreadPolicy_out::operator-> (void)
{
  return this->ptr_;
}


#endif /* end #if !defined */

#endif /* TAO_HAS_MINIMUM_POA == 0 */

#if !defined (_PORTABLESERVER_LIFESPANPOLICY___VAR_CI_)
#define _PORTABLESERVER_LIFESPANPOLICY___VAR_CI_

// *************************************************************
// Inline operations for class PortableServer::LifespanPolicy_var
// *************************************************************

ACE_INLINE
PortableServer::LifespanPolicy_var::LifespanPolicy_var (void) // default constructor
  : ptr_ (LifespanPolicy::_nil ())
{}

ACE_INLINE ::PortableServer::LifespanPolicy_ptr
PortableServer::LifespanPolicy_var::ptr (void) const
{
  return this->ptr_;
}

ACE_INLINE
PortableServer::LifespanPolicy_var::LifespanPolicy_var (const ::PortableServer::LifespanPolicy_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (LifespanPolicy::_duplicate (p.ptr ()))
{}

ACE_INLINE
PortableServer::LifespanPolicy_var::~LifespanPolicy_var (void) // destructor
{
  CORBA::release (this->ptr_);
}

ACE_INLINE PortableServer::LifespanPolicy_var &
PortableServer::LifespanPolicy_var::operator= (LifespanPolicy_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

ACE_INLINE PortableServer::LifespanPolicy_var &
PortableServer::LifespanPolicy_var::operator= (const ::PortableServer::LifespanPolicy_var &p)
{
  if (this != &p)
  {
    CORBA::release (this->ptr_);
    this->ptr_ = ::PortableServer::LifespanPolicy::_duplicate (p.ptr ());
  }
  return *this;
}

ACE_INLINE
PortableServer::LifespanPolicy_var::operator const ::PortableServer::LifespanPolicy_ptr &() const // cast
{
  return this->ptr_;
}

ACE_INLINE
PortableServer::LifespanPolicy_var::operator ::PortableServer::LifespanPolicy_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE ::PortableServer::LifespanPolicy_ptr
PortableServer::LifespanPolicy_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE ::PortableServer::LifespanPolicy_ptr
PortableServer::LifespanPolicy_var::in (void) const
{
  return this->ptr_;
}

ACE_INLINE ::PortableServer::LifespanPolicy_ptr &
PortableServer::LifespanPolicy_var::inout (void)
{
  return this->ptr_;
}

ACE_INLINE ::PortableServer::LifespanPolicy_ptr &
PortableServer::LifespanPolicy_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::PortableServer::LifespanPolicy::_nil ();
  return this->ptr_;
}

ACE_INLINE ::PortableServer::LifespanPolicy_ptr
PortableServer::LifespanPolicy_var::_retn (void)
{
  // yield ownership of managed obj reference
  ::PortableServer::LifespanPolicy_ptr val = this->ptr_;
  this->ptr_ = ::PortableServer::LifespanPolicy::_nil ();
  return val;
}


#endif /* end #if !defined */


#if !defined (_PORTABLESERVER_LIFESPANPOLICY___OUT_CI_)
#define _PORTABLESERVER_LIFESPANPOLICY___OUT_CI_

// *************************************************************
// Inline operations for class PortableServer::LifespanPolicy_out
// *************************************************************

ACE_INLINE
PortableServer::LifespanPolicy_out::LifespanPolicy_out (LifespanPolicy_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::PortableServer::LifespanPolicy::_nil ();
}

ACE_INLINE
PortableServer::LifespanPolicy_out::LifespanPolicy_out (LifespanPolicy_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::PortableServer::LifespanPolicy::_nil ();
}

ACE_INLINE
PortableServer::LifespanPolicy_out::LifespanPolicy_out (const ::PortableServer::LifespanPolicy_out &p) // copy constructor
  : ptr_ (ACE_const_cast (LifespanPolicy_out &, p).ptr_)
{}

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

ACE_INLINE PortableServer::LifespanPolicy_out &
PortableServer::LifespanPolicy_out::operator= (const ::PortableServer::LifespanPolicy_var &p)
{
  this->ptr_ = ::PortableServer::LifespanPolicy::_duplicate (p.ptr ());
  return *this;
}

ACE_INLINE PortableServer::LifespanPolicy_out &
PortableServer::LifespanPolicy_out::operator= (LifespanPolicy_ptr p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE
PortableServer::LifespanPolicy_out::operator ::PortableServer::LifespanPolicy_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE ::PortableServer::LifespanPolicy_ptr &
PortableServer::LifespanPolicy_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE ::PortableServer::LifespanPolicy_ptr
PortableServer::LifespanPolicy_out::operator-> (void)
{
  return this->ptr_;
}


#endif /* end #if !defined */


#if !defined (_PORTABLESERVER_IDUNIQUENESSPOLICY___VAR_CI_)
#define _PORTABLESERVER_IDUNIQUENESSPOLICY___VAR_CI_

// *************************************************************
// Inline operations for class PortableServer::IdUniquenessPolicy_var
// *************************************************************

ACE_INLINE
PortableServer::IdUniquenessPolicy_var::IdUniquenessPolicy_var (void) // default constructor
  : ptr_ (IdUniquenessPolicy::_nil ())
{}

ACE_INLINE ::PortableServer::IdUniquenessPolicy_ptr
PortableServer::IdUniquenessPolicy_var::ptr (void) const
{
  return this->ptr_;
}

ACE_INLINE
PortableServer::IdUniquenessPolicy_var::IdUniquenessPolicy_var (const ::PortableServer::IdUniquenessPolicy_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (IdUniquenessPolicy::_duplicate (p.ptr ()))
{}

ACE_INLINE
PortableServer::IdUniquenessPolicy_var::~IdUniquenessPolicy_var (void) // destructor
{
  CORBA::release (this->ptr_);
}

ACE_INLINE PortableServer::IdUniquenessPolicy_var &
PortableServer::IdUniquenessPolicy_var::operator= (IdUniquenessPolicy_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

ACE_INLINE PortableServer::IdUniquenessPolicy_var &
PortableServer::IdUniquenessPolicy_var::operator= (const ::PortableServer::IdUniquenessPolicy_var &p)
{
  if (this != &p)
  {
    CORBA::release (this->ptr_);
    this->ptr_ = ::PortableServer::IdUniquenessPolicy::_duplicate (p.ptr ());
  }
  return *this;
}

ACE_INLINE
PortableServer::IdUniquenessPolicy_var::operator const ::PortableServer::IdUniquenessPolicy_ptr &() const // cast
{
  return this->ptr_;
}

ACE_INLINE
PortableServer::IdUniquenessPolicy_var::operator ::PortableServer::IdUniquenessPolicy_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE ::PortableServer::IdUniquenessPolicy_ptr
PortableServer::IdUniquenessPolicy_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE ::PortableServer::IdUniquenessPolicy_ptr
PortableServer::IdUniquenessPolicy_var::in (void) const
{
  return this->ptr_;
}

ACE_INLINE ::PortableServer::IdUniquenessPolicy_ptr &
PortableServer::IdUniquenessPolicy_var::inout (void)
{
  return this->ptr_;
}

ACE_INLINE ::PortableServer::IdUniquenessPolicy_ptr &
PortableServer::IdUniquenessPolicy_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::PortableServer::IdUniquenessPolicy::_nil ();
  return this->ptr_;
}

ACE_INLINE ::PortableServer::IdUniquenessPolicy_ptr
PortableServer::IdUniquenessPolicy_var::_retn (void)
{
  // yield ownership of managed obj reference
  ::PortableServer::IdUniquenessPolicy_ptr val = this->ptr_;
  this->ptr_ = ::PortableServer::IdUniquenessPolicy::_nil ();
  return val;
}


#endif /* end #if !defined */


#if !defined (_PORTABLESERVER_IDUNIQUENESSPOLICY___OUT_CI_)
#define _PORTABLESERVER_IDUNIQUENESSPOLICY___OUT_CI_

// *************************************************************
// Inline operations for class PortableServer::IdUniquenessPolicy_out
// *************************************************************

ACE_INLINE
PortableServer::IdUniquenessPolicy_out::IdUniquenessPolicy_out (IdUniquenessPolicy_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::PortableServer::IdUniquenessPolicy::_nil ();
}

ACE_INLINE
PortableServer::IdUniquenessPolicy_out::IdUniquenessPolicy_out (IdUniquenessPolicy_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::PortableServer::IdUniquenessPolicy::_nil ();
}

ACE_INLINE
PortableServer::IdUniquenessPolicy_out::IdUniquenessPolicy_out (const ::PortableServer::IdUniquenessPolicy_out &p) // copy constructor
  : ptr_ (ACE_const_cast (IdUniquenessPolicy_out &, p).ptr_)
{}

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

ACE_INLINE PortableServer::IdUniquenessPolicy_out &
PortableServer::IdUniquenessPolicy_out::operator= (const ::PortableServer::IdUniquenessPolicy_var &p)
{
  this->ptr_ = ::PortableServer::IdUniquenessPolicy::_duplicate (p.ptr ());
  return *this;
}

ACE_INLINE PortableServer::IdUniquenessPolicy_out &
PortableServer::IdUniquenessPolicy_out::operator= (IdUniquenessPolicy_ptr p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE
PortableServer::IdUniquenessPolicy_out::operator ::PortableServer::IdUniquenessPolicy_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE ::PortableServer::IdUniquenessPolicy_ptr &
PortableServer::IdUniquenessPolicy_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE ::PortableServer::IdUniquenessPolicy_ptr
PortableServer::IdUniquenessPolicy_out::operator-> (void)
{
  return this->ptr_;
}


#endif /* end #if !defined */


#if !defined (_PORTABLESERVER_IDASSIGNMENTPOLICY___VAR_CI_)
#define _PORTABLESERVER_IDASSIGNMENTPOLICY___VAR_CI_

// *************************************************************
// Inline operations for class PortableServer::IdAssignmentPolicy_var
// *************************************************************

ACE_INLINE
PortableServer::IdAssignmentPolicy_var::IdAssignmentPolicy_var (void) // default constructor
  : ptr_ (IdAssignmentPolicy::_nil ())
{}

ACE_INLINE ::PortableServer::IdAssignmentPolicy_ptr
PortableServer::IdAssignmentPolicy_var::ptr (void) const
{
  return this->ptr_;
}

ACE_INLINE
PortableServer::IdAssignmentPolicy_var::IdAssignmentPolicy_var (const ::PortableServer::IdAssignmentPolicy_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (IdAssignmentPolicy::_duplicate (p.ptr ()))
{}

ACE_INLINE
PortableServer::IdAssignmentPolicy_var::~IdAssignmentPolicy_var (void) // destructor
{
  CORBA::release (this->ptr_);
}

ACE_INLINE PortableServer::IdAssignmentPolicy_var &
PortableServer::IdAssignmentPolicy_var::operator= (IdAssignmentPolicy_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

ACE_INLINE PortableServer::IdAssignmentPolicy_var &
PortableServer::IdAssignmentPolicy_var::operator= (const ::PortableServer::IdAssignmentPolicy_var &p)
{
  if (this != &p)
  {
    CORBA::release (this->ptr_);
    this->ptr_ = ::PortableServer::IdAssignmentPolicy::_duplicate (p.ptr ());
  }
  return *this;
}

ACE_INLINE
PortableServer::IdAssignmentPolicy_var::operator const ::PortableServer::IdAssignmentPolicy_ptr &() const // cast
{
  return this->ptr_;
}

ACE_INLINE
PortableServer::IdAssignmentPolicy_var::operator ::PortableServer::IdAssignmentPolicy_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE ::PortableServer::IdAssignmentPolicy_ptr
PortableServer::IdAssignmentPolicy_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE ::PortableServer::IdAssignmentPolicy_ptr
PortableServer::IdAssignmentPolicy_var::in (void) const
{
  return this->ptr_;
}

ACE_INLINE ::PortableServer::IdAssignmentPolicy_ptr &
PortableServer::IdAssignmentPolicy_var::inout (void)
{
  return this->ptr_;
}

ACE_INLINE ::PortableServer::IdAssignmentPolicy_ptr &
PortableServer::IdAssignmentPolicy_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::PortableServer::IdAssignmentPolicy::_nil ();
  return this->ptr_;
}

ACE_INLINE ::PortableServer::IdAssignmentPolicy_ptr
PortableServer::IdAssignmentPolicy_var::_retn (void)
{
  // yield ownership of managed obj reference
  ::PortableServer::IdAssignmentPolicy_ptr val = this->ptr_;
  this->ptr_ = ::PortableServer::IdAssignmentPolicy::_nil ();
  return val;
}


#endif /* end #if !defined */


#if !defined (_PORTABLESERVER_IDASSIGNMENTPOLICY___OUT_CI_)
#define _PORTABLESERVER_IDASSIGNMENTPOLICY___OUT_CI_

// *************************************************************
// Inline operations for class PortableServer::IdAssignmentPolicy_out
// *************************************************************

ACE_INLINE
PortableServer::IdAssignmentPolicy_out::IdAssignmentPolicy_out (IdAssignmentPolicy_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::PortableServer::IdAssignmentPolicy::_nil ();
}

ACE_INLINE
PortableServer::IdAssignmentPolicy_out::IdAssignmentPolicy_out (IdAssignmentPolicy_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::PortableServer::IdAssignmentPolicy::_nil ();
}

ACE_INLINE
PortableServer::IdAssignmentPolicy_out::IdAssignmentPolicy_out (const ::PortableServer::IdAssignmentPolicy_out &p) // copy constructor
  : ptr_ (ACE_const_cast (IdAssignmentPolicy_out &, p).ptr_)
{}

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

ACE_INLINE PortableServer::IdAssignmentPolicy_out &
PortableServer::IdAssignmentPolicy_out::operator= (const ::PortableServer::IdAssignmentPolicy_var &p)
{
  this->ptr_ = ::PortableServer::IdAssignmentPolicy::_duplicate (p.ptr ());
  return *this;
}

ACE_INLINE PortableServer::IdAssignmentPolicy_out &
PortableServer::IdAssignmentPolicy_out::operator= (IdAssignmentPolicy_ptr p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE
PortableServer::IdAssignmentPolicy_out::operator ::PortableServer::IdAssignmentPolicy_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE ::PortableServer::IdAssignmentPolicy_ptr &
PortableServer::IdAssignmentPolicy_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE ::PortableServer::IdAssignmentPolicy_ptr
PortableServer::IdAssignmentPolicy_out::operator-> (void)
{
  return this->ptr_;
}


#endif /* end #if !defined */

#if (TAO_HAS_MINIMUM_POA == 0)

#if !defined (_PORTABLESERVER_IMPLICITACTIVATIONPOLICY___VAR_CI_)
#define _PORTABLESERVER_IMPLICITACTIVATIONPOLICY___VAR_CI_

// *************************************************************
// Inline operations for class PortableServer::ImplicitActivationPolicy_var
// *************************************************************

ACE_INLINE
PortableServer::ImplicitActivationPolicy_var::ImplicitActivationPolicy_var (void) // default constructor
  : ptr_ (ImplicitActivationPolicy::_nil ())
{}

ACE_INLINE ::PortableServer::ImplicitActivationPolicy_ptr
PortableServer::ImplicitActivationPolicy_var::ptr (void) const
{
  return this->ptr_;
}

ACE_INLINE
PortableServer::ImplicitActivationPolicy_var::ImplicitActivationPolicy_var (const ::PortableServer::ImplicitActivationPolicy_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (ImplicitActivationPolicy::_duplicate (p.ptr ()))
{}

ACE_INLINE
PortableServer::ImplicitActivationPolicy_var::~ImplicitActivationPolicy_var (void) // destructor
{
  CORBA::release (this->ptr_);
}

ACE_INLINE PortableServer::ImplicitActivationPolicy_var &
PortableServer::ImplicitActivationPolicy_var::operator= (ImplicitActivationPolicy_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

ACE_INLINE PortableServer::ImplicitActivationPolicy_var &
PortableServer::ImplicitActivationPolicy_var::operator= (const ::PortableServer::ImplicitActivationPolicy_var &p)
{
  if (this != &p)
  {
    CORBA::release (this->ptr_);
    this->ptr_ = ::PortableServer::ImplicitActivationPolicy::_duplicate (p.ptr ());
  }
  return *this;
}

ACE_INLINE
PortableServer::ImplicitActivationPolicy_var::operator const ::PortableServer::ImplicitActivationPolicy_ptr &() const // cast
{
  return this->ptr_;
}

ACE_INLINE
PortableServer::ImplicitActivationPolicy_var::operator ::PortableServer::ImplicitActivationPolicy_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE ::PortableServer::ImplicitActivationPolicy_ptr
PortableServer::ImplicitActivationPolicy_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE ::PortableServer::ImplicitActivationPolicy_ptr
PortableServer::ImplicitActivationPolicy_var::in (void) const
{
  return this->ptr_;
}

ACE_INLINE ::PortableServer::ImplicitActivationPolicy_ptr &
PortableServer::ImplicitActivationPolicy_var::inout (void)
{
  return this->ptr_;
}

ACE_INLINE ::PortableServer::ImplicitActivationPolicy_ptr &
PortableServer::ImplicitActivationPolicy_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::PortableServer::ImplicitActivationPolicy::_nil ();
  return this->ptr_;
}

ACE_INLINE ::PortableServer::ImplicitActivationPolicy_ptr
PortableServer::ImplicitActivationPolicy_var::_retn (void)
{
  // yield ownership of managed obj reference
  ::PortableServer::ImplicitActivationPolicy_ptr val = this->ptr_;
  this->ptr_ = ::PortableServer::ImplicitActivationPolicy::_nil ();
  return val;
}


#endif /* end #if !defined */


#if !defined (_PORTABLESERVER_IMPLICITACTIVATIONPOLICY___OUT_CI_)
#define _PORTABLESERVER_IMPLICITACTIVATIONPOLICY___OUT_CI_

// *************************************************************
// Inline operations for class PortableServer::ImplicitActivationPolicy_out
// *************************************************************

ACE_INLINE
PortableServer::ImplicitActivationPolicy_out::ImplicitActivationPolicy_out (ImplicitActivationPolicy_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::PortableServer::ImplicitActivationPolicy::_nil ();
}

ACE_INLINE
PortableServer::ImplicitActivationPolicy_out::ImplicitActivationPolicy_out (ImplicitActivationPolicy_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::PortableServer::ImplicitActivationPolicy::_nil ();
}

ACE_INLINE
PortableServer::ImplicitActivationPolicy_out::ImplicitActivationPolicy_out (const ::PortableServer::ImplicitActivationPolicy_out &p) // copy constructor
  : ptr_ (ACE_const_cast (ImplicitActivationPolicy_out &, p).ptr_)
{}

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

ACE_INLINE PortableServer::ImplicitActivationPolicy_out &
PortableServer::ImplicitActivationPolicy_out::operator= (const ::PortableServer::ImplicitActivationPolicy_var &p)
{
  this->ptr_ = ::PortableServer::ImplicitActivationPolicy::_duplicate (p.ptr ());
  return *this;
}

ACE_INLINE PortableServer::ImplicitActivationPolicy_out &
PortableServer::ImplicitActivationPolicy_out::operator= (ImplicitActivationPolicy_ptr p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE
PortableServer::ImplicitActivationPolicy_out::operator ::PortableServer::ImplicitActivationPolicy_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE ::PortableServer::ImplicitActivationPolicy_ptr &
PortableServer::ImplicitActivationPolicy_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE ::PortableServer::ImplicitActivationPolicy_ptr
PortableServer::ImplicitActivationPolicy_out::operator-> (void)
{
  return this->ptr_;
}


#endif /* end #if !defined */


#if !defined (_PORTABLESERVER_SERVANTRETENTIONPOLICY___VAR_CI_)
#define _PORTABLESERVER_SERVANTRETENTIONPOLICY___VAR_CI_

// *************************************************************
// Inline operations for class PortableServer::ServantRetentionPolicy_var
// *************************************************************

ACE_INLINE
PortableServer::ServantRetentionPolicy_var::ServantRetentionPolicy_var (void) // default constructor
  : ptr_ (ServantRetentionPolicy::_nil ())
{}

ACE_INLINE ::PortableServer::ServantRetentionPolicy_ptr
PortableServer::ServantRetentionPolicy_var::ptr (void) const
{
  return this->ptr_;
}

ACE_INLINE
PortableServer::ServantRetentionPolicy_var::ServantRetentionPolicy_var (const ::PortableServer::ServantRetentionPolicy_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (ServantRetentionPolicy::_duplicate (p.ptr ()))
{}

ACE_INLINE
PortableServer::ServantRetentionPolicy_var::~ServantRetentionPolicy_var (void) // destructor
{
  CORBA::release (this->ptr_);
}

ACE_INLINE PortableServer::ServantRetentionPolicy_var &
PortableServer::ServantRetentionPolicy_var::operator= (ServantRetentionPolicy_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

ACE_INLINE PortableServer::ServantRetentionPolicy_var &
PortableServer::ServantRetentionPolicy_var::operator= (const ::PortableServer::ServantRetentionPolicy_var &p)
{
  if (this != &p)
  {
    CORBA::release (this->ptr_);
    this->ptr_ = ::PortableServer::ServantRetentionPolicy::_duplicate (p.ptr ());
  }
  return *this;
}

ACE_INLINE
PortableServer::ServantRetentionPolicy_var::operator const ::PortableServer::ServantRetentionPolicy_ptr &() const // cast
{
  return this->ptr_;
}

ACE_INLINE
PortableServer::ServantRetentionPolicy_var::operator ::PortableServer::ServantRetentionPolicy_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE ::PortableServer::ServantRetentionPolicy_ptr
PortableServer::ServantRetentionPolicy_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE ::PortableServer::ServantRetentionPolicy_ptr
PortableServer::ServantRetentionPolicy_var::in (void) const
{
  return this->ptr_;
}

ACE_INLINE ::PortableServer::ServantRetentionPolicy_ptr &
PortableServer::ServantRetentionPolicy_var::inout (void)
{
  return this->ptr_;
}

ACE_INLINE ::PortableServer::ServantRetentionPolicy_ptr &
PortableServer::ServantRetentionPolicy_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::PortableServer::ServantRetentionPolicy::_nil ();
  return this->ptr_;
}

ACE_INLINE ::PortableServer::ServantRetentionPolicy_ptr
PortableServer::ServantRetentionPolicy_var::_retn (void)
{
  // yield ownership of managed obj reference
  ::PortableServer::ServantRetentionPolicy_ptr val = this->ptr_;
  this->ptr_ = ::PortableServer::ServantRetentionPolicy::_nil ();
  return val;
}


#endif /* end #if !defined */


#if !defined (_PORTABLESERVER_SERVANTRETENTIONPOLICY___OUT_CI_)
#define _PORTABLESERVER_SERVANTRETENTIONPOLICY___OUT_CI_

// *************************************************************
// Inline operations for class PortableServer::ServantRetentionPolicy_out
// *************************************************************

ACE_INLINE
PortableServer::ServantRetentionPolicy_out::ServantRetentionPolicy_out (ServantRetentionPolicy_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::PortableServer::ServantRetentionPolicy::_nil ();
}

ACE_INLINE
PortableServer::ServantRetentionPolicy_out::ServantRetentionPolicy_out (ServantRetentionPolicy_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::PortableServer::ServantRetentionPolicy::_nil ();
}

ACE_INLINE
PortableServer::ServantRetentionPolicy_out::ServantRetentionPolicy_out (const ::PortableServer::ServantRetentionPolicy_out &p) // copy constructor
  : ptr_ (ACE_const_cast (ServantRetentionPolicy_out &, p).ptr_)
{}

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

ACE_INLINE PortableServer::ServantRetentionPolicy_out &
PortableServer::ServantRetentionPolicy_out::operator= (const ::PortableServer::ServantRetentionPolicy_var &p)
{
  this->ptr_ = ::PortableServer::ServantRetentionPolicy::_duplicate (p.ptr ());
  return *this;
}

ACE_INLINE PortableServer::ServantRetentionPolicy_out &
PortableServer::ServantRetentionPolicy_out::operator= (ServantRetentionPolicy_ptr p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE
PortableServer::ServantRetentionPolicy_out::operator ::PortableServer::ServantRetentionPolicy_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE ::PortableServer::ServantRetentionPolicy_ptr &
PortableServer::ServantRetentionPolicy_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE ::PortableServer::ServantRetentionPolicy_ptr
PortableServer::ServantRetentionPolicy_out::operator-> (void)
{
  return this->ptr_;
}


#endif /* end #if !defined */


#if !defined (_PORTABLESERVER_REQUESTPROCESSINGPOLICY___VAR_CI_)
#define _PORTABLESERVER_REQUESTPROCESSINGPOLICY___VAR_CI_

// *************************************************************
// Inline operations for class PortableServer::RequestProcessingPolicy_var
// *************************************************************

ACE_INLINE
PortableServer::RequestProcessingPolicy_var::RequestProcessingPolicy_var (void) // default constructor
  : ptr_ (RequestProcessingPolicy::_nil ())
{}

ACE_INLINE ::PortableServer::RequestProcessingPolicy_ptr
PortableServer::RequestProcessingPolicy_var::ptr (void) const
{
  return this->ptr_;
}

ACE_INLINE
PortableServer::RequestProcessingPolicy_var::RequestProcessingPolicy_var (const ::PortableServer::RequestProcessingPolicy_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (RequestProcessingPolicy::_duplicate (p.ptr ()))
{}

ACE_INLINE
PortableServer::RequestProcessingPolicy_var::~RequestProcessingPolicy_var (void) // destructor
{
  CORBA::release (this->ptr_);
}

ACE_INLINE PortableServer::RequestProcessingPolicy_var &
PortableServer::RequestProcessingPolicy_var::operator= (RequestProcessingPolicy_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

ACE_INLINE PortableServer::RequestProcessingPolicy_var &
PortableServer::RequestProcessingPolicy_var::operator= (const ::PortableServer::RequestProcessingPolicy_var &p)
{
  if (this != &p)
  {
    CORBA::release (this->ptr_);
    this->ptr_ = ::PortableServer::RequestProcessingPolicy::_duplicate (p.ptr ());
  }
  return *this;
}

ACE_INLINE
PortableServer::RequestProcessingPolicy_var::operator const ::PortableServer::RequestProcessingPolicy_ptr &() const // cast
{
  return this->ptr_;
}

ACE_INLINE
PortableServer::RequestProcessingPolicy_var::operator ::PortableServer::RequestProcessingPolicy_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE ::PortableServer::RequestProcessingPolicy_ptr
PortableServer::RequestProcessingPolicy_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE ::PortableServer::RequestProcessingPolicy_ptr
PortableServer::RequestProcessingPolicy_var::in (void) const
{
  return this->ptr_;
}

ACE_INLINE ::PortableServer::RequestProcessingPolicy_ptr &
PortableServer::RequestProcessingPolicy_var::inout (void)
{
  return this->ptr_;
}

ACE_INLINE ::PortableServer::RequestProcessingPolicy_ptr &
PortableServer::RequestProcessingPolicy_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::PortableServer::RequestProcessingPolicy::_nil ();
  return this->ptr_;
}

ACE_INLINE ::PortableServer::RequestProcessingPolicy_ptr
PortableServer::RequestProcessingPolicy_var::_retn (void)
{
  // yield ownership of managed obj reference
  ::PortableServer::RequestProcessingPolicy_ptr val = this->ptr_;
  this->ptr_ = ::PortableServer::RequestProcessingPolicy::_nil ();
  return val;
}


#endif /* end #if !defined */


#if !defined (_PORTABLESERVER_REQUESTPROCESSINGPOLICY___OUT_CI_)
#define _PORTABLESERVER_REQUESTPROCESSINGPOLICY___OUT_CI_

// *************************************************************
// Inline operations for class PortableServer::RequestProcessingPolicy_out
// *************************************************************

ACE_INLINE
PortableServer::RequestProcessingPolicy_out::RequestProcessingPolicy_out (RequestProcessingPolicy_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::PortableServer::RequestProcessingPolicy::_nil ();
}

ACE_INLINE
PortableServer::RequestProcessingPolicy_out::RequestProcessingPolicy_out (RequestProcessingPolicy_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::PortableServer::RequestProcessingPolicy::_nil ();
}

ACE_INLINE
PortableServer::RequestProcessingPolicy_out::RequestProcessingPolicy_out (const ::PortableServer::RequestProcessingPolicy_out &p) // copy constructor
  : ptr_ (ACE_const_cast (RequestProcessingPolicy_out &, p).ptr_)
{}

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

ACE_INLINE PortableServer::RequestProcessingPolicy_out &
PortableServer::RequestProcessingPolicy_out::operator= (const ::PortableServer::RequestProcessingPolicy_var &p)
{
  this->ptr_ = ::PortableServer::RequestProcessingPolicy::_duplicate (p.ptr ());
  return *this;
}

ACE_INLINE PortableServer::RequestProcessingPolicy_out &
PortableServer::RequestProcessingPolicy_out::operator= (RequestProcessingPolicy_ptr p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE
PortableServer::RequestProcessingPolicy_out::operator ::PortableServer::RequestProcessingPolicy_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE ::PortableServer::RequestProcessingPolicy_ptr &
PortableServer::RequestProcessingPolicy_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE ::PortableServer::RequestProcessingPolicy_ptr
PortableServer::RequestProcessingPolicy_out::operator-> (void)
{
  return this->ptr_;
}


#endif /* end #if !defined */

#endif /* TAO_HAS_MINIMUM_POA == 0 */

// *************************************************************
// Inline operations for exception PortableServer::POAManager::AdapterInactive
// *************************************************************


#if !defined (_PORTABLESERVER_POAMANAGER___VAR_CI_)
#define _PORTABLESERVER_POAMANAGER___VAR_CI_

// *************************************************************
// Inline operations for class PortableServer::POAManager_var
// *************************************************************

ACE_INLINE
PortableServer::POAManager_var::POAManager_var (void) // default constructor
  : ptr_ (POAManager::_nil ())
{}

ACE_INLINE ::PortableServer::POAManager_ptr
PortableServer::POAManager_var::ptr (void) const
{
  return this->ptr_;
}

ACE_INLINE
PortableServer::POAManager_var::POAManager_var (const ::PortableServer::POAManager_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (POAManager::_duplicate (p.ptr ()))
{}

ACE_INLINE
PortableServer::POAManager_var::~POAManager_var (void) // destructor
{
  CORBA::release (this->ptr_);
}

ACE_INLINE PortableServer::POAManager_var &
PortableServer::POAManager_var::operator= (POAManager_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

ACE_INLINE PortableServer::POAManager_var &
PortableServer::POAManager_var::operator= (const ::PortableServer::POAManager_var &p)
{
  if (this != &p)
  {
    CORBA::release (this->ptr_);
    this->ptr_ = ::PortableServer::POAManager::_duplicate (p.ptr ());
  }
  return *this;
}

ACE_INLINE
PortableServer::POAManager_var::operator const ::PortableServer::POAManager_ptr &() const // cast
{
  return this->ptr_;
}

ACE_INLINE
PortableServer::POAManager_var::operator ::PortableServer::POAManager_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE ::PortableServer::POAManager_ptr
PortableServer::POAManager_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE ::PortableServer::POAManager_ptr
PortableServer::POAManager_var::in (void) const
{
  return this->ptr_;
}

ACE_INLINE ::PortableServer::POAManager_ptr &
PortableServer::POAManager_var::inout (void)
{
  return this->ptr_;
}

ACE_INLINE ::PortableServer::POAManager_ptr &
PortableServer::POAManager_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::PortableServer::POAManager::_nil ();
  return this->ptr_;
}

ACE_INLINE ::PortableServer::POAManager_ptr
PortableServer::POAManager_var::_retn (void)
{
  // yield ownership of managed obj reference
  ::PortableServer::POAManager_ptr val = this->ptr_;
  this->ptr_ = ::PortableServer::POAManager::_nil ();
  return val;
}


#endif /* end #if !defined */


#if !defined (_PORTABLESERVER_POAMANAGER___OUT_CI_)
#define _PORTABLESERVER_POAMANAGER___OUT_CI_

// *************************************************************
// Inline operations for class PortableServer::POAManager_out
// *************************************************************

ACE_INLINE
PortableServer::POAManager_out::POAManager_out (POAManager_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::PortableServer::POAManager::_nil ();
}

ACE_INLINE
PortableServer::POAManager_out::POAManager_out (POAManager_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::PortableServer::POAManager::_nil ();
}

ACE_INLINE
PortableServer::POAManager_out::POAManager_out (const ::PortableServer::POAManager_out &p) // copy constructor
  : ptr_ (ACE_const_cast (POAManager_out &, p).ptr_)
{}

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

ACE_INLINE PortableServer::POAManager_out &
PortableServer::POAManager_out::operator= (const ::PortableServer::POAManager_var &p)
{
  this->ptr_ = ::PortableServer::POAManager::_duplicate (p.ptr ());
  return *this;
}

ACE_INLINE PortableServer::POAManager_out &
PortableServer::POAManager_out::operator= (POAManager_ptr p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE
PortableServer::POAManager_out::operator ::PortableServer::POAManager_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE ::PortableServer::POAManager_ptr &
PortableServer::POAManager_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE ::PortableServer::POAManager_ptr
PortableServer::POAManager_out::operator-> (void)
{
  return this->ptr_;
}


#endif /* end #if !defined */

#if (TAO_HAS_MINIMUM_POA == 0)

#if !defined (_PORTABLESERVER_ADAPTERACTIVATOR___VAR_CI_)
#define _PORTABLESERVER_ADAPTERACTIVATOR___VAR_CI_

// *************************************************************
// Inline operations for class PortableServer::AdapterActivator_var
// *************************************************************

ACE_INLINE
PortableServer::AdapterActivator_var::AdapterActivator_var (void) // default constructor
  : ptr_ (AdapterActivator::_nil ())
{}

ACE_INLINE ::PortableServer::AdapterActivator_ptr
PortableServer::AdapterActivator_var::ptr (void) const
{
  return this->ptr_;
}

ACE_INLINE
PortableServer::AdapterActivator_var::AdapterActivator_var (const ::PortableServer::AdapterActivator_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (AdapterActivator::_duplicate (p.ptr ()))
{}

ACE_INLINE
PortableServer::AdapterActivator_var::~AdapterActivator_var (void) // destructor
{
  CORBA::release (this->ptr_);
}

ACE_INLINE PortableServer::AdapterActivator_var &
PortableServer::AdapterActivator_var::operator= (AdapterActivator_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

ACE_INLINE PortableServer::AdapterActivator_var &
PortableServer::AdapterActivator_var::operator= (const ::PortableServer::AdapterActivator_var &p)
{
  if (this != &p)
  {
    CORBA::release (this->ptr_);
    this->ptr_ = ::PortableServer::AdapterActivator::_duplicate (p.ptr ());
  }
  return *this;
}

ACE_INLINE
PortableServer::AdapterActivator_var::operator const ::PortableServer::AdapterActivator_ptr &() const // cast
{
  return this->ptr_;
}

ACE_INLINE
PortableServer::AdapterActivator_var::operator ::PortableServer::AdapterActivator_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE ::PortableServer::AdapterActivator_ptr
PortableServer::AdapterActivator_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE ::PortableServer::AdapterActivator_ptr
PortableServer::AdapterActivator_var::in (void) const
{
  return this->ptr_;
}

ACE_INLINE ::PortableServer::AdapterActivator_ptr &
PortableServer::AdapterActivator_var::inout (void)
{
  return this->ptr_;
}

ACE_INLINE ::PortableServer::AdapterActivator_ptr &
PortableServer::AdapterActivator_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::PortableServer::AdapterActivator::_nil ();
  return this->ptr_;
}

ACE_INLINE ::PortableServer::AdapterActivator_ptr
PortableServer::AdapterActivator_var::_retn (void)
{
  // yield ownership of managed obj reference
  ::PortableServer::AdapterActivator_ptr val = this->ptr_;
  this->ptr_ = ::PortableServer::AdapterActivator::_nil ();
  return val;
}


#endif /* end #if !defined */


#if !defined (_PORTABLESERVER_ADAPTERACTIVATOR___OUT_CI_)
#define _PORTABLESERVER_ADAPTERACTIVATOR___OUT_CI_

// *************************************************************
// Inline operations for class PortableServer::AdapterActivator_out
// *************************************************************

ACE_INLINE
PortableServer::AdapterActivator_out::AdapterActivator_out (AdapterActivator_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::PortableServer::AdapterActivator::_nil ();
}

ACE_INLINE
PortableServer::AdapterActivator_out::AdapterActivator_out (AdapterActivator_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::PortableServer::AdapterActivator::_nil ();
}

ACE_INLINE
PortableServer::AdapterActivator_out::AdapterActivator_out (const ::PortableServer::AdapterActivator_out &p) // copy constructor
  : ptr_ (ACE_const_cast (AdapterActivator_out &, p).ptr_)
{}

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

ACE_INLINE PortableServer::AdapterActivator_out &
PortableServer::AdapterActivator_out::operator= (const ::PortableServer::AdapterActivator_var &p)
{
  this->ptr_ = ::PortableServer::AdapterActivator::_duplicate (p.ptr ());
  return *this;
}

ACE_INLINE PortableServer::AdapterActivator_out &
PortableServer::AdapterActivator_out::operator= (AdapterActivator_ptr p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE
PortableServer::AdapterActivator_out::operator ::PortableServer::AdapterActivator_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE ::PortableServer::AdapterActivator_ptr &
PortableServer::AdapterActivator_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE ::PortableServer::AdapterActivator_ptr
PortableServer::AdapterActivator_out::operator-> (void)
{
  return this->ptr_;
}


#endif /* end #if !defined */


#if !defined (_PORTABLESERVER_SERVANTMANAGER___VAR_CI_)
#define _PORTABLESERVER_SERVANTMANAGER___VAR_CI_

// *************************************************************
// Inline operations for class PortableServer::ServantManager_var
// *************************************************************

ACE_INLINE
PortableServer::ServantManager_var::ServantManager_var (void) // default constructor
  : ptr_ (ServantManager::_nil ())
{}

ACE_INLINE ::PortableServer::ServantManager_ptr
PortableServer::ServantManager_var::ptr (void) const
{
  return this->ptr_;
}

ACE_INLINE
PortableServer::ServantManager_var::ServantManager_var (const ::PortableServer::ServantManager_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (ServantManager::_duplicate (p.ptr ()))
{}

ACE_INLINE
PortableServer::ServantManager_var::~ServantManager_var (void) // destructor
{
  CORBA::release (this->ptr_);
}

ACE_INLINE PortableServer::ServantManager_var &
PortableServer::ServantManager_var::operator= (ServantManager_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

ACE_INLINE PortableServer::ServantManager_var &
PortableServer::ServantManager_var::operator= (const ::PortableServer::ServantManager_var &p)
{
  if (this != &p)
  {
    CORBA::release (this->ptr_);
    this->ptr_ = ::PortableServer::ServantManager::_duplicate (p.ptr ());
  }
  return *this;
}

ACE_INLINE
PortableServer::ServantManager_var::operator const ::PortableServer::ServantManager_ptr &() const // cast
{
  return this->ptr_;
}

ACE_INLINE
PortableServer::ServantManager_var::operator ::PortableServer::ServantManager_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE ::PortableServer::ServantManager_ptr
PortableServer::ServantManager_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE ::PortableServer::ServantManager_ptr
PortableServer::ServantManager_var::in (void) const
{
  return this->ptr_;
}

ACE_INLINE ::PortableServer::ServantManager_ptr &
PortableServer::ServantManager_var::inout (void)
{
  return this->ptr_;
}

ACE_INLINE ::PortableServer::ServantManager_ptr &
PortableServer::ServantManager_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::PortableServer::ServantManager::_nil ();
  return this->ptr_;
}

ACE_INLINE ::PortableServer::ServantManager_ptr
PortableServer::ServantManager_var::_retn (void)
{
  // yield ownership of managed obj reference
  ::PortableServer::ServantManager_ptr val = this->ptr_;
  this->ptr_ = ::PortableServer::ServantManager::_nil ();
  return val;
}


#endif /* end #if !defined */


#if !defined (_PORTABLESERVER_SERVANTMANAGER___OUT_CI_)
#define _PORTABLESERVER_SERVANTMANAGER___OUT_CI_

// *************************************************************
// Inline operations for class PortableServer::ServantManager_out
// *************************************************************

ACE_INLINE
PortableServer::ServantManager_out::ServantManager_out (ServantManager_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::PortableServer::ServantManager::_nil ();
}

ACE_INLINE
PortableServer::ServantManager_out::ServantManager_out (ServantManager_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::PortableServer::ServantManager::_nil ();
}

ACE_INLINE
PortableServer::ServantManager_out::ServantManager_out (const ::PortableServer::ServantManager_out &p) // copy constructor
  : ptr_ (ACE_const_cast (ServantManager_out &, p).ptr_)
{}

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

ACE_INLINE PortableServer::ServantManager_out &
PortableServer::ServantManager_out::operator= (const ::PortableServer::ServantManager_var &p)
{
  this->ptr_ = ::PortableServer::ServantManager::_duplicate (p.ptr ());
  return *this;
}

ACE_INLINE PortableServer::ServantManager_out &
PortableServer::ServantManager_out::operator= (ServantManager_ptr p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE
PortableServer::ServantManager_out::operator ::PortableServer::ServantManager_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE ::PortableServer::ServantManager_ptr &
PortableServer::ServantManager_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE ::PortableServer::ServantManager_ptr
PortableServer::ServantManager_out::operator-> (void)
{
  return this->ptr_;
}


#endif /* end #if !defined */


#if !defined (_PORTABLESERVER_SERVANTACTIVATOR___VAR_CI_)
#define _PORTABLESERVER_SERVANTACTIVATOR___VAR_CI_

// *************************************************************
// Inline operations for class PortableServer::ServantActivator_var
// *************************************************************

ACE_INLINE
PortableServer::ServantActivator_var::ServantActivator_var (void) // default constructor
  : ptr_ (ServantActivator::_nil ())
{}

ACE_INLINE ::PortableServer::ServantActivator_ptr
PortableServer::ServantActivator_var::ptr (void) const
{
  return this->ptr_;
}

ACE_INLINE
PortableServer::ServantActivator_var::ServantActivator_var (const ::PortableServer::ServantActivator_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (ServantActivator::_duplicate (p.ptr ()))
{}

ACE_INLINE
PortableServer::ServantActivator_var::~ServantActivator_var (void) // destructor
{
  CORBA::release (this->ptr_);
}

ACE_INLINE PortableServer::ServantActivator_var &
PortableServer::ServantActivator_var::operator= (ServantActivator_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

ACE_INLINE PortableServer::ServantActivator_var &
PortableServer::ServantActivator_var::operator= (const ::PortableServer::ServantActivator_var &p)
{
  if (this != &p)
  {
    CORBA::release (this->ptr_);
    this->ptr_ = ::PortableServer::ServantActivator::_duplicate (p.ptr ());
  }
  return *this;
}

ACE_INLINE
PortableServer::ServantActivator_var::operator const ::PortableServer::ServantActivator_ptr &() const // cast
{
  return this->ptr_;
}

ACE_INLINE
PortableServer::ServantActivator_var::operator ::PortableServer::ServantActivator_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE ::PortableServer::ServantActivator_ptr
PortableServer::ServantActivator_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE ::PortableServer::ServantActivator_ptr
PortableServer::ServantActivator_var::in (void) const
{
  return this->ptr_;
}

ACE_INLINE ::PortableServer::ServantActivator_ptr &
PortableServer::ServantActivator_var::inout (void)
{
  return this->ptr_;
}

ACE_INLINE ::PortableServer::ServantActivator_ptr &
PortableServer::ServantActivator_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::PortableServer::ServantActivator::_nil ();
  return this->ptr_;
}

ACE_INLINE ::PortableServer::ServantActivator_ptr
PortableServer::ServantActivator_var::_retn (void)
{
  // yield ownership of managed obj reference
  ::PortableServer::ServantActivator_ptr val = this->ptr_;
  this->ptr_ = ::PortableServer::ServantActivator::_nil ();
  return val;
}


#endif /* end #if !defined */


#if !defined (_PORTABLESERVER_SERVANTACTIVATOR___OUT_CI_)
#define _PORTABLESERVER_SERVANTACTIVATOR___OUT_CI_

// *************************************************************
// Inline operations for class PortableServer::ServantActivator_out
// *************************************************************

ACE_INLINE
PortableServer::ServantActivator_out::ServantActivator_out (ServantActivator_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::PortableServer::ServantActivator::_nil ();
}

ACE_INLINE
PortableServer::ServantActivator_out::ServantActivator_out (ServantActivator_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::PortableServer::ServantActivator::_nil ();
}

ACE_INLINE
PortableServer::ServantActivator_out::ServantActivator_out (const ::PortableServer::ServantActivator_out &p) // copy constructor
  : ptr_ (ACE_const_cast (ServantActivator_out &, p).ptr_)
{}

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

ACE_INLINE PortableServer::ServantActivator_out &
PortableServer::ServantActivator_out::operator= (const ::PortableServer::ServantActivator_var &p)
{
  this->ptr_ = ::PortableServer::ServantActivator::_duplicate (p.ptr ());
  return *this;
}

ACE_INLINE PortableServer::ServantActivator_out &
PortableServer::ServantActivator_out::operator= (ServantActivator_ptr p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE
PortableServer::ServantActivator_out::operator ::PortableServer::ServantActivator_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE ::PortableServer::ServantActivator_ptr &
PortableServer::ServantActivator_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE ::PortableServer::ServantActivator_ptr
PortableServer::ServantActivator_out::operator-> (void)
{
  return this->ptr_;
}


#endif /* end #if !defined */


#if !defined (_PORTABLESERVER_SERVANTLOCATOR___VAR_CI_)
#define _PORTABLESERVER_SERVANTLOCATOR___VAR_CI_

// *************************************************************
// Inline operations for class PortableServer::ServantLocator_var
// *************************************************************

ACE_INLINE
PortableServer::ServantLocator_var::ServantLocator_var (void) // default constructor
  : ptr_ (ServantLocator::_nil ())
{}

ACE_INLINE ::PortableServer::ServantLocator_ptr
PortableServer::ServantLocator_var::ptr (void) const
{
  return this->ptr_;
}

ACE_INLINE
PortableServer::ServantLocator_var::ServantLocator_var (const ::PortableServer::ServantLocator_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (ServantLocator::_duplicate (p.ptr ()))
{}

ACE_INLINE
PortableServer::ServantLocator_var::~ServantLocator_var (void) // destructor
{
  CORBA::release (this->ptr_);
}

ACE_INLINE PortableServer::ServantLocator_var &
PortableServer::ServantLocator_var::operator= (ServantLocator_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

ACE_INLINE PortableServer::ServantLocator_var &
PortableServer::ServantLocator_var::operator= (const ::PortableServer::ServantLocator_var &p)
{
  if (this != &p)
  {
    CORBA::release (this->ptr_);
    this->ptr_ = ::PortableServer::ServantLocator::_duplicate (p.ptr ());
  }
  return *this;
}

ACE_INLINE
PortableServer::ServantLocator_var::operator const ::PortableServer::ServantLocator_ptr &() const // cast
{
  return this->ptr_;
}

ACE_INLINE
PortableServer::ServantLocator_var::operator ::PortableServer::ServantLocator_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE ::PortableServer::ServantLocator_ptr
PortableServer::ServantLocator_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE ::PortableServer::ServantLocator_ptr
PortableServer::ServantLocator_var::in (void) const
{
  return this->ptr_;
}

ACE_INLINE ::PortableServer::ServantLocator_ptr &
PortableServer::ServantLocator_var::inout (void)
{
  return this->ptr_;
}

ACE_INLINE ::PortableServer::ServantLocator_ptr &
PortableServer::ServantLocator_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::PortableServer::ServantLocator::_nil ();
  return this->ptr_;
}

ACE_INLINE ::PortableServer::ServantLocator_ptr
PortableServer::ServantLocator_var::_retn (void)
{
  // yield ownership of managed obj reference
  ::PortableServer::ServantLocator_ptr val = this->ptr_;
  this->ptr_ = ::PortableServer::ServantLocator::_nil ();
  return val;
}


#endif /* end #if !defined */


#if !defined (_PORTABLESERVER_SERVANTLOCATOR___OUT_CI_)
#define _PORTABLESERVER_SERVANTLOCATOR___OUT_CI_

// *************************************************************
// Inline operations for class PortableServer::ServantLocator_out
// *************************************************************

ACE_INLINE
PortableServer::ServantLocator_out::ServantLocator_out (ServantLocator_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::PortableServer::ServantLocator::_nil ();
}

ACE_INLINE
PortableServer::ServantLocator_out::ServantLocator_out (ServantLocator_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::PortableServer::ServantLocator::_nil ();
}

ACE_INLINE
PortableServer::ServantLocator_out::ServantLocator_out (const ::PortableServer::ServantLocator_out &p) // copy constructor
  : ptr_ (ACE_const_cast (ServantLocator_out &, p).ptr_)
{}

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

ACE_INLINE PortableServer::ServantLocator_out &
PortableServer::ServantLocator_out::operator= (const ::PortableServer::ServantLocator_var &p)
{
  this->ptr_ = ::PortableServer::ServantLocator::_duplicate (p.ptr ());
  return *this;
}

ACE_INLINE PortableServer::ServantLocator_out &
PortableServer::ServantLocator_out::operator= (ServantLocator_ptr p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE
PortableServer::ServantLocator_out::operator ::PortableServer::ServantLocator_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE ::PortableServer::ServantLocator_ptr &
PortableServer::ServantLocator_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE ::PortableServer::ServantLocator_ptr
PortableServer::ServantLocator_out::operator-> (void)
{
  return this->ptr_;
}


#endif /* end #if !defined */

#endif /* TAO_HAS_MINIMUM_POA == 0 */

// *************************************************************
// Inline operations for exception PortableServer::POA::AdapterAlreadyExists
// *************************************************************

// *************************************************************
// Inline operations for exception PortableServer::POA::AdapterNonExistent
// *************************************************************

// *************************************************************
// Inline operations for exception PortableServer::POA::InvalidPolicy
// *************************************************************

// *************************************************************
// Inline operations for exception PortableServer::POA::NoServant
// *************************************************************

// *************************************************************
// Inline operations for exception PortableServer::POA::ObjectAlreadyActive
// *************************************************************

// *************************************************************
// Inline operations for exception PortableServer::POA::ObjectNotActive
// *************************************************************

// *************************************************************
// Inline operations for exception PortableServer::POA::ServantAlreadyActive
// *************************************************************

// *************************************************************
// Inline operations for exception PortableServer::POA::ServantNotActive
// *************************************************************

// *************************************************************
// Inline operations for exception PortableServer::POA::WrongAdapter
// *************************************************************

// *************************************************************
// Inline operations for exception PortableServer::POA::WrongPolicy
// *************************************************************

// *************************************************************
// Inline operations for exception PortableServer::Current::NoContext
// *************************************************************


#if !defined (_PORTABLESERVER_CURRENT___VAR_CI_)
#define _PORTABLESERVER_CURRENT___VAR_CI_

// *************************************************************
// Inline operations for class PortableServer::Current_var
// *************************************************************

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

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

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

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

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

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

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

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

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

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

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

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

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


#endif /* end #if !defined */


#if !defined (_PORTABLESERVER_CURRENT___OUT_CI_)
#define _PORTABLESERVER_CURRENT___OUT_CI_

// *************************************************************
// Inline operations for class PortableServer::Current_out
// *************************************************************

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

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

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

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

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

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

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

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

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


#endif /* end #if !defined */

ACE_INLINE CORBA::Boolean
operator<< (
    TAO_OutputCDR &,
    const PortableServer::POA_ptr
  );
ACE_INLINE CORBA::Boolean
operator>> (
    TAO_InputCDR &,
    PortableServer::POA_ptr &
  );

#if !defined _TAO_CDR_OP_PortableServer_ObjectId_I_
#define _TAO_CDR_OP_PortableServer_ObjectId_I_

CORBA::Boolean TAO_PortableServer_Export operator<< (
    TAO_OutputCDR &,
    const PortableServer::ObjectId &
  );
CORBA::Boolean TAO_PortableServer_Export operator>> (
    TAO_InputCDR &,
    PortableServer::ObjectId &
  );

#endif /* _TAO_CDR_OP_PortableServer_ObjectId_I_ */

#if (TAO_HAS_MINIMUM_CORBA == 0)

ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const PortableServer::ForwardRequest &_tao_aggregate)
{
  // first marshal the repository ID
  if (strm << _tao_aggregate._id ())
  {
    // now marshal the members (if any)
    if (
      (strm << _tao_aggregate.forward_reference.in ())
    )
      return 1;
    else
      return 0;
  }
  else
    return 0;
}

ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm,PortableServer::ForwardRequest &_tao_aggregate)
{
  // now marshal the members
  if (
    (strm >> _tao_aggregate.forward_reference.out ())
  )
    return 1;
  else
    return 0;
}

#if !defined (ACE_LACKS_IOSTREAM_TOTALLY)

ACE_INLINE
ostream & operator<< (ostream &os, const PortableServer::ForwardRequest &_tao_aggregate)
{
  CORBA::TypeCode_ptr tc = _tao_aggregate._type ();
  if (tc)
    {
      os << tc->name () << " (";
    }
  os << _tao_aggregate._id ();
  if (tc)
    {
      os << ")";
    }
  return os;
}

#endif /* ACE_LACKS_IOSTREAM_TOTALLY */

#endif /* TAO_HAS_MINIMUM_CORBA == 0 */

#if (TAO_HAS_MINIMUM_POA == 0)

ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const PortableServer::ThreadPolicyValue &_tao_enumval)
{
  return strm.write_ulong ((CORBA::ULong) _tao_enumval);
}

ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, PortableServer::ThreadPolicyValue &_tao_enumval)
{
  CORBA::ULong _tao_temp;
  if (strm.read_ulong (_tao_temp))
  {
    ACE_OS::memcpy (&_tao_enumval, &_tao_temp, sizeof (CORBA::ULong));
    return 1;
  }
  else
    return 0;
}

#endif /* TAO_HAS_MINIMUM_POA == 0 */

ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const PortableServer::LifespanPolicyValue &_tao_enumval)
{
  return strm.write_ulong ((CORBA::ULong) _tao_enumval);
}

ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, PortableServer::LifespanPolicyValue &_tao_enumval)
{
  CORBA::ULong _tao_temp;
  if (strm.read_ulong (_tao_temp))
  {
    ACE_OS::memcpy (&_tao_enumval, &_tao_temp, sizeof (CORBA::ULong));
    return 1;
  }
  else
    return 0;
}

ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const PortableServer::IdUniquenessPolicyValue &_tao_enumval)
{
  return strm.write_ulong ((CORBA::ULong) _tao_enumval);
}

ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, PortableServer::IdUniquenessPolicyValue &_tao_enumval)
{
  CORBA::ULong _tao_temp;
  if (strm.read_ulong (_tao_temp))
  {
    ACE_OS::memcpy (&_tao_enumval, &_tao_temp, sizeof (CORBA::ULong));
    return 1;
  }
  else
    return 0;
}

ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const PortableServer::IdAssignmentPolicyValue &_tao_enumval)
{
  return strm.write_ulong ((CORBA::ULong) _tao_enumval);
}

ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, PortableServer::IdAssignmentPolicyValue &_tao_enumval)
{
  CORBA::ULong _tao_temp;
  if (strm.read_ulong (_tao_temp))
  {
    ACE_OS::memcpy (&_tao_enumval, &_tao_temp, sizeof (CORBA::ULong));
    return 1;
  }
  else
    return 0;
}

#if (TAO_HAS_MINIMUM_POA == 0)

ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const PortableServer::ImplicitActivationPolicyValue &_tao_enumval)
{
  return strm.write_ulong ((CORBA::ULong) _tao_enumval);
}

ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, PortableServer::ImplicitActivationPolicyValue &_tao_enumval)
{
  CORBA::ULong _tao_temp;
  if (strm.read_ulong (_tao_temp))
  {
    ACE_OS::memcpy (&_tao_enumval, &_tao_temp, sizeof (CORBA::ULong));
    return 1;
  }
  else
    return 0;
}

ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const PortableServer::ServantRetentionPolicyValue &_tao_enumval)
{
  return strm.write_ulong ((CORBA::ULong) _tao_enumval);
}

ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, PortableServer::ServantRetentionPolicyValue &_tao_enumval)
{
  CORBA::ULong _tao_temp;
  if (strm.read_ulong (_tao_temp))
  {
    ACE_OS::memcpy (&_tao_enumval, &_tao_temp, sizeof (CORBA::ULong));
    return 1;
  }
  else
    return 0;
}

ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const PortableServer::RequestProcessingPolicyValue &_tao_enumval)
{
  return strm.write_ulong ((CORBA::ULong) _tao_enumval);
}

ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, PortableServer::RequestProcessingPolicyValue &_tao_enumval)
{
  CORBA::ULong _tao_temp;
  if (strm.read_ulong (_tao_temp))
  {
    ACE_OS::memcpy (&_tao_enumval, &_tao_temp, sizeof (CORBA::ULong));
    return 1;
  }
  else
    return 0;
}

#endif /* TAO_HAS_MINIMUM_POA == 0 */