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

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

// *************************************************************
// Inline operations for class RTCORBA::ThreadpoolLane_var
// *************************************************************

ACE_INLINE
RTCORBA::ThreadpoolLane_var::ThreadpoolLane_var (void) // default constructor
  : ptr_ (0)
{}

ACE_INLINE
RTCORBA::ThreadpoolLane_var::ThreadpoolLane_var (ThreadpoolLane *p)
  : ptr_ (p)
{}

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

// fixed-size types only
ACE_INLINE
RTCORBA::ThreadpoolLane_var::ThreadpoolLane_var (const ::RTCORBA::ThreadpoolLane &p)
{
  ACE_NEW (this->ptr_, ::RTCORBA::ThreadpoolLane (p));
}

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

ACE_INLINE RTCORBA::ThreadpoolLane_var &
RTCORBA::ThreadpoolLane_var::operator= (ThreadpoolLane *p)
{
  delete this->ptr_;
  this->ptr_ = p;
  return *this;
}

ACE_INLINE ::RTCORBA::ThreadpoolLane_var &
RTCORBA::ThreadpoolLane_var::operator= (const ::RTCORBA::ThreadpoolLane_var &p)
{
  if (this != &p)
  {
    delete this->ptr_;
    ACE_NEW_RETURN (this->ptr_, ::RTCORBA::ThreadpoolLane (*p.ptr_), *this);
  }
  return *this;
}

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

ACE_INLINE const ::RTCORBA::ThreadpoolLane *
RTCORBA::ThreadpoolLane_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::ThreadpoolLane *
RTCORBA::ThreadpoolLane_var::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE
RTCORBA::ThreadpoolLane_var::operator const ::RTCORBA::ThreadpoolLane &() const // cast
{
  return *this->ptr_;
}

ACE_INLINE
RTCORBA::ThreadpoolLane_var::operator ::RTCORBA::ThreadpoolLane &() // cast
{
  return *this->ptr_;
}

ACE_INLINE
RTCORBA::ThreadpoolLane_var::operator ::RTCORBA::ThreadpoolLane &() const // cast
{
  return *this->ptr_;
}

ACE_INLINE const ::RTCORBA::ThreadpoolLane &
RTCORBA::ThreadpoolLane_var::in (void) const
{
  return *this->ptr_;
}

ACE_INLINE ::RTCORBA::ThreadpoolLane &
RTCORBA::ThreadpoolLane_var::inout (void)
{
  return *this->ptr_;
}

// mapping for fixed size
ACE_INLINE ::RTCORBA::ThreadpoolLane &
RTCORBA::ThreadpoolLane_var::out (void)
{
  return *this->ptr_;
}

ACE_INLINE ::RTCORBA::ThreadpoolLane
RTCORBA::ThreadpoolLane_var::_retn (void)
{
  return *this->ptr_;
}

ACE_INLINE ::RTCORBA::ThreadpoolLane *
RTCORBA::ThreadpoolLane_var::ptr (void) const
{
  return this->ptr_;
}


#if !defined (TAO_USE_SEQUENCE_TEMPLATES)

#if !defined (__TAO_UNBOUNDED_SEQUENCE_RTCORBA_THREADPOOLLANES_CI_)
#define __TAO_UNBOUNDED_SEQUENCE_RTCORBA_THREADPOOLLANES_CI_

  // = Static operations.
  ACE_INLINE RTCORBA::ThreadpoolLane *
  RTCORBA::_TAO_Unbounded_Sequence_RTCORBA_ThreadpoolLanes::allocbuf (CORBA::ULong size)
  // Allocate storage for the sequence.
  {
    RTCORBA::ThreadpoolLane *retval = 0;
    ACE_NEW_RETURN (retval, RTCORBA::ThreadpoolLane[size], 0);
    return retval;
  }

  ACE_INLINE void RTCORBA::_TAO_Unbounded_Sequence_RTCORBA_ThreadpoolLanes::freebuf (RTCORBA::ThreadpoolLane *buffer)
  // Free the sequence.
  {
    delete [] buffer;
  }

  ACE_INLINE
  RTCORBA::_TAO_Unbounded_Sequence_RTCORBA_ThreadpoolLanes::_TAO_Unbounded_Sequence_RTCORBA_ThreadpoolLanes (void) // Default constructor.
  {
  }

  ACE_INLINE
  RTCORBA::_TAO_Unbounded_Sequence_RTCORBA_ThreadpoolLanes::_TAO_Unbounded_Sequence_RTCORBA_ThreadpoolLanes (CORBA::ULong maximum) // Constructor using a maximum length value.
    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Sequence_RTCORBA_ThreadpoolLanes::allocbuf (maximum))
  {
  }

  ACE_INLINE
  RTCORBA::_TAO_Unbounded_Sequence_RTCORBA_ThreadpoolLanes::_TAO_Unbounded_Sequence_RTCORBA_ThreadpoolLanes (CORBA::ULong maximum,
    CORBA::ULong length,
    RTCORBA::ThreadpoolLane *data,
    CORBA::Boolean release)
  : TAO_Unbounded_Base_Sequence (maximum, length, data, release)
  {
  }

  ACE_INLINE
  RTCORBA::_TAO_Unbounded_Sequence_RTCORBA_ThreadpoolLanes::_TAO_Unbounded_Sequence_RTCORBA_ThreadpoolLanes (const _TAO_Unbounded_Sequence_RTCORBA_ThreadpoolLanes &rhs)
  // Copy constructor.
    : TAO_Unbounded_Base_Sequence (rhs)
  {
    if (rhs.buffer_ != 0)
    {
      RTCORBA::ThreadpoolLane *tmp1 = _TAO_Unbounded_Sequence_RTCORBA_ThreadpoolLanes::allocbuf (this->maximum_);
      RTCORBA::ThreadpoolLane * const tmp2 = ACE_reinterpret_cast (RTCORBA::ThreadpoolLane * ACE_CAST_CONST, rhs.buffer_);

      for (CORBA::ULong i = 0; i < this->length_; ++i)
        tmp1[i] = tmp2[i];

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

  ACE_INLINE RTCORBA::_TAO_Unbounded_Sequence_RTCORBA_ThreadpoolLanes &
  RTCORBA::_TAO_Unbounded_Sequence_RTCORBA_ThreadpoolLanes::operator= (const _TAO_Unbounded_Sequence_RTCORBA_ThreadpoolLanes &rhs)
  // Assignment operator.
  {
    if (this == &rhs)
      return *this;

    if (this->release_)
    {
      if (this->maximum_ < rhs.maximum_)
      {
        // free the old buffer
        RTCORBA::ThreadpoolLane *tmp = ACE_reinterpret_cast (RTCORBA::ThreadpoolLane *, this->buffer_);
        _TAO_Unbounded_Sequence_RTCORBA_ThreadpoolLanes::freebuf (tmp);
        this->buffer_ = _TAO_Unbounded_Sequence_RTCORBA_ThreadpoolLanes::allocbuf (rhs.maximum_);
      }
    }
    else
      this->buffer_ = _TAO_Unbounded_Sequence_RTCORBA_ThreadpoolLanes::allocbuf (rhs.maximum_);

    TAO_Unbounded_Base_Sequence::operator= (rhs);

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

    for (CORBA::ULong i = 0; i < this->length_; ++i)
      tmp1[i] = tmp2[i];

    return *this;
  }

  // = Accessors.
  ACE_INLINE RTCORBA::ThreadpoolLane &
  RTCORBA::_TAO_Unbounded_Sequence_RTCORBA_ThreadpoolLanes::operator[] (CORBA::ULong i)
  // operator []
  {
    ACE_ASSERT (i < this->maximum_);
    RTCORBA::ThreadpoolLane* tmp = ACE_reinterpret_cast(RTCORBA::ThreadpoolLane*,this->buffer_);
    return tmp[i];
  }

  ACE_INLINE const RTCORBA::ThreadpoolLane &
  RTCORBA::_TAO_Unbounded_Sequence_RTCORBA_ThreadpoolLanes::operator[] (CORBA::ULong i) const
  // operator []
  {
    ACE_ASSERT (i < this->maximum_);
    RTCORBA::ThreadpoolLane * const tmp = ACE_reinterpret_cast (RTCORBA::ThreadpoolLane* ACE_CAST_CONST, this->buffer_);
    return tmp[i];
  }

  // Implement the TAO_Base_Sequence methods (see Sequence.h)

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

  ACE_INLINE const RTCORBA::ThreadpoolLane *
  RTCORBA::_TAO_Unbounded_Sequence_RTCORBA_ThreadpoolLanes::get_buffer (void) const
  {
    return ACE_reinterpret_cast(const RTCORBA::ThreadpoolLane * ACE_CAST_CONST, this->buffer_);
  }

  ACE_INLINE void
  RTCORBA::_TAO_Unbounded_Sequence_RTCORBA_ThreadpoolLanes::replace (CORBA::ULong max,
  CORBA::ULong length,
  RTCORBA::ThreadpoolLane *data,
  CORBA::Boolean release)
  {
    this->maximum_ = max;
    this->length_ = length;
    if (this->buffer_ && this->release_ == 1)
    {
      RTCORBA::ThreadpoolLane *tmp = ACE_reinterpret_cast(RTCORBA::ThreadpoolLane*,this->buffer_);
      _TAO_Unbounded_Sequence_RTCORBA_ThreadpoolLanes::freebuf (tmp);
    }
    this->buffer_ = data;
    this->release_ = release;
  }

#endif /* end #if !defined */


#endif /* !TAO_USE_SEQUENCE_TEMPLATES */

#if !defined (_RTCORBA_THREADPOOLLANES_CI_)
#define _RTCORBA_THREADPOOLLANES_CI_

// *************************************************************
// Inline operations for class RTCORBA::ThreadpoolLanes_var
// *************************************************************

ACE_INLINE
RTCORBA::ThreadpoolLanes_var::ThreadpoolLanes_var (void) // default constructor
  : ptr_ (0)
{}

ACE_INLINE
RTCORBA::ThreadpoolLanes_var::ThreadpoolLanes_var (ThreadpoolLanes *p)
  : ptr_ (p)
{}

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

// fixed-size base types only
ACE_INLINE
RTCORBA::ThreadpoolLanes_var::ThreadpoolLanes_var (const ::RTCORBA::ThreadpoolLanes &p)
{
  ACE_NEW (this->ptr_, ::RTCORBA::ThreadpoolLanes (p));
}

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

ACE_INLINE RTCORBA::ThreadpoolLanes_var &
RTCORBA::ThreadpoolLanes_var::operator= (ThreadpoolLanes *p)
{
  delete this->ptr_;
  this->ptr_ = p;
  return *this;
}

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

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

ACE_INLINE const ::RTCORBA::ThreadpoolLanes *
RTCORBA::ThreadpoolLanes_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::ThreadpoolLanes *
RTCORBA::ThreadpoolLanes_var::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE
RTCORBA::ThreadpoolLanes_var::operator const ::RTCORBA::ThreadpoolLanes &() const // cast
{
  return *this->ptr_;
}

ACE_INLINE
RTCORBA::ThreadpoolLanes_var::operator ::RTCORBA::ThreadpoolLanes &() // cast
{
  return *this->ptr_;
}

ACE_INLINE
RTCORBA::ThreadpoolLanes_var::operator ::RTCORBA::ThreadpoolLanes &() const // cast
{
  return *this->ptr_;
}

ACE_INLINE RTCORBA::ThreadpoolLane &
RTCORBA::ThreadpoolLanes_var::operator[] (CORBA::ULong index)
{
  return this->ptr_->operator[] (index);
}

ACE_INLINE const ::RTCORBA::ThreadpoolLanes &
RTCORBA::ThreadpoolLanes_var::in (void) const
{
  return *this->ptr_;
}

ACE_INLINE ::RTCORBA::ThreadpoolLanes &
RTCORBA::ThreadpoolLanes_var::inout (void)
{
  return *this->ptr_;
}

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

ACE_INLINE ::RTCORBA::ThreadpoolLanes *
RTCORBA::ThreadpoolLanes_var::_retn (void)
{
  ::RTCORBA::ThreadpoolLanes *tmp = this->ptr_;
  this->ptr_ = 0;
  return tmp;
}

ACE_INLINE ::RTCORBA::ThreadpoolLanes *
RTCORBA::ThreadpoolLanes_var::ptr (void) const
{
  return this->ptr_;
}

// *************************************************************
// Inline operations for class RTCORBA::ThreadpoolLanes_out
// *************************************************************

ACE_INLINE
RTCORBA::ThreadpoolLanes_out::ThreadpoolLanes_out (ThreadpoolLanes *&p)
  : ptr_ (p)
{
  this->ptr_ = 0;
}

ACE_INLINE
RTCORBA::ThreadpoolLanes_out::ThreadpoolLanes_out (ThreadpoolLanes_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  delete this->ptr_;
  this->ptr_ = 0;
}

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

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

ACE_INLINE ::RTCORBA::ThreadpoolLanes_out &
RTCORBA::ThreadpoolLanes_out::operator= (ThreadpoolLanes *p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE
RTCORBA::ThreadpoolLanes_out::operator ::RTCORBA::ThreadpoolLanes *&() // cast
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::ThreadpoolLanes *&
RTCORBA::ThreadpoolLanes_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::ThreadpoolLanes *
RTCORBA::ThreadpoolLanes_out::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE RTCORBA::ThreadpoolLane &
RTCORBA::ThreadpoolLanes_out::operator[] (CORBA::ULong index)
{
  return this->ptr_->operator[] (index);
}


#endif /* end #if !defined */

ACE_INLINE
RTCORBA::PriorityModelPolicy::PriorityModelPolicy (void) // default constructor
{}

ACE_INLINE
RTCORBA::PriorityModelPolicy::~PriorityModelPolicy (void) // destructor
{}


#if !defined (_RTCORBA_PRIORITYMODELPOLICY___VAR_CI_)
#define _RTCORBA_PRIORITYMODELPOLICY___VAR_CI_

// *************************************************************
// Inline operations for class RTCORBA::PriorityModelPolicy_var
// *************************************************************

ACE_INLINE
RTCORBA::PriorityModelPolicy_var::PriorityModelPolicy_var (void) // default constructor
  : ptr_ (PriorityModelPolicy::_nil ())
{}

ACE_INLINE
RTCORBA::PriorityModelPolicy_var::PriorityModelPolicy_var (PriorityModelPolicy_ptr p)
  : ptr_ (p)
{}

ACE_INLINE ::RTCORBA::PriorityModelPolicy_ptr
RTCORBA::PriorityModelPolicy_var::ptr (void) const
{
  return this->ptr_;
}

ACE_INLINE
RTCORBA::PriorityModelPolicy_var::PriorityModelPolicy_var (const ::RTCORBA::PriorityModelPolicy_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (PriorityModelPolicy::_duplicate (p.ptr ()))
{}

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

ACE_INLINE RTCORBA::PriorityModelPolicy_var &
RTCORBA::PriorityModelPolicy_var::operator= (PriorityModelPolicy_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE
RTCORBA::PriorityModelPolicy_var::operator const ::RTCORBA::PriorityModelPolicy_ptr &() const // cast
{
  return this->ptr_;
}

ACE_INLINE
RTCORBA::PriorityModelPolicy_var::operator ::RTCORBA::PriorityModelPolicy_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::PriorityModelPolicy_ptr
RTCORBA::PriorityModelPolicy_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::PriorityModelPolicy_ptr
RTCORBA::PriorityModelPolicy_var::in (void) const
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::PriorityModelPolicy_ptr &
RTCORBA::PriorityModelPolicy_var::inout (void)
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::PriorityModelPolicy_ptr &
RTCORBA::PriorityModelPolicy_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::RTCORBA::PriorityModelPolicy::_nil ();
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::PriorityModelPolicy_ptr
RTCORBA::PriorityModelPolicy_var::_retn (void)
{
  // yield ownership of managed obj reference
  ::RTCORBA::PriorityModelPolicy_ptr val = this->ptr_;
  this->ptr_ = ::RTCORBA::PriorityModelPolicy::_nil ();
  return val;
}


#endif /* end #if !defined */


#if !defined (_RTCORBA_PRIORITYMODELPOLICY___OUT_CI_)
#define _RTCORBA_PRIORITYMODELPOLICY___OUT_CI_

// *************************************************************
// Inline operations for class RTCORBA::PriorityModelPolicy_out
// *************************************************************

ACE_INLINE
RTCORBA::PriorityModelPolicy_out::PriorityModelPolicy_out (PriorityModelPolicy_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::RTCORBA::PriorityModelPolicy::_nil ();
}

ACE_INLINE
RTCORBA::PriorityModelPolicy_out::PriorityModelPolicy_out (PriorityModelPolicy_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::RTCORBA::PriorityModelPolicy::_nil ();
}

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

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

ACE_INLINE RTCORBA::PriorityModelPolicy_out &
RTCORBA::PriorityModelPolicy_out::operator= (const ::RTCORBA::PriorityModelPolicy_var &p)
{
  this->ptr_ = ::RTCORBA::PriorityModelPolicy::_duplicate (p.ptr ());
  return *this;
}

ACE_INLINE RTCORBA::PriorityModelPolicy_out &
RTCORBA::PriorityModelPolicy_out::operator= (PriorityModelPolicy_ptr p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE
RTCORBA::PriorityModelPolicy_out::operator ::RTCORBA::PriorityModelPolicy_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::PriorityModelPolicy_ptr &
RTCORBA::PriorityModelPolicy_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::PriorityModelPolicy_ptr
RTCORBA::PriorityModelPolicy_out::operator-> (void)
{
  return this->ptr_;
}


#endif /* end #if !defined */

ACE_INLINE
RTCORBA::ThreadpoolPolicy::ThreadpoolPolicy (void) // default constructor
{}

ACE_INLINE
RTCORBA::ThreadpoolPolicy::~ThreadpoolPolicy (void) // destructor
{}


#if !defined (_RTCORBA_THREADPOOLPOLICY___VAR_CI_)
#define _RTCORBA_THREADPOOLPOLICY___VAR_CI_

// *************************************************************
// Inline operations for class RTCORBA::ThreadpoolPolicy_var
// *************************************************************

ACE_INLINE
RTCORBA::ThreadpoolPolicy_var::ThreadpoolPolicy_var (void) // default constructor
  : ptr_ (ThreadpoolPolicy::_nil ())
{}

ACE_INLINE
RTCORBA::ThreadpoolPolicy_var::ThreadpoolPolicy_var (ThreadpoolPolicy_ptr p)
  : ptr_ (p)
{}

ACE_INLINE ::RTCORBA::ThreadpoolPolicy_ptr
RTCORBA::ThreadpoolPolicy_var::ptr (void) const
{
  return this->ptr_;
}

ACE_INLINE
RTCORBA::ThreadpoolPolicy_var::ThreadpoolPolicy_var (const ::RTCORBA::ThreadpoolPolicy_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (ThreadpoolPolicy::_duplicate (p.ptr ()))
{}

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

ACE_INLINE RTCORBA::ThreadpoolPolicy_var &
RTCORBA::ThreadpoolPolicy_var::operator= (ThreadpoolPolicy_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE
RTCORBA::ThreadpoolPolicy_var::operator const ::RTCORBA::ThreadpoolPolicy_ptr &() const // cast
{
  return this->ptr_;
}

ACE_INLINE
RTCORBA::ThreadpoolPolicy_var::operator ::RTCORBA::ThreadpoolPolicy_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::ThreadpoolPolicy_ptr
RTCORBA::ThreadpoolPolicy_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::ThreadpoolPolicy_ptr
RTCORBA::ThreadpoolPolicy_var::in (void) const
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::ThreadpoolPolicy_ptr &
RTCORBA::ThreadpoolPolicy_var::inout (void)
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::ThreadpoolPolicy_ptr &
RTCORBA::ThreadpoolPolicy_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::RTCORBA::ThreadpoolPolicy::_nil ();
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::ThreadpoolPolicy_ptr
RTCORBA::ThreadpoolPolicy_var::_retn (void)
{
  // yield ownership of managed obj reference
  ::RTCORBA::ThreadpoolPolicy_ptr val = this->ptr_;
  this->ptr_ = ::RTCORBA::ThreadpoolPolicy::_nil ();
  return val;
}


#endif /* end #if !defined */


#if !defined (_RTCORBA_THREADPOOLPOLICY___OUT_CI_)
#define _RTCORBA_THREADPOOLPOLICY___OUT_CI_

// *************************************************************
// Inline operations for class RTCORBA::ThreadpoolPolicy_out
// *************************************************************

ACE_INLINE
RTCORBA::ThreadpoolPolicy_out::ThreadpoolPolicy_out (ThreadpoolPolicy_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::RTCORBA::ThreadpoolPolicy::_nil ();
}

ACE_INLINE
RTCORBA::ThreadpoolPolicy_out::ThreadpoolPolicy_out (ThreadpoolPolicy_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::RTCORBA::ThreadpoolPolicy::_nil ();
}

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

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

ACE_INLINE RTCORBA::ThreadpoolPolicy_out &
RTCORBA::ThreadpoolPolicy_out::operator= (const ::RTCORBA::ThreadpoolPolicy_var &p)
{
  this->ptr_ = ::RTCORBA::ThreadpoolPolicy::_duplicate (p.ptr ());
  return *this;
}

ACE_INLINE RTCORBA::ThreadpoolPolicy_out &
RTCORBA::ThreadpoolPolicy_out::operator= (ThreadpoolPolicy_ptr p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE
RTCORBA::ThreadpoolPolicy_out::operator ::RTCORBA::ThreadpoolPolicy_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::ThreadpoolPolicy_ptr &
RTCORBA::ThreadpoolPolicy_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::ThreadpoolPolicy_ptr
RTCORBA::ThreadpoolPolicy_out::operator-> (void)
{
  return this->ptr_;
}


#endif /* end #if !defined */

ACE_INLINE
RTCORBA::PrivateConnectionPolicy::PrivateConnectionPolicy (void) // default constructor
{}

ACE_INLINE
RTCORBA::PrivateConnectionPolicy::~PrivateConnectionPolicy (void) // destructor
{}


#if !defined (_RTCORBA_PRIVATECONNECTIONPOLICY___VAR_CI_)
#define _RTCORBA_PRIVATECONNECTIONPOLICY___VAR_CI_

// *************************************************************
// Inline operations for class RTCORBA::PrivateConnectionPolicy_var
// *************************************************************

ACE_INLINE
RTCORBA::PrivateConnectionPolicy_var::PrivateConnectionPolicy_var (void) // default constructor
  : ptr_ (PrivateConnectionPolicy::_nil ())
{}

ACE_INLINE
RTCORBA::PrivateConnectionPolicy_var::PrivateConnectionPolicy_var (PrivateConnectionPolicy_ptr p)
  : ptr_ (p)
{}

ACE_INLINE ::RTCORBA::PrivateConnectionPolicy_ptr
RTCORBA::PrivateConnectionPolicy_var::ptr (void) const
{
  return this->ptr_;
}

ACE_INLINE
RTCORBA::PrivateConnectionPolicy_var::PrivateConnectionPolicy_var (const ::RTCORBA::PrivateConnectionPolicy_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (PrivateConnectionPolicy::_duplicate (p.ptr ()))
{}

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

ACE_INLINE RTCORBA::PrivateConnectionPolicy_var &
RTCORBA::PrivateConnectionPolicy_var::operator= (PrivateConnectionPolicy_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE
RTCORBA::PrivateConnectionPolicy_var::operator const ::RTCORBA::PrivateConnectionPolicy_ptr &() const // cast
{
  return this->ptr_;
}

ACE_INLINE
RTCORBA::PrivateConnectionPolicy_var::operator ::RTCORBA::PrivateConnectionPolicy_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::PrivateConnectionPolicy_ptr
RTCORBA::PrivateConnectionPolicy_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::PrivateConnectionPolicy_ptr
RTCORBA::PrivateConnectionPolicy_var::in (void) const
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::PrivateConnectionPolicy_ptr &
RTCORBA::PrivateConnectionPolicy_var::inout (void)
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::PrivateConnectionPolicy_ptr &
RTCORBA::PrivateConnectionPolicy_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::RTCORBA::PrivateConnectionPolicy::_nil ();
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::PrivateConnectionPolicy_ptr
RTCORBA::PrivateConnectionPolicy_var::_retn (void)
{
  // yield ownership of managed obj reference
  ::RTCORBA::PrivateConnectionPolicy_ptr val = this->ptr_;
  this->ptr_ = ::RTCORBA::PrivateConnectionPolicy::_nil ();
  return val;
}


#endif /* end #if !defined */


#if !defined (_RTCORBA_PRIVATECONNECTIONPOLICY___OUT_CI_)
#define _RTCORBA_PRIVATECONNECTIONPOLICY___OUT_CI_

// *************************************************************
// Inline operations for class RTCORBA::PrivateConnectionPolicy_out
// *************************************************************

ACE_INLINE
RTCORBA::PrivateConnectionPolicy_out::PrivateConnectionPolicy_out (PrivateConnectionPolicy_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::RTCORBA::PrivateConnectionPolicy::_nil ();
}

ACE_INLINE
RTCORBA::PrivateConnectionPolicy_out::PrivateConnectionPolicy_out (PrivateConnectionPolicy_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::RTCORBA::PrivateConnectionPolicy::_nil ();
}

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

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

ACE_INLINE RTCORBA::PrivateConnectionPolicy_out &
RTCORBA::PrivateConnectionPolicy_out::operator= (const ::RTCORBA::PrivateConnectionPolicy_var &p)
{
  this->ptr_ = ::RTCORBA::PrivateConnectionPolicy::_duplicate (p.ptr ());
  return *this;
}

ACE_INLINE RTCORBA::PrivateConnectionPolicy_out &
RTCORBA::PrivateConnectionPolicy_out::operator= (PrivateConnectionPolicy_ptr p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE
RTCORBA::PrivateConnectionPolicy_out::operator ::RTCORBA::PrivateConnectionPolicy_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::PrivateConnectionPolicy_ptr &
RTCORBA::PrivateConnectionPolicy_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::PrivateConnectionPolicy_ptr
RTCORBA::PrivateConnectionPolicy_out::operator-> (void)
{
  return this->ptr_;
}


#endif /* end #if !defined */

// *************************************************************
// Inline operations for class RTCORBA::PriorityBand_var
// *************************************************************

ACE_INLINE
RTCORBA::PriorityBand_var::PriorityBand_var (void) // default constructor
  : ptr_ (0)
{}

ACE_INLINE
RTCORBA::PriorityBand_var::PriorityBand_var (PriorityBand *p)
  : ptr_ (p)
{}

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

// fixed-size types only
ACE_INLINE
RTCORBA::PriorityBand_var::PriorityBand_var (const ::RTCORBA::PriorityBand &p)
{
  ACE_NEW (this->ptr_, ::RTCORBA::PriorityBand (p));
}

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

ACE_INLINE RTCORBA::PriorityBand_var &
RTCORBA::PriorityBand_var::operator= (PriorityBand *p)
{
  delete this->ptr_;
  this->ptr_ = p;
  return *this;
}

ACE_INLINE ::RTCORBA::PriorityBand_var &
RTCORBA::PriorityBand_var::operator= (const ::RTCORBA::PriorityBand_var &p)
{
  if (this != &p)
  {
    delete this->ptr_;
    ACE_NEW_RETURN (this->ptr_, ::RTCORBA::PriorityBand (*p.ptr_), *this);
  }
  return *this;
}

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

ACE_INLINE const ::RTCORBA::PriorityBand *
RTCORBA::PriorityBand_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::PriorityBand *
RTCORBA::PriorityBand_var::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE
RTCORBA::PriorityBand_var::operator const ::RTCORBA::PriorityBand &() const // cast
{
  return *this->ptr_;
}

ACE_INLINE
RTCORBA::PriorityBand_var::operator ::RTCORBA::PriorityBand &() // cast
{
  return *this->ptr_;
}

ACE_INLINE
RTCORBA::PriorityBand_var::operator ::RTCORBA::PriorityBand &() const // cast
{
  return *this->ptr_;
}

ACE_INLINE const ::RTCORBA::PriorityBand &
RTCORBA::PriorityBand_var::in (void) const
{
  return *this->ptr_;
}

ACE_INLINE ::RTCORBA::PriorityBand &
RTCORBA::PriorityBand_var::inout (void)
{
  return *this->ptr_;
}

// mapping for fixed size
ACE_INLINE ::RTCORBA::PriorityBand &
RTCORBA::PriorityBand_var::out (void)
{
  return *this->ptr_;
}

ACE_INLINE ::RTCORBA::PriorityBand
RTCORBA::PriorityBand_var::_retn (void)
{
  return *this->ptr_;
}

ACE_INLINE ::RTCORBA::PriorityBand *
RTCORBA::PriorityBand_var::ptr (void) const
{
  return this->ptr_;
}


#if !defined (TAO_USE_SEQUENCE_TEMPLATES)

#if !defined (__TAO_UNBOUNDED_SEQUENCE_RTCORBA_PRIORITYBANDS_CI_)
#define __TAO_UNBOUNDED_SEQUENCE_RTCORBA_PRIORITYBANDS_CI_

  // = Static operations.
  ACE_INLINE RTCORBA::PriorityBand *
  RTCORBA::_TAO_Unbounded_Sequence_RTCORBA_PriorityBands::allocbuf (CORBA::ULong size)
  // Allocate storage for the sequence.
  {
    RTCORBA::PriorityBand *retval = 0;
    ACE_NEW_RETURN (retval, RTCORBA::PriorityBand[size], 0);
    return retval;
  }

  ACE_INLINE void RTCORBA::_TAO_Unbounded_Sequence_RTCORBA_PriorityBands::freebuf (RTCORBA::PriorityBand *buffer)
  // Free the sequence.
  {
    delete [] buffer;
  }

  ACE_INLINE
  RTCORBA::_TAO_Unbounded_Sequence_RTCORBA_PriorityBands::_TAO_Unbounded_Sequence_RTCORBA_PriorityBands (void) // Default constructor.
  {
  }

  ACE_INLINE
  RTCORBA::_TAO_Unbounded_Sequence_RTCORBA_PriorityBands::_TAO_Unbounded_Sequence_RTCORBA_PriorityBands (CORBA::ULong maximum) // Constructor using a maximum length value.
    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Sequence_RTCORBA_PriorityBands::allocbuf (maximum))
  {
  }

  ACE_INLINE
  RTCORBA::_TAO_Unbounded_Sequence_RTCORBA_PriorityBands::_TAO_Unbounded_Sequence_RTCORBA_PriorityBands (CORBA::ULong maximum,
    CORBA::ULong length,
    RTCORBA::PriorityBand *data,
    CORBA::Boolean release)
  : TAO_Unbounded_Base_Sequence (maximum, length, data, release)
  {
  }

  ACE_INLINE
  RTCORBA::_TAO_Unbounded_Sequence_RTCORBA_PriorityBands::_TAO_Unbounded_Sequence_RTCORBA_PriorityBands (const _TAO_Unbounded_Sequence_RTCORBA_PriorityBands &rhs)
  // Copy constructor.
    : TAO_Unbounded_Base_Sequence (rhs)
  {
    if (rhs.buffer_ != 0)
    {
      RTCORBA::PriorityBand *tmp1 = _TAO_Unbounded_Sequence_RTCORBA_PriorityBands::allocbuf (this->maximum_);
      RTCORBA::PriorityBand * const tmp2 = ACE_reinterpret_cast (RTCORBA::PriorityBand * ACE_CAST_CONST, rhs.buffer_);

      for (CORBA::ULong i = 0; i < this->length_; ++i)
        tmp1[i] = tmp2[i];

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

  ACE_INLINE RTCORBA::_TAO_Unbounded_Sequence_RTCORBA_PriorityBands &
  RTCORBA::_TAO_Unbounded_Sequence_RTCORBA_PriorityBands::operator= (const _TAO_Unbounded_Sequence_RTCORBA_PriorityBands &rhs)
  // Assignment operator.
  {
    if (this == &rhs)
      return *this;

    if (this->release_)
    {
      if (this->maximum_ < rhs.maximum_)
      {
        // free the old buffer
        RTCORBA::PriorityBand *tmp = ACE_reinterpret_cast (RTCORBA::PriorityBand *, this->buffer_);
        _TAO_Unbounded_Sequence_RTCORBA_PriorityBands::freebuf (tmp);
        this->buffer_ = _TAO_Unbounded_Sequence_RTCORBA_PriorityBands::allocbuf (rhs.maximum_);
      }
    }
    else
      this->buffer_ = _TAO_Unbounded_Sequence_RTCORBA_PriorityBands::allocbuf (rhs.maximum_);

    TAO_Unbounded_Base_Sequence::operator= (rhs);

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

    for (CORBA::ULong i = 0; i < this->length_; ++i)
      tmp1[i] = tmp2[i];

    return *this;
  }

  // = Accessors.
  ACE_INLINE RTCORBA::PriorityBand &
  RTCORBA::_TAO_Unbounded_Sequence_RTCORBA_PriorityBands::operator[] (CORBA::ULong i)
  // operator []
  {
    ACE_ASSERT (i < this->maximum_);
    RTCORBA::PriorityBand* tmp = ACE_reinterpret_cast(RTCORBA::PriorityBand*,this->buffer_);
    return tmp[i];
  }

  ACE_INLINE const RTCORBA::PriorityBand &
  RTCORBA::_TAO_Unbounded_Sequence_RTCORBA_PriorityBands::operator[] (CORBA::ULong i) const
  // operator []
  {
    ACE_ASSERT (i < this->maximum_);
    RTCORBA::PriorityBand * const tmp = ACE_reinterpret_cast (RTCORBA::PriorityBand* ACE_CAST_CONST, this->buffer_);
    return tmp[i];
  }

  // Implement the TAO_Base_Sequence methods (see Sequence.h)

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

  ACE_INLINE const RTCORBA::PriorityBand *
  RTCORBA::_TAO_Unbounded_Sequence_RTCORBA_PriorityBands::get_buffer (void) const
  {
    return ACE_reinterpret_cast(const RTCORBA::PriorityBand * ACE_CAST_CONST, this->buffer_);
  }

  ACE_INLINE void
  RTCORBA::_TAO_Unbounded_Sequence_RTCORBA_PriorityBands::replace (CORBA::ULong max,
  CORBA::ULong length,
  RTCORBA::PriorityBand *data,
  CORBA::Boolean release)
  {
    this->maximum_ = max;
    this->length_ = length;
    if (this->buffer_ && this->release_ == 1)
    {
      RTCORBA::PriorityBand *tmp = ACE_reinterpret_cast(RTCORBA::PriorityBand*,this->buffer_);
      _TAO_Unbounded_Sequence_RTCORBA_PriorityBands::freebuf (tmp);
    }
    this->buffer_ = data;
    this->release_ = release;
  }

#endif /* end #if !defined */


#endif /* !TAO_USE_SEQUENCE_TEMPLATES */

#if !defined (_RTCORBA_PRIORITYBANDS_CI_)
#define _RTCORBA_PRIORITYBANDS_CI_

// *************************************************************
// Inline operations for class RTCORBA::PriorityBands_var
// *************************************************************

ACE_INLINE
RTCORBA::PriorityBands_var::PriorityBands_var (void) // default constructor
  : ptr_ (0)
{}

ACE_INLINE
RTCORBA::PriorityBands_var::PriorityBands_var (PriorityBands *p)
  : ptr_ (p)
{}

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

// fixed-size base types only
ACE_INLINE
RTCORBA::PriorityBands_var::PriorityBands_var (const ::RTCORBA::PriorityBands &p)
{
  ACE_NEW (this->ptr_, ::RTCORBA::PriorityBands (p));
}

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

ACE_INLINE RTCORBA::PriorityBands_var &
RTCORBA::PriorityBands_var::operator= (PriorityBands *p)
{
  delete this->ptr_;
  this->ptr_ = p;
  return *this;
}

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

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

ACE_INLINE const ::RTCORBA::PriorityBands *
RTCORBA::PriorityBands_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::PriorityBands *
RTCORBA::PriorityBands_var::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE
RTCORBA::PriorityBands_var::operator const ::RTCORBA::PriorityBands &() const // cast
{
  return *this->ptr_;
}

ACE_INLINE
RTCORBA::PriorityBands_var::operator ::RTCORBA::PriorityBands &() // cast
{
  return *this->ptr_;
}

ACE_INLINE
RTCORBA::PriorityBands_var::operator ::RTCORBA::PriorityBands &() const // cast
{
  return *this->ptr_;
}

ACE_INLINE RTCORBA::PriorityBand &
RTCORBA::PriorityBands_var::operator[] (CORBA::ULong index)
{
  return this->ptr_->operator[] (index);
}

ACE_INLINE const ::RTCORBA::PriorityBands &
RTCORBA::PriorityBands_var::in (void) const
{
  return *this->ptr_;
}

ACE_INLINE ::RTCORBA::PriorityBands &
RTCORBA::PriorityBands_var::inout (void)
{
  return *this->ptr_;
}

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

ACE_INLINE ::RTCORBA::PriorityBands *
RTCORBA::PriorityBands_var::_retn (void)
{
  ::RTCORBA::PriorityBands *tmp = this->ptr_;
  this->ptr_ = 0;
  return tmp;
}

ACE_INLINE ::RTCORBA::PriorityBands *
RTCORBA::PriorityBands_var::ptr (void) const
{
  return this->ptr_;
}

// *************************************************************
// Inline operations for class RTCORBA::PriorityBands_out
// *************************************************************

ACE_INLINE
RTCORBA::PriorityBands_out::PriorityBands_out (PriorityBands *&p)
  : ptr_ (p)
{
  this->ptr_ = 0;
}

ACE_INLINE
RTCORBA::PriorityBands_out::PriorityBands_out (PriorityBands_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  delete this->ptr_;
  this->ptr_ = 0;
}

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

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

ACE_INLINE ::RTCORBA::PriorityBands_out &
RTCORBA::PriorityBands_out::operator= (PriorityBands *p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE
RTCORBA::PriorityBands_out::operator ::RTCORBA::PriorityBands *&() // cast
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::PriorityBands *&
RTCORBA::PriorityBands_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::PriorityBands *
RTCORBA::PriorityBands_out::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE RTCORBA::PriorityBand &
RTCORBA::PriorityBands_out::operator[] (CORBA::ULong index)
{
  return this->ptr_->operator[] (index);
}


#endif /* end #if !defined */

ACE_INLINE
RTCORBA::PriorityBandedConnectionPolicy::PriorityBandedConnectionPolicy (void) // default constructor
{}

ACE_INLINE
RTCORBA::PriorityBandedConnectionPolicy::~PriorityBandedConnectionPolicy (void) // destructor
{}


#if !defined (_RTCORBA_PRIORITYBANDEDCONNECTIONPOLICY___VAR_CI_)
#define _RTCORBA_PRIORITYBANDEDCONNECTIONPOLICY___VAR_CI_

// *************************************************************
// Inline operations for class RTCORBA::PriorityBandedConnectionPolicy_var
// *************************************************************

ACE_INLINE
RTCORBA::PriorityBandedConnectionPolicy_var::PriorityBandedConnectionPolicy_var (void) // default constructor
  : ptr_ (PriorityBandedConnectionPolicy::_nil ())
{}

ACE_INLINE
RTCORBA::PriorityBandedConnectionPolicy_var::PriorityBandedConnectionPolicy_var (PriorityBandedConnectionPolicy_ptr p)
  : ptr_ (p)
{}

ACE_INLINE ::RTCORBA::PriorityBandedConnectionPolicy_ptr
RTCORBA::PriorityBandedConnectionPolicy_var::ptr (void) const
{
  return this->ptr_;
}

ACE_INLINE
RTCORBA::PriorityBandedConnectionPolicy_var::PriorityBandedConnectionPolicy_var (const ::RTCORBA::PriorityBandedConnectionPolicy_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (PriorityBandedConnectionPolicy::_duplicate (p.ptr ()))
{}

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

ACE_INLINE RTCORBA::PriorityBandedConnectionPolicy_var &
RTCORBA::PriorityBandedConnectionPolicy_var::operator= (PriorityBandedConnectionPolicy_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE
RTCORBA::PriorityBandedConnectionPolicy_var::operator const ::RTCORBA::PriorityBandedConnectionPolicy_ptr &() const // cast
{
  return this->ptr_;
}

ACE_INLINE
RTCORBA::PriorityBandedConnectionPolicy_var::operator ::RTCORBA::PriorityBandedConnectionPolicy_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::PriorityBandedConnectionPolicy_ptr
RTCORBA::PriorityBandedConnectionPolicy_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::PriorityBandedConnectionPolicy_ptr
RTCORBA::PriorityBandedConnectionPolicy_var::in (void) const
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::PriorityBandedConnectionPolicy_ptr &
RTCORBA::PriorityBandedConnectionPolicy_var::inout (void)
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::PriorityBandedConnectionPolicy_ptr &
RTCORBA::PriorityBandedConnectionPolicy_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::RTCORBA::PriorityBandedConnectionPolicy::_nil ();
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::PriorityBandedConnectionPolicy_ptr
RTCORBA::PriorityBandedConnectionPolicy_var::_retn (void)
{
  // yield ownership of managed obj reference
  ::RTCORBA::PriorityBandedConnectionPolicy_ptr val = this->ptr_;
  this->ptr_ = ::RTCORBA::PriorityBandedConnectionPolicy::_nil ();
  return val;
}


#endif /* end #if !defined */


#if !defined (_RTCORBA_PRIORITYBANDEDCONNECTIONPOLICY___OUT_CI_)
#define _RTCORBA_PRIORITYBANDEDCONNECTIONPOLICY___OUT_CI_

// *************************************************************
// Inline operations for class RTCORBA::PriorityBandedConnectionPolicy_out
// *************************************************************

ACE_INLINE
RTCORBA::PriorityBandedConnectionPolicy_out::PriorityBandedConnectionPolicy_out (PriorityBandedConnectionPolicy_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::RTCORBA::PriorityBandedConnectionPolicy::_nil ();
}

ACE_INLINE
RTCORBA::PriorityBandedConnectionPolicy_out::PriorityBandedConnectionPolicy_out (PriorityBandedConnectionPolicy_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::RTCORBA::PriorityBandedConnectionPolicy::_nil ();
}

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

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

ACE_INLINE RTCORBA::PriorityBandedConnectionPolicy_out &
RTCORBA::PriorityBandedConnectionPolicy_out::operator= (const ::RTCORBA::PriorityBandedConnectionPolicy_var &p)
{
  this->ptr_ = ::RTCORBA::PriorityBandedConnectionPolicy::_duplicate (p.ptr ());
  return *this;
}

ACE_INLINE RTCORBA::PriorityBandedConnectionPolicy_out &
RTCORBA::PriorityBandedConnectionPolicy_out::operator= (PriorityBandedConnectionPolicy_ptr p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE
RTCORBA::PriorityBandedConnectionPolicy_out::operator ::RTCORBA::PriorityBandedConnectionPolicy_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::PriorityBandedConnectionPolicy_ptr &
RTCORBA::PriorityBandedConnectionPolicy_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::PriorityBandedConnectionPolicy_ptr
RTCORBA::PriorityBandedConnectionPolicy_out::operator-> (void)
{
  return this->ptr_;
}


#endif /* end #if !defined */

ACE_INLINE
RTCORBA::ProtocolProperties::ProtocolProperties (void) // default constructor
{}

ACE_INLINE
RTCORBA::ProtocolProperties::~ProtocolProperties (void) // destructor
{}


#if !defined (_RTCORBA_PROTOCOLPROPERTIES___VAR_CI_)
#define _RTCORBA_PROTOCOLPROPERTIES___VAR_CI_

// *************************************************************
// Inline operations for class RTCORBA::ProtocolProperties_var
// *************************************************************

ACE_INLINE
RTCORBA::ProtocolProperties_var::ProtocolProperties_var (void) // default constructor
  : ptr_ (ProtocolProperties::_nil ())
{}

ACE_INLINE
RTCORBA::ProtocolProperties_var::ProtocolProperties_var (ProtocolProperties_ptr p)
  : ptr_ (p)
{}

ACE_INLINE ::RTCORBA::ProtocolProperties_ptr
RTCORBA::ProtocolProperties_var::ptr (void) const
{
  return this->ptr_;
}

ACE_INLINE
RTCORBA::ProtocolProperties_var::ProtocolProperties_var (const ::RTCORBA::ProtocolProperties_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (ProtocolProperties::_duplicate (p.ptr ()))
{}

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

ACE_INLINE RTCORBA::ProtocolProperties_var &
RTCORBA::ProtocolProperties_var::operator= (ProtocolProperties_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE
RTCORBA::ProtocolProperties_var::operator const ::RTCORBA::ProtocolProperties_ptr &() const // cast
{
  return this->ptr_;
}

ACE_INLINE
RTCORBA::ProtocolProperties_var::operator ::RTCORBA::ProtocolProperties_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::ProtocolProperties_ptr
RTCORBA::ProtocolProperties_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::ProtocolProperties_ptr
RTCORBA::ProtocolProperties_var::in (void) const
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::ProtocolProperties_ptr &
RTCORBA::ProtocolProperties_var::inout (void)
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::ProtocolProperties_ptr &
RTCORBA::ProtocolProperties_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::RTCORBA::ProtocolProperties::_nil ();
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::ProtocolProperties_ptr
RTCORBA::ProtocolProperties_var::_retn (void)
{
  // yield ownership of managed obj reference
  ::RTCORBA::ProtocolProperties_ptr val = this->ptr_;
  this->ptr_ = ::RTCORBA::ProtocolProperties::_nil ();
  return val;
}


#endif /* end #if !defined */


#if !defined (_RTCORBA_PROTOCOLPROPERTIES___OUT_CI_)
#define _RTCORBA_PROTOCOLPROPERTIES___OUT_CI_

// *************************************************************
// Inline operations for class RTCORBA::ProtocolProperties_out
// *************************************************************

ACE_INLINE
RTCORBA::ProtocolProperties_out::ProtocolProperties_out (ProtocolProperties_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::RTCORBA::ProtocolProperties::_nil ();
}

ACE_INLINE
RTCORBA::ProtocolProperties_out::ProtocolProperties_out (ProtocolProperties_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::RTCORBA::ProtocolProperties::_nil ();
}

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

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

ACE_INLINE RTCORBA::ProtocolProperties_out &
RTCORBA::ProtocolProperties_out::operator= (const ::RTCORBA::ProtocolProperties_var &p)
{
  this->ptr_ = ::RTCORBA::ProtocolProperties::_duplicate (p.ptr ());
  return *this;
}

ACE_INLINE RTCORBA::ProtocolProperties_out &
RTCORBA::ProtocolProperties_out::operator= (ProtocolProperties_ptr p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE
RTCORBA::ProtocolProperties_out::operator ::RTCORBA::ProtocolProperties_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::ProtocolProperties_ptr &
RTCORBA::ProtocolProperties_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::ProtocolProperties_ptr
RTCORBA::ProtocolProperties_out::operator-> (void)
{
  return this->ptr_;
}


#endif /* end #if !defined */

ACE_INLINE
RTCORBA::TCPProtocolProperties::TCPProtocolProperties (void) // default constructor
{}

ACE_INLINE
RTCORBA::TCPProtocolProperties::~TCPProtocolProperties (void) // destructor
{}


#if !defined (_RTCORBA_TCPPROTOCOLPROPERTIES___VAR_CI_)
#define _RTCORBA_TCPPROTOCOLPROPERTIES___VAR_CI_

// *************************************************************
// Inline operations for class RTCORBA::TCPProtocolProperties_var
// *************************************************************

ACE_INLINE
RTCORBA::TCPProtocolProperties_var::TCPProtocolProperties_var (void) // default constructor
  : ptr_ (TCPProtocolProperties::_nil ())
{}

ACE_INLINE
RTCORBA::TCPProtocolProperties_var::TCPProtocolProperties_var (TCPProtocolProperties_ptr p)
  : ptr_ (p)
{}

ACE_INLINE ::RTCORBA::TCPProtocolProperties_ptr
RTCORBA::TCPProtocolProperties_var::ptr (void) const
{
  return this->ptr_;
}

ACE_INLINE
RTCORBA::TCPProtocolProperties_var::TCPProtocolProperties_var (const ::RTCORBA::TCPProtocolProperties_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (TCPProtocolProperties::_duplicate (p.ptr ()))
{}

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

ACE_INLINE RTCORBA::TCPProtocolProperties_var &
RTCORBA::TCPProtocolProperties_var::operator= (TCPProtocolProperties_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE
RTCORBA::TCPProtocolProperties_var::operator const ::RTCORBA::TCPProtocolProperties_ptr &() const // cast
{
  return this->ptr_;
}

ACE_INLINE
RTCORBA::TCPProtocolProperties_var::operator ::RTCORBA::TCPProtocolProperties_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::TCPProtocolProperties_ptr
RTCORBA::TCPProtocolProperties_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::TCPProtocolProperties_ptr
RTCORBA::TCPProtocolProperties_var::in (void) const
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::TCPProtocolProperties_ptr &
RTCORBA::TCPProtocolProperties_var::inout (void)
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::TCPProtocolProperties_ptr &
RTCORBA::TCPProtocolProperties_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::RTCORBA::TCPProtocolProperties::_nil ();
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::TCPProtocolProperties_ptr
RTCORBA::TCPProtocolProperties_var::_retn (void)
{
  // yield ownership of managed obj reference
  ::RTCORBA::TCPProtocolProperties_ptr val = this->ptr_;
  this->ptr_ = ::RTCORBA::TCPProtocolProperties::_nil ();
  return val;
}


#endif /* end #if !defined */


#if !defined (_RTCORBA_TCPPROTOCOLPROPERTIES___OUT_CI_)
#define _RTCORBA_TCPPROTOCOLPROPERTIES___OUT_CI_

// *************************************************************
// Inline operations for class RTCORBA::TCPProtocolProperties_out
// *************************************************************

ACE_INLINE
RTCORBA::TCPProtocolProperties_out::TCPProtocolProperties_out (TCPProtocolProperties_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::RTCORBA::TCPProtocolProperties::_nil ();
}

ACE_INLINE
RTCORBA::TCPProtocolProperties_out::TCPProtocolProperties_out (TCPProtocolProperties_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::RTCORBA::TCPProtocolProperties::_nil ();
}

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

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

ACE_INLINE RTCORBA::TCPProtocolProperties_out &
RTCORBA::TCPProtocolProperties_out::operator= (const ::RTCORBA::TCPProtocolProperties_var &p)
{
  this->ptr_ = ::RTCORBA::TCPProtocolProperties::_duplicate (p.ptr ());
  return *this;
}

ACE_INLINE RTCORBA::TCPProtocolProperties_out &
RTCORBA::TCPProtocolProperties_out::operator= (TCPProtocolProperties_ptr p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE
RTCORBA::TCPProtocolProperties_out::operator ::RTCORBA::TCPProtocolProperties_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::TCPProtocolProperties_ptr &
RTCORBA::TCPProtocolProperties_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::TCPProtocolProperties_ptr
RTCORBA::TCPProtocolProperties_out::operator-> (void)
{
  return this->ptr_;
}


#endif /* end #if !defined */

ACE_INLINE
RTCORBA::GIOPProtocolProperties::GIOPProtocolProperties (void) // default constructor
{}

ACE_INLINE
RTCORBA::GIOPProtocolProperties::~GIOPProtocolProperties (void) // destructor
{}


#if !defined (_RTCORBA_GIOPPROTOCOLPROPERTIES___VAR_CI_)
#define _RTCORBA_GIOPPROTOCOLPROPERTIES___VAR_CI_

// *************************************************************
// Inline operations for class RTCORBA::GIOPProtocolProperties_var
// *************************************************************

ACE_INLINE
RTCORBA::GIOPProtocolProperties_var::GIOPProtocolProperties_var (void) // default constructor
  : ptr_ (GIOPProtocolProperties::_nil ())
{}

ACE_INLINE
RTCORBA::GIOPProtocolProperties_var::GIOPProtocolProperties_var (GIOPProtocolProperties_ptr p)
  : ptr_ (p)
{}

ACE_INLINE ::RTCORBA::GIOPProtocolProperties_ptr
RTCORBA::GIOPProtocolProperties_var::ptr (void) const
{
  return this->ptr_;
}

ACE_INLINE
RTCORBA::GIOPProtocolProperties_var::GIOPProtocolProperties_var (const ::RTCORBA::GIOPProtocolProperties_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (GIOPProtocolProperties::_duplicate (p.ptr ()))
{}

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

ACE_INLINE RTCORBA::GIOPProtocolProperties_var &
RTCORBA::GIOPProtocolProperties_var::operator= (GIOPProtocolProperties_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE
RTCORBA::GIOPProtocolProperties_var::operator const ::RTCORBA::GIOPProtocolProperties_ptr &() const // cast
{
  return this->ptr_;
}

ACE_INLINE
RTCORBA::GIOPProtocolProperties_var::operator ::RTCORBA::GIOPProtocolProperties_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::GIOPProtocolProperties_ptr
RTCORBA::GIOPProtocolProperties_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::GIOPProtocolProperties_ptr
RTCORBA::GIOPProtocolProperties_var::in (void) const
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::GIOPProtocolProperties_ptr &
RTCORBA::GIOPProtocolProperties_var::inout (void)
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::GIOPProtocolProperties_ptr &
RTCORBA::GIOPProtocolProperties_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::RTCORBA::GIOPProtocolProperties::_nil ();
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::GIOPProtocolProperties_ptr
RTCORBA::GIOPProtocolProperties_var::_retn (void)
{
  // yield ownership of managed obj reference
  ::RTCORBA::GIOPProtocolProperties_ptr val = this->ptr_;
  this->ptr_ = ::RTCORBA::GIOPProtocolProperties::_nil ();
  return val;
}


#endif /* end #if !defined */


#if !defined (_RTCORBA_GIOPPROTOCOLPROPERTIES___OUT_CI_)
#define _RTCORBA_GIOPPROTOCOLPROPERTIES___OUT_CI_

// *************************************************************
// Inline operations for class RTCORBA::GIOPProtocolProperties_out
// *************************************************************

ACE_INLINE
RTCORBA::GIOPProtocolProperties_out::GIOPProtocolProperties_out (GIOPProtocolProperties_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::RTCORBA::GIOPProtocolProperties::_nil ();
}

ACE_INLINE
RTCORBA::GIOPProtocolProperties_out::GIOPProtocolProperties_out (GIOPProtocolProperties_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::RTCORBA::GIOPProtocolProperties::_nil ();
}

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

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

ACE_INLINE RTCORBA::GIOPProtocolProperties_out &
RTCORBA::GIOPProtocolProperties_out::operator= (const ::RTCORBA::GIOPProtocolProperties_var &p)
{
  this->ptr_ = ::RTCORBA::GIOPProtocolProperties::_duplicate (p.ptr ());
  return *this;
}

ACE_INLINE RTCORBA::GIOPProtocolProperties_out &
RTCORBA::GIOPProtocolProperties_out::operator= (GIOPProtocolProperties_ptr p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE
RTCORBA::GIOPProtocolProperties_out::operator ::RTCORBA::GIOPProtocolProperties_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::GIOPProtocolProperties_ptr &
RTCORBA::GIOPProtocolProperties_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::GIOPProtocolProperties_ptr
RTCORBA::GIOPProtocolProperties_out::operator-> (void)
{
  return this->ptr_;
}


#endif /* end #if !defined */


#if !defined (_RTCORBA_UNIXDOMAINPROTOCOLPROPERTIES___VAR_CI_)
#define _RTCORBA_UNIXDOMAINPROTOCOLPROPERTIES___VAR_CI_

// *************************************************************
// Inline operations for class RTCORBA::UnixDomainProtocolProperties_var
// *************************************************************

ACE_INLINE
RTCORBA::UnixDomainProtocolProperties_var::UnixDomainProtocolProperties_var (void) // default constructor
  : ptr_ (UnixDomainProtocolProperties::_nil ())
{}

ACE_INLINE ::RTCORBA::UnixDomainProtocolProperties_ptr
RTCORBA::UnixDomainProtocolProperties_var::ptr (void) const
{
  return this->ptr_;
}

ACE_INLINE
RTCORBA::UnixDomainProtocolProperties_var::UnixDomainProtocolProperties_var (const ::RTCORBA::UnixDomainProtocolProperties_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (UnixDomainProtocolProperties::_duplicate (p.ptr ()))
{}

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

ACE_INLINE RTCORBA::UnixDomainProtocolProperties_var &
RTCORBA::UnixDomainProtocolProperties_var::operator= (UnixDomainProtocolProperties_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE
RTCORBA::UnixDomainProtocolProperties_var::operator const ::RTCORBA::UnixDomainProtocolProperties_ptr &() const // cast
{
  return this->ptr_;
}

ACE_INLINE
RTCORBA::UnixDomainProtocolProperties_var::operator ::RTCORBA::UnixDomainProtocolProperties_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::UnixDomainProtocolProperties_ptr
RTCORBA::UnixDomainProtocolProperties_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::UnixDomainProtocolProperties_ptr
RTCORBA::UnixDomainProtocolProperties_var::in (void) const
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::UnixDomainProtocolProperties_ptr &
RTCORBA::UnixDomainProtocolProperties_var::inout (void)
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::UnixDomainProtocolProperties_ptr &
RTCORBA::UnixDomainProtocolProperties_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::RTCORBA::UnixDomainProtocolProperties::_nil ();
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::UnixDomainProtocolProperties_ptr
RTCORBA::UnixDomainProtocolProperties_var::_retn (void)
{
  // yield ownership of managed obj reference
  ::RTCORBA::UnixDomainProtocolProperties_ptr val = this->ptr_;
  this->ptr_ = ::RTCORBA::UnixDomainProtocolProperties::_nil ();
  return val;
}


#endif /* end #if !defined */


#if !defined (_RTCORBA_UNIXDOMAINPROTOCOLPROPERTIES___OUT_CI_)
#define _RTCORBA_UNIXDOMAINPROTOCOLPROPERTIES___OUT_CI_

// *************************************************************
// Inline operations for class RTCORBA::UnixDomainProtocolProperties_out
// *************************************************************

ACE_INLINE
RTCORBA::UnixDomainProtocolProperties_out::UnixDomainProtocolProperties_out (UnixDomainProtocolProperties_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::RTCORBA::UnixDomainProtocolProperties::_nil ();
}

ACE_INLINE
RTCORBA::UnixDomainProtocolProperties_out::UnixDomainProtocolProperties_out (UnixDomainProtocolProperties_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::RTCORBA::UnixDomainProtocolProperties::_nil ();
}

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

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

ACE_INLINE RTCORBA::UnixDomainProtocolProperties_out &
RTCORBA::UnixDomainProtocolProperties_out::operator= (const ::RTCORBA::UnixDomainProtocolProperties_var &p)
{
  this->ptr_ = ::RTCORBA::UnixDomainProtocolProperties::_duplicate (p.ptr ());
  return *this;
}

ACE_INLINE RTCORBA::UnixDomainProtocolProperties_out &
RTCORBA::UnixDomainProtocolProperties_out::operator= (UnixDomainProtocolProperties_ptr p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE
RTCORBA::UnixDomainProtocolProperties_out::operator ::RTCORBA::UnixDomainProtocolProperties_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::UnixDomainProtocolProperties_ptr &
RTCORBA::UnixDomainProtocolProperties_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::UnixDomainProtocolProperties_ptr
RTCORBA::UnixDomainProtocolProperties_out::operator-> (void)
{
  return this->ptr_;
}


#endif /* end #if !defined */


#if !defined (_RTCORBA_SHAREDMEMORYPROTOCOLPROPERTIES___VAR_CI_)
#define _RTCORBA_SHAREDMEMORYPROTOCOLPROPERTIES___VAR_CI_

// *************************************************************
// Inline operations for class RTCORBA::SharedMemoryProtocolProperties_var
// *************************************************************

ACE_INLINE
RTCORBA::SharedMemoryProtocolProperties_var::SharedMemoryProtocolProperties_var (void) // default constructor
  : ptr_ (SharedMemoryProtocolProperties::_nil ())
{}

ACE_INLINE ::RTCORBA::SharedMemoryProtocolProperties_ptr
RTCORBA::SharedMemoryProtocolProperties_var::ptr (void) const
{
  return this->ptr_;
}

ACE_INLINE
RTCORBA::SharedMemoryProtocolProperties_var::SharedMemoryProtocolProperties_var (const ::RTCORBA::SharedMemoryProtocolProperties_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (SharedMemoryProtocolProperties::_duplicate (p.ptr ()))
{}

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

ACE_INLINE RTCORBA::SharedMemoryProtocolProperties_var &
RTCORBA::SharedMemoryProtocolProperties_var::operator= (SharedMemoryProtocolProperties_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE
RTCORBA::SharedMemoryProtocolProperties_var::operator const ::RTCORBA::SharedMemoryProtocolProperties_ptr &() const // cast
{
  return this->ptr_;
}

ACE_INLINE
RTCORBA::SharedMemoryProtocolProperties_var::operator ::RTCORBA::SharedMemoryProtocolProperties_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::SharedMemoryProtocolProperties_ptr
RTCORBA::SharedMemoryProtocolProperties_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::SharedMemoryProtocolProperties_ptr
RTCORBA::SharedMemoryProtocolProperties_var::in (void) const
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::SharedMemoryProtocolProperties_ptr &
RTCORBA::SharedMemoryProtocolProperties_var::inout (void)
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::SharedMemoryProtocolProperties_ptr &
RTCORBA::SharedMemoryProtocolProperties_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::RTCORBA::SharedMemoryProtocolProperties::_nil ();
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::SharedMemoryProtocolProperties_ptr
RTCORBA::SharedMemoryProtocolProperties_var::_retn (void)
{
  // yield ownership of managed obj reference
  ::RTCORBA::SharedMemoryProtocolProperties_ptr val = this->ptr_;
  this->ptr_ = ::RTCORBA::SharedMemoryProtocolProperties::_nil ();
  return val;
}


#endif /* end #if !defined */


#if !defined (_RTCORBA_SHAREDMEMORYPROTOCOLPROPERTIES___OUT_CI_)
#define _RTCORBA_SHAREDMEMORYPROTOCOLPROPERTIES___OUT_CI_

// *************************************************************
// Inline operations for class RTCORBA::SharedMemoryProtocolProperties_out
// *************************************************************

ACE_INLINE
RTCORBA::SharedMemoryProtocolProperties_out::SharedMemoryProtocolProperties_out (SharedMemoryProtocolProperties_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::RTCORBA::SharedMemoryProtocolProperties::_nil ();
}

ACE_INLINE
RTCORBA::SharedMemoryProtocolProperties_out::SharedMemoryProtocolProperties_out (SharedMemoryProtocolProperties_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::RTCORBA::SharedMemoryProtocolProperties::_nil ();
}

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

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

ACE_INLINE RTCORBA::SharedMemoryProtocolProperties_out &
RTCORBA::SharedMemoryProtocolProperties_out::operator= (const ::RTCORBA::SharedMemoryProtocolProperties_var &p)
{
  this->ptr_ = ::RTCORBA::SharedMemoryProtocolProperties::_duplicate (p.ptr ());
  return *this;
}

ACE_INLINE RTCORBA::SharedMemoryProtocolProperties_out &
RTCORBA::SharedMemoryProtocolProperties_out::operator= (SharedMemoryProtocolProperties_ptr p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE
RTCORBA::SharedMemoryProtocolProperties_out::operator ::RTCORBA::SharedMemoryProtocolProperties_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::SharedMemoryProtocolProperties_ptr &
RTCORBA::SharedMemoryProtocolProperties_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::SharedMemoryProtocolProperties_ptr
RTCORBA::SharedMemoryProtocolProperties_out::operator-> (void)
{
  return this->ptr_;
}


#endif /* end #if !defined */

// *************************************************************
// Inline operations for class RTCORBA::Protocol_var
// *************************************************************

ACE_INLINE
RTCORBA::Protocol_var::Protocol_var (void) // default constructor
  : ptr_ (0)
{}

ACE_INLINE
RTCORBA::Protocol_var::Protocol_var (Protocol *p)
  : ptr_ (p)
{}

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

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

ACE_INLINE RTCORBA::Protocol_var &
RTCORBA::Protocol_var::operator= (Protocol *p)
{
  delete this->ptr_;
  this->ptr_ = p;
  return *this;
}

ACE_INLINE ::RTCORBA::Protocol_var &
RTCORBA::Protocol_var::operator= (const ::RTCORBA::Protocol_var &p)
{
  if (this != &p)
  {
    delete this->ptr_;
    ACE_NEW_RETURN (this->ptr_, ::RTCORBA::Protocol (*p.ptr_), *this);
  }
  return *this;
}

ACE_INLINE const ::RTCORBA::Protocol *
RTCORBA::Protocol_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::Protocol *
RTCORBA::Protocol_var::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE
RTCORBA::Protocol_var::operator const ::RTCORBA::Protocol &() const // cast
{
  return *this->ptr_;
}

ACE_INLINE
RTCORBA::Protocol_var::operator ::RTCORBA::Protocol &() // cast
{
  return *this->ptr_;
}

ACE_INLINE
RTCORBA::Protocol_var::operator ::RTCORBA::Protocol &() const // cast
{
  return *this->ptr_;
}

// variable-size types only
ACE_INLINE
RTCORBA::Protocol_var::operator ::RTCORBA::Protocol *&() // cast
{
  return this->ptr_;
}

ACE_INLINE const ::RTCORBA::Protocol &
RTCORBA::Protocol_var::in (void) const
{
  return *this->ptr_;
}

ACE_INLINE ::RTCORBA::Protocol &
RTCORBA::Protocol_var::inout (void)
{
  return *this->ptr_;
}

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

ACE_INLINE ::RTCORBA::Protocol *
RTCORBA::Protocol_var::_retn (void)
{
  ::RTCORBA::Protocol *tmp = this->ptr_;
  this->ptr_ = 0;
  return tmp;
}

ACE_INLINE ::RTCORBA::Protocol *
RTCORBA::Protocol_var::ptr (void) const
{
  return this->ptr_;
}

// *************************************************************
// Inline operations for class RTCORBA::Protocol_out
// *************************************************************

ACE_INLINE
RTCORBA::Protocol_out::Protocol_out (::RTCORBA::Protocol *&p)
  : ptr_ (p)
{
  this->ptr_ = 0;
}

ACE_INLINE
RTCORBA::Protocol_out::Protocol_out (Protocol_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  delete this->ptr_;
  this->ptr_ = 0;
}

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

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

ACE_INLINE RTCORBA::Protocol_out &
RTCORBA::Protocol_out::operator= (Protocol *p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE
RTCORBA::Protocol_out::operator ::RTCORBA::Protocol *&() // cast
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::Protocol *&
RTCORBA::Protocol_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::Protocol *
RTCORBA::Protocol_out::operator-> (void)
{
  return this->ptr_;
}


#if !defined (TAO_USE_SEQUENCE_TEMPLATES)

#if !defined (__TAO_UNBOUNDED_SEQUENCE_RTCORBA_PROTOCOLLIST_CI_)
#define __TAO_UNBOUNDED_SEQUENCE_RTCORBA_PROTOCOLLIST_CI_

  // = Static operations.
  ACE_INLINE RTCORBA::Protocol *
  RTCORBA::_TAO_Unbounded_Sequence_RTCORBA_ProtocolList::allocbuf (CORBA::ULong size)
  // Allocate storage for the sequence.
  {
    RTCORBA::Protocol *retval = 0;
    ACE_NEW_RETURN (retval, RTCORBA::Protocol[size], 0);
    return retval;
  }

  ACE_INLINE void RTCORBA::_TAO_Unbounded_Sequence_RTCORBA_ProtocolList::freebuf (RTCORBA::Protocol *buffer)
  // Free the sequence.
  {
    delete [] buffer;
  }

  ACE_INLINE
  RTCORBA::_TAO_Unbounded_Sequence_RTCORBA_ProtocolList::_TAO_Unbounded_Sequence_RTCORBA_ProtocolList (void) // Default constructor.
  {
  }

  ACE_INLINE
  RTCORBA::_TAO_Unbounded_Sequence_RTCORBA_ProtocolList::_TAO_Unbounded_Sequence_RTCORBA_ProtocolList (CORBA::ULong maximum) // Constructor using a maximum length value.
    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Sequence_RTCORBA_ProtocolList::allocbuf (maximum))
  {
  }

  ACE_INLINE
  RTCORBA::_TAO_Unbounded_Sequence_RTCORBA_ProtocolList::_TAO_Unbounded_Sequence_RTCORBA_ProtocolList (CORBA::ULong maximum,
    CORBA::ULong length,
    RTCORBA::Protocol *data,
    CORBA::Boolean release)
  : TAO_Unbounded_Base_Sequence (maximum, length, data, release)
  {
  }

  ACE_INLINE
  RTCORBA::_TAO_Unbounded_Sequence_RTCORBA_ProtocolList::_TAO_Unbounded_Sequence_RTCORBA_ProtocolList (const _TAO_Unbounded_Sequence_RTCORBA_ProtocolList &rhs)
  // Copy constructor.
    : TAO_Unbounded_Base_Sequence (rhs)
  {
    if (rhs.buffer_ != 0)
    {
      RTCORBA::Protocol *tmp1 = _TAO_Unbounded_Sequence_RTCORBA_ProtocolList::allocbuf (this->maximum_);
      RTCORBA::Protocol * const tmp2 = ACE_reinterpret_cast (RTCORBA::Protocol * ACE_CAST_CONST, rhs.buffer_);

      for (CORBA::ULong i = 0; i < this->length_; ++i)
        tmp1[i] = tmp2[i];

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

  ACE_INLINE RTCORBA::_TAO_Unbounded_Sequence_RTCORBA_ProtocolList &
  RTCORBA::_TAO_Unbounded_Sequence_RTCORBA_ProtocolList::operator= (const _TAO_Unbounded_Sequence_RTCORBA_ProtocolList &rhs)
  // Assignment operator.
  {
    if (this == &rhs)
      return *this;

    if (this->release_)
    {
      if (this->maximum_ < rhs.maximum_)
      {
        // free the old buffer
        RTCORBA::Protocol *tmp = ACE_reinterpret_cast (RTCORBA::Protocol *, this->buffer_);
        _TAO_Unbounded_Sequence_RTCORBA_ProtocolList::freebuf (tmp);
        this->buffer_ = _TAO_Unbounded_Sequence_RTCORBA_ProtocolList::allocbuf (rhs.maximum_);
      }
    }
    else
      this->buffer_ = _TAO_Unbounded_Sequence_RTCORBA_ProtocolList::allocbuf (rhs.maximum_);

    TAO_Unbounded_Base_Sequence::operator= (rhs);

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

    for (CORBA::ULong i = 0; i < this->length_; ++i)
      tmp1[i] = tmp2[i];

    return *this;
  }

  // = Accessors.
  ACE_INLINE RTCORBA::Protocol &
  RTCORBA::_TAO_Unbounded_Sequence_RTCORBA_ProtocolList::operator[] (CORBA::ULong i)
  // operator []
  {
    ACE_ASSERT (i < this->maximum_);
    RTCORBA::Protocol* tmp = ACE_reinterpret_cast(RTCORBA::Protocol*,this->buffer_);
    return tmp[i];
  }

  ACE_INLINE const RTCORBA::Protocol &
  RTCORBA::_TAO_Unbounded_Sequence_RTCORBA_ProtocolList::operator[] (CORBA::ULong i) const
  // operator []
  {
    ACE_ASSERT (i < this->maximum_);
    RTCORBA::Protocol * const tmp = ACE_reinterpret_cast (RTCORBA::Protocol* ACE_CAST_CONST, this->buffer_);
    return tmp[i];
  }

  // Implement the TAO_Base_Sequence methods (see Sequence.h)

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

  ACE_INLINE const RTCORBA::Protocol *
  RTCORBA::_TAO_Unbounded_Sequence_RTCORBA_ProtocolList::get_buffer (void) const
  {
    return ACE_reinterpret_cast(const RTCORBA::Protocol * ACE_CAST_CONST, this->buffer_);
  }

  ACE_INLINE void
  RTCORBA::_TAO_Unbounded_Sequence_RTCORBA_ProtocolList::replace (CORBA::ULong max,
  CORBA::ULong length,
  RTCORBA::Protocol *data,
  CORBA::Boolean release)
  {
    this->maximum_ = max;
    this->length_ = length;
    if (this->buffer_ && this->release_ == 1)
    {
      RTCORBA::Protocol *tmp = ACE_reinterpret_cast(RTCORBA::Protocol*,this->buffer_);
      _TAO_Unbounded_Sequence_RTCORBA_ProtocolList::freebuf (tmp);
    }
    this->buffer_ = data;
    this->release_ = release;
  }

#endif /* end #if !defined */


#endif /* !TAO_USE_SEQUENCE_TEMPLATES */

#if !defined (_RTCORBA_PROTOCOLLIST_CI_)
#define _RTCORBA_PROTOCOLLIST_CI_

// *************************************************************
// Inline operations for class RTCORBA::ProtocolList_var
// *************************************************************

ACE_INLINE
RTCORBA::ProtocolList_var::ProtocolList_var (void) // default constructor
  : ptr_ (0)
{}

ACE_INLINE
RTCORBA::ProtocolList_var::ProtocolList_var (ProtocolList *p)
  : ptr_ (p)
{}

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

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

ACE_INLINE RTCORBA::ProtocolList_var &
RTCORBA::ProtocolList_var::operator= (ProtocolList *p)
{
  delete this->ptr_;
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE const ::RTCORBA::ProtocolList *
RTCORBA::ProtocolList_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::ProtocolList *
RTCORBA::ProtocolList_var::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE
RTCORBA::ProtocolList_var::operator const ::RTCORBA::ProtocolList &() const // cast
{
  return *this->ptr_;
}

ACE_INLINE
RTCORBA::ProtocolList_var::operator ::RTCORBA::ProtocolList &() // cast
{
  return *this->ptr_;
}

ACE_INLINE
RTCORBA::ProtocolList_var::operator ::RTCORBA::ProtocolList &() const // cast
{
  return *this->ptr_;
}

// variable-size types only
ACE_INLINE
RTCORBA::ProtocolList_var::operator ::RTCORBA::ProtocolList *&() // cast
{
  return this->ptr_;
}

ACE_INLINE RTCORBA::Protocol &
RTCORBA::ProtocolList_var::operator[] (CORBA::ULong index)
{
  return this->ptr_->operator[] (index);
}

ACE_INLINE const ::RTCORBA::ProtocolList &
RTCORBA::ProtocolList_var::in (void) const
{
  return *this->ptr_;
}

ACE_INLINE ::RTCORBA::ProtocolList &
RTCORBA::ProtocolList_var::inout (void)
{
  return *this->ptr_;
}

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

ACE_INLINE ::RTCORBA::ProtocolList *
RTCORBA::ProtocolList_var::_retn (void)
{
  ::RTCORBA::ProtocolList *tmp = this->ptr_;
  this->ptr_ = 0;
  return tmp;
}

ACE_INLINE ::RTCORBA::ProtocolList *
RTCORBA::ProtocolList_var::ptr (void) const
{
  return this->ptr_;
}

// *************************************************************
// Inline operations for class RTCORBA::ProtocolList_out
// *************************************************************

ACE_INLINE
RTCORBA::ProtocolList_out::ProtocolList_out (ProtocolList *&p)
  : ptr_ (p)
{
  this->ptr_ = 0;
}

ACE_INLINE
RTCORBA::ProtocolList_out::ProtocolList_out (ProtocolList_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  delete this->ptr_;
  this->ptr_ = 0;
}

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

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

ACE_INLINE ::RTCORBA::ProtocolList_out &
RTCORBA::ProtocolList_out::operator= (ProtocolList *p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE
RTCORBA::ProtocolList_out::operator ::RTCORBA::ProtocolList *&() // cast
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::ProtocolList *&
RTCORBA::ProtocolList_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::ProtocolList *
RTCORBA::ProtocolList_out::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE RTCORBA::Protocol &
RTCORBA::ProtocolList_out::operator[] (CORBA::ULong index)
{
  return this->ptr_->operator[] (index);
}


#endif /* end #if !defined */

ACE_INLINE
RTCORBA::ServerProtocolPolicy::ServerProtocolPolicy (void) // default constructor
{}

ACE_INLINE
RTCORBA::ServerProtocolPolicy::~ServerProtocolPolicy (void) // destructor
{}


#if !defined (_RTCORBA_SERVERPROTOCOLPOLICY___VAR_CI_)
#define _RTCORBA_SERVERPROTOCOLPOLICY___VAR_CI_

// *************************************************************
// Inline operations for class RTCORBA::ServerProtocolPolicy_var
// *************************************************************

ACE_INLINE
RTCORBA::ServerProtocolPolicy_var::ServerProtocolPolicy_var (void) // default constructor
  : ptr_ (ServerProtocolPolicy::_nil ())
{}

ACE_INLINE
RTCORBA::ServerProtocolPolicy_var::ServerProtocolPolicy_var (ServerProtocolPolicy_ptr p)
  : ptr_ (p)
{}

ACE_INLINE ::RTCORBA::ServerProtocolPolicy_ptr
RTCORBA::ServerProtocolPolicy_var::ptr (void) const
{
  return this->ptr_;
}

ACE_INLINE
RTCORBA::ServerProtocolPolicy_var::ServerProtocolPolicy_var (const ::RTCORBA::ServerProtocolPolicy_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (ServerProtocolPolicy::_duplicate (p.ptr ()))
{}

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

ACE_INLINE RTCORBA::ServerProtocolPolicy_var &
RTCORBA::ServerProtocolPolicy_var::operator= (ServerProtocolPolicy_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE
RTCORBA::ServerProtocolPolicy_var::operator const ::RTCORBA::ServerProtocolPolicy_ptr &() const // cast
{
  return this->ptr_;
}

ACE_INLINE
RTCORBA::ServerProtocolPolicy_var::operator ::RTCORBA::ServerProtocolPolicy_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::ServerProtocolPolicy_ptr
RTCORBA::ServerProtocolPolicy_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::ServerProtocolPolicy_ptr
RTCORBA::ServerProtocolPolicy_var::in (void) const
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::ServerProtocolPolicy_ptr &
RTCORBA::ServerProtocolPolicy_var::inout (void)
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::ServerProtocolPolicy_ptr &
RTCORBA::ServerProtocolPolicy_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::RTCORBA::ServerProtocolPolicy::_nil ();
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::ServerProtocolPolicy_ptr
RTCORBA::ServerProtocolPolicy_var::_retn (void)
{
  // yield ownership of managed obj reference
  ::RTCORBA::ServerProtocolPolicy_ptr val = this->ptr_;
  this->ptr_ = ::RTCORBA::ServerProtocolPolicy::_nil ();
  return val;
}


#endif /* end #if !defined */


#if !defined (_RTCORBA_SERVERPROTOCOLPOLICY___OUT_CI_)
#define _RTCORBA_SERVERPROTOCOLPOLICY___OUT_CI_

// *************************************************************
// Inline operations for class RTCORBA::ServerProtocolPolicy_out
// *************************************************************

ACE_INLINE
RTCORBA::ServerProtocolPolicy_out::ServerProtocolPolicy_out (ServerProtocolPolicy_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::RTCORBA::ServerProtocolPolicy::_nil ();
}

ACE_INLINE
RTCORBA::ServerProtocolPolicy_out::ServerProtocolPolicy_out (ServerProtocolPolicy_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::RTCORBA::ServerProtocolPolicy::_nil ();
}

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

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

ACE_INLINE RTCORBA::ServerProtocolPolicy_out &
RTCORBA::ServerProtocolPolicy_out::operator= (const ::RTCORBA::ServerProtocolPolicy_var &p)
{
  this->ptr_ = ::RTCORBA::ServerProtocolPolicy::_duplicate (p.ptr ());
  return *this;
}

ACE_INLINE RTCORBA::ServerProtocolPolicy_out &
RTCORBA::ServerProtocolPolicy_out::operator= (ServerProtocolPolicy_ptr p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE
RTCORBA::ServerProtocolPolicy_out::operator ::RTCORBA::ServerProtocolPolicy_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::ServerProtocolPolicy_ptr &
RTCORBA::ServerProtocolPolicy_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::ServerProtocolPolicy_ptr
RTCORBA::ServerProtocolPolicy_out::operator-> (void)
{
  return this->ptr_;
}


#endif /* end #if !defined */

ACE_INLINE
RTCORBA::ClientProtocolPolicy::ClientProtocolPolicy (void) // default constructor
{}

ACE_INLINE
RTCORBA::ClientProtocolPolicy::~ClientProtocolPolicy (void) // destructor
{}


#if !defined (_RTCORBA_CLIENTPROTOCOLPOLICY___VAR_CI_)
#define _RTCORBA_CLIENTPROTOCOLPOLICY___VAR_CI_

// *************************************************************
// Inline operations for class RTCORBA::ClientProtocolPolicy_var
// *************************************************************

ACE_INLINE
RTCORBA::ClientProtocolPolicy_var::ClientProtocolPolicy_var (void) // default constructor
  : ptr_ (ClientProtocolPolicy::_nil ())
{}

ACE_INLINE
RTCORBA::ClientProtocolPolicy_var::ClientProtocolPolicy_var (ClientProtocolPolicy_ptr p)
  : ptr_ (p)
{}

ACE_INLINE ::RTCORBA::ClientProtocolPolicy_ptr
RTCORBA::ClientProtocolPolicy_var::ptr (void) const
{
  return this->ptr_;
}

ACE_INLINE
RTCORBA::ClientProtocolPolicy_var::ClientProtocolPolicy_var (const ::RTCORBA::ClientProtocolPolicy_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (ClientProtocolPolicy::_duplicate (p.ptr ()))
{}

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

ACE_INLINE RTCORBA::ClientProtocolPolicy_var &
RTCORBA::ClientProtocolPolicy_var::operator= (ClientProtocolPolicy_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE
RTCORBA::ClientProtocolPolicy_var::operator const ::RTCORBA::ClientProtocolPolicy_ptr &() const // cast
{
  return this->ptr_;
}

ACE_INLINE
RTCORBA::ClientProtocolPolicy_var::operator ::RTCORBA::ClientProtocolPolicy_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::ClientProtocolPolicy_ptr
RTCORBA::ClientProtocolPolicy_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::ClientProtocolPolicy_ptr
RTCORBA::ClientProtocolPolicy_var::in (void) const
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::ClientProtocolPolicy_ptr &
RTCORBA::ClientProtocolPolicy_var::inout (void)
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::ClientProtocolPolicy_ptr &
RTCORBA::ClientProtocolPolicy_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::RTCORBA::ClientProtocolPolicy::_nil ();
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::ClientProtocolPolicy_ptr
RTCORBA::ClientProtocolPolicy_var::_retn (void)
{
  // yield ownership of managed obj reference
  ::RTCORBA::ClientProtocolPolicy_ptr val = this->ptr_;
  this->ptr_ = ::RTCORBA::ClientProtocolPolicy::_nil ();
  return val;
}


#endif /* end #if !defined */


#if !defined (_RTCORBA_CLIENTPROTOCOLPOLICY___OUT_CI_)
#define _RTCORBA_CLIENTPROTOCOLPOLICY___OUT_CI_

// *************************************************************
// Inline operations for class RTCORBA::ClientProtocolPolicy_out
// *************************************************************

ACE_INLINE
RTCORBA::ClientProtocolPolicy_out::ClientProtocolPolicy_out (ClientProtocolPolicy_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::RTCORBA::ClientProtocolPolicy::_nil ();
}

ACE_INLINE
RTCORBA::ClientProtocolPolicy_out::ClientProtocolPolicy_out (ClientProtocolPolicy_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::RTCORBA::ClientProtocolPolicy::_nil ();
}

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

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

ACE_INLINE RTCORBA::ClientProtocolPolicy_out &
RTCORBA::ClientProtocolPolicy_out::operator= (const ::RTCORBA::ClientProtocolPolicy_var &p)
{
  this->ptr_ = ::RTCORBA::ClientProtocolPolicy::_duplicate (p.ptr ());
  return *this;
}

ACE_INLINE RTCORBA::ClientProtocolPolicy_out &
RTCORBA::ClientProtocolPolicy_out::operator= (ClientProtocolPolicy_ptr p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE
RTCORBA::ClientProtocolPolicy_out::operator ::RTCORBA::ClientProtocolPolicy_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::ClientProtocolPolicy_ptr &
RTCORBA::ClientProtocolPolicy_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::ClientProtocolPolicy_ptr
RTCORBA::ClientProtocolPolicy_out::operator-> (void)
{
  return this->ptr_;
}


#endif /* end #if !defined */

ACE_INLINE
RTCORBA::Current::Current (void) // default constructor
{}

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


#if !defined (_RTCORBA_CURRENT___VAR_CI_)
#define _RTCORBA_CURRENT___VAR_CI_

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


#endif /* end #if !defined */


#if !defined (_RTCORBA_CURRENT___OUT_CI_)
#define _RTCORBA_CURRENT___OUT_CI_

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

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

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

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

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

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

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

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

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

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


#endif /* end #if !defined */

ACE_INLINE
RTCORBA::Mutex::Mutex (void) // default constructor
{}

ACE_INLINE
RTCORBA::Mutex::~Mutex (void) // destructor
{}


#if !defined (_RTCORBA_MUTEX___VAR_CI_)
#define _RTCORBA_MUTEX___VAR_CI_

// *************************************************************
// Inline operations for class RTCORBA::Mutex_var
// *************************************************************

ACE_INLINE
RTCORBA::Mutex_var::Mutex_var (void) // default constructor
  : ptr_ (Mutex::_nil ())
{}

ACE_INLINE
RTCORBA::Mutex_var::Mutex_var (Mutex_ptr p)
  : ptr_ (p)
{}

ACE_INLINE ::RTCORBA::Mutex_ptr
RTCORBA::Mutex_var::ptr (void) const
{
  return this->ptr_;
}

ACE_INLINE
RTCORBA::Mutex_var::Mutex_var (const ::RTCORBA::Mutex_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (Mutex::_duplicate (p.ptr ()))
{}

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

ACE_INLINE RTCORBA::Mutex_var &
RTCORBA::Mutex_var::operator= (Mutex_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE
RTCORBA::Mutex_var::operator const ::RTCORBA::Mutex_ptr &() const // cast
{
  return this->ptr_;
}

ACE_INLINE
RTCORBA::Mutex_var::operator ::RTCORBA::Mutex_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::Mutex_ptr
RTCORBA::Mutex_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::Mutex_ptr
RTCORBA::Mutex_var::in (void) const
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::Mutex_ptr &
RTCORBA::Mutex_var::inout (void)
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::Mutex_ptr &
RTCORBA::Mutex_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::RTCORBA::Mutex::_nil ();
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::Mutex_ptr
RTCORBA::Mutex_var::_retn (void)
{
  // yield ownership of managed obj reference
  ::RTCORBA::Mutex_ptr val = this->ptr_;
  this->ptr_ = ::RTCORBA::Mutex::_nil ();
  return val;
}


#endif /* end #if !defined */


#if !defined (_RTCORBA_MUTEX___OUT_CI_)
#define _RTCORBA_MUTEX___OUT_CI_

// *************************************************************
// Inline operations for class RTCORBA::Mutex_out
// *************************************************************

ACE_INLINE
RTCORBA::Mutex_out::Mutex_out (Mutex_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::RTCORBA::Mutex::_nil ();
}

ACE_INLINE
RTCORBA::Mutex_out::Mutex_out (Mutex_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::RTCORBA::Mutex::_nil ();
}

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

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

ACE_INLINE RTCORBA::Mutex_out &
RTCORBA::Mutex_out::operator= (const ::RTCORBA::Mutex_var &p)
{
  this->ptr_ = ::RTCORBA::Mutex::_duplicate (p.ptr ());
  return *this;
}

ACE_INLINE RTCORBA::Mutex_out &
RTCORBA::Mutex_out::operator= (Mutex_ptr p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE
RTCORBA::Mutex_out::operator ::RTCORBA::Mutex_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::Mutex_ptr &
RTCORBA::Mutex_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::Mutex_ptr
RTCORBA::Mutex_out::operator-> (void)
{
  return this->ptr_;
}


#endif /* end #if !defined */

ACE_INLINE
RTCORBA::RTORB::RTORB (void) // default constructor
{}

ACE_INLINE
RTCORBA::RTORB::~RTORB (void) // destructor
{}


#if !defined (_RTCORBA_RTORB___VAR_CI_)
#define _RTCORBA_RTORB___VAR_CI_

// *************************************************************
// Inline operations for class RTCORBA::RTORB_var
// *************************************************************

ACE_INLINE
RTCORBA::RTORB_var::RTORB_var (void) // default constructor
  : ptr_ (RTORB::_nil ())
{}

ACE_INLINE
RTCORBA::RTORB_var::RTORB_var (RTORB_ptr p)
  : ptr_ (p)
{}

ACE_INLINE ::RTCORBA::RTORB_ptr
RTCORBA::RTORB_var::ptr (void) const
{
  return this->ptr_;
}

ACE_INLINE
RTCORBA::RTORB_var::RTORB_var (const ::RTCORBA::RTORB_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (RTORB::_duplicate (p.ptr ()))
{}

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

ACE_INLINE RTCORBA::RTORB_var &
RTCORBA::RTORB_var::operator= (RTORB_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE
RTCORBA::RTORB_var::operator const ::RTCORBA::RTORB_ptr &() const // cast
{
  return this->ptr_;
}

ACE_INLINE
RTCORBA::RTORB_var::operator ::RTCORBA::RTORB_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::RTORB_ptr
RTCORBA::RTORB_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::RTORB_ptr
RTCORBA::RTORB_var::in (void) const
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::RTORB_ptr &
RTCORBA::RTORB_var::inout (void)
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::RTORB_ptr &
RTCORBA::RTORB_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::RTCORBA::RTORB::_nil ();
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::RTORB_ptr
RTCORBA::RTORB_var::_retn (void)
{
  // yield ownership of managed obj reference
  ::RTCORBA::RTORB_ptr val = this->ptr_;
  this->ptr_ = ::RTCORBA::RTORB::_nil ();
  return val;
}


#endif /* end #if !defined */


#if !defined (_RTCORBA_RTORB___OUT_CI_)
#define _RTCORBA_RTORB___OUT_CI_

// *************************************************************
// Inline operations for class RTCORBA::RTORB_out
// *************************************************************

ACE_INLINE
RTCORBA::RTORB_out::RTORB_out (RTORB_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::RTCORBA::RTORB::_nil ();
}

ACE_INLINE
RTCORBA::RTORB_out::RTORB_out (RTORB_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::RTCORBA::RTORB::_nil ();
}

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

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

ACE_INLINE RTCORBA::RTORB_out &
RTCORBA::RTORB_out::operator= (const ::RTCORBA::RTORB_var &p)
{
  this->ptr_ = ::RTCORBA::RTORB::_duplicate (p.ptr ());
  return *this;
}

ACE_INLINE RTCORBA::RTORB_out &
RTCORBA::RTORB_out::operator= (RTORB_ptr p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE
RTCORBA::RTORB_out::operator ::RTCORBA::RTORB_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::RTORB_ptr &
RTCORBA::RTORB_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE ::RTCORBA::RTORB_ptr
RTCORBA::RTORB_out::operator-> (void)
{
  return this->ptr_;
}


#endif /* end #if !defined */

// *************************************************************
// Inline operations for exception RTCORBA::RTORB::InvalidThreadpool
// *************************************************************

ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const RTCORBA::ThreadpoolLane &_tao_aggregate)
{
  if (
    (strm << _tao_aggregate.lane_priority) &&
    (strm << _tao_aggregate.static_threads) &&
    (strm << _tao_aggregate.dynamic_threads)
  )
    return 1;
  else
    return 0;

}

ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, RTCORBA::ThreadpoolLane &_tao_aggregate)
{
  if (
    (strm >> _tao_aggregate.lane_priority) &&
    (strm >> _tao_aggregate.static_threads) &&
    (strm >> _tao_aggregate.dynamic_threads)
  )
    return 1;
  else
    return 0;

}


#if !defined _TAO_CDR_OP_RTCORBA_ThreadpoolLanes_I_
#define _TAO_CDR_OP_RTCORBA_ThreadpoolLanes_I_

CORBA::Boolean TAO_Export operator<< (
    TAO_OutputCDR &,
    const RTCORBA::ThreadpoolLanes &
  );
CORBA::Boolean TAO_Export operator>> (
    TAO_InputCDR &,
    RTCORBA::ThreadpoolLanes &
  );

#endif /* _TAO_CDR_OP_RTCORBA_ThreadpoolLanes_I_ */

ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const RTCORBA::PriorityModel &_tao_enumval)
{
  CORBA::ULong _tao_temp = _tao_enumval;
  return strm << _tao_temp;
}

ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, RTCORBA::PriorityModel &_tao_enumval)
{
  CORBA::ULong _tao_temp = 0;
  CORBA::Boolean _tao_result = strm >> _tao_temp;
  
  if (_tao_result == 1)
    {
      _tao_enumval = ACE_static_cast (RTCORBA::PriorityModel, _tao_temp);
    }
  
  return _tao_result;
}

ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const RTCORBA::PriorityBand &_tao_aggregate)
{
  if (
    (strm << _tao_aggregate.low) &&
    (strm << _tao_aggregate.high)
  )
    return 1;
  else
    return 0;

}

ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, RTCORBA::PriorityBand &_tao_aggregate)
{
  if (
    (strm >> _tao_aggregate.low) &&
    (strm >> _tao_aggregate.high)
  )
    return 1;
  else
    return 0;

}


#if !defined _TAO_CDR_OP_RTCORBA_PriorityBands_I_
#define _TAO_CDR_OP_RTCORBA_PriorityBands_I_

CORBA::Boolean TAO_Export operator<< (
    TAO_OutputCDR &,
    const RTCORBA::PriorityBands &
  );
CORBA::Boolean TAO_Export operator>> (
    TAO_InputCDR &,
    RTCORBA::PriorityBands &
  );

#endif /* _TAO_CDR_OP_RTCORBA_PriorityBands_I_ */