// $Id$
//
// ******  Code generated by the The ACE ORB (TAO) IDL Compiler *******
// TAO ORB and the TAO IDL Compiler have been developed by Washington
// University Computer Science's Distributed Object Computing Group.
//
// Information on 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_ptr
PortableServer::POA::_nil (void)
{
  return (PortableServer::POA_ptr)0;
}

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

ACE_INLINE
PortableServer::POA_var::POA_var (PortableServer::POA_ptr p)
  : ptr_ (p)
{}

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
  : ptr_ (PortableServer::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 (POA_out&,p).ptr_)
{}

ACE_INLINE PortableServer::POA_out &
PortableServer::POA_out::operator= (PortableServer::POA_out &p)
{
  this->ptr_ = 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 (_PORTABLESERVER__TAO_SEQ_OCTET___VAR_CI_)
#define _PORTABLESERVER__TAO_SEQ_OCTET___VAR_CI_

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

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

ACE_INLINE
PortableServer::_tao_seq_Octet_var::_tao_seq_Octet_var (PortableServer::_tao_seq_Octet *p)
  : ptr_ (p)
{}

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

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

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

ACE_INLINE PortableServer::_tao_seq_Octet_var &
PortableServer::_tao_seq_Octet_var::operator= (const PortableServer::_tao_seq_Octet_var &p) // deep copy
{
  if (this != &p)
    {
      delete this->ptr_;
      ACE_NEW_RETURN (this->ptr_, 
                      PortableServer::_tao_seq_Octet (*p.ptr_), 
		      *this);
    }
  return *this;
}

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

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

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

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

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

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

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

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

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

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

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


#endif // end #if !defined


#if !defined (_PORTABLESERVER__TAO_SEQ_OCTET___OUT_CI_)
#define _PORTABLESERVER__TAO_SEQ_OCTET___OUT_CI_

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

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

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

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

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

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

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

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

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

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


#endif // end #if !defined

#if !defined (TAO_HAS_MINIMUM_CORBA)

ACE_INLINE
PortableServer::ThreadPolicy::ThreadPolicy(
                                           TAO_Stub *objref,
                                           TAO_ServantBase *servant,
                                           CORBA::Boolean collocated
                                           )
  : ACE_CORBA_1 (Object) (objref, servant, collocated)
{}

ACE_INLINE
PortableServer::ThreadPolicy::~ThreadPolicy (void) // destructor
{}

ACE_INLINE PortableServer::ThreadPolicy_ptr
PortableServer::ThreadPolicy::_nil (void)
{
  return (PortableServer::ThreadPolicy_ptr)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_ (PortableServer::ThreadPolicy::_nil ())
{}

ACE_INLINE
PortableServer::ThreadPolicy_var::ThreadPolicy_var (PortableServer::ThreadPolicy_ptr p)
  : ptr_ (p)
{}

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
  : ptr_ (PortableServer::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= (PortableServer::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 (PortableServer::ThreadPolicy_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = PortableServer::ThreadPolicy::_nil ();
}

ACE_INLINE
PortableServer::ThreadPolicy_out::ThreadPolicy_out (PortableServer::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= (PortableServer::ThreadPolicy_out &p)
{
  this->ptr_ = 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= (PortableServer::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_CORBA */

ACE_INLINE
PortableServer::LifespanPolicy::LifespanPolicy(
                                               TAO_Stub *objref,
                                               TAO_ServantBase *servant,
                                               CORBA::Boolean collocated
                                               )
  : ACE_CORBA_1 (Object) (objref, servant, collocated)
{}

ACE_INLINE
PortableServer::LifespanPolicy::~LifespanPolicy (void) // destructor
{}

ACE_INLINE PortableServer::LifespanPolicy_ptr
PortableServer::LifespanPolicy::_nil (void)
{
  return (PortableServer::LifespanPolicy_ptr)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_ (PortableServer::LifespanPolicy::_nil ())
{}

ACE_INLINE
PortableServer::LifespanPolicy_var::LifespanPolicy_var (PortableServer::LifespanPolicy_ptr p)
  : ptr_ (p)
{}

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
  : ptr_ (PortableServer::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= (PortableServer::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 (PortableServer::LifespanPolicy_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = PortableServer::LifespanPolicy::_nil ();
}

ACE_INLINE
PortableServer::LifespanPolicy_out::LifespanPolicy_out (PortableServer::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= (PortableServer::LifespanPolicy_out &p)
{
  this->ptr_ = 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= (PortableServer::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

ACE_INLINE
PortableServer::IdUniquenessPolicy::IdUniquenessPolicy(
                                                       TAO_Stub *objref,
                                                       TAO_ServantBase *servant,
                                                       CORBA::Boolean collocated
                                                       )
  : ACE_CORBA_1 (Object) (objref, servant, collocated)
{}

ACE_INLINE
PortableServer::IdUniquenessPolicy::~IdUniquenessPolicy (void) // destructor
{}

ACE_INLINE PortableServer::IdUniquenessPolicy_ptr
PortableServer::IdUniquenessPolicy::_nil (void)
{
  return (PortableServer::IdUniquenessPolicy_ptr)0;
}


#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_ (PortableServer::IdUniquenessPolicy::_nil ())
{}

ACE_INLINE
PortableServer::IdUniquenessPolicy_var::IdUniquenessPolicy_var (PortableServer::IdUniquenessPolicy_ptr p)
  : ptr_ (p)
{}

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
  : ptr_ (PortableServer::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= (PortableServer::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 (PortableServer::IdUniquenessPolicy_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = PortableServer::IdUniquenessPolicy::_nil ();
}

ACE_INLINE
PortableServer::IdUniquenessPolicy_out::IdUniquenessPolicy_out (PortableServer::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= (PortableServer::IdUniquenessPolicy_out &p)
{
  this->ptr_ = 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= (PortableServer::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

ACE_INLINE
PortableServer::IdAssignmentPolicy::IdAssignmentPolicy(
                                                       TAO_Stub *objref,
                                                       TAO_ServantBase *servant,
                                                       CORBA::Boolean collocated
                                                       )
  : ACE_CORBA_1 (Object) (objref, servant, collocated)
{}

ACE_INLINE
PortableServer::IdAssignmentPolicy::~IdAssignmentPolicy (void) // destructor
{}

ACE_INLINE PortableServer::IdAssignmentPolicy_ptr
PortableServer::IdAssignmentPolicy::_nil (void)
{
  return (PortableServer::IdAssignmentPolicy_ptr)0;
}


#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_ (PortableServer::IdAssignmentPolicy::_nil ())
{}

ACE_INLINE
PortableServer::IdAssignmentPolicy_var::IdAssignmentPolicy_var (PortableServer::IdAssignmentPolicy_ptr p)
  : ptr_ (p)
{}

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
  : ptr_ (PortableServer::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= (PortableServer::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 (PortableServer::IdAssignmentPolicy_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = PortableServer::IdAssignmentPolicy::_nil ();
}

ACE_INLINE
PortableServer::IdAssignmentPolicy_out::IdAssignmentPolicy_out (PortableServer::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= (PortableServer::IdAssignmentPolicy_out &p)
{
  this->ptr_ = 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= (PortableServer::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 !defined (TAO_HAS_MINIMUM_CORBA)

ACE_INLINE
PortableServer::ImplicitActivationPolicy::ImplicitActivationPolicy(
                                                                   TAO_Stub *objref,
                                                                   TAO_ServantBase *servant,
                                                                   CORBA::Boolean collocated
                                                                   )
  : ACE_CORBA_1 (Object) (objref, servant, collocated)
{}

ACE_INLINE
PortableServer::ImplicitActivationPolicy::~ImplicitActivationPolicy (void) // destructor
{}

ACE_INLINE PortableServer::ImplicitActivationPolicy_ptr
PortableServer::ImplicitActivationPolicy::_nil (void)
{
  return (PortableServer::ImplicitActivationPolicy_ptr)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_ (PortableServer::ImplicitActivationPolicy::_nil ())
{}

ACE_INLINE
PortableServer::ImplicitActivationPolicy_var::ImplicitActivationPolicy_var (PortableServer::ImplicitActivationPolicy_ptr p)
  : ptr_ (p)
{}

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
  : ptr_ (PortableServer::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= (PortableServer::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 (PortableServer::ImplicitActivationPolicy_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = PortableServer::ImplicitActivationPolicy::_nil ();
}

ACE_INLINE
PortableServer::ImplicitActivationPolicy_out::ImplicitActivationPolicy_out (PortableServer::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= (PortableServer::ImplicitActivationPolicy_out &p)
{
  this->ptr_ = 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= (PortableServer::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

ACE_INLINE
PortableServer::ServantRetentionPolicy::ServantRetentionPolicy(
                                                               TAO_Stub *objref,
                                                               TAO_ServantBase *servant,
                                                               CORBA::Boolean collocated
                                                               )
  : ACE_CORBA_1 (Object) (objref, servant, collocated)
{}

ACE_INLINE
PortableServer::ServantRetentionPolicy::~ServantRetentionPolicy (void) // destructor
{}

ACE_INLINE PortableServer::ServantRetentionPolicy_ptr
PortableServer::ServantRetentionPolicy::_nil (void)
{
  return (PortableServer::ServantRetentionPolicy_ptr)0;
}


#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_ (PortableServer::ServantRetentionPolicy::_nil ())
{}

ACE_INLINE
PortableServer::ServantRetentionPolicy_var::ServantRetentionPolicy_var (PortableServer::ServantRetentionPolicy_ptr p)
  : ptr_ (p)
{}

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
  : ptr_ (PortableServer::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= (PortableServer::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 (PortableServer::ServantRetentionPolicy_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = PortableServer::ServantRetentionPolicy::_nil ();
}

ACE_INLINE
PortableServer::ServantRetentionPolicy_out::ServantRetentionPolicy_out (PortableServer::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= (PortableServer::ServantRetentionPolicy_out &p)
{
  this->ptr_ = 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= (PortableServer::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

ACE_INLINE
PortableServer::RequestProcessingPolicy::RequestProcessingPolicy(
                                                                 TAO_Stub *objref,
                                                                 TAO_ServantBase *servant,
                                                                 CORBA::Boolean collocated
                                                                 )
  : ACE_CORBA_1 (Object) (objref, servant, collocated)
{}

ACE_INLINE
PortableServer::RequestProcessingPolicy::~RequestProcessingPolicy (void) // destructor
{}

ACE_INLINE PortableServer::RequestProcessingPolicy_ptr
PortableServer::RequestProcessingPolicy::_nil (void)
{
  return (PortableServer::RequestProcessingPolicy_ptr)0;
}


#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_ (PortableServer::RequestProcessingPolicy::_nil ())
{}

ACE_INLINE
PortableServer::RequestProcessingPolicy_var::RequestProcessingPolicy_var (PortableServer::RequestProcessingPolicy_ptr p)
  : ptr_ (p)
{}

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
  : ptr_ (PortableServer::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= (PortableServer::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 (PortableServer::RequestProcessingPolicy_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = PortableServer::RequestProcessingPolicy::_nil ();
}

ACE_INLINE
PortableServer::RequestProcessingPolicy_out::RequestProcessingPolicy_out (PortableServer::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= (PortableServer::RequestProcessingPolicy_out &p)
{
  this->ptr_ = 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= (PortableServer::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_CORBA */

ACE_INLINE
PortableServer::POAManager::POAManager(
                                       TAO_Stub *objref,
                                       TAO_ServantBase *servant,
                                       CORBA::Boolean collocated
                                       )
  : ACE_CORBA_1 (Object) (objref, servant, collocated)
{}

ACE_INLINE
PortableServer::POAManager::~POAManager (void) // destructor
{}

ACE_INLINE PortableServer::POAManager_ptr
PortableServer::POAManager::_nil (void)
{
  return (PortableServer::POAManager_ptr)0;
}


#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_ (PortableServer::POAManager::_nil ())
{}

ACE_INLINE
PortableServer::POAManager_var::POAManager_var (PortableServer::POAManager_ptr p)
  : ptr_ (p)
{}

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
  : ptr_ (PortableServer::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= (PortableServer::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 (PortableServer::POAManager_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = PortableServer::POAManager::_nil ();
}

ACE_INLINE
PortableServer::POAManager_out::POAManager_out (PortableServer::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= (PortableServer::POAManager_out &p)
{
  this->ptr_ = 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= (PortableServer::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 !defined (TAO_HAS_MINIMUM_CORBA)

ACE_INLINE
PortableServer::AdapterActivator::AdapterActivator(
                                                   TAO_Stub *objref,
                                                   TAO_ServantBase *servant,
                                                   CORBA::Boolean collocated
                                                   )
  : ACE_CORBA_1 (Object) (objref, servant, collocated)
{}

ACE_INLINE
PortableServer::AdapterActivator::~AdapterActivator (void) // destructor
{}

ACE_INLINE PortableServer::AdapterActivator_ptr
PortableServer::AdapterActivator::_nil (void)
{
  return (PortableServer::AdapterActivator_ptr)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_ (PortableServer::AdapterActivator::_nil ())
{}

ACE_INLINE
PortableServer::AdapterActivator_var::AdapterActivator_var (PortableServer::AdapterActivator_ptr p)
  : ptr_ (p)
{}

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
  : ptr_ (PortableServer::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= (PortableServer::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 (PortableServer::AdapterActivator_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = PortableServer::AdapterActivator::_nil ();
}

ACE_INLINE
PortableServer::AdapterActivator_out::AdapterActivator_out (PortableServer::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= (PortableServer::AdapterActivator_out &p)
{
  this->ptr_ = 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= (PortableServer::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

ACE_INLINE
PortableServer::ServantManager::ServantManager(
                                               TAO_Stub *objref,
                                               TAO_ServantBase *servant,
                                               CORBA::Boolean collocated
                                               )
  : ACE_CORBA_1 (Object) (objref, servant, collocated)
{}

ACE_INLINE
PortableServer::ServantManager::~ServantManager (void) // destructor
{}

ACE_INLINE PortableServer::ServantManager_ptr
PortableServer::ServantManager::_nil (void)
{
  return (PortableServer::ServantManager_ptr)0;
}


#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_ (PortableServer::ServantManager::_nil ())
{}

ACE_INLINE
PortableServer::ServantManager_var::ServantManager_var (PortableServer::ServantManager_ptr p)
  : ptr_ (p)
{}

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
  : ptr_ (PortableServer::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= (PortableServer::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 (PortableServer::ServantManager_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = PortableServer::ServantManager::_nil ();
}

ACE_INLINE
PortableServer::ServantManager_out::ServantManager_out (PortableServer::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= (PortableServer::ServantManager_out &p)
{
  this->ptr_ = 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= (PortableServer::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

ACE_INLINE
PortableServer::ServantActivator::ServantActivator(
                                                   TAO_Stub *objref,
                                                   TAO_ServantBase *servant,
                                                   CORBA::Boolean collocated
                                                   )
  : ACE_CORBA_1 (Object) (objref, servant, collocated)
{}

ACE_INLINE
PortableServer::ServantActivator::~ServantActivator (void) // destructor
{}

ACE_INLINE PortableServer::ServantActivator_ptr
PortableServer::ServantActivator::_nil (void)
{
  return (PortableServer::ServantActivator_ptr)0;
}


#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_ (PortableServer::ServantActivator::_nil ())
{}

ACE_INLINE
PortableServer::ServantActivator_var::ServantActivator_var (PortableServer::ServantActivator_ptr p)
  : ptr_ (p)
{}

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
  : ptr_ (PortableServer::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= (PortableServer::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 (PortableServer::ServantActivator_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = PortableServer::ServantActivator::_nil ();
}

ACE_INLINE
PortableServer::ServantActivator_out::ServantActivator_out (PortableServer::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= (PortableServer::ServantActivator_out &p)
{
  this->ptr_ = 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= (PortableServer::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

ACE_INLINE
PortableServer::ServantLocator::ServantLocator(
                                               TAO_Stub *objref,
                                               TAO_ServantBase *servant,
                                               CORBA::Boolean collocated
                                               )
  : ACE_CORBA_1 (Object) (objref, servant, collocated)
{}

ACE_INLINE
PortableServer::ServantLocator::~ServantLocator (void) // destructor
{}

ACE_INLINE PortableServer::ServantLocator_ptr
PortableServer::ServantLocator::_nil (void)
{
  return (PortableServer::ServantLocator_ptr)0;
}


#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_ (PortableServer::ServantLocator::_nil ())
{}

ACE_INLINE
PortableServer::ServantLocator_var::ServantLocator_var (PortableServer::ServantLocator_ptr p)
  : ptr_ (p)
{}

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
  : ptr_ (PortableServer::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= (PortableServer::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 (PortableServer::ServantLocator_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = PortableServer::ServantLocator::_nil ();
}

ACE_INLINE
PortableServer::ServantLocator_out::ServantLocator_out (PortableServer::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= (PortableServer::ServantLocator_out &p)
{
  this->ptr_ = 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= (PortableServer::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_CORBA */

ACE_INLINE
PortableServer::POA::POA(
                         TAO_Stub *objref,
                         TAO_ServantBase *servant,
                         CORBA::Boolean collocated
                         )
  : ACE_CORBA_1 (Object) (objref, servant, collocated)
{}

ACE_INLINE
PortableServer::POA::~POA (void) // destructor
{}


#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_var::POA_var (PortableServer::POA_ptr p)
  : ptr_ (p)
{}

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
  : ptr_ (PortableServer::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 (POA_out&,p).ptr_)
{}

ACE_INLINE PortableServer::POA_out &
PortableServer::POA_out::operator= (PortableServer::POA_out &p)
{
  this->ptr_ = 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

ACE_INLINE
PortableServer::Current::Current(
                                 TAO_Stub *objref,
                                 TAO_ServantBase *servant,
                                 CORBA::Boolean collocated
                                 )
  : ACE_CORBA_1 (Object) (objref, servant, collocated)
{}

ACE_INLINE
PortableServer::Current::~Current (void) // destructor
{}

ACE_INLINE PortableServer::Current_ptr
PortableServer::Current::_nil (void)
{
  return (PortableServer::Current_ptr)0;
}


#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_ (PortableServer::Current::_nil ())
{}

ACE_INLINE
PortableServer::Current_var::Current_var (PortableServer::Current_ptr p)
  : ptr_ (p)
{}

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
  : ptr_ (PortableServer::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= (PortableServer::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 (PortableServer::Current_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = PortableServer::Current::_nil ();
}

ACE_INLINE
PortableServer::Current_out::Current_out (PortableServer::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= (PortableServer::Current_out &p)
{
  this->ptr_ = 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= (PortableServer::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_;
}

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

#if !defined (TAO_HAS_MINIMUM_CORBA)
ACE_INLINE CORBA::Boolean
operator<< (
    TAO_OutputCDR &,
    const PortableServer::ThreadPolicy_ptr
  );
ACE_INLINE CORBA::Boolean
operator>> (
    TAO_InputCDR &,
    PortableServer::ThreadPolicy_ptr &
  );

ACE_INLINE CORBA::Boolean
operator<< (
    TAO_OutputCDR &strm,
    const PortableServer::ThreadPolicy_ptr _tao_objref
  )
{
  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
  return (strm << _tao_corba_obj);
}

ACE_INLINE CORBA::Boolean
operator>> (
    TAO_InputCDR &strm,
    PortableServer::ThreadPolicy_ptr &_tao_objref
  )
{
  ACE_TRY_NEW_ENV
  {
    CORBA::Object_var obj;
    if ((strm >> obj.inout ()) == 0)
      return 0;
    // narrow to the right type
    _tao_objref =
      PortableServer::ThreadPolicy::_narrow (
          obj.in (),
          ACE_TRY_ENV
        );
    ACE_TRY_CHECK;
    return 1;
  }
  ACE_CATCHANY
  {
    // do nothing
  }
  ACE_ENDTRY;
  return 0;
}
#endif /* end #if !defined */

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 &,
    const PortableServer::LifespanPolicy_ptr
  );
ACE_INLINE CORBA::Boolean
operator>> (
    TAO_InputCDR &,
    PortableServer::LifespanPolicy_ptr &
  );

ACE_INLINE CORBA::Boolean
operator<< (
    TAO_OutputCDR &strm,
    const PortableServer::LifespanPolicy_ptr _tao_objref
  )
{
  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
  return (strm << _tao_corba_obj);
}

ACE_INLINE CORBA::Boolean
operator>> (
    TAO_InputCDR &strm,
    PortableServer::LifespanPolicy_ptr &_tao_objref
  )
{
  ACE_TRY_NEW_ENV
  {
    CORBA::Object_var obj;
    if ((strm >> obj.inout ()) == 0)
      return 0;
    // narrow to the right type
    _tao_objref =
      PortableServer::LifespanPolicy::_narrow (
          obj.in (),
          ACE_TRY_ENV
        );
    ACE_TRY_CHECK;
    return 1;
  }
  ACE_CATCHANY
  {
    // do nothing
  }
  ACE_ENDTRY;
  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 &,
    const PortableServer::IdUniquenessPolicy_ptr
  );
ACE_INLINE CORBA::Boolean
operator>> (
    TAO_InputCDR &,
    PortableServer::IdUniquenessPolicy_ptr &
  );

ACE_INLINE CORBA::Boolean
operator<< (
    TAO_OutputCDR &strm,
    const PortableServer::IdUniquenessPolicy_ptr _tao_objref
  )
{
  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
  return (strm << _tao_corba_obj);
}

ACE_INLINE CORBA::Boolean
operator>> (
    TAO_InputCDR &strm,
    PortableServer::IdUniquenessPolicy_ptr &_tao_objref
  )
{
  ACE_TRY_NEW_ENV
  {
    CORBA::Object_var obj;
    if ((strm >> obj.inout ()) == 0)
      return 0;
    // narrow to the right type
    _tao_objref =
      PortableServer::IdUniquenessPolicy::_narrow (
          obj.in (),
          ACE_TRY_ENV
        );
    ACE_TRY_CHECK;
    return 1;
  }
  ACE_CATCHANY
  {
    // do nothing
  }
  ACE_ENDTRY;
  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;
}

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

ACE_INLINE CORBA::Boolean
operator<< (
    TAO_OutputCDR &strm,
    const PortableServer::IdAssignmentPolicy_ptr _tao_objref
  )
{
  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
  return (strm << _tao_corba_obj);
}

ACE_INLINE CORBA::Boolean
operator>> (
    TAO_InputCDR &strm,
    PortableServer::IdAssignmentPolicy_ptr &_tao_objref
  )
{
  ACE_TRY_NEW_ENV
  {
    CORBA::Object_var obj;
    if ((strm >> obj.inout ()) == 0)
      return 0;
    // narrow to the right type
    _tao_objref =
      PortableServer::IdAssignmentPolicy::_narrow (
          obj.in (),
          ACE_TRY_ENV
        );
    ACE_TRY_CHECK;
    return 1;
  }
  ACE_CATCHANY
  {
    // do nothing
  }
  ACE_ENDTRY;
  return 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;
}

#if !defined (TAO_HAS_MINIMUM_CORBA)

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

ACE_INLINE CORBA::Boolean
operator<< (
    TAO_OutputCDR &strm,
    const PortableServer::ImplicitActivationPolicy_ptr _tao_objref
  )
{
  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
  return (strm << _tao_corba_obj);
}

ACE_INLINE CORBA::Boolean
operator>> (
    TAO_InputCDR &strm,
    PortableServer::ImplicitActivationPolicy_ptr &_tao_objref
  )
{
  ACE_TRY_NEW_ENV
  {
    CORBA::Object_var obj;
    if ((strm >> obj.inout ()) == 0)
      return 0;
    // narrow to the right type
    _tao_objref =
      PortableServer::ImplicitActivationPolicy::_narrow (
          obj.in (),
          ACE_TRY_ENV
        );
    ACE_TRY_CHECK;
    return 1;
  }
  ACE_CATCHANY
  {
    // do nothing
  }
  ACE_ENDTRY;
  return 0;
}
#endif /* !defined (TAO_HAS_MINIMUM_CORBA) */


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

#if !defined (TAO_HAS_MINIMUM_CORBA)

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

ACE_INLINE CORBA::Boolean
operator<< (
    TAO_OutputCDR &strm,
    const PortableServer::ServantRetentionPolicy_ptr _tao_objref
  )
{
  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
  return (strm << _tao_corba_obj);
}

ACE_INLINE CORBA::Boolean
operator>> (
    TAO_InputCDR &strm,
    PortableServer::ServantRetentionPolicy_ptr &_tao_objref
  )
{
  ACE_TRY_NEW_ENV
  {
    CORBA::Object_var obj;
    if ((strm >> obj.inout ()) == 0)
      return 0;
    // narrow to the right type
    _tao_objref =
      PortableServer::ServantRetentionPolicy::_narrow (
          obj.in (),
          ACE_TRY_ENV
        );
    ACE_TRY_CHECK;
    return 1;
  }
  ACE_CATCHANY
  {
    // do nothing
  }
  ACE_ENDTRY;
  return 0;
}

#endif /* TAO_HAS_MINIMUM_CORBA */

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

#if !defined(TAO_HAS_MINIMUM_CORBA)

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

ACE_INLINE CORBA::Boolean
operator<< (
    TAO_OutputCDR &strm,
    const PortableServer::RequestProcessingPolicy_ptr _tao_objref
  )
{
  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
  return (strm << _tao_corba_obj);
}

ACE_INLINE CORBA::Boolean
operator>> (
    TAO_InputCDR &strm,
    PortableServer::RequestProcessingPolicy_ptr &_tao_objref
  )
{
  ACE_TRY_NEW_ENV
  {
    CORBA::Object_var obj;
    if ((strm >> obj.inout ()) == 0)
      return 0;
    // narrow to the right type
    _tao_objref =
      PortableServer::RequestProcessingPolicy::_narrow (
          obj.in (),
          ACE_TRY_ENV
        );
    ACE_TRY_CHECK;
    return 1;
  }
  ACE_CATCHANY
  {
    // do nothing
  }
  ACE_ENDTRY;
  return 0;
}
#endif /* TAO_HAS_MINIMUM_CORBA */


ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const PortableServer::POA::AdapterAlreadyExists &_tao_aggregate)
{
  // first marshal the repository ID
  if (strm << _tao_aggregate._id ())
    return 1;
  else
    return 0;
}

ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, PortableServer::POA::AdapterAlreadyExists &_tao_aggregate)
{
  // retrieve  RepoID and verify if we are of that type
  char *_tao_repoID;
  if ((strm >> _tao_repoID) &&
      (_tao_aggregate._is_a (_tao_repoID)))
  {
    return 1;
  }
  else
    return 0;
}

#if !defined (TAO_HAS_MINIMUM_CORBA)

ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const PortableServer::POA::AdapterInactive &_tao_aggregate)
{
  // first marshal the repository ID
  if (strm << _tao_aggregate._id ())
    return 1;
  else
    return 0;
}

ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, PortableServer::POA::AdapterInactive &_tao_aggregate)
{
  // retrieve  RepoID and verify if we are of that type
  char *_tao_repoID;
  if ((strm >> _tao_repoID) &&
      (_tao_aggregate._is_a (_tao_repoID)))
  {
    return 1;
  }
  else
    return 0;
}
#endif /* TAO_HAS_MINIMUM_CORBA */

ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const PortableServer::POA::AdapterNonExistent &_tao_aggregate)
{
  // first marshal the repository ID
  if (strm << _tao_aggregate._id ())
    return 1;
  else
    return 0;
}

ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, PortableServer::POA::AdapterNonExistent &_tao_aggregate)
{
  // retrieve  RepoID and verify if we are of that type
  char *_tao_repoID;
  if ((strm >> _tao_repoID) &&
      (_tao_aggregate._is_a (_tao_repoID)))
  {
    return 1;
  }
  else
    return 0;
}

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

ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, PortableServer::POA::InvalidPolicy &_tao_aggregate)
{
  // retrieve  RepoID and verify if we are of that type
  char *_tao_repoID;
  if ((strm >> _tao_repoID) &&
      (_tao_aggregate._is_a (_tao_repoID)))
  {
    // now marshal the members
    if ((strm >> _tao_aggregate.index))
      return 1;
    else
      return 0;
  }
  else
    return 0;
}

#if !defined (TAO_HAS_MINIMUM_CORBA)

ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const PortableServer::POA::NoServant &_tao_aggregate)
{
  // first marshal the repository ID
  if (strm << _tao_aggregate._id ())
    return 1;
  else
    return 0;
}

ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, PortableServer::POA::NoServant &_tao_aggregate)
{
  // retrieve  RepoID and verify if we are of that type
  char *_tao_repoID;
  if ((strm >> _tao_repoID) &&
      (_tao_aggregate._is_a (_tao_repoID)))
  {
    return 1;
  }
  else
    return 0;
}
#endif /* !defined (TAO_HAS_MINIMUM_CORBA) */

ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const PortableServer::POA::ObjectAlreadyActive &_tao_aggregate)
{
  // first marshal the repository ID
  if (strm << _tao_aggregate._id ())
    return 1;
  else
    return 0;
}

ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, PortableServer::POA::ObjectAlreadyActive &_tao_aggregate)
{
  // retrieve  RepoID and verify if we are of that type
  char *_tao_repoID;
  if ((strm >> _tao_repoID) &&
      (_tao_aggregate._is_a (_tao_repoID)))
  {
    return 1;
  }
  else
    return 0;
}

ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const PortableServer::POA::ObjectNotActive &_tao_aggregate)
{
  // first marshal the repository ID
  if (strm << _tao_aggregate._id ())
    return 1;
  else
    return 0;
}

ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, PortableServer::POA::ObjectNotActive &_tao_aggregate)
{
  // retrieve  RepoID and verify if we are of that type
  char *_tao_repoID;
  if ((strm >> _tao_repoID) &&
      (_tao_aggregate._is_a (_tao_repoID)))
  {
    return 1;
  }
  else
    return 0;
}

ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const PortableServer::POA::ServantAlreadyActive &_tao_aggregate)
{
  // first marshal the repository ID
  if (strm << _tao_aggregate._id ())
    return 1;
  else
    return 0;
}

ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, PortableServer::POA::ServantAlreadyActive &_tao_aggregate)
{
  // retrieve  RepoID and verify if we are of that type
  char *_tao_repoID;
  if ((strm >> _tao_repoID) &&
      (_tao_aggregate._is_a (_tao_repoID)))
  {
    return 1;
  }
  else
    return 0;
}

ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const PortableServer::POA::ServantNotActive &_tao_aggregate)
{
  // first marshal the repository ID
  if (strm << _tao_aggregate._id ())
    return 1;
  else
    return 0;
}

ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, PortableServer::POA::ServantNotActive &_tao_aggregate)
{
  // retrieve  RepoID and verify if we are of that type
  char *_tao_repoID;
  if ((strm >> _tao_repoID) &&
      (_tao_aggregate._is_a (_tao_repoID)))
  {
    return 1;
  }
  else
    return 0;
}

ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const PortableServer::POA::WrongAdapter &_tao_aggregate)
{
  // first marshal the repository ID
  if (strm << _tao_aggregate._id ())
    return 1;
  else
    return 0;
}

ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, PortableServer::POA::WrongAdapter &_tao_aggregate)
{
  // retrieve  RepoID and verify if we are of that type
  char *_tao_repoID;
  if ((strm >> _tao_repoID) &&
      (_tao_aggregate._is_a (_tao_repoID)))
  {
    return 1;
  }
  else
    return 0;
}

ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const PortableServer::POA::WrongPolicy &_tao_aggregate)
{
  // first marshal the repository ID
  if (strm << _tao_aggregate._id ())
    return 1;
  else
    return 0;
}

ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, PortableServer::POA::WrongPolicy &_tao_aggregate)
{
  // retrieve  RepoID and verify if we are of that type
  char *_tao_repoID;
  if ((strm >> _tao_repoID) &&
      (_tao_aggregate._is_a (_tao_repoID)))
  {
    return 1;
  }
  else
    return 0;
}


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

ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const PortableServer::Current::NoContext &_tao_aggregate)
{
  // first marshal the repository ID
  if (strm << _tao_aggregate._id ())
    return 1;
  else
    return 0;
}

ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, PortableServer::Current::NoContext &_tao_aggregate)
{
  // retrieve  RepoID and verify if we are of that type
  char *_tao_repoID;
  if ((strm >> _tao_repoID) &&
      (_tao_aggregate._is_a (_tao_repoID)))
  {
    return 1;
  }
  else
    return 0;
}

ACE_INLINE CORBA::Boolean
operator<< (
    TAO_OutputCDR &strm,
    const PortableServer::Current_ptr _tao_objref
  )
{
  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
  return (strm << _tao_corba_obj);
}

ACE_INLINE CORBA::Boolean
operator>> (
    TAO_InputCDR &strm,
    PortableServer::Current_ptr &_tao_objref
  )
{
  ACE_TRY_NEW_ENV
  {
    CORBA::Object_var obj;
    if ((strm >> obj.inout ()) == 0)
      return 0;
    // narrow to the right type
    _tao_objref =
      PortableServer::Current::_narrow (
          obj.in (),
          ACE_TRY_ENV
        );
    ACE_TRY_CHECK;
    return 1;
  }
  ACE_CATCHANY
  {
    // do nothing
  }
  ACE_ENDTRY;
  return 0;
}
#endif // end #if !defined