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

ACE_INLINE
CORBA_IRObject::CORBA_IRObject (void) // default constructor
{}

ACE_INLINE
CORBA_IRObject::CORBA_IRObject (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
  : CORBA_Object (objref, _tao_servant, _tao_collocated)
{}

ACE_INLINE
CORBA_IRObject::~CORBA_IRObject (void) // destructor
{}


#if !defined (_CORBA_IROBJECT___VAR_CI_)
#define _CORBA_IROBJECT___VAR_CI_

// *************************************************************
// Inline operations for class CORBA::IRObject_var
// *************************************************************

ACE_INLINE
CORBA_IRObject_var::CORBA_IRObject_var (void) // default constructor
  : ptr_ (CORBA::IRObject::_nil ())
{}

ACE_INLINE
CORBA_IRObject_var::CORBA_IRObject_var (CORBA_IRObject_ptr p)
  : ptr_ (p)
{}

ACE_INLINE CORBA_IRObject_ptr 
CORBA_IRObject_var::ptr (void) const
{
  return this->ptr_;
}

ACE_INLINE
CORBA_IRObject_var::CORBA_IRObject_var (const CORBA::IRObject_var &p) // copy constructor
  : ptr_ (CORBA::IRObject::_duplicate (p.ptr ()))
{}

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

ACE_INLINE CORBA_IRObject_var &
CORBA_IRObject_var::operator= (CORBA_IRObject_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE 
CORBA_IRObject_var::operator const CORBA_IRObject_ptr &() const // cast
{
  return this->ptr_;
}

ACE_INLINE 
CORBA_IRObject_var::operator CORBA_IRObject_ptr &() // cast 
{
  return this->ptr_;
}

ACE_INLINE CORBA_IRObject_ptr 
CORBA_IRObject_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_IRObject_ptr
CORBA_IRObject_var::in (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_IRObject_ptr &
CORBA_IRObject_var::inout (void)
{
  return this->ptr_;
}

ACE_INLINE CORBA_IRObject_ptr &
CORBA_IRObject_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = CORBA::IRObject::_nil ();
  return this->ptr_;
}

ACE_INLINE CORBA_IRObject_ptr 
CORBA_IRObject_var::_retn (void)
{
  // yield ownership of managed obj reference
  CORBA::IRObject_ptr val = this->ptr_;
  this->ptr_ = CORBA::IRObject::_nil ();
  return val;
}


#endif /* end #if !defined */


#if !defined (_CORBA_IROBJECT___OUT_CI_)
#define _CORBA_IROBJECT___OUT_CI_

// *************************************************************
// Inline operations for class CORBA::IRObject_out
// *************************************************************

ACE_INLINE
CORBA_IRObject_out::CORBA_IRObject_out (CORBA::IRObject_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = CORBA::IRObject::_nil ();
}

ACE_INLINE
CORBA_IRObject_out::CORBA_IRObject_out (CORBA::IRObject_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = CORBA::IRObject::_nil ();
}

ACE_INLINE
CORBA_IRObject_out::CORBA_IRObject_out (const CORBA_IRObject_out &p) // copy constructor
  : ptr_ (ACE_const_cast (CORBA::IRObject_out&,p).ptr_)
{}

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

ACE_INLINE CORBA_IRObject_out &
CORBA_IRObject_out::operator= (const CORBA_IRObject_var &p)
{
  this->ptr_ = CORBA::IRObject::_duplicate (p.ptr ());
  return *this;
}

ACE_INLINE CORBA_IRObject_out &
CORBA_IRObject_out::operator= (CORBA::IRObject_ptr p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE 
CORBA_IRObject_out::operator CORBA_IRObject_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE CORBA_IRObject_ptr &
CORBA_IRObject_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE CORBA_IRObject_ptr 
CORBA_IRObject_out::operator-> (void)
{
  return this->ptr_;
}


#endif /* end #if !defined */

ACE_INLINE
CORBA_Contained::CORBA_Contained (void) // default constructor
{}

ACE_INLINE
CORBA_Contained::CORBA_Contained (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
  : CORBA_Object (objref, _tao_servant, _tao_collocated)
{}

ACE_INLINE
CORBA_Contained::~CORBA_Contained (void) // destructor
{}


#if !defined (_CORBA_CONTAINED___VAR_CI_)
#define _CORBA_CONTAINED___VAR_CI_

// *************************************************************
// Inline operations for class CORBA::Contained_var
// *************************************************************

ACE_INLINE
CORBA_Contained_var::CORBA_Contained_var (void) // default constructor
  : ptr_ (CORBA::Contained::_nil ())
{}

ACE_INLINE
CORBA_Contained_var::CORBA_Contained_var (CORBA::Contained_ptr p)
  : ptr_ (p)
{}

ACE_INLINE CORBA_Contained_ptr 
CORBA_Contained_var::ptr (void) const
{
  return this->ptr_;
}

ACE_INLINE
CORBA_Contained_var::CORBA_Contained_var (const CORBA::Contained_var &p) // copy constructor
  : ptr_ (CORBA::Contained::_duplicate (p.ptr ()))
{}

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

ACE_INLINE CORBA_Contained_var &
CORBA_Contained_var::operator= (CORBA::Contained_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE 
CORBA_Contained_var::operator const CORBA::Contained_ptr &() const // cast
{
  return this->ptr_;
}

ACE_INLINE 
CORBA_Contained_var::operator CORBA_Contained_ptr &() // cast 
{
  return this->ptr_;
}

ACE_INLINE CORBA_Contained_ptr 
CORBA_Contained_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_Contained_ptr
CORBA_Contained_var::in (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_Contained_ptr &
CORBA_Contained_var::inout (void)
{
  return this->ptr_;
}

ACE_INLINE CORBA_Contained_ptr &
CORBA_Contained_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = CORBA::Contained::_nil ();
  return this->ptr_;
}

ACE_INLINE CORBA_Contained_ptr 
CORBA_Contained_var::_retn (void)
{
  // yield ownership of managed obj reference
  CORBA::Contained_ptr val = this->ptr_;
  this->ptr_ = CORBA::Contained::_nil ();
  return val;
}


#endif /* end #if !defined */


#if !defined (_CORBA_CONTAINED___OUT_CI_)
#define _CORBA_CONTAINED___OUT_CI_

// *************************************************************
// Inline operations for class CORBA::Contained_out
// *************************************************************

ACE_INLINE
CORBA_Contained_out::CORBA_Contained_out (CORBA_Contained_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = CORBA::Contained::_nil ();
}

ACE_INLINE
CORBA_Contained_out::CORBA_Contained_out (CORBA_Contained_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = CORBA::Contained::_nil ();
}

ACE_INLINE
CORBA_Contained_out::CORBA_Contained_out (const CORBA_Contained_out &p) // copy constructor
  : ptr_ (ACE_const_cast (CORBA::Contained_out&,p).ptr_)
{}

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

ACE_INLINE CORBA_Contained_out &
CORBA_Contained_out::operator= (const CORBA_Contained_var &p)
{
  this->ptr_ = CORBA_Contained::_duplicate (p.ptr ());
  return *this;
}

ACE_INLINE CORBA_Contained_out &
CORBA_Contained_out::operator= (CORBA_Contained_ptr p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE 
CORBA_Contained_out::operator CORBA_Contained_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE CORBA_Contained_ptr &
CORBA_Contained_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE CORBA_Contained_ptr 
CORBA_Contained_out::operator-> (void)
{
  return this->ptr_;
}


#endif /* end #if !defined */

// *************************************************************
// Inline operations for class CORBA::Contained::Description_var
// *************************************************************

ACE_INLINE
CORBA_Contained::Description_var::Description_var (void) // default constructor
  : ptr_ (0)
{}

ACE_INLINE
CORBA_Contained::Description_var::Description_var (CORBA_Contained::Description *p)
  : ptr_ (p)
{}

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

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

ACE_INLINE CORBA_Contained::Description_var &
CORBA_Contained::Description_var::operator= (CORBA_Contained::Description *p)
{
  delete this->ptr_;
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE const CORBA_Contained::Description *
CORBA_Contained::Description_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_Contained::Description *
CORBA_Contained::Description_var::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE 
CORBA_Contained::Description_var::operator const CORBA_Contained::Description &() const // cast
{
  return *this->ptr_;
}

ACE_INLINE 
CORBA_Contained::Description_var::operator CORBA_Contained::Description &() // cast 
{
  return *this->ptr_;
}

ACE_INLINE 
CORBA_Contained::Description_var::operator CORBA_Contained::Description &() const// cast 
{
  return *this->ptr_;
}

ACE_INLINE const CORBA_Contained::Description &
CORBA_Contained::Description_var::in (void) const
{
  return *this->ptr_;
}

ACE_INLINE CORBA_Contained::Description &
CORBA_Contained::Description_var::inout (void)
{
  return *this->ptr_;
}

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

ACE_INLINE CORBA_Contained::Description *
CORBA_Contained::Description_var::_retn (void)
{
  CORBA_Contained::Description *tmp = this->ptr_;
  this->ptr_ = 0;
  return tmp;
}

ACE_INLINE CORBA_Contained::Description *
CORBA_Contained::Description_var::ptr (void) const
{
  return this->ptr_;
}

// *************************************************************
// Inline operations for class CORBA::Contained::Description_out
// *************************************************************

ACE_INLINE
CORBA_Contained::Description_out::Description_out (CORBA_Contained::Description *&p)
  : ptr_ (p)
{
  this->ptr_ = 0;
}

ACE_INLINE
CORBA_Contained::Description_out::Description_out (CORBA_Contained::Description_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  delete this->ptr_;
  this->ptr_ = 0;
}

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

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

ACE_INLINE CORBA_Contained::Description_out &
CORBA_Contained::Description_out::operator= (CORBA_Contained::Description *p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE 
CORBA_Contained::Description_out::operator CORBA_Contained::Description *&() // cast
{
  return this->ptr_;
}

ACE_INLINE CORBA_Contained::Description *&
CORBA_Contained::Description_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE CORBA_Contained::Description *
CORBA_Contained::Description_out::operator-> (void)
{
  return this->ptr_;
}


#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
  
#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_INTERFACEDEFSEQ_CI_)
#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_INTERFACEDEFSEQ_CI_

  ACE_INLINE CORBA_InterfaceDef **
  _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::allocbuf (CORBA::ULong nelems)
  {
    CORBA::InterfaceDef **buf = 0;
    
    ACE_NEW_RETURN (buf, 
                    CORBA::InterfaceDef*[nelems], 
		    0);
    
    for (CORBA::ULong i = 0; i < nelems; i++)
      buf[i] = CORBA::InterfaceDef::_nil ();
    
    return buf;
  }
  
  ACE_INLINE void 
  _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::freebuf (CORBA::InterfaceDef **buffer)
  {
    if (buffer == 0)
      return;
    delete[] buffer;
  }
  
  ACE_INLINE
  _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq (void)
  {
  }
  
  ACE_INLINE
  _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq (CORBA::ULong maximum)
    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::allocbuf (maximum))
  {
  }
  
  ACE_INLINE
  _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq (CORBA::ULong maximum,
    CORBA::ULong length,
    CORBA::InterfaceDef* *value,
    CORBA::Boolean release)
  : TAO_Unbounded_Base_Sequence (maximum, length, value, release)
  {
  }
  
  ACE_INLINE
  _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq(const _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq &rhs)
    : TAO_Unbounded_Base_Sequence (rhs)
  {
    CORBA::InterfaceDef **tmp1 = _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::allocbuf (this->maximum_);
    CORBA::InterfaceDef ** const tmp2 = ACE_reinterpret_cast (CORBA::InterfaceDef ** ACE_CAST_CONST, rhs.buffer_);
    
    for (CORBA::ULong i = 0; i < rhs.length_; ++i)
      tmp1[i] = CORBA::InterfaceDef::_duplicate (tmp2[i]);
    
    this->buffer_ = tmp1;
  }
  
  ACE_INLINE _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq &
  _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::operator= (const _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq &rhs)
  {
    if (this == &rhs)
      return *this;
    
    if (this->release_)
    {
      CORBA::InterfaceDef **tmp = ACE_reinterpret_cast (CORBA::InterfaceDef **, this->buffer_);
      
      for (CORBA::ULong i = 0; i < this->length_; ++i)
      {
        CORBA::release (tmp[i]);
        tmp[i] = CORBA::InterfaceDef::_nil ();
      }
      if (this->maximum_ < rhs.maximum_)
      {
        _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::freebuf (tmp);
        this->buffer_ = _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::allocbuf (rhs.maximum_);
      }
    }
    else
      this->buffer_ = _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::allocbuf (rhs.maximum_);
    
    TAO_Unbounded_Base_Sequence::operator= (rhs);
    
    CORBA::InterfaceDef **tmp1 = ACE_reinterpret_cast (CORBA::InterfaceDef **, this->buffer_);
    CORBA::InterfaceDef ** const tmp2 = ACE_reinterpret_cast (CORBA::InterfaceDef ** ACE_CAST_CONST, rhs.buffer_);
    
    for (CORBA::ULong i = 0; i < rhs.length_; ++i)
      tmp1[i] = CORBA::InterfaceDef::_duplicate (tmp2[i]);
    
    return *this;
  }
  
  ACE_INLINE TAO_Object_Manager<CORBA::InterfaceDef,CORBA::InterfaceDef_var>
  _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::operator[] (CORBA::ULong index) const
  // read-write accessor
  {
    ACE_ASSERT (index < this->maximum_);
    CORBA::InterfaceDef ** const tmp = ACE_reinterpret_cast (CORBA::InterfaceDef ** ACE_CAST_CONST, this->buffer_);
    return TAO_Object_Manager<CORBA::InterfaceDef,CORBA::InterfaceDef_var> (tmp + index, this->release_);
  }
  
  ACE_INLINE CORBA::InterfaceDef* *
  _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::get_buffer (CORBA::Boolean orphan)
  {
    CORBA::InterfaceDef **result = 0;
    if (orphan == 0)
    {
      // We retain ownership.
      if (this->buffer_ == 0)
      {
        result = _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::allocbuf (this->maximum_);
        this->buffer_ = result;
      }
      else
      {
        result = ACE_reinterpret_cast (CORBA::InterfaceDef**, this->buffer_);
      }
    }
    else // if (orphan == 1)
    {
      if (this->release_ != 0)
      {
        // We set the state back to default and relinquish
        // ownership.
        result = ACE_reinterpret_cast(CORBA::InterfaceDef**,this->buffer_);
        this->maximum_ = 0;
        this->length_ = 0;
        this->buffer_ = 0;
        this->release_ = 0;
      }
    }
    return result;
  }
  
  ACE_INLINE const CORBA::InterfaceDef* *
  _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::get_buffer (void) const
  {
    return ACE_reinterpret_cast(const CORBA::InterfaceDef ** ACE_CAST_CONST, this->buffer_);
  }
  
  
#endif /* end #if !defined */


#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 

#if !defined (_CORBA_INTERFACEDEFSEQ_CI_)
#define _CORBA_INTERFACEDEFSEQ_CI_

// *************************************************************
// Inline operations for class CORBA::InterfaceDefSeq_var
// *************************************************************

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

ACE_INLINE
CORBA_InterfaceDefSeq_var::CORBA_InterfaceDefSeq_var (CORBA::InterfaceDefSeq *p)
  : ptr_ (p)
{}

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

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

ACE_INLINE CORBA_InterfaceDefSeq_var &
CORBA_InterfaceDefSeq_var::operator= (CORBA::InterfaceDefSeq *p)
{
  delete this->ptr_;
  this->ptr_ = p;
  return *this;
}

ACE_INLINE CORBA_InterfaceDefSeq_var &
CORBA_InterfaceDefSeq_var::operator= (const CORBA::InterfaceDefSeq_var &p) // deep copy
{
  if (this != &p)
  {
    delete this->ptr_;
    ACE_NEW_RETURN (this->ptr_, 
                    CORBA::InterfaceDefSeq (*p.ptr_), 
		    *this);
  }
  return *this;
}

ACE_INLINE const CORBA_InterfaceDefSeq *
CORBA_InterfaceDefSeq_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_InterfaceDefSeq *
CORBA_InterfaceDefSeq_var::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE 
CORBA_InterfaceDefSeq_var::operator const CORBA::InterfaceDefSeq &() const // cast
{
  return *this->ptr_;
}

ACE_INLINE 
CORBA_InterfaceDefSeq_var::operator CORBA_InterfaceDefSeq &() // cast 
{
  return *this->ptr_;
}

ACE_INLINE 
CORBA_InterfaceDefSeq_var::operator CORBA::InterfaceDefSeq &() const// cast 
{
  return *this->ptr_;
}

ACE_INLINE TAO_Object_Manager<CORBA::InterfaceDef,CORBA::InterfaceDef_var> 
CORBA_InterfaceDefSeq_var::operator[] (CORBA::ULong index)
{
  return this->ptr_->operator[] (index);
}

ACE_INLINE const CORBA_InterfaceDefSeq &
CORBA_InterfaceDefSeq_var::in (void) const
{
  return *this->ptr_;
}

ACE_INLINE CORBA_InterfaceDefSeq &
CORBA_InterfaceDefSeq_var::inout (void)
{
  return *this->ptr_;
}

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

ACE_INLINE CORBA_InterfaceDefSeq *
CORBA_InterfaceDefSeq_var::_retn (void)
{
  CORBA::InterfaceDefSeq *tmp = this->ptr_;
  this->ptr_ = 0;
  return tmp;
}

ACE_INLINE CORBA_InterfaceDefSeq *
CORBA_InterfaceDefSeq_var::ptr (void) const
{
  return this->ptr_;
}

// *************************************************************
// Inline operations for class CORBA::InterfaceDefSeq_out
// *************************************************************

ACE_INLINE
CORBA_InterfaceDefSeq_out::CORBA_InterfaceDefSeq_out (CORBA::InterfaceDefSeq *&p)
  : ptr_ (p)
{
  this->ptr_ = 0;
}

ACE_INLINE
CORBA_InterfaceDefSeq_out::CORBA_InterfaceDefSeq_out (CORBA::InterfaceDefSeq_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  delete this->ptr_;
  this->ptr_ = 0;
}

ACE_INLINE
CORBA_InterfaceDefSeq_out::CORBA_InterfaceDefSeq_out (const CORBA_InterfaceDefSeq_out &p) // copy constructor
  : ptr_ (ACE_const_cast (CORBA::InterfaceDefSeq_out&,p).ptr_)
{}

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

ACE_INLINE CORBA_InterfaceDefSeq_out &
CORBA_InterfaceDefSeq_out::operator= (CORBA_InterfaceDefSeq *p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE 
CORBA_InterfaceDefSeq_out::operator CORBA_InterfaceDefSeq *&() // cast
{
  return this->ptr_;
}

ACE_INLINE CORBA_InterfaceDefSeq *&
CORBA_InterfaceDefSeq_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE CORBA_InterfaceDefSeq *
CORBA_InterfaceDefSeq_out::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE TAO_Object_Manager<CORBA::InterfaceDef,CORBA::InterfaceDef_var> 
CORBA_InterfaceDefSeq_out::operator[] (CORBA::ULong index)
{
  return this->ptr_->operator[] (index);
}


#endif /* end #if !defined */


#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
  
#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_VALUEDEFSEQ_CI_)
#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_VALUEDEFSEQ_CI_

  ACE_INLINE CORBA::ValueDef **
  _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::allocbuf (CORBA::ULong nelems)
  {
    CORBA::ValueDef **buf = 0;
    
    ACE_NEW_RETURN (buf, 
                    CORBA::ValueDef*[nelems], 
		    0);
    
    for (CORBA::ULong i = 0; i < nelems; i++)
      buf[i] = CORBA::ValueDef::_nil ();
    
    return buf;
  }
  
  ACE_INLINE void 
  _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::freebuf (CORBA::ValueDef **buffer)
  {
    if (buffer == 0)
      return;
    delete[] buffer;
  }
  
  ACE_INLINE
  _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq (void)
  {
  }
  
  ACE_INLINE
  _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq (CORBA::ULong maximum)
    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::allocbuf (maximum))
  {
  }
  
  ACE_INLINE
  _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq (CORBA::ULong maximum,
    CORBA::ULong length,
    CORBA::ValueDef* *value,
    CORBA::Boolean release)
  : TAO_Unbounded_Base_Sequence (maximum, length, value, release)
  {
  }
  
  ACE_INLINE
  _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq(const _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq &rhs)
    : TAO_Unbounded_Base_Sequence (rhs)
  {
    CORBA::ValueDef **tmp1 = _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::allocbuf (this->maximum_);
    CORBA::ValueDef ** const tmp2 = ACE_reinterpret_cast (CORBA::ValueDef ** ACE_CAST_CONST, rhs.buffer_);
    
    for (CORBA::ULong i = 0; i < rhs.length_; ++i)
      tmp1[i] = CORBA::ValueDef::_duplicate (tmp2[i]);
    
    this->buffer_ = tmp1;
  }
  
  ACE_INLINE _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq &
  _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::operator= (const _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq &rhs)
  {
    if (this == &rhs)
      return *this;
    
    if (this->release_)
    {
      CORBA::ValueDef **tmp = ACE_reinterpret_cast (CORBA::ValueDef **, this->buffer_);
      
      for (CORBA::ULong i = 0; i < this->length_; ++i)
      {
        CORBA::release (tmp[i]);
        tmp[i] = CORBA::ValueDef::_nil ();
      }
      if (this->maximum_ < rhs.maximum_)
      {
        _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::freebuf (tmp);
        this->buffer_ = _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::allocbuf (rhs.maximum_);
      }
    }
    else
      this->buffer_ = _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::allocbuf (rhs.maximum_);
    
    TAO_Unbounded_Base_Sequence::operator= (rhs);
    
    CORBA::ValueDef **tmp1 = ACE_reinterpret_cast (CORBA::ValueDef **, this->buffer_);
    CORBA::ValueDef ** const tmp2 = ACE_reinterpret_cast (CORBA::ValueDef ** ACE_CAST_CONST, rhs.buffer_);
    
    for (CORBA::ULong i = 0; i < rhs.length_; ++i)
      tmp1[i] = CORBA::ValueDef::_duplicate (tmp2[i]);
    
    return *this;
  }
  
  ACE_INLINE TAO_Object_Manager<CORBA::ValueDef,CORBA::ValueDef_var>
  _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::operator[] (CORBA::ULong index) const
  // read-write accessor
  {
    ACE_ASSERT (index < this->maximum_);
    CORBA::ValueDef ** const tmp = ACE_reinterpret_cast (CORBA::ValueDef ** ACE_CAST_CONST, this->buffer_);
    return TAO_Object_Manager<CORBA::ValueDef,CORBA::ValueDef_var> (tmp + index, this->release_);
  }
  
  ACE_INLINE CORBA::ValueDef* *
  _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::get_buffer (CORBA::Boolean orphan)
  {
    CORBA::ValueDef **result = 0;
    if (orphan == 0)
    {
      // We retain ownership.
      if (this->buffer_ == 0)
      {
        result = _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::allocbuf (this->maximum_);
        this->buffer_ = result;
      }
      else
      {
        result = ACE_reinterpret_cast (CORBA::ValueDef**, this->buffer_);
      }
    }
    else // if (orphan == 1)
    {
      if (this->release_ != 0)
      {
        // We set the state back to default and relinquish
        // ownership.
        result = ACE_reinterpret_cast(CORBA::ValueDef**,this->buffer_);
        this->maximum_ = 0;
        this->length_ = 0;
        this->buffer_ = 0;
        this->release_ = 0;
      }
    }
    return result;
  }
  
  ACE_INLINE const CORBA::ValueDef* *
  _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::get_buffer (void) const
  {
    return ACE_reinterpret_cast(const CORBA::ValueDef ** ACE_CAST_CONST, this->buffer_);
  }
  
  
#endif /* end #if !defined */


#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 

#if !defined (_CORBA_VALUEDEFSEQ_CI_)
#define _CORBA_VALUEDEFSEQ_CI_

// *************************************************************
// Inline operations for class CORBA::ValueDefSeq_var
// *************************************************************

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

ACE_INLINE
CORBA_ValueDefSeq_var::CORBA_ValueDefSeq_var (CORBA::ValueDefSeq *p)
  : ptr_ (p)
{}

ACE_INLINE
CORBA_ValueDefSeq_var::CORBA_ValueDefSeq_var (const CORBA::ValueDefSeq_var &p) // copy constructor
{
  if (p.ptr_)
    ACE_NEW (this->ptr_, 
             CORBA::ValueDefSeq(*p.ptr_));
  else
    this->ptr_ = 0;
}

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

ACE_INLINE CORBA_ValueDefSeq_var &
CORBA_ValueDefSeq_var::operator= (CORBA::ValueDefSeq *p)
{
  delete this->ptr_;
  this->ptr_ = p;
  return *this;
}

ACE_INLINE CORBA_ValueDefSeq_var &
CORBA_ValueDefSeq_var::operator= (const CORBA::ValueDefSeq_var &p) // deep copy
{
  if (this != &p)
  {
    delete this->ptr_;
    ACE_NEW_RETURN (this->ptr_, 
                    CORBA::ValueDefSeq (*p.ptr_), 
		    *this);
  }
  return *this;
}

ACE_INLINE const CORBA_ValueDefSeq *
CORBA_ValueDefSeq_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_ValueDefSeq *
CORBA_ValueDefSeq_var::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE 
CORBA_ValueDefSeq_var::operator const CORBA::ValueDefSeq &() const // cast
{
  return *this->ptr_;
}

ACE_INLINE 
CORBA_ValueDefSeq_var::operator CORBA::ValueDefSeq &() // cast 
{
  return *this->ptr_;
}

ACE_INLINE 
CORBA_ValueDefSeq_var::operator CORBA::ValueDefSeq &() const// cast 
{
  return *this->ptr_;
}

ACE_INLINE TAO_Object_Manager<CORBA::ValueDef,CORBA::ValueDef_var> 
CORBA_ValueDefSeq_var::operator[] (CORBA::ULong index)
{
  return this->ptr_->operator[] (index);
}

ACE_INLINE const CORBA_ValueDefSeq &
CORBA_ValueDefSeq_var::in (void) const
{
  return *this->ptr_;
}

ACE_INLINE CORBA_ValueDefSeq &
CORBA_ValueDefSeq_var::inout (void)
{
  return *this->ptr_;
}

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

ACE_INLINE CORBA_ValueDefSeq *
CORBA_ValueDefSeq_var::_retn (void)
{
  CORBA::ValueDefSeq *tmp = this->ptr_;
  this->ptr_ = 0;
  return tmp;
}

ACE_INLINE CORBA_ValueDefSeq *
CORBA_ValueDefSeq_var::ptr (void) const
{
  return this->ptr_;
}

// *************************************************************
// Inline operations for class CORBA::ValueDefSeq_out
// *************************************************************

ACE_INLINE
CORBA_ValueDefSeq_out::CORBA_ValueDefSeq_out (CORBA::ValueDefSeq *&p)
  : ptr_ (p)
{
  this->ptr_ = 0;
}

ACE_INLINE
CORBA_ValueDefSeq_out::CORBA_ValueDefSeq_out (CORBA::ValueDefSeq_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  delete this->ptr_;
  this->ptr_ = 0;
}

ACE_INLINE
CORBA_ValueDefSeq_out::CORBA_ValueDefSeq_out (const CORBA::ValueDefSeq_out &p) // copy constructor
  : ptr_ (ACE_const_cast (CORBA_ValueDefSeq_out&,p).ptr_)
{}

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

ACE_INLINE CORBA_ValueDefSeq_out &
CORBA_ValueDefSeq_out::operator= (CORBA_ValueDefSeq *p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE 
CORBA_ValueDefSeq_out::operator CORBA_ValueDefSeq *&() // cast
{
  return this->ptr_;
}

ACE_INLINE CORBA_ValueDefSeq *&
CORBA_ValueDefSeq_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE CORBA_ValueDefSeq *
CORBA_ValueDefSeq_out::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE TAO_Object_Manager<CORBA_ValueDef,CORBA_ValueDef_var> 
CORBA_ValueDefSeq_out::operator[] (CORBA::ULong index)
{
  return this->ptr_->operator[] (index);
}


#endif /* end #if !defined */


#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
  
#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_CONTAINEDSEQ_CI_)
#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_CONTAINEDSEQ_CI_

  ACE_INLINE CORBA_Contained **
  _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::allocbuf (CORBA::ULong nelems)
  {
    CORBA::Contained **buf = 0;
    
    ACE_NEW_RETURN (buf, 
                    CORBA::Contained*[nelems], 
		    0);
    
    for (CORBA::ULong i = 0; i < nelems; i++)
      buf[i] = CORBA::Contained::_nil ();
    
    return buf;
  }
  
  ACE_INLINE void 
  _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::freebuf (CORBA::Contained **buffer)
  {
    if (buffer == 0)
      return;
    delete[] buffer;
  }
  
  ACE_INLINE
  _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq (void)
  {
  }
  
  ACE_INLINE
  _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq (CORBA::ULong maximum)
    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::allocbuf (maximum))
  {
  }
  
  ACE_INLINE
  _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq (CORBA::ULong maximum,
    CORBA::ULong length,
    CORBA::Contained* *value,
    CORBA::Boolean release)
  : TAO_Unbounded_Base_Sequence (maximum, length, value, release)
  {
  }
  
  ACE_INLINE
  _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq(const _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq &rhs)
    : TAO_Unbounded_Base_Sequence (rhs)
  {
    CORBA::Contained **tmp1 = _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::allocbuf (this->maximum_);
    CORBA::Contained ** const tmp2 = ACE_reinterpret_cast (CORBA::Contained ** ACE_CAST_CONST, rhs.buffer_);
    
    for (CORBA::ULong i = 0; i < rhs.length_; ++i)
      tmp1[i] = CORBA::Contained::_duplicate (tmp2[i]);
    
    this->buffer_ = tmp1;
  }
  
  ACE_INLINE _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq &
  _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::operator= (const _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq &rhs)
  {
    if (this == &rhs)
      return *this;
    
    if (this->release_)
    {
      CORBA::Contained **tmp = ACE_reinterpret_cast (CORBA::Contained **, this->buffer_);
      
      for (CORBA::ULong i = 0; i < this->length_; ++i)
      {
        CORBA::release (tmp[i]);
        tmp[i] = CORBA::Contained::_nil ();
      }
      if (this->maximum_ < rhs.maximum_)
      {
        _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::freebuf (tmp);
        this->buffer_ = _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::allocbuf (rhs.maximum_);
      }
    }
    else
      this->buffer_ = _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::allocbuf (rhs.maximum_);
    
    TAO_Unbounded_Base_Sequence::operator= (rhs);
    
    CORBA::Contained **tmp1 = ACE_reinterpret_cast (CORBA::Contained **, this->buffer_);
    CORBA::Contained ** const tmp2 = ACE_reinterpret_cast (CORBA::Contained ** ACE_CAST_CONST, rhs.buffer_);
    
    for (CORBA::ULong i = 0; i < rhs.length_; ++i)
      tmp1[i] = CORBA::Contained::_duplicate (tmp2[i]);
    
    return *this;
  }
  
  ACE_INLINE TAO_Object_Manager<CORBA::Contained,CORBA::Contained_var>
  _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::operator[] (CORBA::ULong index) const
  // read-write accessor
  {
    ACE_ASSERT (index < this->maximum_);
    CORBA::Contained ** const tmp = ACE_reinterpret_cast (CORBA::Contained ** ACE_CAST_CONST, this->buffer_);
    return TAO_Object_Manager<CORBA::Contained,CORBA::Contained_var> (tmp + index, this->release_);
  }
  
  ACE_INLINE CORBA::Contained* *
  _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::get_buffer (CORBA::Boolean orphan)
  {
    CORBA::Contained **result = 0;
    if (orphan == 0)
    {
      // We retain ownership.
      if (this->buffer_ == 0)
      {
        result = _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::allocbuf (this->maximum_);
        this->buffer_ = result;
      }
      else
      {
        result = ACE_reinterpret_cast (CORBA::Contained**, this->buffer_);
      }
    }
    else // if (orphan == 1)
    {
      if (this->release_ != 0)
      {
        // We set the state back to default and relinquish
        // ownership.
        result = ACE_reinterpret_cast(CORBA::Contained**,this->buffer_);
        this->maximum_ = 0;
        this->length_ = 0;
        this->buffer_ = 0;
        this->release_ = 0;
      }
    }
    return result;
  }
  
  ACE_INLINE const CORBA::Contained* *
  _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::get_buffer (void) const
  {
    return ACE_reinterpret_cast(const CORBA::Contained ** ACE_CAST_CONST, this->buffer_);
  }
  
  
#endif /* end #if !defined */


#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 

#if !defined (_CORBA_CONTAINEDSEQ_CI_)
#define _CORBA_CONTAINEDSEQ_CI_

// *************************************************************
// Inline operations for class CORBA::ContainedSeq_var
// *************************************************************

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

ACE_INLINE
CORBA_ContainedSeq_var::CORBA_ContainedSeq_var (CORBA::ContainedSeq *p)
  : ptr_ (p)
{}

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

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

ACE_INLINE CORBA_ContainedSeq_var &
CORBA_ContainedSeq_var::operator= (CORBA_ContainedSeq *p)
{
  delete this->ptr_;
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE const CORBA_ContainedSeq *
CORBA_ContainedSeq_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_ContainedSeq *
CORBA_ContainedSeq_var::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE 
CORBA_ContainedSeq_var::operator const CORBA_ContainedSeq &() const // cast
{
  return *this->ptr_;
}

ACE_INLINE 
CORBA_ContainedSeq_var::operator CORBA_ContainedSeq &() // cast 
{
  return *this->ptr_;
}

ACE_INLINE 
CORBA_ContainedSeq_var::operator CORBA_ContainedSeq &() const// cast 
{
  return *this->ptr_;
}

ACE_INLINE TAO_Object_Manager<CORBA::Contained,CORBA::Contained_var> 
CORBA_ContainedSeq_var::operator[] (CORBA::ULong index)
{
  return this->ptr_->operator[] (index);
}

ACE_INLINE const CORBA_ContainedSeq &
CORBA_ContainedSeq_var::in (void) const
{
  return *this->ptr_;
}

ACE_INLINE CORBA_ContainedSeq &
CORBA_ContainedSeq_var::inout (void)
{
  return *this->ptr_;
}

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

ACE_INLINE CORBA_ContainedSeq *
CORBA_ContainedSeq_var::_retn (void)
{
  CORBA_ContainedSeq *tmp = this->ptr_;
  this->ptr_ = 0;
  return tmp;
}

ACE_INLINE CORBA_ContainedSeq *
CORBA_ContainedSeq_var::ptr (void) const
{
  return this->ptr_;
}

// *************************************************************
// Inline operations for class CORBA::ContainedSeq_out
// *************************************************************

ACE_INLINE
CORBA_ContainedSeq_out::CORBA_ContainedSeq_out (CORBA_ContainedSeq *&p)
  : ptr_ (p)
{
  this->ptr_ = 0;
}

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

ACE_INLINE
CORBA_ContainedSeq_out::CORBA_ContainedSeq_out (const CORBA_ContainedSeq_out &p) // copy constructor
  : ptr_ (ACE_const_cast (CORBA::ContainedSeq_out&,p).ptr_)
{}

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

ACE_INLINE CORBA_ContainedSeq_out &
CORBA_ContainedSeq_out::operator= (CORBA_ContainedSeq *p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE 
CORBA_ContainedSeq_out::operator CORBA_ContainedSeq *&() // cast
{
  return this->ptr_;
}

ACE_INLINE CORBA_ContainedSeq *&
CORBA_ContainedSeq_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE CORBA_ContainedSeq *
CORBA_ContainedSeq_out::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE TAO_Object_Manager<CORBA::Contained,CORBA::Contained_var> 
CORBA_ContainedSeq_out::operator[] (CORBA::ULong index)
{
  return this->ptr_->operator[] (index);
}


#endif /* end #if !defined */

// *************************************************************
// Inline operations for class CORBA::StructMember_var
// *************************************************************

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

ACE_INLINE
CORBA_StructMember_var::CORBA_StructMember_var (CORBA_StructMember *p)
  : ptr_ (p)
{}

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

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

ACE_INLINE CORBA_StructMember_var &
CORBA_StructMember_var::operator= (CORBA::StructMember *p)
{
  delete this->ptr_;
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE const CORBA_StructMember *
CORBA_StructMember_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_StructMember *
CORBA_StructMember_var::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE 
CORBA_StructMember_var::operator const CORBA::StructMember &() const // cast
{
  return *this->ptr_;
}

ACE_INLINE 
CORBA_StructMember_var::operator CORBA_StructMember &() // cast 
{
  return *this->ptr_;
}

ACE_INLINE 
CORBA_StructMember_var::operator CORBA_StructMember &() const// cast 
{
  return *this->ptr_;
}

ACE_INLINE const CORBA_StructMember &
CORBA_StructMember_var::in (void) const
{
  return *this->ptr_;
}

ACE_INLINE CORBA_StructMember &
CORBA_StructMember_var::inout (void)
{
  return *this->ptr_;
}

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

ACE_INLINE CORBA_StructMember *
CORBA_StructMember_var::_retn (void)
{
  CORBA_StructMember *tmp = this->ptr_;
  this->ptr_ = 0;
  return tmp;
}

ACE_INLINE CORBA_StructMember *
CORBA_StructMember_var::ptr (void) const
{
  return this->ptr_;
}

// *************************************************************
// Inline operations for class CORBA_StructMember_out
// *************************************************************

ACE_INLINE
CORBA_StructMember_out::CORBA_StructMember_out (CORBA_StructMember *&p)
  : ptr_ (p)
{
  this->ptr_ = 0;
}

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

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

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

ACE_INLINE CORBA_StructMember_out &
CORBA_StructMember_out::operator= (CORBA_StructMember *p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE 
CORBA_StructMember_out::operator CORBA_StructMember *&() // cast
{
  return this->ptr_;
}

ACE_INLINE CORBA_StructMember *&
CORBA_StructMember_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE CORBA_StructMember *
CORBA_StructMember_out::operator-> (void)
{
  return this->ptr_;
}


#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
  
#if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_STRUCTMEMBERSEQ_CI_)
#define __TAO_UNBOUNDED_SEQUENCE_CORBA_STRUCTMEMBERSEQ_CI_

  // = Static operations.
  ACE_INLINE CORBA_StructMember *
  _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::allocbuf (CORBA::ULong size)
  // Allocate storage for the sequence.
  {
    CORBA_StructMember *retval = 0;
    ACE_NEW_RETURN (retval,
                    CORBA_StructMember[size],
		    0);
    return retval;
  }
  
  ACE_INLINE void _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::freebuf (CORBA_StructMember *buffer)
  // Free the sequence.
  {
    delete [] buffer;
  }
  
  ACE_INLINE
  _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::_TAO_Unbounded_Sequence_CORBA_StructMemberSeq (void) // Default constructor.
  {
  }
  
  ACE_INLINE
  _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::_TAO_Unbounded_Sequence_CORBA_StructMemberSeq (CORBA::ULong maximum) // Constructor using a maximum length value.
    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::allocbuf (maximum))
  {
  }
  
  ACE_INLINE
  _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::_TAO_Unbounded_Sequence_CORBA_StructMemberSeq (CORBA::ULong maximum,
    CORBA::ULong length,
    CORBA_StructMember *data,
    CORBA::Boolean release)
  : TAO_Unbounded_Base_Sequence (maximum, length, data, release)
  {
  }
  
  ACE_INLINE
  _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::_TAO_Unbounded_Sequence_CORBA_StructMemberSeq (const _TAO_Unbounded_Sequence_CORBA_StructMemberSeq &rhs)
  // Copy constructor.
    : TAO_Unbounded_Base_Sequence (rhs)
  {
    CORBA_StructMember *tmp1 = _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::allocbuf (this->maximum_);
    CORBA_StructMember * const tmp2 = ACE_reinterpret_cast (CORBA_StructMember * ACE_CAST_CONST, rhs.buffer_);
    
    for (CORBA::ULong i = 0; i < this->length_; ++i)
      tmp1[i] = tmp2[i];
    
    this->buffer_ = tmp1;
  }
  
  ACE_INLINE _TAO_Unbounded_Sequence_CORBA_StructMemberSeq &
  _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::operator= (const _TAO_Unbounded_Sequence_CORBA_StructMemberSeq &rhs)
  // Assignment operator.
  {
    if (this == &rhs)
      return *this;
    
    if (this->release_)
    {
      if (this->maximum_ < rhs.maximum_)
      {
        // free the old buffer
        CORBA_StructMember *tmp = ACE_reinterpret_cast (CORBA_StructMember *, this->buffer_);
        _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::freebuf (tmp);
        this->buffer_ = _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::allocbuf (rhs.maximum_);
      }
    }
    else
      this->buffer_ = _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::allocbuf (rhs.maximum_);
    
    TAO_Unbounded_Base_Sequence::operator= (rhs);
    
    CORBA_StructMember *tmp1 = ACE_reinterpret_cast (CORBA_StructMember *, this->buffer_);
    CORBA_StructMember * const tmp2 = ACE_reinterpret_cast (CORBA_StructMember * ACE_CAST_CONST, rhs.buffer_);
    
    for (CORBA::ULong i = 0; i < this->length_; ++i)
      tmp1[i] = tmp2[i];
    
    return *this;
  }
  
  // = Accessors.
  ACE_INLINE CORBA_StructMember &
  _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::operator[] (CORBA::ULong i)
  // operator []
  {
    ACE_ASSERT (i < this->maximum_);
    CORBA_StructMember* tmp = ACE_reinterpret_cast(CORBA_StructMember*,this->buffer_);
    return tmp[i];
  }
  
  ACE_INLINE const CORBA_StructMember &
  _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::operator[] (CORBA::ULong i) const
  // operator []
  {
    ACE_ASSERT (i < this->maximum_);
    CORBA_StructMember * const tmp = ACE_reinterpret_cast (CORBA_StructMember* ACE_CAST_CONST, this->buffer_);
    return tmp[i];
  }
  
  // Implement the TAO_Base_Sequence methods (see Sequence.h)
  
  ACE_INLINE CORBA_StructMember *
  _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::get_buffer (CORBA::Boolean orphan)
  {
    CORBA_StructMember *result = 0;
    if (orphan == 0)
    {
      // We retain ownership.
      if (this->buffer_ == 0)
      {
        result = _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::allocbuf (this->length_);
        this->buffer_ = result;
      }
      else
      {
        result = ACE_reinterpret_cast (CORBA_StructMember*, this->buffer_);
      }
    }
    else // if (orphan == 1)
    {
      if (this->release_ != 0)
      {
        // We set the state back to default and relinquish
        // ownership.
        result = ACE_reinterpret_cast(CORBA_StructMember*,this->buffer_);
        this->maximum_ = 0;
        this->length_ = 0;
        this->buffer_ = 0;
        this->release_ = 0;
      }
    }
    return result;
  }
  
  ACE_INLINE const CORBA_StructMember *
  _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::get_buffer (void) const
  {
    return ACE_reinterpret_cast(const CORBA_StructMember * ACE_CAST_CONST, this->buffer_);
  }
  
  ACE_INLINE void
  _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::replace (CORBA::ULong max,
  CORBA::ULong length,
  CORBA_StructMember *data,
  CORBA::Boolean release)
  {
    this->maximum_ = max;
    this->length_ = length;
    if (this->buffer_ && this->release_ == 1)
    {
      CORBA_StructMember *tmp = ACE_reinterpret_cast(CORBA_StructMember*,this->buffer_);
      _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::freebuf (tmp);
    }
    this->buffer_ = data;
    this->release_ = release;
  }
  
#endif /* end #if !defined */


#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 

#if !defined (_CORBA_STRUCTMEMBERSEQ_CI_)
#define _CORBA_STRUCTMEMBERSEQ_CI_

// *************************************************************
// Inline operations for class CORBA_StructMemberSeq_var
// *************************************************************

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

ACE_INLINE
CORBA_StructMemberSeq_var::CORBA_StructMemberSeq_var (CORBA_StructMemberSeq *p)
  : ptr_ (p)
{}

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

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

ACE_INLINE CORBA_StructMemberSeq_var &
CORBA_StructMemberSeq_var::operator= (CORBA_StructMemberSeq *p)
{
  delete this->ptr_;
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE const CORBA_StructMemberSeq *
CORBA_StructMemberSeq_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_StructMemberSeq *
CORBA_StructMemberSeq_var::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE 
CORBA_StructMemberSeq_var::operator const CORBA_StructMemberSeq &() const // cast
{
  return *this->ptr_;
}

ACE_INLINE 
CORBA_StructMemberSeq_var::operator CORBA_StructMemberSeq &() // cast 
{
  return *this->ptr_;
}

ACE_INLINE 
CORBA_StructMemberSeq_var::operator CORBA_StructMemberSeq &() const// cast 
{
  return *this->ptr_;
}

ACE_INLINE CORBA_StructMember &
CORBA_StructMemberSeq_var::operator[] (CORBA::ULong index)
{
  return this->ptr_->operator[] (index);
}

ACE_INLINE const CORBA_StructMemberSeq &
CORBA_StructMemberSeq_var::in (void) const
{
  return *this->ptr_;
}

ACE_INLINE CORBA_StructMemberSeq &
CORBA_StructMemberSeq_var::inout (void)
{
  return *this->ptr_;
}

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

ACE_INLINE CORBA_StructMemberSeq *
CORBA_StructMemberSeq_var::_retn (void)
{
  CORBA_StructMemberSeq *tmp = this->ptr_;
  this->ptr_ = 0;
  return tmp;
}

ACE_INLINE CORBA_StructMemberSeq *
CORBA_StructMemberSeq_var::ptr (void) const
{
  return this->ptr_;
}

// *************************************************************
// Inline operations for class CORBA_StructMemberSeq_out
// *************************************************************

ACE_INLINE
CORBA_StructMemberSeq_out::CORBA_StructMemberSeq_out (CORBA_StructMemberSeq *&p)
  : ptr_ (p)
{
  this->ptr_ = 0;
}

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

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

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

ACE_INLINE CORBA_StructMemberSeq_out &
CORBA_StructMemberSeq_out::operator= (CORBA_StructMemberSeq *p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE 
CORBA_StructMemberSeq_out::operator CORBA_StructMemberSeq *&() // cast
{
  return this->ptr_;
}

ACE_INLINE CORBA_StructMemberSeq *&
CORBA_StructMemberSeq_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE CORBA_StructMemberSeq *
CORBA_StructMemberSeq_out::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE CORBA_StructMember &
CORBA_StructMemberSeq_out::operator[] (CORBA::ULong index)
{
  return this->ptr_->operator[] (index);
}


#endif /* end #if !defined */

// *************************************************************
// Inline operations for class CORBA_Initializer_var
// *************************************************************

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

ACE_INLINE
CORBA_Initializer_var::CORBA_Initializer_var (CORBA_Initializer *p)
  : ptr_ (p)
{}

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

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

ACE_INLINE CORBA_Initializer_var &
CORBA_Initializer_var::operator= (CORBA_Initializer *p)
{
  delete this->ptr_;
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE const CORBA_Initializer *
CORBA_Initializer_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_Initializer *
CORBA_Initializer_var::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE 
CORBA_Initializer_var::operator const CORBA_Initializer &() const // cast
{
  return *this->ptr_;
}

ACE_INLINE 
CORBA_Initializer_var::operator CORBA_Initializer &() // cast 
{
  return *this->ptr_;
}

ACE_INLINE 
CORBA_Initializer_var::operator CORBA_Initializer &() const// cast 
{
  return *this->ptr_;
}

ACE_INLINE const CORBA_Initializer &
CORBA_Initializer_var::in (void) const
{
  return *this->ptr_;
}

ACE_INLINE CORBA_Initializer &
CORBA_Initializer_var::inout (void)
{
  return *this->ptr_;
}

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

ACE_INLINE CORBA_Initializer *
CORBA_Initializer_var::_retn (void)
{
  CORBA_Initializer *tmp = this->ptr_;
  this->ptr_ = 0;
  return tmp;
}

ACE_INLINE CORBA_Initializer *
CORBA_Initializer_var::ptr (void) const
{
  return this->ptr_;
}

// *************************************************************
// Inline operations for class CORBA_Initializer_out
// *************************************************************

ACE_INLINE
CORBA_Initializer_out::CORBA_Initializer_out (CORBA_Initializer *&p)
  : ptr_ (p)
{
  this->ptr_ = 0;
}

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

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

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

ACE_INLINE CORBA_Initializer_out &
CORBA_Initializer_out::operator= (CORBA_Initializer *p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE 
CORBA_Initializer_out::operator CORBA_Initializer *&() // cast
{
  return this->ptr_;
}

ACE_INLINE CORBA_Initializer *&
CORBA_Initializer_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE CORBA_Initializer *
CORBA_Initializer_out::operator-> (void)
{
  return this->ptr_;
}


#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
  
#if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_INITIALIZERSEQ_CI_)
#define __TAO_UNBOUNDED_SEQUENCE_CORBA_INITIALIZERSEQ_CI_

  // = Static operations.
  ACE_INLINE CORBA_Initializer *
  _TAO_Unbounded_Sequence_CORBA_InitializerSeq::allocbuf (CORBA::ULong size)
  // Allocate storage for the sequence.
  {
    CORBA_Initializer *retval = 0;
    ACE_NEW_RETURN (retval,
                    CORBA_Initializer[size],
		    0);
    return retval;
  }
  
  ACE_INLINE void _TAO_Unbounded_Sequence_CORBA_InitializerSeq::freebuf (CORBA_Initializer *buffer)
  // Free the sequence.
  {
    delete [] buffer;
  }
  
  ACE_INLINE
  _TAO_Unbounded_Sequence_CORBA_InitializerSeq::_TAO_Unbounded_Sequence_CORBA_InitializerSeq (void) // Default constructor.
  {
  }
  
  ACE_INLINE
  _TAO_Unbounded_Sequence_CORBA_InitializerSeq::_TAO_Unbounded_Sequence_CORBA_InitializerSeq (CORBA::ULong maximum) // Constructor using a maximum length value.
    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Sequence_CORBA_InitializerSeq::allocbuf (maximum))
  {
  }
  
  ACE_INLINE
  _TAO_Unbounded_Sequence_CORBA_InitializerSeq::_TAO_Unbounded_Sequence_CORBA_InitializerSeq (CORBA::ULong maximum,
    CORBA::ULong length,
    CORBA_Initializer *data,
    CORBA::Boolean release)
  : TAO_Unbounded_Base_Sequence (maximum, length, data, release)
  {
  }
  
  ACE_INLINE
  _TAO_Unbounded_Sequence_CORBA_InitializerSeq::_TAO_Unbounded_Sequence_CORBA_InitializerSeq (const _TAO_Unbounded_Sequence_CORBA_InitializerSeq &rhs)
  // Copy constructor.
    : TAO_Unbounded_Base_Sequence (rhs)
  {
    CORBA_Initializer *tmp1 = _TAO_Unbounded_Sequence_CORBA_InitializerSeq::allocbuf (this->maximum_);
    CORBA_Initializer * const tmp2 = ACE_reinterpret_cast (CORBA_Initializer * ACE_CAST_CONST, rhs.buffer_);
    
    for (CORBA::ULong i = 0; i < this->length_; ++i)
      tmp1[i] = tmp2[i];
    
    this->buffer_ = tmp1;
  }
  
  ACE_INLINE _TAO_Unbounded_Sequence_CORBA_InitializerSeq &
  _TAO_Unbounded_Sequence_CORBA_InitializerSeq::operator= (const _TAO_Unbounded_Sequence_CORBA_InitializerSeq &rhs)
  // Assignment operator.
  {
    if (this == &rhs)
      return *this;
    
    if (this->release_)
    {
      if (this->maximum_ < rhs.maximum_)
      {
        // free the old buffer
        CORBA_Initializer *tmp = ACE_reinterpret_cast (CORBA_Initializer *, this->buffer_);
        _TAO_Unbounded_Sequence_CORBA_InitializerSeq::freebuf (tmp);
        this->buffer_ = _TAO_Unbounded_Sequence_CORBA_InitializerSeq::allocbuf (rhs.maximum_);
      }
    }
    else
      this->buffer_ = _TAO_Unbounded_Sequence_CORBA_InitializerSeq::allocbuf (rhs.maximum_);
    
    TAO_Unbounded_Base_Sequence::operator= (rhs);
    
    CORBA_Initializer *tmp1 = ACE_reinterpret_cast (CORBA_Initializer *, this->buffer_);
    CORBA_Initializer * const tmp2 = ACE_reinterpret_cast (CORBA_Initializer * ACE_CAST_CONST, rhs.buffer_);
    
    for (CORBA::ULong i = 0; i < this->length_; ++i)
      tmp1[i] = tmp2[i];
    
    return *this;
  }
  
  // = Accessors.
  ACE_INLINE CORBA_Initializer &
  _TAO_Unbounded_Sequence_CORBA_InitializerSeq::operator[] (CORBA::ULong i)
  // operator []
  {
    ACE_ASSERT (i < this->maximum_);
    CORBA_Initializer* tmp = ACE_reinterpret_cast(CORBA_Initializer*,this->buffer_);
    return tmp[i];
  }
  
  ACE_INLINE const CORBA_Initializer &
  _TAO_Unbounded_Sequence_CORBA_InitializerSeq::operator[] (CORBA::ULong i) const
  // operator []
  {
    ACE_ASSERT (i < this->maximum_);
    CORBA_Initializer * const tmp = ACE_reinterpret_cast (CORBA_Initializer* ACE_CAST_CONST, this->buffer_);
    return tmp[i];
  }
  
  // Implement the TAO_Base_Sequence methods (see Sequence.h)
  
  ACE_INLINE CORBA_Initializer *
  _TAO_Unbounded_Sequence_CORBA_InitializerSeq::get_buffer (CORBA::Boolean orphan)
  {
    CORBA_Initializer *result = 0;
    if (orphan == 0)
    {
      // We retain ownership.
      if (this->buffer_ == 0)
      {
        result = _TAO_Unbounded_Sequence_CORBA_InitializerSeq::allocbuf (this->length_);
        this->buffer_ = result;
      }
      else
      {
        result = ACE_reinterpret_cast (CORBA_Initializer*, this->buffer_);
      }
    }
    else // if (orphan == 1)
    {
      if (this->release_ != 0)
      {
        // We set the state back to default and relinquish
        // ownership.
        result = ACE_reinterpret_cast(CORBA_Initializer*,this->buffer_);
        this->maximum_ = 0;
        this->length_ = 0;
        this->buffer_ = 0;
        this->release_ = 0;
      }
    }
    return result;
  }
  
  ACE_INLINE const CORBA_Initializer *
  _TAO_Unbounded_Sequence_CORBA_InitializerSeq::get_buffer (void) const
  {
    return ACE_reinterpret_cast(const CORBA_Initializer * ACE_CAST_CONST, this->buffer_);
  }
  
  ACE_INLINE void
  _TAO_Unbounded_Sequence_CORBA_InitializerSeq::replace (CORBA::ULong max,
  CORBA::ULong length,
  CORBA_Initializer *data,
  CORBA::Boolean release)
  {
    this->maximum_ = max;
    this->length_ = length;
    if (this->buffer_ && this->release_ == 1)
    {
      CORBA_Initializer *tmp = ACE_reinterpret_cast(CORBA_Initializer*,this->buffer_);
      _TAO_Unbounded_Sequence_CORBA_InitializerSeq::freebuf (tmp);
    }
    this->buffer_ = data;
    this->release_ = release;
  }
  
#endif /* end #if !defined */


#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 

#if !defined (_CORBA_INITIALIZERSEQ_CI_)
#define _CORBA_INITIALIZERSEQ_CI_

// *************************************************************
// Inline operations for class CORBA_InitializerSeq_var
// *************************************************************

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

ACE_INLINE
CORBA_InitializerSeq_var::CORBA_InitializerSeq_var (CORBA_InitializerSeq *p)
  : ptr_ (p)
{}

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

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

ACE_INLINE CORBA_InitializerSeq_var &
CORBA_InitializerSeq_var::operator= (CORBA_InitializerSeq *p)
{
  delete this->ptr_;
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE const CORBA_InitializerSeq *
CORBA_InitializerSeq_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_InitializerSeq *
CORBA_InitializerSeq_var::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE 
CORBA_InitializerSeq_var::operator const CORBA_InitializerSeq &() const // cast
{
  return *this->ptr_;
}

ACE_INLINE 
CORBA_InitializerSeq_var::operator CORBA_InitializerSeq &() // cast 
{
  return *this->ptr_;
}

ACE_INLINE 
CORBA_InitializerSeq_var::operator CORBA_InitializerSeq &() const// cast 
{
  return *this->ptr_;
}

ACE_INLINE CORBA_Initializer &
CORBA_InitializerSeq_var::operator[] (CORBA::ULong index)
{
  return this->ptr_->operator[] (index);
}

ACE_INLINE const CORBA_InitializerSeq &
CORBA_InitializerSeq_var::in (void) const
{
  return *this->ptr_;
}

ACE_INLINE CORBA_InitializerSeq &
CORBA_InitializerSeq_var::inout (void)
{
  return *this->ptr_;
}

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

ACE_INLINE CORBA_InitializerSeq *
CORBA_InitializerSeq_var::_retn (void)
{
  CORBA_InitializerSeq *tmp = this->ptr_;
  this->ptr_ = 0;
  return tmp;
}

ACE_INLINE CORBA_InitializerSeq *
CORBA_InitializerSeq_var::ptr (void) const
{
  return this->ptr_;
}

// *************************************************************
// Inline operations for class CORBA_InitializerSeq_out
// *************************************************************

ACE_INLINE
CORBA_InitializerSeq_out::CORBA_InitializerSeq_out (CORBA_InitializerSeq *&p)
  : ptr_ (p)
{
  this->ptr_ = 0;
}

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

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

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

ACE_INLINE CORBA_InitializerSeq_out &
CORBA_InitializerSeq_out::operator= (CORBA_InitializerSeq *p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE 
CORBA_InitializerSeq_out::operator CORBA_InitializerSeq *&() // cast
{
  return this->ptr_;
}

ACE_INLINE CORBA_InitializerSeq *&
CORBA_InitializerSeq_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE CORBA_InitializerSeq *
CORBA_InitializerSeq_out::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE CORBA_Initializer &
CORBA_InitializerSeq_out::operator[] (CORBA::ULong index)
{
  return this->ptr_->operator[] (index);
}


#endif /* end #if !defined */

// *************************************************************
// Inline operations for class CORBA_UnionMember_var
// *************************************************************

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

ACE_INLINE
CORBA_UnionMember_var::CORBA_UnionMember_var (CORBA_UnionMember *p)
  : ptr_ (p)
{}

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

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

ACE_INLINE CORBA_UnionMember_var &
CORBA_UnionMember_var::operator= (CORBA_UnionMember *p)
{
  delete this->ptr_;
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE const CORBA_UnionMember *
CORBA_UnionMember_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_UnionMember *
CORBA_UnionMember_var::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE 
CORBA_UnionMember_var::operator const CORBA_UnionMember &() const // cast
{
  return *this->ptr_;
}

ACE_INLINE 
CORBA_UnionMember_var::operator CORBA_UnionMember &() // cast 
{
  return *this->ptr_;
}

ACE_INLINE 
CORBA_UnionMember_var::operator CORBA_UnionMember &() const// cast 
{
  return *this->ptr_;
}

ACE_INLINE const CORBA_UnionMember &
CORBA_UnionMember_var::in (void) const
{
  return *this->ptr_;
}

ACE_INLINE CORBA_UnionMember &
CORBA_UnionMember_var::inout (void)
{
  return *this->ptr_;
}

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

ACE_INLINE CORBA_UnionMember *
CORBA_UnionMember_var::_retn (void)
{
  CORBA_UnionMember *tmp = this->ptr_;
  this->ptr_ = 0;
  return tmp;
}

ACE_INLINE CORBA_UnionMember *
CORBA_UnionMember_var::ptr (void) const
{
  return this->ptr_;
}

// *************************************************************
// Inline operations for class CORBA_UnionMember_out
// *************************************************************

ACE_INLINE
CORBA_UnionMember_out::CORBA_UnionMember_out (CORBA_UnionMember *&p)
  : ptr_ (p)
{
  this->ptr_ = 0;
}

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

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

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

ACE_INLINE CORBA_UnionMember_out &
CORBA_UnionMember_out::operator= (CORBA_UnionMember *p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE 
CORBA_UnionMember_out::operator CORBA_UnionMember *&() // cast
{
  return this->ptr_;
}

ACE_INLINE CORBA_UnionMember *&
CORBA_UnionMember_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE CORBA_UnionMember *
CORBA_UnionMember_out::operator-> (void)
{
  return this->ptr_;
}


#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
  
#if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_UNIONMEMBERSEQ_CI_)
#define __TAO_UNBOUNDED_SEQUENCE_CORBA_UNIONMEMBERSEQ_CI_

  // = Static operations.
  ACE_INLINE CORBA_UnionMember *
  _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::allocbuf (CORBA::ULong size)
  // Allocate storage for the sequence.
  {
    CORBA_UnionMember *retval = 0;
    ACE_NEW_RETURN (retval,
                    CORBA_UnionMember[size],
		    0);
    return retval;
  }
  
  ACE_INLINE void _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::freebuf (CORBA_UnionMember *buffer)
  // Free the sequence.
  {
    delete [] buffer;
  }
  
  ACE_INLINE
  _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq (void) // Default constructor.
  {
  }
  
  ACE_INLINE
  _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq (CORBA::ULong maximum) // Constructor using a maximum length value.
    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::allocbuf (maximum))
  {
  }
  
  ACE_INLINE
  _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq (CORBA::ULong maximum,
    CORBA::ULong length,
    CORBA_UnionMember *data,
    CORBA::Boolean release)
  : TAO_Unbounded_Base_Sequence (maximum, length, data, release)
  {
  }
  
  ACE_INLINE
  _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq (const _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq &rhs)
  // Copy constructor.
    : TAO_Unbounded_Base_Sequence (rhs)
  {
    CORBA_UnionMember *tmp1 = _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::allocbuf (this->maximum_);
    CORBA_UnionMember * const tmp2 = ACE_reinterpret_cast (CORBA_UnionMember * ACE_CAST_CONST, rhs.buffer_);
    
    for (CORBA::ULong i = 0; i < this->length_; ++i)
      tmp1[i] = tmp2[i];
    
    this->buffer_ = tmp1;
  }
  
  ACE_INLINE _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq &
  _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::operator= (const _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq &rhs)
  // Assignment operator.
  {
    if (this == &rhs)
      return *this;
    
    if (this->release_)
    {
      if (this->maximum_ < rhs.maximum_)
      {
        // free the old buffer
        CORBA_UnionMember *tmp = ACE_reinterpret_cast (CORBA_UnionMember *, this->buffer_);
        _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::freebuf (tmp);
        this->buffer_ = _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::allocbuf (rhs.maximum_);
      }
    }
    else
      this->buffer_ = _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::allocbuf (rhs.maximum_);
    
    TAO_Unbounded_Base_Sequence::operator= (rhs);
    
    CORBA_UnionMember *tmp1 = ACE_reinterpret_cast (CORBA_UnionMember *, this->buffer_);
    CORBA_UnionMember * const tmp2 = ACE_reinterpret_cast (CORBA_UnionMember * ACE_CAST_CONST, rhs.buffer_);
    
    for (CORBA::ULong i = 0; i < this->length_; ++i)
      tmp1[i] = tmp2[i];
    
    return *this;
  }
  
  // = Accessors.
  ACE_INLINE CORBA_UnionMember &
  _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::operator[] (CORBA::ULong i)
  // operator []
  {
    ACE_ASSERT (i < this->maximum_);
    CORBA_UnionMember* tmp = ACE_reinterpret_cast(CORBA_UnionMember*,this->buffer_);
    return tmp[i];
  }
  
  ACE_INLINE const CORBA_UnionMember &
  _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::operator[] (CORBA::ULong i) const
  // operator []
  {
    ACE_ASSERT (i < this->maximum_);
    CORBA_UnionMember * const tmp = ACE_reinterpret_cast (CORBA_UnionMember* ACE_CAST_CONST, this->buffer_);
    return tmp[i];
  }
  
  // Implement the TAO_Base_Sequence methods (see Sequence.h)
  
  ACE_INLINE CORBA_UnionMember *
  _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::get_buffer (CORBA::Boolean orphan)
  {
    CORBA_UnionMember *result = 0;
    if (orphan == 0)
    {
      // We retain ownership.
      if (this->buffer_ == 0)
      {
        result = _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::allocbuf (this->length_);
        this->buffer_ = result;
      }
      else
      {
        result = ACE_reinterpret_cast (CORBA_UnionMember*, this->buffer_);
      }
    }
    else // if (orphan == 1)
    {
      if (this->release_ != 0)
      {
        // We set the state back to default and relinquish
        // ownership.
        result = ACE_reinterpret_cast(CORBA_UnionMember*,this->buffer_);
        this->maximum_ = 0;
        this->length_ = 0;
        this->buffer_ = 0;
        this->release_ = 0;
      }
    }
    return result;
  }
  
  ACE_INLINE const CORBA_UnionMember *
  _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::get_buffer (void) const
  {
    return ACE_reinterpret_cast(const CORBA_UnionMember * ACE_CAST_CONST, this->buffer_);
  }
  
  ACE_INLINE void
  _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::replace (CORBA::ULong max,
  CORBA::ULong length,
  CORBA_UnionMember *data,
  CORBA::Boolean release)
  {
    this->maximum_ = max;
    this->length_ = length;
    if (this->buffer_ && this->release_ == 1)
    {
      CORBA_UnionMember *tmp = ACE_reinterpret_cast(CORBA_UnionMember*,this->buffer_);
      _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::freebuf (tmp);
    }
    this->buffer_ = data;
    this->release_ = release;
  }
  
#endif /* end #if !defined */


#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 

#if !defined (_CORBA_UNIONMEMBERSEQ_CI_)
#define _CORBA_UNIONMEMBERSEQ_CI_

// *************************************************************
// Inline operations for class CORBA_UnionMemberSeq_var
// *************************************************************

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

ACE_INLINE
CORBA_UnionMemberSeq_var::CORBA_UnionMemberSeq_var (CORBA_UnionMemberSeq *p)
  : ptr_ (p)
{}

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

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

ACE_INLINE CORBA_UnionMemberSeq_var &
CORBA_UnionMemberSeq_var::operator= (CORBA_UnionMemberSeq *p)
{
  delete this->ptr_;
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE const CORBA_UnionMemberSeq *
CORBA_UnionMemberSeq_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_UnionMemberSeq *
CORBA_UnionMemberSeq_var::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE 
CORBA_UnionMemberSeq_var::operator const CORBA_UnionMemberSeq &() const // cast
{
  return *this->ptr_;
}

ACE_INLINE 
CORBA_UnionMemberSeq_var::operator CORBA_UnionMemberSeq &() // cast 
{
  return *this->ptr_;
}

ACE_INLINE 
CORBA_UnionMemberSeq_var::operator CORBA_UnionMemberSeq &() const// cast 
{
  return *this->ptr_;
}

ACE_INLINE CORBA_UnionMember &
CORBA_UnionMemberSeq_var::operator[] (CORBA::ULong index)
{
  return this->ptr_->operator[] (index);
}

ACE_INLINE const CORBA_UnionMemberSeq &
CORBA_UnionMemberSeq_var::in (void) const
{
  return *this->ptr_;
}

ACE_INLINE CORBA_UnionMemberSeq &
CORBA_UnionMemberSeq_var::inout (void)
{
  return *this->ptr_;
}

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

ACE_INLINE CORBA_UnionMemberSeq *
CORBA_UnionMemberSeq_var::_retn (void)
{
  CORBA_UnionMemberSeq *tmp = this->ptr_;
  this->ptr_ = 0;
  return tmp;
}

ACE_INLINE CORBA_UnionMemberSeq *
CORBA_UnionMemberSeq_var::ptr (void) const
{
  return this->ptr_;
}

// *************************************************************
// Inline operations for class CORBA_UnionMemberSeq_out
// *************************************************************

ACE_INLINE
CORBA_UnionMemberSeq_out::CORBA_UnionMemberSeq_out (CORBA_UnionMemberSeq *&p)
  : ptr_ (p)
{
  this->ptr_ = 0;
}

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

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

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

ACE_INLINE CORBA_UnionMemberSeq_out &
CORBA_UnionMemberSeq_out::operator= (CORBA_UnionMemberSeq *p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE 
CORBA_UnionMemberSeq_out::operator CORBA_UnionMemberSeq *&() // cast
{
  return this->ptr_;
}

ACE_INLINE CORBA_UnionMemberSeq *&
CORBA_UnionMemberSeq_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE CORBA_UnionMemberSeq *
CORBA_UnionMemberSeq_out::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE CORBA_UnionMember &
CORBA_UnionMemberSeq_out::operator[] (CORBA::ULong index)
{
  return this->ptr_->operator[] (index);
}


#endif /* end #if !defined */


#if !defined (_CORBA_ENUMMEMBERSEQ_CI_)
#define _CORBA_ENUMMEMBERSEQ_CI_

// *************************************************************
// Inline operations for class CORBA_EnumMemberSeq_var
// *************************************************************

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

ACE_INLINE
CORBA_EnumMemberSeq_var::CORBA_EnumMemberSeq_var (CORBA_EnumMemberSeq *p)
  : ptr_ (p)
{}

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

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

ACE_INLINE CORBA_EnumMemberSeq_var &
CORBA_EnumMemberSeq_var::operator= (CORBA_EnumMemberSeq *p)
{
  delete this->ptr_;
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE const CORBA_EnumMemberSeq *
CORBA_EnumMemberSeq_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_EnumMemberSeq *
CORBA_EnumMemberSeq_var::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE 
CORBA_EnumMemberSeq_var::operator const CORBA_EnumMemberSeq &() const // cast
{
  return *this->ptr_;
}

ACE_INLINE 
CORBA_EnumMemberSeq_var::operator CORBA_EnumMemberSeq &() // cast 
{
  return *this->ptr_;
}

ACE_INLINE 
CORBA_EnumMemberSeq_var::operator CORBA_EnumMemberSeq &() const// cast 
{
  return *this->ptr_;
}

ACE_INLINE TAO_SeqElem_String_Manager 
CORBA_EnumMemberSeq_var::operator[] (CORBA::ULong index)
{
  return this->ptr_->operator[] (index);
}

ACE_INLINE const CORBA_EnumMemberSeq &
CORBA_EnumMemberSeq_var::in (void) const
{
  return *this->ptr_;
}

ACE_INLINE CORBA_EnumMemberSeq &
CORBA_EnumMemberSeq_var::inout (void)
{
  return *this->ptr_;
}

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

ACE_INLINE CORBA_EnumMemberSeq *
CORBA_EnumMemberSeq_var::_retn (void)
{
  CORBA_EnumMemberSeq *tmp = this->ptr_;
  this->ptr_ = 0;
  return tmp;
}

ACE_INLINE CORBA_EnumMemberSeq *
CORBA_EnumMemberSeq_var::ptr (void) const
{
  return this->ptr_;
}

// *************************************************************
// Inline operations for class CORBA_EnumMemberSeq_out
// *************************************************************

ACE_INLINE
CORBA_EnumMemberSeq_out::CORBA_EnumMemberSeq_out (CORBA_EnumMemberSeq *&p)
  : ptr_ (p)
{
  this->ptr_ = 0;
}

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

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

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

ACE_INLINE CORBA_EnumMemberSeq_out &
CORBA_EnumMemberSeq_out::operator= (CORBA_EnumMemberSeq *p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE 
CORBA_EnumMemberSeq_out::operator CORBA_EnumMemberSeq *&() // cast
{
  return this->ptr_;
}

ACE_INLINE CORBA_EnumMemberSeq *&
CORBA_EnumMemberSeq_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE CORBA_EnumMemberSeq *
CORBA_EnumMemberSeq_out::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE TAO_SeqElem_String_Manager 
CORBA_EnumMemberSeq_out::operator[] (CORBA::ULong index)
{
  return this->ptr_->operator[] (index);
}


#endif /* end #if !defined */

ACE_INLINE
CORBA_Container::CORBA_Container (void) // default constructor
{}

ACE_INLINE
CORBA_Container::CORBA_Container (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
  : CORBA_Object (objref, _tao_servant, _tao_collocated)
{}

ACE_INLINE
CORBA_Container::~CORBA_Container (void) // destructor
{}


#if !defined (_CORBA_CONTAINER___VAR_CI_)
#define _CORBA_CONTAINER___VAR_CI_

// *************************************************************
// Inline operations for class CORBA_Container_var
// *************************************************************

ACE_INLINE
CORBA_Container_var::CORBA_Container_var (void) // default constructor
  : ptr_ (CORBA_Container::_nil ())
{}

ACE_INLINE
CORBA_Container_var::CORBA_Container_var (CORBA_Container_ptr p)
  : ptr_ (p)
{}

ACE_INLINE CORBA_Container_ptr 
CORBA_Container_var::ptr (void) const
{
  return this->ptr_;
}

ACE_INLINE
CORBA_Container_var::CORBA_Container_var (const CORBA_Container_var &p) // copy constructor
  : ptr_ (CORBA_Container::_duplicate (p.ptr ()))
{}

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

ACE_INLINE CORBA_Container_var &
CORBA_Container_var::operator= (CORBA_Container_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE 
CORBA_Container_var::operator const CORBA_Container_ptr &() const // cast
{
  return this->ptr_;
}

ACE_INLINE 
CORBA_Container_var::operator CORBA_Container_ptr &() // cast 
{
  return this->ptr_;
}

ACE_INLINE CORBA_Container_ptr 
CORBA_Container_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_Container_ptr
CORBA_Container_var::in (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_Container_ptr &
CORBA_Container_var::inout (void)
{
  return this->ptr_;
}

ACE_INLINE CORBA_Container_ptr &
CORBA_Container_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = CORBA_Container::_nil ();
  return this->ptr_;
}

ACE_INLINE CORBA_Container_ptr 
CORBA_Container_var::_retn (void)
{
  // yield ownership of managed obj reference
  CORBA_Container_ptr val = this->ptr_;
  this->ptr_ = CORBA_Container::_nil ();
  return val;
}


#endif /* end #if !defined */


#if !defined (_CORBA_CONTAINER___OUT_CI_)
#define _CORBA_CONTAINER___OUT_CI_

// *************************************************************
// Inline operations for class CORBA_Container_out
// *************************************************************

ACE_INLINE
CORBA_Container_out::CORBA_Container_out (CORBA_Container_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = CORBA_Container::_nil ();
}

ACE_INLINE
CORBA_Container_out::CORBA_Container_out (CORBA_Container_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = CORBA_Container::_nil ();
}

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

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

ACE_INLINE CORBA_Container_out &
CORBA_Container_out::operator= (const CORBA_Container_var &p)
{
  this->ptr_ = CORBA_Container::_duplicate (p.ptr ());
  return *this;
}

ACE_INLINE CORBA_Container_out &
CORBA_Container_out::operator= (CORBA_Container_ptr p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE 
CORBA_Container_out::operator CORBA_Container_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE CORBA_Container_ptr &
CORBA_Container_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE CORBA_Container_ptr 
CORBA_Container_out::operator-> (void)
{
  return this->ptr_;
}


#endif /* end #if !defined */

// *************************************************************
// Inline operations for class CORBA_Container::Description_var
// *************************************************************

ACE_INLINE
CORBA_Container::Description_var::Description_var (void) // default constructor
  : ptr_ (0)
{}

ACE_INLINE
CORBA_Container::Description_var::Description_var (CORBA_Container::Description *p)
  : ptr_ (p)
{}

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

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

ACE_INLINE CORBA_Container::Description_var &
CORBA_Container::Description_var::operator= (CORBA_Container::Description *p)
{
  delete this->ptr_;
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE const CORBA_Container::Description *
CORBA_Container::Description_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_Container::Description *
CORBA_Container::Description_var::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE 
CORBA_Container::Description_var::operator const CORBA_Container::Description &() const // cast
{
  return *this->ptr_;
}

ACE_INLINE 
CORBA_Container::Description_var::operator CORBA_Container::Description &() // cast 
{
  return *this->ptr_;
}

ACE_INLINE 
CORBA_Container::Description_var::operator CORBA_Container::Description &() const// cast 
{
  return *this->ptr_;
}

ACE_INLINE const CORBA_Container::Description &
CORBA_Container::Description_var::in (void) const
{
  return *this->ptr_;
}

ACE_INLINE CORBA_Container::Description &
CORBA_Container::Description_var::inout (void)
{
  return *this->ptr_;
}

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

ACE_INLINE CORBA_Container::Description *
CORBA_Container::Description_var::_retn (void)
{
  CORBA_Container::Description *tmp = this->ptr_;
  this->ptr_ = 0;
  return tmp;
}

ACE_INLINE CORBA_Container::Description *
CORBA_Container::Description_var::ptr (void) const
{
  return this->ptr_;
}

// *************************************************************
// Inline operations for class CORBA_Container::Description_out
// *************************************************************

ACE_INLINE
CORBA_Container::Description_out::Description_out (CORBA_Container::Description *&p)
  : ptr_ (p)
{
  this->ptr_ = 0;
}

ACE_INLINE
CORBA_Container::Description_out::Description_out (CORBA_Container::Description_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  delete this->ptr_;
  this->ptr_ = 0;
}

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

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

ACE_INLINE CORBA_Container::Description_out &
CORBA_Container::Description_out::operator= (CORBA_Container::Description *p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE 
CORBA_Container::Description_out::operator CORBA_Container::Description *&() // cast
{
  return this->ptr_;
}

ACE_INLINE CORBA_Container::Description *&
CORBA_Container::Description_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE CORBA_Container::Description *
CORBA_Container::Description_out::operator-> (void)
{
  return this->ptr_;
}


#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
  
#if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_CONTAINER_DESCRIPTIONSEQ_CI_)
#define __TAO_UNBOUNDED_SEQUENCE_CORBA_CONTAINER_DESCRIPTIONSEQ_CI_

  // = Static operations.
  ACE_INLINE CORBA_Container::Description *
  CORBA_Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::allocbuf (CORBA::ULong size)
  // Allocate storage for the sequence.
  {
    CORBA_Container::Description *retval = 0;
    ACE_NEW_RETURN (retval,
                    CORBA_Container::Description[size],
		    0);
    return retval;
  }
  
  ACE_INLINE void CORBA_Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::freebuf (CORBA_Container::Description *buffer)
  // Free the sequence.
  {
    delete [] buffer;
  }
  
  ACE_INLINE
  CORBA_Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq (void) // Default constructor.
  {
  }
  
  ACE_INLINE
  CORBA_Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq (CORBA::ULong maximum) // Constructor using a maximum length value.
    : TAO_Unbounded_Base_Sequence (maximum, CORBA_Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::allocbuf (maximum))
  {
  }
  
  ACE_INLINE
  CORBA_Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq (CORBA::ULong maximum,
    CORBA::ULong length,
    CORBA_Container::Description *data,
    CORBA::Boolean release)
  : TAO_Unbounded_Base_Sequence (maximum, length, data, release)
  {
  }
  
  ACE_INLINE
  CORBA_Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq (const CORBA_Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq &rhs)
  // Copy constructor.
    : TAO_Unbounded_Base_Sequence (rhs)
  {
    CORBA_Container::Description *tmp1 = CORBA_Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::allocbuf (this->maximum_);
    CORBA_Container::Description * const tmp2 = ACE_reinterpret_cast (CORBA_Container::Description * ACE_CAST_CONST, rhs.buffer_);
    
    for (CORBA::ULong i = 0; i < this->length_; ++i)
      tmp1[i] = tmp2[i];
    
    this->buffer_ = tmp1;
  }
  
  ACE_INLINE CORBA_Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq &
  CORBA_Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::operator= (const CORBA_Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq &rhs)
  // Assignment operator.
  {
    if (this == &rhs)
      return *this;
    
    if (this->release_)
    {
      if (this->maximum_ < rhs.maximum_)
      {
        // free the old buffer
        CORBA_Container::Description *tmp = ACE_reinterpret_cast (CORBA_Container::Description *, this->buffer_);
        CORBA_Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::freebuf (tmp);
        this->buffer_ = CORBA_Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::allocbuf (rhs.maximum_);
      }
    }
    else
      this->buffer_ = CORBA_Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::allocbuf (rhs.maximum_);
    
    TAO_Unbounded_Base_Sequence::operator= (rhs);
    
    CORBA_Container::Description *tmp1 = ACE_reinterpret_cast (CORBA_Container::Description *, this->buffer_);
    CORBA_Container::Description * const tmp2 = ACE_reinterpret_cast (CORBA_Container::Description * ACE_CAST_CONST, rhs.buffer_);
    
    for (CORBA::ULong i = 0; i < this->length_; ++i)
      tmp1[i] = tmp2[i];
    
    return *this;
  }
  
  // = Accessors.
  ACE_INLINE CORBA_Container::Description &
  CORBA_Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::operator[] (CORBA::ULong i)
  // operator []
  {
    ACE_ASSERT (i < this->maximum_);
    CORBA_Container::Description* tmp = ACE_reinterpret_cast(CORBA_Container::Description*,this->buffer_);
    return tmp[i];
  }
  
  ACE_INLINE const CORBA_Container::Description &
  CORBA_Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::operator[] (CORBA::ULong i) const
  // operator []
  {
    ACE_ASSERT (i < this->maximum_);
    CORBA_Container::Description * const tmp = ACE_reinterpret_cast (CORBA_Container::Description* ACE_CAST_CONST, this->buffer_);
    return tmp[i];
  }
  
  // Implement the TAO_Base_Sequence methods (see Sequence.h)
  
  ACE_INLINE CORBA_Container::Description *
  CORBA_Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::get_buffer (CORBA::Boolean orphan)
  {
    CORBA_Container::Description *result = 0;
    if (orphan == 0)
    {
      // We retain ownership.
      if (this->buffer_ == 0)
      {
        result = CORBA_Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::allocbuf (this->length_);
        this->buffer_ = result;
      }
      else
      {
        result = ACE_reinterpret_cast (CORBA_Container::Description*, this->buffer_);
      }
    }
    else // if (orphan == 1)
    {
      if (this->release_ != 0)
      {
        // We set the state back to default and relinquish
        // ownership.
        result = ACE_reinterpret_cast(CORBA_Container::Description*,this->buffer_);
        this->maximum_ = 0;
        this->length_ = 0;
        this->buffer_ = 0;
        this->release_ = 0;
      }
    }
    return result;
  }
  
  ACE_INLINE const CORBA_Container::Description *
  CORBA_Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::get_buffer (void) const
  {
    return ACE_reinterpret_cast(const CORBA_Container::Description * ACE_CAST_CONST, this->buffer_);
  }
  
  ACE_INLINE void
  CORBA_Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::replace (CORBA::ULong max,
  CORBA::ULong length,
  CORBA_Container::Description *data,
  CORBA::Boolean release)
  {
    this->maximum_ = max;
    this->length_ = length;
    if (this->buffer_ && this->release_ == 1)
    {
      CORBA_Container::Description *tmp = ACE_reinterpret_cast(CORBA_Container::Description*,this->buffer_);
      CORBA_Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::freebuf (tmp);
    }
    this->buffer_ = data;
    this->release_ = release;
  }
  
#endif /* end #if !defined */


#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 

#if !defined (_CORBA_CONTAINER_DESCRIPTIONSEQ_CI_)
#define _CORBA_CONTAINER_DESCRIPTIONSEQ_CI_

// *************************************************************
// Inline operations for class CORBA_Container::DescriptionSeq_var
// *************************************************************

ACE_INLINE
CORBA_Container::DescriptionSeq_var::DescriptionSeq_var (void) // default constructor
  : ptr_ (0)
{}

ACE_INLINE
CORBA_Container::DescriptionSeq_var::DescriptionSeq_var (CORBA_Container::DescriptionSeq *p)
  : ptr_ (p)
{}

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

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

ACE_INLINE CORBA_Container::DescriptionSeq_var &
CORBA_Container::DescriptionSeq_var::operator= (CORBA_Container::DescriptionSeq *p)
{
  delete this->ptr_;
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE const CORBA_Container::DescriptionSeq *
CORBA_Container::DescriptionSeq_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_Container::DescriptionSeq *
CORBA_Container::DescriptionSeq_var::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE 
CORBA_Container::DescriptionSeq_var::operator const CORBA_Container::DescriptionSeq &() const // cast
{
  return *this->ptr_;
}

ACE_INLINE 
CORBA_Container::DescriptionSeq_var::operator CORBA_Container::DescriptionSeq &() // cast 
{
  return *this->ptr_;
}

ACE_INLINE 
CORBA_Container::DescriptionSeq_var::operator CORBA_Container::DescriptionSeq &() const// cast 
{
  return *this->ptr_;
}

ACE_INLINE CORBA_Container::Description &
CORBA_Container::DescriptionSeq_var::operator[] (CORBA::ULong index)
{
  return this->ptr_->operator[] (index);
}

ACE_INLINE const CORBA_Container::DescriptionSeq &
CORBA_Container::DescriptionSeq_var::in (void) const
{
  return *this->ptr_;
}

ACE_INLINE CORBA_Container::DescriptionSeq &
CORBA_Container::DescriptionSeq_var::inout (void)
{
  return *this->ptr_;
}

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

ACE_INLINE CORBA_Container::DescriptionSeq *
CORBA_Container::DescriptionSeq_var::_retn (void)
{
  CORBA_Container::DescriptionSeq *tmp = this->ptr_;
  this->ptr_ = 0;
  return tmp;
}

ACE_INLINE CORBA_Container::DescriptionSeq *
CORBA_Container::DescriptionSeq_var::ptr (void) const
{
  return this->ptr_;
}

// *************************************************************
// Inline operations for class CORBA_Container::DescriptionSeq_out
// *************************************************************

ACE_INLINE
CORBA_Container::DescriptionSeq_out::DescriptionSeq_out (CORBA_Container::DescriptionSeq *&p)
  : ptr_ (p)
{
  this->ptr_ = 0;
}

ACE_INLINE
CORBA_Container::DescriptionSeq_out::DescriptionSeq_out (CORBA_Container::DescriptionSeq_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  delete this->ptr_;
  this->ptr_ = 0;
}

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

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

ACE_INLINE CORBA_Container::DescriptionSeq_out &
CORBA_Container::DescriptionSeq_out::operator= (CORBA_Container::DescriptionSeq *p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE 
CORBA_Container::DescriptionSeq_out::operator CORBA_Container::DescriptionSeq *&() // cast
{
  return this->ptr_;
}

ACE_INLINE CORBA_Container::DescriptionSeq *&
CORBA_Container::DescriptionSeq_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE CORBA_Container::DescriptionSeq *
CORBA_Container::DescriptionSeq_out::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE CORBA_Container::Description &
CORBA_Container::DescriptionSeq_out::operator[] (CORBA::ULong index)
{
  return this->ptr_->operator[] (index);
}


#endif /* end #if !defined */

ACE_INLINE
CORBA_IDLType::CORBA_IDLType (void) // default constructor
{}

ACE_INLINE
CORBA_IDLType::CORBA_IDLType (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
  : CORBA_Object (objref, _tao_servant, _tao_collocated)
{}

ACE_INLINE
CORBA_IDLType::~CORBA_IDLType (void) // destructor
{}


#if !defined (_CORBA_IDLTYPE___VAR_CI_)
#define _CORBA_IDLTYPE___VAR_CI_

// *************************************************************
// Inline operations for class CORBA_IDLType_var
// *************************************************************

ACE_INLINE
CORBA_IDLType_var::CORBA_IDLType_var (void) // default constructor
  : ptr_ (CORBA_IDLType::_nil ())
{}

ACE_INLINE
CORBA_IDLType_var::CORBA_IDLType_var (CORBA_IDLType_ptr p)
  : ptr_ (p)
{}

ACE_INLINE CORBA_IDLType_ptr 
CORBA_IDLType_var::ptr (void) const
{
  return this->ptr_;
}

ACE_INLINE
CORBA_IDLType_var::CORBA_IDLType_var (const CORBA_IDLType_var &p) // copy constructor
  : ptr_ (CORBA_IDLType::_duplicate (p.ptr ()))
{}

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

ACE_INLINE CORBA_IDLType_var &
CORBA_IDLType_var::operator= (CORBA_IDLType_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE 
CORBA_IDLType_var::operator const CORBA_IDLType_ptr &() const // cast
{
  return this->ptr_;
}

ACE_INLINE 
CORBA_IDLType_var::operator CORBA_IDLType_ptr &() // cast 
{
  return this->ptr_;
}

ACE_INLINE CORBA_IDLType_ptr 
CORBA_IDLType_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_IDLType_ptr
CORBA_IDLType_var::in (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_IDLType_ptr &
CORBA_IDLType_var::inout (void)
{
  return this->ptr_;
}

ACE_INLINE CORBA_IDLType_ptr &
CORBA_IDLType_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = CORBA_IDLType::_nil ();
  return this->ptr_;
}

ACE_INLINE CORBA_IDLType_ptr 
CORBA_IDLType_var::_retn (void)
{
  // yield ownership of managed obj reference
  CORBA_IDLType_ptr val = this->ptr_;
  this->ptr_ = CORBA_IDLType::_nil ();
  return val;
}


#endif /* end #if !defined */


#if !defined (_CORBA_IDLTYPE___OUT_CI_)
#define _CORBA_IDLTYPE___OUT_CI_

// *************************************************************
// Inline operations for class CORBA_IDLType_out
// *************************************************************

ACE_INLINE
CORBA_IDLType_out::CORBA_IDLType_out (CORBA_IDLType_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = CORBA_IDLType::_nil ();
}

ACE_INLINE
CORBA_IDLType_out::CORBA_IDLType_out (CORBA_IDLType_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = CORBA_IDLType::_nil ();
}

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

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

ACE_INLINE CORBA_IDLType_out &
CORBA_IDLType_out::operator= (const CORBA_IDLType_var &p)
{
  this->ptr_ = CORBA_IDLType::_duplicate (p.ptr ());
  return *this;
}

ACE_INLINE CORBA_IDLType_out &
CORBA_IDLType_out::operator= (CORBA_IDLType_ptr p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE 
CORBA_IDLType_out::operator CORBA_IDLType_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE CORBA_IDLType_ptr &
CORBA_IDLType_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE CORBA_IDLType_ptr 
CORBA_IDLType_out::operator-> (void)
{
  return this->ptr_;
}


#endif /* end #if !defined */

ACE_INLINE
CORBA_Repository::CORBA_Repository (void) // default constructor
{}

ACE_INLINE
CORBA_Repository::CORBA_Repository (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
  : CORBA_Object (objref, _tao_servant, _tao_collocated)
{}

ACE_INLINE
CORBA_Repository::~CORBA_Repository (void) // destructor
{}


#if !defined (_CORBA_REPOSITORY___VAR_CI_)
#define _CORBA_REPOSITORY___VAR_CI_

// *************************************************************
// Inline operations for class CORBA_Repository_var
// *************************************************************

ACE_INLINE
CORBA_Repository_var::CORBA_Repository_var (void) // default constructor
  : ptr_ (CORBA_Repository::_nil ())
{}

ACE_INLINE
CORBA_Repository_var::CORBA_Repository_var (CORBA_Repository_ptr p)
  : ptr_ (p)
{}

ACE_INLINE CORBA_Repository_ptr 
CORBA_Repository_var::ptr (void) const
{
  return this->ptr_;
}

ACE_INLINE
CORBA_Repository_var::CORBA_Repository_var (const CORBA_Repository_var &p) // copy constructor
  : ptr_ (CORBA_Repository::_duplicate (p.ptr ()))
{}

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

ACE_INLINE CORBA_Repository_var &
CORBA_Repository_var::operator= (CORBA_Repository_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE 
CORBA_Repository_var::operator const CORBA_Repository_ptr &() const // cast
{
  return this->ptr_;
}

ACE_INLINE 
CORBA_Repository_var::operator CORBA_Repository_ptr &() // cast 
{
  return this->ptr_;
}

ACE_INLINE CORBA_Repository_ptr 
CORBA_Repository_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_Repository_ptr
CORBA_Repository_var::in (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_Repository_ptr &
CORBA_Repository_var::inout (void)
{
  return this->ptr_;
}

ACE_INLINE CORBA_Repository_ptr &
CORBA_Repository_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = CORBA_Repository::_nil ();
  return this->ptr_;
}

ACE_INLINE CORBA_Repository_ptr 
CORBA_Repository_var::_retn (void)
{
  // yield ownership of managed obj reference
  CORBA_Repository_ptr val = this->ptr_;
  this->ptr_ = CORBA_Repository::_nil ();
  return val;
}


#endif /* end #if !defined */


#if !defined (_CORBA_REPOSITORY___OUT_CI_)
#define _CORBA_REPOSITORY___OUT_CI_

// *************************************************************
// Inline operations for class CORBA_Repository_out
// *************************************************************

ACE_INLINE
CORBA_Repository_out::CORBA_Repository_out (CORBA_Repository_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = CORBA_Repository::_nil ();
}

ACE_INLINE
CORBA_Repository_out::CORBA_Repository_out (CORBA_Repository_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = CORBA_Repository::_nil ();
}

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

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

ACE_INLINE CORBA_Repository_out &
CORBA_Repository_out::operator= (const CORBA_Repository_var &p)
{
  this->ptr_ = CORBA_Repository::_duplicate (p.ptr ());
  return *this;
}

ACE_INLINE CORBA_Repository_out &
CORBA_Repository_out::operator= (CORBA_Repository_ptr p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE 
CORBA_Repository_out::operator CORBA_Repository_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE CORBA_Repository_ptr &
CORBA_Repository_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE CORBA_Repository_ptr 
CORBA_Repository_out::operator-> (void)
{
  return this->ptr_;
}


#endif /* end #if !defined */

ACE_INLINE
CORBA_ModuleDef::CORBA_ModuleDef (void) // default constructor
{}

ACE_INLINE
CORBA_ModuleDef::CORBA_ModuleDef (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
  : CORBA_Object (objref, _tao_servant, _tao_collocated)
{}

ACE_INLINE
CORBA_ModuleDef::~CORBA_ModuleDef (void) // destructor
{}


#if !defined (_CORBA_MODULEDEF___VAR_CI_)
#define _CORBA_MODULEDEF___VAR_CI_

// *************************************************************
// Inline operations for class CORBA_ModuleDef_var
// *************************************************************

ACE_INLINE
CORBA_ModuleDef_var::CORBA_ModuleDef_var (void) // default constructor
  : ptr_ (CORBA_ModuleDef::_nil ())
{}

ACE_INLINE
CORBA_ModuleDef_var::CORBA_ModuleDef_var (CORBA_ModuleDef_ptr p)
  : ptr_ (p)
{}

ACE_INLINE CORBA_ModuleDef_ptr 
CORBA_ModuleDef_var::ptr (void) const
{
  return this->ptr_;
}

ACE_INLINE
CORBA_ModuleDef_var::CORBA_ModuleDef_var (const CORBA_ModuleDef_var &p) // copy constructor
  : ptr_ (CORBA_ModuleDef::_duplicate (p.ptr ()))
{}

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

ACE_INLINE CORBA_ModuleDef_var &
CORBA_ModuleDef_var::operator= (CORBA_ModuleDef_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE 
CORBA_ModuleDef_var::operator const CORBA_ModuleDef_ptr &() const // cast
{
  return this->ptr_;
}

ACE_INLINE 
CORBA_ModuleDef_var::operator CORBA_ModuleDef_ptr &() // cast 
{
  return this->ptr_;
}

ACE_INLINE CORBA_ModuleDef_ptr 
CORBA_ModuleDef_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_ModuleDef_ptr
CORBA_ModuleDef_var::in (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_ModuleDef_ptr &
CORBA_ModuleDef_var::inout (void)
{
  return this->ptr_;
}

ACE_INLINE CORBA_ModuleDef_ptr &
CORBA_ModuleDef_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = CORBA_ModuleDef::_nil ();
  return this->ptr_;
}

ACE_INLINE CORBA_ModuleDef_ptr 
CORBA_ModuleDef_var::_retn (void)
{
  // yield ownership of managed obj reference
  CORBA_ModuleDef_ptr val = this->ptr_;
  this->ptr_ = CORBA_ModuleDef::_nil ();
  return val;
}


#endif /* end #if !defined */


#if !defined (_CORBA_MODULEDEF___OUT_CI_)
#define _CORBA_MODULEDEF___OUT_CI_

// *************************************************************
// Inline operations for class CORBA_ModuleDef_out
// *************************************************************

ACE_INLINE
CORBA_ModuleDef_out::CORBA_ModuleDef_out (CORBA_ModuleDef_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = CORBA_ModuleDef::_nil ();
}

ACE_INLINE
CORBA_ModuleDef_out::CORBA_ModuleDef_out (CORBA_ModuleDef_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = CORBA_ModuleDef::_nil ();
}

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

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

ACE_INLINE CORBA_ModuleDef_out &
CORBA_ModuleDef_out::operator= (const CORBA_ModuleDef_var &p)
{
  this->ptr_ = CORBA_ModuleDef::_duplicate (p.ptr ());
  return *this;
}

ACE_INLINE CORBA_ModuleDef_out &
CORBA_ModuleDef_out::operator= (CORBA_ModuleDef_ptr p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE 
CORBA_ModuleDef_out::operator CORBA_ModuleDef_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE CORBA_ModuleDef_ptr &
CORBA_ModuleDef_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE CORBA_ModuleDef_ptr 
CORBA_ModuleDef_out::operator-> (void)
{
  return this->ptr_;
}


#endif /* end #if !defined */

// *************************************************************
// Inline operations for class CORBA_ModuleDescription_var
// *************************************************************

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

ACE_INLINE
CORBA_ModuleDescription_var::CORBA_ModuleDescription_var (CORBA_ModuleDescription *p)
  : ptr_ (p)
{}

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

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

ACE_INLINE CORBA_ModuleDescription_var &
CORBA_ModuleDescription_var::operator= (CORBA_ModuleDescription *p)
{
  delete this->ptr_;
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE const CORBA_ModuleDescription *
CORBA_ModuleDescription_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_ModuleDescription *
CORBA_ModuleDescription_var::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE 
CORBA_ModuleDescription_var::operator const CORBA_ModuleDescription &() const // cast
{
  return *this->ptr_;
}

ACE_INLINE 
CORBA_ModuleDescription_var::operator CORBA_ModuleDescription &() // cast 
{
  return *this->ptr_;
}

ACE_INLINE 
CORBA_ModuleDescription_var::operator CORBA_ModuleDescription &() const// cast 
{
  return *this->ptr_;
}

ACE_INLINE const CORBA_ModuleDescription &
CORBA_ModuleDescription_var::in (void) const
{
  return *this->ptr_;
}

ACE_INLINE CORBA_ModuleDescription &
CORBA_ModuleDescription_var::inout (void)
{
  return *this->ptr_;
}

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

ACE_INLINE CORBA_ModuleDescription *
CORBA_ModuleDescription_var::_retn (void)
{
  CORBA_ModuleDescription *tmp = this->ptr_;
  this->ptr_ = 0;
  return tmp;
}

ACE_INLINE CORBA_ModuleDescription *
CORBA_ModuleDescription_var::ptr (void) const
{
  return this->ptr_;
}

// *************************************************************
// Inline operations for class CORBA_ModuleDescription_out
// *************************************************************

ACE_INLINE
CORBA_ModuleDescription_out::CORBA_ModuleDescription_out (CORBA_ModuleDescription *&p)
  : ptr_ (p)
{
  this->ptr_ = 0;
}

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

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

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

ACE_INLINE CORBA_ModuleDescription_out &
CORBA_ModuleDescription_out::operator= (CORBA_ModuleDescription *p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE 
CORBA_ModuleDescription_out::operator CORBA_ModuleDescription *&() // cast
{
  return this->ptr_;
}

ACE_INLINE CORBA_ModuleDescription *&
CORBA_ModuleDescription_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE CORBA_ModuleDescription *
CORBA_ModuleDescription_out::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE
CORBA_ConstantDef::CORBA_ConstantDef (void) // default constructor
{}

ACE_INLINE
CORBA_ConstantDef::CORBA_ConstantDef (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
  : CORBA_Object (objref, _tao_servant, _tao_collocated)
{}

ACE_INLINE
CORBA_ConstantDef::~CORBA_ConstantDef (void) // destructor
{}


#if !defined (_CORBA_CONSTANTDEF___VAR_CI_)
#define _CORBA_CONSTANTDEF___VAR_CI_

// *************************************************************
// Inline operations for class CORBA_ConstantDef_var
// *************************************************************

ACE_INLINE
CORBA_ConstantDef_var::CORBA_ConstantDef_var (void) // default constructor
  : ptr_ (CORBA_ConstantDef::_nil ())
{}

ACE_INLINE
CORBA_ConstantDef_var::CORBA_ConstantDef_var (CORBA_ConstantDef_ptr p)
  : ptr_ (p)
{}

ACE_INLINE CORBA_ConstantDef_ptr 
CORBA_ConstantDef_var::ptr (void) const
{
  return this->ptr_;
}

ACE_INLINE
CORBA_ConstantDef_var::CORBA_ConstantDef_var (const CORBA_ConstantDef_var &p) // copy constructor
  : ptr_ (CORBA_ConstantDef::_duplicate (p.ptr ()))
{}

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

ACE_INLINE CORBA_ConstantDef_var &
CORBA_ConstantDef_var::operator= (CORBA_ConstantDef_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE 
CORBA_ConstantDef_var::operator const CORBA_ConstantDef_ptr &() const // cast
{
  return this->ptr_;
}

ACE_INLINE 
CORBA_ConstantDef_var::operator CORBA_ConstantDef_ptr &() // cast 
{
  return this->ptr_;
}

ACE_INLINE CORBA_ConstantDef_ptr 
CORBA_ConstantDef_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_ConstantDef_ptr
CORBA_ConstantDef_var::in (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_ConstantDef_ptr &
CORBA_ConstantDef_var::inout (void)
{
  return this->ptr_;
}

ACE_INLINE CORBA_ConstantDef_ptr &
CORBA_ConstantDef_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = CORBA_ConstantDef::_nil ();
  return this->ptr_;
}

ACE_INLINE CORBA_ConstantDef_ptr 
CORBA_ConstantDef_var::_retn (void)
{
  // yield ownership of managed obj reference
  CORBA_ConstantDef_ptr val = this->ptr_;
  this->ptr_ = CORBA_ConstantDef::_nil ();
  return val;
}


#endif /* end #if !defined */


#if !defined (_CORBA_CONSTANTDEF___OUT_CI_)
#define _CORBA_CONSTANTDEF___OUT_CI_

// *************************************************************
// Inline operations for class CORBA_ConstantDef_out
// *************************************************************

ACE_INLINE
CORBA_ConstantDef_out::CORBA_ConstantDef_out (CORBA_ConstantDef_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = CORBA_ConstantDef::_nil ();
}

ACE_INLINE
CORBA_ConstantDef_out::CORBA_ConstantDef_out (CORBA_ConstantDef_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = CORBA_ConstantDef::_nil ();
}

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

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

ACE_INLINE CORBA_ConstantDef_out &
CORBA_ConstantDef_out::operator= (const CORBA_ConstantDef_var &p)
{
  this->ptr_ = CORBA_ConstantDef::_duplicate (p.ptr ());
  return *this;
}

ACE_INLINE CORBA_ConstantDef_out &
CORBA_ConstantDef_out::operator= (CORBA_ConstantDef_ptr p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE 
CORBA_ConstantDef_out::operator CORBA_ConstantDef_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE CORBA_ConstantDef_ptr &
CORBA_ConstantDef_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE CORBA_ConstantDef_ptr 
CORBA_ConstantDef_out::operator-> (void)
{
  return this->ptr_;
}


#endif /* end #if !defined */

// *************************************************************
// Inline operations for class CORBA_ConstantDescription_var
// *************************************************************

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

ACE_INLINE
CORBA_ConstantDescription_var::CORBA_ConstantDescription_var (CORBA_ConstantDescription *p)
  : ptr_ (p)
{}

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

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

ACE_INLINE CORBA_ConstantDescription_var &
CORBA_ConstantDescription_var::operator= (CORBA_ConstantDescription *p)
{
  delete this->ptr_;
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE const CORBA_ConstantDescription *
CORBA_ConstantDescription_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_ConstantDescription *
CORBA_ConstantDescription_var::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE 
CORBA_ConstantDescription_var::operator const CORBA_ConstantDescription &() const // cast
{
  return *this->ptr_;
}

ACE_INLINE 
CORBA_ConstantDescription_var::operator CORBA_ConstantDescription &() // cast 
{
  return *this->ptr_;
}

ACE_INLINE 
CORBA_ConstantDescription_var::operator CORBA_ConstantDescription &() const// cast 
{
  return *this->ptr_;
}

ACE_INLINE const CORBA_ConstantDescription &
CORBA_ConstantDescription_var::in (void) const
{
  return *this->ptr_;
}

ACE_INLINE CORBA_ConstantDescription &
CORBA_ConstantDescription_var::inout (void)
{
  return *this->ptr_;
}

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

ACE_INLINE CORBA_ConstantDescription *
CORBA_ConstantDescription_var::_retn (void)
{
  CORBA_ConstantDescription *tmp = this->ptr_;
  this->ptr_ = 0;
  return tmp;
}

ACE_INLINE CORBA_ConstantDescription *
CORBA_ConstantDescription_var::ptr (void) const
{
  return this->ptr_;
}

// *************************************************************
// Inline operations for class CORBA_ConstantDescription_out
// *************************************************************

ACE_INLINE
CORBA_ConstantDescription_out::CORBA_ConstantDescription_out (CORBA_ConstantDescription *&p)
  : ptr_ (p)
{
  this->ptr_ = 0;
}

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

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

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

ACE_INLINE CORBA_ConstantDescription_out &
CORBA_ConstantDescription_out::operator= (CORBA_ConstantDescription *p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE 
CORBA_ConstantDescription_out::operator CORBA_ConstantDescription *&() // cast
{
  return this->ptr_;
}

ACE_INLINE CORBA_ConstantDescription *&
CORBA_ConstantDescription_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE CORBA_ConstantDescription *
CORBA_ConstantDescription_out::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE
CORBA_TypedefDef::CORBA_TypedefDef (void) // default constructor
{}

ACE_INLINE
CORBA_TypedefDef::CORBA_TypedefDef (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
  : CORBA_Object (objref, _tao_servant, _tao_collocated)
{}

ACE_INLINE
CORBA_TypedefDef::~CORBA_TypedefDef (void) // destructor
{}


#if !defined (_CORBA_TYPEDEFDEF___VAR_CI_)
#define _CORBA_TYPEDEFDEF___VAR_CI_

// *************************************************************
// Inline operations for class CORBA_TypedefDef_var
// *************************************************************

ACE_INLINE
CORBA_TypedefDef_var::CORBA_TypedefDef_var (void) // default constructor
  : ptr_ (CORBA_TypedefDef::_nil ())
{}

ACE_INLINE
CORBA_TypedefDef_var::CORBA_TypedefDef_var (CORBA_TypedefDef_ptr p)
  : ptr_ (p)
{}

ACE_INLINE CORBA_TypedefDef_ptr 
CORBA_TypedefDef_var::ptr (void) const
{
  return this->ptr_;
}

ACE_INLINE
CORBA_TypedefDef_var::CORBA_TypedefDef_var (const CORBA_TypedefDef_var &p) // copy constructor
  : ptr_ (CORBA_TypedefDef::_duplicate (p.ptr ()))
{}

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

ACE_INLINE CORBA_TypedefDef_var &
CORBA_TypedefDef_var::operator= (CORBA_TypedefDef_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE 
CORBA_TypedefDef_var::operator const CORBA_TypedefDef_ptr &() const // cast
{
  return this->ptr_;
}

ACE_INLINE 
CORBA_TypedefDef_var::operator CORBA_TypedefDef_ptr &() // cast 
{
  return this->ptr_;
}

ACE_INLINE CORBA_TypedefDef_ptr 
CORBA_TypedefDef_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_TypedefDef_ptr
CORBA_TypedefDef_var::in (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_TypedefDef_ptr &
CORBA_TypedefDef_var::inout (void)
{
  return this->ptr_;
}

ACE_INLINE CORBA_TypedefDef_ptr &
CORBA_TypedefDef_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = CORBA_TypedefDef::_nil ();
  return this->ptr_;
}

ACE_INLINE CORBA_TypedefDef_ptr 
CORBA_TypedefDef_var::_retn (void)
{
  // yield ownership of managed obj reference
  CORBA_TypedefDef_ptr val = this->ptr_;
  this->ptr_ = CORBA_TypedefDef::_nil ();
  return val;
}


#endif /* end #if !defined */


#if !defined (_CORBA_TYPEDEFDEF___OUT_CI_)
#define _CORBA_TYPEDEFDEF___OUT_CI_

// *************************************************************
// Inline operations for class CORBA_TypedefDef_out
// *************************************************************

ACE_INLINE
CORBA_TypedefDef_out::CORBA_TypedefDef_out (CORBA_TypedefDef_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = CORBA_TypedefDef::_nil ();
}

ACE_INLINE
CORBA_TypedefDef_out::CORBA_TypedefDef_out (CORBA_TypedefDef_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = CORBA_TypedefDef::_nil ();
}

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

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

ACE_INLINE CORBA_TypedefDef_out &
CORBA_TypedefDef_out::operator= (const CORBA_TypedefDef_var &p)
{
  this->ptr_ = CORBA_TypedefDef::_duplicate (p.ptr ());
  return *this;
}

ACE_INLINE CORBA_TypedefDef_out &
CORBA_TypedefDef_out::operator= (CORBA_TypedefDef_ptr p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE 
CORBA_TypedefDef_out::operator CORBA_TypedefDef_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE CORBA_TypedefDef_ptr &
CORBA_TypedefDef_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE CORBA_TypedefDef_ptr 
CORBA_TypedefDef_out::operator-> (void)
{
  return this->ptr_;
}


#endif /* end #if !defined */

// *************************************************************
// Inline operations for class CORBA_TypeDescription_var
// *************************************************************

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

ACE_INLINE
CORBA_TypeDescription_var::CORBA_TypeDescription_var (CORBA_TypeDescription *p)
  : ptr_ (p)
{}

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

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

ACE_INLINE CORBA_TypeDescription_var &
CORBA_TypeDescription_var::operator= (CORBA_TypeDescription *p)
{
  delete this->ptr_;
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE const CORBA_TypeDescription *
CORBA_TypeDescription_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_TypeDescription *
CORBA_TypeDescription_var::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE 
CORBA_TypeDescription_var::operator const CORBA_TypeDescription &() const // cast
{
  return *this->ptr_;
}

ACE_INLINE 
CORBA_TypeDescription_var::operator CORBA_TypeDescription &() // cast 
{
  return *this->ptr_;
}

ACE_INLINE 
CORBA_TypeDescription_var::operator CORBA_TypeDescription &() const// cast 
{
  return *this->ptr_;
}

ACE_INLINE const CORBA_TypeDescription &
CORBA_TypeDescription_var::in (void) const
{
  return *this->ptr_;
}

ACE_INLINE CORBA_TypeDescription &
CORBA_TypeDescription_var::inout (void)
{
  return *this->ptr_;
}

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

ACE_INLINE CORBA_TypeDescription *
CORBA_TypeDescription_var::_retn (void)
{
  CORBA_TypeDescription *tmp = this->ptr_;
  this->ptr_ = 0;
  return tmp;
}

ACE_INLINE CORBA_TypeDescription *
CORBA_TypeDescription_var::ptr (void) const
{
  return this->ptr_;
}

// *************************************************************
// Inline operations for class CORBA_TypeDescription_out
// *************************************************************

ACE_INLINE
CORBA_TypeDescription_out::CORBA_TypeDescription_out (CORBA_TypeDescription *&p)
  : ptr_ (p)
{
  this->ptr_ = 0;
}

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

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

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

ACE_INLINE CORBA_TypeDescription_out &
CORBA_TypeDescription_out::operator= (CORBA_TypeDescription *p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE 
CORBA_TypeDescription_out::operator CORBA_TypeDescription *&() // cast
{
  return this->ptr_;
}

ACE_INLINE CORBA_TypeDescription *&
CORBA_TypeDescription_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE CORBA_TypeDescription *
CORBA_TypeDescription_out::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE
CORBA_StructDef::CORBA_StructDef (void) // default constructor
{}

ACE_INLINE
CORBA_StructDef::CORBA_StructDef (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
  : CORBA_Object (objref, _tao_servant, _tao_collocated)
{}

ACE_INLINE
CORBA_StructDef::~CORBA_StructDef (void) // destructor
{}


#if !defined (_CORBA_STRUCTDEF___VAR_CI_)
#define _CORBA_STRUCTDEF___VAR_CI_

// *************************************************************
// Inline operations for class CORBA_StructDef_var
// *************************************************************

ACE_INLINE
CORBA_StructDef_var::CORBA_StructDef_var (void) // default constructor
  : ptr_ (CORBA_StructDef::_nil ())
{}

ACE_INLINE
CORBA_StructDef_var::CORBA_StructDef_var (CORBA_StructDef_ptr p)
  : ptr_ (p)
{}

ACE_INLINE CORBA_StructDef_ptr 
CORBA_StructDef_var::ptr (void) const
{
  return this->ptr_;
}

ACE_INLINE
CORBA_StructDef_var::CORBA_StructDef_var (const CORBA_StructDef_var &p) // copy constructor
  : ptr_ (CORBA_StructDef::_duplicate (p.ptr ()))
{}

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

ACE_INLINE CORBA_StructDef_var &
CORBA_StructDef_var::operator= (CORBA_StructDef_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE 
CORBA_StructDef_var::operator const CORBA_StructDef_ptr &() const // cast
{
  return this->ptr_;
}

ACE_INLINE 
CORBA_StructDef_var::operator CORBA_StructDef_ptr &() // cast 
{
  return this->ptr_;
}

ACE_INLINE CORBA_StructDef_ptr 
CORBA_StructDef_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_StructDef_ptr
CORBA_StructDef_var::in (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_StructDef_ptr &
CORBA_StructDef_var::inout (void)
{
  return this->ptr_;
}

ACE_INLINE CORBA_StructDef_ptr &
CORBA_StructDef_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = CORBA_StructDef::_nil ();
  return this->ptr_;
}

ACE_INLINE CORBA_StructDef_ptr 
CORBA_StructDef_var::_retn (void)
{
  // yield ownership of managed obj reference
  CORBA_StructDef_ptr val = this->ptr_;
  this->ptr_ = CORBA_StructDef::_nil ();
  return val;
}


#endif /* end #if !defined */


#if !defined (_CORBA_STRUCTDEF___OUT_CI_)
#define _CORBA_STRUCTDEF___OUT_CI_

// *************************************************************
// Inline operations for class CORBA_StructDef_out
// *************************************************************

ACE_INLINE
CORBA_StructDef_out::CORBA_StructDef_out (CORBA_StructDef_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = CORBA_StructDef::_nil ();
}

ACE_INLINE
CORBA_StructDef_out::CORBA_StructDef_out (CORBA_StructDef_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = CORBA_StructDef::_nil ();
}

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

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

ACE_INLINE CORBA_StructDef_out &
CORBA_StructDef_out::operator= (const CORBA_StructDef_var &p)
{
  this->ptr_ = CORBA_StructDef::_duplicate (p.ptr ());
  return *this;
}

ACE_INLINE CORBA_StructDef_out &
CORBA_StructDef_out::operator= (CORBA_StructDef_ptr p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE 
CORBA_StructDef_out::operator CORBA_StructDef_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE CORBA_StructDef_ptr &
CORBA_StructDef_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE CORBA_StructDef_ptr 
CORBA_StructDef_out::operator-> (void)
{
  return this->ptr_;
}


#endif /* end #if !defined */

ACE_INLINE
CORBA_UnionDef::CORBA_UnionDef (void) // default constructor
{}

ACE_INLINE
CORBA_UnionDef::CORBA_UnionDef (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
  : CORBA_Object (objref, _tao_servant, _tao_collocated)
{}

ACE_INLINE
CORBA_UnionDef::~CORBA_UnionDef (void) // destructor
{}


#if !defined (_CORBA_UNIONDEF___VAR_CI_)
#define _CORBA_UNIONDEF___VAR_CI_

// *************************************************************
// Inline operations for class CORBA_UnionDef_var
// *************************************************************

ACE_INLINE
CORBA_UnionDef_var::CORBA_UnionDef_var (void) // default constructor
  : ptr_ (CORBA_UnionDef::_nil ())
{}

ACE_INLINE
CORBA_UnionDef_var::CORBA_UnionDef_var (CORBA_UnionDef_ptr p)
  : ptr_ (p)
{}

ACE_INLINE CORBA_UnionDef_ptr 
CORBA_UnionDef_var::ptr (void) const
{
  return this->ptr_;
}

ACE_INLINE
CORBA_UnionDef_var::CORBA_UnionDef_var (const CORBA_UnionDef_var &p) // copy constructor
  : ptr_ (CORBA_UnionDef::_duplicate (p.ptr ()))
{}

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

ACE_INLINE CORBA_UnionDef_var &
CORBA_UnionDef_var::operator= (CORBA_UnionDef_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE 
CORBA_UnionDef_var::operator const CORBA_UnionDef_ptr &() const // cast
{
  return this->ptr_;
}

ACE_INLINE 
CORBA_UnionDef_var::operator CORBA_UnionDef_ptr &() // cast 
{
  return this->ptr_;
}

ACE_INLINE CORBA_UnionDef_ptr 
CORBA_UnionDef_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_UnionDef_ptr
CORBA_UnionDef_var::in (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_UnionDef_ptr &
CORBA_UnionDef_var::inout (void)
{
  return this->ptr_;
}

ACE_INLINE CORBA_UnionDef_ptr &
CORBA_UnionDef_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = CORBA_UnionDef::_nil ();
  return this->ptr_;
}

ACE_INLINE CORBA_UnionDef_ptr 
CORBA_UnionDef_var::_retn (void)
{
  // yield ownership of managed obj reference
  CORBA_UnionDef_ptr val = this->ptr_;
  this->ptr_ = CORBA_UnionDef::_nil ();
  return val;
}


#endif /* end #if !defined */


#if !defined (_CORBA_UNIONDEF___OUT_CI_)
#define _CORBA_UNIONDEF___OUT_CI_

// *************************************************************
// Inline operations for class CORBA_UnionDef_out
// *************************************************************

ACE_INLINE
CORBA_UnionDef_out::CORBA_UnionDef_out (CORBA_UnionDef_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = CORBA_UnionDef::_nil ();
}

ACE_INLINE
CORBA_UnionDef_out::CORBA_UnionDef_out (CORBA_UnionDef_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = CORBA_UnionDef::_nil ();
}

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

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

ACE_INLINE CORBA_UnionDef_out &
CORBA_UnionDef_out::operator= (const CORBA_UnionDef_var &p)
{
  this->ptr_ = CORBA_UnionDef::_duplicate (p.ptr ());
  return *this;
}

ACE_INLINE CORBA_UnionDef_out &
CORBA_UnionDef_out::operator= (CORBA_UnionDef_ptr p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE 
CORBA_UnionDef_out::operator CORBA_UnionDef_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE CORBA_UnionDef_ptr &
CORBA_UnionDef_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE CORBA_UnionDef_ptr 
CORBA_UnionDef_out::operator-> (void)
{
  return this->ptr_;
}


#endif /* end #if !defined */

ACE_INLINE
CORBA_EnumDef::CORBA_EnumDef (void) // default constructor
{}

ACE_INLINE
CORBA_EnumDef::CORBA_EnumDef (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
  : CORBA_Object (objref, _tao_servant, _tao_collocated)
{}

ACE_INLINE
CORBA_EnumDef::~CORBA_EnumDef (void) // destructor
{}


#if !defined (_CORBA_ENUMDEF___VAR_CI_)
#define _CORBA_ENUMDEF___VAR_CI_

// *************************************************************
// Inline operations for class CORBA_EnumDef_var
// *************************************************************

ACE_INLINE
CORBA_EnumDef_var::CORBA_EnumDef_var (void) // default constructor
  : ptr_ (CORBA_EnumDef::_nil ())
{}

ACE_INLINE
CORBA_EnumDef_var::CORBA_EnumDef_var (CORBA_EnumDef_ptr p)
  : ptr_ (p)
{}

ACE_INLINE CORBA_EnumDef_ptr 
CORBA_EnumDef_var::ptr (void) const
{
  return this->ptr_;
}

ACE_INLINE
CORBA_EnumDef_var::CORBA_EnumDef_var (const CORBA_EnumDef_var &p) // copy constructor
  : ptr_ (CORBA_EnumDef::_duplicate (p.ptr ()))
{}

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

ACE_INLINE CORBA_EnumDef_var &
CORBA_EnumDef_var::operator= (CORBA_EnumDef_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE 
CORBA_EnumDef_var::operator const CORBA_EnumDef_ptr &() const // cast
{
  return this->ptr_;
}

ACE_INLINE 
CORBA_EnumDef_var::operator CORBA_EnumDef_ptr &() // cast 
{
  return this->ptr_;
}

ACE_INLINE CORBA_EnumDef_ptr 
CORBA_EnumDef_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_EnumDef_ptr
CORBA_EnumDef_var::in (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_EnumDef_ptr &
CORBA_EnumDef_var::inout (void)
{
  return this->ptr_;
}

ACE_INLINE CORBA_EnumDef_ptr &
CORBA_EnumDef_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = CORBA_EnumDef::_nil ();
  return this->ptr_;
}

ACE_INLINE CORBA_EnumDef_ptr 
CORBA_EnumDef_var::_retn (void)
{
  // yield ownership of managed obj reference
  CORBA_EnumDef_ptr val = this->ptr_;
  this->ptr_ = CORBA_EnumDef::_nil ();
  return val;
}


#endif /* end #if !defined */


#if !defined (_CORBA_ENUMDEF___OUT_CI_)
#define _CORBA_ENUMDEF___OUT_CI_

// *************************************************************
// Inline operations for class CORBA_EnumDef_out
// *************************************************************

ACE_INLINE
CORBA_EnumDef_out::CORBA_EnumDef_out (CORBA_EnumDef_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = CORBA_EnumDef::_nil ();
}

ACE_INLINE
CORBA_EnumDef_out::CORBA_EnumDef_out (CORBA_EnumDef_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = CORBA_EnumDef::_nil ();
}

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

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

ACE_INLINE CORBA_EnumDef_out &
CORBA_EnumDef_out::operator= (const CORBA_EnumDef_var &p)
{
  this->ptr_ = CORBA_EnumDef::_duplicate (p.ptr ());
  return *this;
}

ACE_INLINE CORBA_EnumDef_out &
CORBA_EnumDef_out::operator= (CORBA_EnumDef_ptr p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE 
CORBA_EnumDef_out::operator CORBA_EnumDef_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE CORBA_EnumDef_ptr &
CORBA_EnumDef_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE CORBA_EnumDef_ptr 
CORBA_EnumDef_out::operator-> (void)
{
  return this->ptr_;
}


#endif /* end #if !defined */

ACE_INLINE
CORBA_AliasDef::CORBA_AliasDef (void) // default constructor
{}

ACE_INLINE
CORBA_AliasDef::CORBA_AliasDef (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
  : CORBA_Object (objref, _tao_servant, _tao_collocated)
{}

ACE_INLINE
CORBA_AliasDef::~CORBA_AliasDef (void) // destructor
{}


#if !defined (_CORBA_ALIASDEF___VAR_CI_)
#define _CORBA_ALIASDEF___VAR_CI_

// *************************************************************
// Inline operations for class CORBA_AliasDef_var
// *************************************************************

ACE_INLINE
CORBA_AliasDef_var::CORBA_AliasDef_var (void) // default constructor
  : ptr_ (CORBA_AliasDef::_nil ())
{}

ACE_INLINE
CORBA_AliasDef_var::CORBA_AliasDef_var (CORBA_AliasDef_ptr p)
  : ptr_ (p)
{}

ACE_INLINE CORBA_AliasDef_ptr 
CORBA_AliasDef_var::ptr (void) const
{
  return this->ptr_;
}

ACE_INLINE
CORBA_AliasDef_var::CORBA_AliasDef_var (const CORBA_AliasDef_var &p) // copy constructor
  : ptr_ (CORBA_AliasDef::_duplicate (p.ptr ()))
{}

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

ACE_INLINE CORBA_AliasDef_var &
CORBA_AliasDef_var::operator= (CORBA_AliasDef_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE 
CORBA_AliasDef_var::operator const CORBA_AliasDef_ptr &() const // cast
{
  return this->ptr_;
}

ACE_INLINE 
CORBA_AliasDef_var::operator CORBA_AliasDef_ptr &() // cast 
{
  return this->ptr_;
}

ACE_INLINE CORBA_AliasDef_ptr 
CORBA_AliasDef_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_AliasDef_ptr
CORBA_AliasDef_var::in (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_AliasDef_ptr &
CORBA_AliasDef_var::inout (void)
{
  return this->ptr_;
}

ACE_INLINE CORBA_AliasDef_ptr &
CORBA_AliasDef_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = CORBA_AliasDef::_nil ();
  return this->ptr_;
}

ACE_INLINE CORBA_AliasDef_ptr 
CORBA_AliasDef_var::_retn (void)
{
  // yield ownership of managed obj reference
  CORBA_AliasDef_ptr val = this->ptr_;
  this->ptr_ = CORBA_AliasDef::_nil ();
  return val;
}


#endif /* end #if !defined */


#if !defined (_CORBA_ALIASDEF___OUT_CI_)
#define _CORBA_ALIASDEF___OUT_CI_

// *************************************************************
// Inline operations for class CORBA_AliasDef_out
// *************************************************************

ACE_INLINE
CORBA_AliasDef_out::CORBA_AliasDef_out (CORBA_AliasDef_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = CORBA_AliasDef::_nil ();
}

ACE_INLINE
CORBA_AliasDef_out::CORBA_AliasDef_out (CORBA_AliasDef_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = CORBA_AliasDef::_nil ();
}

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

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

ACE_INLINE CORBA_AliasDef_out &
CORBA_AliasDef_out::operator= (const CORBA_AliasDef_var &p)
{
  this->ptr_ = CORBA_AliasDef::_duplicate (p.ptr ());
  return *this;
}

ACE_INLINE CORBA_AliasDef_out &
CORBA_AliasDef_out::operator= (CORBA_AliasDef_ptr p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE 
CORBA_AliasDef_out::operator CORBA_AliasDef_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE CORBA_AliasDef_ptr &
CORBA_AliasDef_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE CORBA_AliasDef_ptr 
CORBA_AliasDef_out::operator-> (void)
{
  return this->ptr_;
}


#endif /* end #if !defined */

ACE_INLINE
CORBA_PrimitiveDef::CORBA_PrimitiveDef (void) // default constructor
{}

ACE_INLINE
CORBA_PrimitiveDef::CORBA_PrimitiveDef (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
  : CORBA_Object (objref, _tao_servant, _tao_collocated)
{}

ACE_INLINE
CORBA_PrimitiveDef::~CORBA_PrimitiveDef (void) // destructor
{}


#if !defined (_CORBA_PRIMITIVEDEF___VAR_CI_)
#define _CORBA_PRIMITIVEDEF___VAR_CI_

// *************************************************************
// Inline operations for class CORBA_PrimitiveDef_var
// *************************************************************

ACE_INLINE
CORBA_PrimitiveDef_var::CORBA_PrimitiveDef_var (void) // default constructor
  : ptr_ (CORBA_PrimitiveDef::_nil ())
{}

ACE_INLINE
CORBA_PrimitiveDef_var::CORBA_PrimitiveDef_var (CORBA_PrimitiveDef_ptr p)
  : ptr_ (p)
{}

ACE_INLINE CORBA_PrimitiveDef_ptr 
CORBA_PrimitiveDef_var::ptr (void) const
{
  return this->ptr_;
}

ACE_INLINE
CORBA_PrimitiveDef_var::CORBA_PrimitiveDef_var (const CORBA_PrimitiveDef_var &p) // copy constructor
  : ptr_ (CORBA_PrimitiveDef::_duplicate (p.ptr ()))
{}

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

ACE_INLINE CORBA_PrimitiveDef_var &
CORBA_PrimitiveDef_var::operator= (CORBA_PrimitiveDef_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE 
CORBA_PrimitiveDef_var::operator const CORBA_PrimitiveDef_ptr &() const // cast
{
  return this->ptr_;
}

ACE_INLINE 
CORBA_PrimitiveDef_var::operator CORBA_PrimitiveDef_ptr &() // cast 
{
  return this->ptr_;
}

ACE_INLINE CORBA_PrimitiveDef_ptr 
CORBA_PrimitiveDef_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_PrimitiveDef_ptr
CORBA_PrimitiveDef_var::in (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_PrimitiveDef_ptr &
CORBA_PrimitiveDef_var::inout (void)
{
  return this->ptr_;
}

ACE_INLINE CORBA_PrimitiveDef_ptr &
CORBA_PrimitiveDef_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = CORBA_PrimitiveDef::_nil ();
  return this->ptr_;
}

ACE_INLINE CORBA_PrimitiveDef_ptr 
CORBA_PrimitiveDef_var::_retn (void)
{
  // yield ownership of managed obj reference
  CORBA_PrimitiveDef_ptr val = this->ptr_;
  this->ptr_ = CORBA_PrimitiveDef::_nil ();
  return val;
}


#endif /* end #if !defined */


#if !defined (_CORBA_PRIMITIVEDEF___OUT_CI_)
#define _CORBA_PRIMITIVEDEF___OUT_CI_

// *************************************************************
// Inline operations for class CORBA_PrimitiveDef_out
// *************************************************************

ACE_INLINE
CORBA_PrimitiveDef_out::CORBA_PrimitiveDef_out (CORBA_PrimitiveDef_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = CORBA_PrimitiveDef::_nil ();
}

ACE_INLINE
CORBA_PrimitiveDef_out::CORBA_PrimitiveDef_out (CORBA_PrimitiveDef_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = CORBA_PrimitiveDef::_nil ();
}

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

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

ACE_INLINE CORBA_PrimitiveDef_out &
CORBA_PrimitiveDef_out::operator= (const CORBA_PrimitiveDef_var &p)
{
  this->ptr_ = CORBA_PrimitiveDef::_duplicate (p.ptr ());
  return *this;
}

ACE_INLINE CORBA_PrimitiveDef_out &
CORBA_PrimitiveDef_out::operator= (CORBA_PrimitiveDef_ptr p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE 
CORBA_PrimitiveDef_out::operator CORBA_PrimitiveDef_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE CORBA_PrimitiveDef_ptr &
CORBA_PrimitiveDef_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE CORBA_PrimitiveDef_ptr 
CORBA_PrimitiveDef_out::operator-> (void)
{
  return this->ptr_;
}


#endif /* end #if !defined */

ACE_INLINE
CORBA_StringDef::CORBA_StringDef (void) // default constructor
{}

ACE_INLINE
CORBA_StringDef::CORBA_StringDef (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
  : CORBA_Object (objref, _tao_servant, _tao_collocated)
{}

ACE_INLINE
CORBA_StringDef::~CORBA_StringDef (void) // destructor
{}


#if !defined (_CORBA_STRINGDEF___VAR_CI_)
#define _CORBA_STRINGDEF___VAR_CI_

// *************************************************************
// Inline operations for class CORBA_StringDef_var
// *************************************************************

ACE_INLINE
CORBA_StringDef_var::CORBA_StringDef_var (void) // default constructor
  : ptr_ (CORBA_StringDef::_nil ())
{}

ACE_INLINE
CORBA_StringDef_var::CORBA_StringDef_var (CORBA_StringDef_ptr p)
  : ptr_ (p)
{}

ACE_INLINE CORBA_StringDef_ptr 
CORBA_StringDef_var::ptr (void) const
{
  return this->ptr_;
}

ACE_INLINE
CORBA_StringDef_var::CORBA_StringDef_var (const CORBA_StringDef_var &p) // copy constructor
  : ptr_ (CORBA_StringDef::_duplicate (p.ptr ()))
{}

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

ACE_INLINE CORBA_StringDef_var &
CORBA_StringDef_var::operator= (CORBA_StringDef_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE 
CORBA_StringDef_var::operator const CORBA_StringDef_ptr &() const // cast
{
  return this->ptr_;
}

ACE_INLINE 
CORBA_StringDef_var::operator CORBA_StringDef_ptr &() // cast 
{
  return this->ptr_;
}

ACE_INLINE CORBA_StringDef_ptr 
CORBA_StringDef_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_StringDef_ptr
CORBA_StringDef_var::in (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_StringDef_ptr &
CORBA_StringDef_var::inout (void)
{
  return this->ptr_;
}

ACE_INLINE CORBA_StringDef_ptr &
CORBA_StringDef_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = CORBA_StringDef::_nil ();
  return this->ptr_;
}

ACE_INLINE CORBA_StringDef_ptr 
CORBA_StringDef_var::_retn (void)
{
  // yield ownership of managed obj reference
  CORBA_StringDef_ptr val = this->ptr_;
  this->ptr_ = CORBA_StringDef::_nil ();
  return val;
}


#endif /* end #if !defined */


#if !defined (_CORBA_STRINGDEF___OUT_CI_)
#define _CORBA_STRINGDEF___OUT_CI_

// *************************************************************
// Inline operations for class CORBA_StringDef_out
// *************************************************************

ACE_INLINE
CORBA_StringDef_out::CORBA_StringDef_out (CORBA_StringDef_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = CORBA_StringDef::_nil ();
}

ACE_INLINE
CORBA_StringDef_out::CORBA_StringDef_out (CORBA_StringDef_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = CORBA_StringDef::_nil ();
}

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

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

ACE_INLINE CORBA_StringDef_out &
CORBA_StringDef_out::operator= (const CORBA_StringDef_var &p)
{
  this->ptr_ = CORBA_StringDef::_duplicate (p.ptr ());
  return *this;
}

ACE_INLINE CORBA_StringDef_out &
CORBA_StringDef_out::operator= (CORBA_StringDef_ptr p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE 
CORBA_StringDef_out::operator CORBA_StringDef_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE CORBA_StringDef_ptr &
CORBA_StringDef_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE CORBA_StringDef_ptr 
CORBA_StringDef_out::operator-> (void)
{
  return this->ptr_;
}


#endif /* end #if !defined */

ACE_INLINE
CORBA_WstringDef::CORBA_WstringDef (void) // default constructor
{}

ACE_INLINE
CORBA_WstringDef::CORBA_WstringDef (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
  : CORBA_Object (objref, _tao_servant, _tao_collocated)
{}

ACE_INLINE
CORBA_WstringDef::~CORBA_WstringDef (void) // destructor
{}


#if !defined (_CORBA_WSTRINGDEF___VAR_CI_)
#define _CORBA_WSTRINGDEF___VAR_CI_

// *************************************************************
// Inline operations for class CORBA_WstringDef_var
// *************************************************************

ACE_INLINE
CORBA_WstringDef_var::CORBA_WstringDef_var (void) // default constructor
  : ptr_ (CORBA_WstringDef::_nil ())
{}

ACE_INLINE
CORBA_WstringDef_var::CORBA_WstringDef_var (CORBA_WstringDef_ptr p)
  : ptr_ (p)
{}

ACE_INLINE CORBA_WstringDef_ptr 
CORBA_WstringDef_var::ptr (void) const
{
  return this->ptr_;
}

ACE_INLINE
CORBA_WstringDef_var::CORBA_WstringDef_var (const CORBA_WstringDef_var &p) // copy constructor
  : ptr_ (CORBA_WstringDef::_duplicate (p.ptr ()))
{}

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

ACE_INLINE CORBA_WstringDef_var &
CORBA_WstringDef_var::operator= (CORBA_WstringDef_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE 
CORBA_WstringDef_var::operator const CORBA_WstringDef_ptr &() const // cast
{
  return this->ptr_;
}

ACE_INLINE 
CORBA_WstringDef_var::operator CORBA_WstringDef_ptr &() // cast 
{
  return this->ptr_;
}

ACE_INLINE CORBA_WstringDef_ptr 
CORBA_WstringDef_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_WstringDef_ptr
CORBA_WstringDef_var::in (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_WstringDef_ptr &
CORBA_WstringDef_var::inout (void)
{
  return this->ptr_;
}

ACE_INLINE CORBA_WstringDef_ptr &
CORBA_WstringDef_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = CORBA_WstringDef::_nil ();
  return this->ptr_;
}

ACE_INLINE CORBA_WstringDef_ptr 
CORBA_WstringDef_var::_retn (void)
{
  // yield ownership of managed obj reference
  CORBA_WstringDef_ptr val = this->ptr_;
  this->ptr_ = CORBA_WstringDef::_nil ();
  return val;
}


#endif /* end #if !defined */


#if !defined (_CORBA_WSTRINGDEF___OUT_CI_)
#define _CORBA_WSTRINGDEF___OUT_CI_

// *************************************************************
// Inline operations for class CORBA_WstringDef_out
// *************************************************************

ACE_INLINE
CORBA_WstringDef_out::CORBA_WstringDef_out (CORBA_WstringDef_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = CORBA_WstringDef::_nil ();
}

ACE_INLINE
CORBA_WstringDef_out::CORBA_WstringDef_out (CORBA_WstringDef_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = CORBA_WstringDef::_nil ();
}

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

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

ACE_INLINE CORBA_WstringDef_out &
CORBA_WstringDef_out::operator= (const CORBA_WstringDef_var &p)
{
  this->ptr_ = CORBA_WstringDef::_duplicate (p.ptr ());
  return *this;
}

ACE_INLINE CORBA_WstringDef_out &
CORBA_WstringDef_out::operator= (CORBA_WstringDef_ptr p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE 
CORBA_WstringDef_out::operator CORBA_WstringDef_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE CORBA_WstringDef_ptr &
CORBA_WstringDef_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE CORBA_WstringDef_ptr 
CORBA_WstringDef_out::operator-> (void)
{
  return this->ptr_;
}


#endif /* end #if !defined */

ACE_INLINE
CORBA_FixedDef::CORBA_FixedDef (void) // default constructor
{}

ACE_INLINE
CORBA_FixedDef::CORBA_FixedDef (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
  : CORBA_Object (objref, _tao_servant, _tao_collocated)
{}

ACE_INLINE
CORBA_FixedDef::~CORBA_FixedDef (void) // destructor
{}


#if !defined (_CORBA_FIXEDDEF___VAR_CI_)
#define _CORBA_FIXEDDEF___VAR_CI_

// *************************************************************
// Inline operations for class CORBA_FixedDef_var
// *************************************************************

ACE_INLINE
CORBA_FixedDef_var::CORBA_FixedDef_var (void) // default constructor
  : ptr_ (CORBA_FixedDef::_nil ())
{}

ACE_INLINE
CORBA_FixedDef_var::CORBA_FixedDef_var (CORBA_FixedDef_ptr p)
  : ptr_ (p)
{}

ACE_INLINE CORBA_FixedDef_ptr 
CORBA_FixedDef_var::ptr (void) const
{
  return this->ptr_;
}

ACE_INLINE
CORBA_FixedDef_var::CORBA_FixedDef_var (const CORBA_FixedDef_var &p) // copy constructor
  : ptr_ (CORBA_FixedDef::_duplicate (p.ptr ()))
{}

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

ACE_INLINE CORBA_FixedDef_var &
CORBA_FixedDef_var::operator= (CORBA_FixedDef_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE 
CORBA_FixedDef_var::operator const CORBA_FixedDef_ptr &() const // cast
{
  return this->ptr_;
}

ACE_INLINE 
CORBA_FixedDef_var::operator CORBA_FixedDef_ptr &() // cast 
{
  return this->ptr_;
}

ACE_INLINE CORBA_FixedDef_ptr 
CORBA_FixedDef_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_FixedDef_ptr
CORBA_FixedDef_var::in (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_FixedDef_ptr &
CORBA_FixedDef_var::inout (void)
{
  return this->ptr_;
}

ACE_INLINE CORBA_FixedDef_ptr &
CORBA_FixedDef_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = CORBA_FixedDef::_nil ();
  return this->ptr_;
}

ACE_INLINE CORBA_FixedDef_ptr 
CORBA_FixedDef_var::_retn (void)
{
  // yield ownership of managed obj reference
  CORBA_FixedDef_ptr val = this->ptr_;
  this->ptr_ = CORBA_FixedDef::_nil ();
  return val;
}


#endif /* end #if !defined */


#if !defined (_CORBA_FIXEDDEF___OUT_CI_)
#define _CORBA_FIXEDDEF___OUT_CI_

// *************************************************************
// Inline operations for class CORBA_FixedDef_out
// *************************************************************

ACE_INLINE
CORBA_FixedDef_out::CORBA_FixedDef_out (CORBA_FixedDef_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = CORBA_FixedDef::_nil ();
}

ACE_INLINE
CORBA_FixedDef_out::CORBA_FixedDef_out (CORBA_FixedDef_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = CORBA_FixedDef::_nil ();
}

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

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

ACE_INLINE CORBA_FixedDef_out &
CORBA_FixedDef_out::operator= (const CORBA_FixedDef_var &p)
{
  this->ptr_ = CORBA_FixedDef::_duplicate (p.ptr ());
  return *this;
}

ACE_INLINE CORBA_FixedDef_out &
CORBA_FixedDef_out::operator= (CORBA_FixedDef_ptr p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE 
CORBA_FixedDef_out::operator CORBA_FixedDef_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE CORBA_FixedDef_ptr &
CORBA_FixedDef_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE CORBA_FixedDef_ptr 
CORBA_FixedDef_out::operator-> (void)
{
  return this->ptr_;
}


#endif /* end #if !defined */

ACE_INLINE
CORBA_SequenceDef::CORBA_SequenceDef (void) // default constructor
{}

ACE_INLINE
CORBA_SequenceDef::CORBA_SequenceDef (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
  : CORBA_Object (objref, _tao_servant, _tao_collocated)
{}

ACE_INLINE
CORBA_SequenceDef::~CORBA_SequenceDef (void) // destructor
{}


#if !defined (_CORBA_SEQUENCEDEF___VAR_CI_)
#define _CORBA_SEQUENCEDEF___VAR_CI_

// *************************************************************
// Inline operations for class CORBA_SequenceDef_var
// *************************************************************

ACE_INLINE
CORBA_SequenceDef_var::CORBA_SequenceDef_var (void) // default constructor
  : ptr_ (CORBA_SequenceDef::_nil ())
{}

ACE_INLINE
CORBA_SequenceDef_var::CORBA_SequenceDef_var (CORBA_SequenceDef_ptr p)
  : ptr_ (p)
{}

ACE_INLINE CORBA_SequenceDef_ptr 
CORBA_SequenceDef_var::ptr (void) const
{
  return this->ptr_;
}

ACE_INLINE
CORBA_SequenceDef_var::CORBA_SequenceDef_var (const CORBA_SequenceDef_var &p) // copy constructor
  : ptr_ (CORBA_SequenceDef::_duplicate (p.ptr ()))
{}

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

ACE_INLINE CORBA_SequenceDef_var &
CORBA_SequenceDef_var::operator= (CORBA_SequenceDef_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE 
CORBA_SequenceDef_var::operator const CORBA_SequenceDef_ptr &() const // cast
{
  return this->ptr_;
}

ACE_INLINE 
CORBA_SequenceDef_var::operator CORBA_SequenceDef_ptr &() // cast 
{
  return this->ptr_;
}

ACE_INLINE CORBA_SequenceDef_ptr 
CORBA_SequenceDef_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_SequenceDef_ptr
CORBA_SequenceDef_var::in (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_SequenceDef_ptr &
CORBA_SequenceDef_var::inout (void)
{
  return this->ptr_;
}

ACE_INLINE CORBA_SequenceDef_ptr &
CORBA_SequenceDef_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = CORBA_SequenceDef::_nil ();
  return this->ptr_;
}

ACE_INLINE CORBA_SequenceDef_ptr 
CORBA_SequenceDef_var::_retn (void)
{
  // yield ownership of managed obj reference
  CORBA_SequenceDef_ptr val = this->ptr_;
  this->ptr_ = CORBA_SequenceDef::_nil ();
  return val;
}


#endif /* end #if !defined */


#if !defined (_CORBA_SEQUENCEDEF___OUT_CI_)
#define _CORBA_SEQUENCEDEF___OUT_CI_

// *************************************************************
// Inline operations for class CORBA_SequenceDef_out
// *************************************************************

ACE_INLINE
CORBA_SequenceDef_out::CORBA_SequenceDef_out (CORBA_SequenceDef_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = CORBA_SequenceDef::_nil ();
}

ACE_INLINE
CORBA_SequenceDef_out::CORBA_SequenceDef_out (CORBA_SequenceDef_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = CORBA_SequenceDef::_nil ();
}

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

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

ACE_INLINE CORBA_SequenceDef_out &
CORBA_SequenceDef_out::operator= (const CORBA_SequenceDef_var &p)
{
  this->ptr_ = CORBA_SequenceDef::_duplicate (p.ptr ());
  return *this;
}

ACE_INLINE CORBA_SequenceDef_out &
CORBA_SequenceDef_out::operator= (CORBA_SequenceDef_ptr p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE 
CORBA_SequenceDef_out::operator CORBA_SequenceDef_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE CORBA_SequenceDef_ptr &
CORBA_SequenceDef_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE CORBA_SequenceDef_ptr 
CORBA_SequenceDef_out::operator-> (void)
{
  return this->ptr_;
}


#endif /* end #if !defined */

ACE_INLINE
CORBA_ArrayDef::CORBA_ArrayDef (void) // default constructor
{}

ACE_INLINE
CORBA_ArrayDef::CORBA_ArrayDef (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
  : CORBA_Object (objref, _tao_servant, _tao_collocated)
{}

ACE_INLINE
CORBA_ArrayDef::~CORBA_ArrayDef (void) // destructor
{}


#if !defined (_CORBA_ARRAYDEF___VAR_CI_)
#define _CORBA_ARRAYDEF___VAR_CI_

// *************************************************************
// Inline operations for class CORBA_ArrayDef_var
// *************************************************************

ACE_INLINE
CORBA_ArrayDef_var::CORBA_ArrayDef_var (void) // default constructor
  : ptr_ (CORBA_ArrayDef::_nil ())
{}

ACE_INLINE
CORBA_ArrayDef_var::CORBA_ArrayDef_var (CORBA_ArrayDef_ptr p)
  : ptr_ (p)
{}

ACE_INLINE CORBA_ArrayDef_ptr 
CORBA_ArrayDef_var::ptr (void) const
{
  return this->ptr_;
}

ACE_INLINE
CORBA_ArrayDef_var::CORBA_ArrayDef_var (const CORBA_ArrayDef_var &p) // copy constructor
  : ptr_ (CORBA_ArrayDef::_duplicate (p.ptr ()))
{}

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

ACE_INLINE CORBA_ArrayDef_var &
CORBA_ArrayDef_var::operator= (CORBA_ArrayDef_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE 
CORBA_ArrayDef_var::operator const CORBA_ArrayDef_ptr &() const // cast
{
  return this->ptr_;
}

ACE_INLINE 
CORBA_ArrayDef_var::operator CORBA_ArrayDef_ptr &() // cast 
{
  return this->ptr_;
}

ACE_INLINE CORBA_ArrayDef_ptr 
CORBA_ArrayDef_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_ArrayDef_ptr
CORBA_ArrayDef_var::in (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_ArrayDef_ptr &
CORBA_ArrayDef_var::inout (void)
{
  return this->ptr_;
}

ACE_INLINE CORBA_ArrayDef_ptr &
CORBA_ArrayDef_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = CORBA_ArrayDef::_nil ();
  return this->ptr_;
}

ACE_INLINE CORBA_ArrayDef_ptr 
CORBA_ArrayDef_var::_retn (void)
{
  // yield ownership of managed obj reference
  CORBA_ArrayDef_ptr val = this->ptr_;
  this->ptr_ = CORBA_ArrayDef::_nil ();
  return val;
}


#endif /* end #if !defined */


#if !defined (_CORBA_ARRAYDEF___OUT_CI_)
#define _CORBA_ARRAYDEF___OUT_CI_

// *************************************************************
// Inline operations for class CORBA_ArrayDef_out
// *************************************************************

ACE_INLINE
CORBA_ArrayDef_out::CORBA_ArrayDef_out (CORBA_ArrayDef_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = CORBA_ArrayDef::_nil ();
}

ACE_INLINE
CORBA_ArrayDef_out::CORBA_ArrayDef_out (CORBA_ArrayDef_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = CORBA_ArrayDef::_nil ();
}

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

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

ACE_INLINE CORBA_ArrayDef_out &
CORBA_ArrayDef_out::operator= (const CORBA_ArrayDef_var &p)
{
  this->ptr_ = CORBA_ArrayDef::_duplicate (p.ptr ());
  return *this;
}

ACE_INLINE CORBA_ArrayDef_out &
CORBA_ArrayDef_out::operator= (CORBA_ArrayDef_ptr p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE 
CORBA_ArrayDef_out::operator CORBA_ArrayDef_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE CORBA_ArrayDef_ptr &
CORBA_ArrayDef_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE CORBA_ArrayDef_ptr 
CORBA_ArrayDef_out::operator-> (void)
{
  return this->ptr_;
}


#endif /* end #if !defined */

ACE_INLINE
CORBA_ExceptionDef::CORBA_ExceptionDef (void) // default constructor
{}

ACE_INLINE
CORBA_ExceptionDef::CORBA_ExceptionDef (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
  : CORBA_Object (objref, _tao_servant, _tao_collocated)
{}

ACE_INLINE
CORBA_ExceptionDef::~CORBA_ExceptionDef (void) // destructor
{}


#if !defined (_CORBA_EXCEPTIONDEF___VAR_CI_)
#define _CORBA_EXCEPTIONDEF___VAR_CI_

// *************************************************************
// Inline operations for class CORBA_ExceptionDef_var
// *************************************************************

ACE_INLINE
CORBA_ExceptionDef_var::CORBA_ExceptionDef_var (void) // default constructor
  : ptr_ (CORBA_ExceptionDef::_nil ())
{}

ACE_INLINE
CORBA_ExceptionDef_var::CORBA_ExceptionDef_var (CORBA_ExceptionDef_ptr p)
  : ptr_ (p)
{}

ACE_INLINE CORBA_ExceptionDef_ptr 
CORBA_ExceptionDef_var::ptr (void) const
{
  return this->ptr_;
}

ACE_INLINE
CORBA_ExceptionDef_var::CORBA_ExceptionDef_var (const CORBA_ExceptionDef_var &p) // copy constructor
  : ptr_ (CORBA_ExceptionDef::_duplicate (p.ptr ()))
{}

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

ACE_INLINE CORBA_ExceptionDef_var &
CORBA_ExceptionDef_var::operator= (CORBA_ExceptionDef_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE 
CORBA_ExceptionDef_var::operator const CORBA_ExceptionDef_ptr &() const // cast
{
  return this->ptr_;
}

ACE_INLINE 
CORBA_ExceptionDef_var::operator CORBA_ExceptionDef_ptr &() // cast 
{
  return this->ptr_;
}

ACE_INLINE CORBA_ExceptionDef_ptr 
CORBA_ExceptionDef_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_ExceptionDef_ptr
CORBA_ExceptionDef_var::in (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_ExceptionDef_ptr &
CORBA_ExceptionDef_var::inout (void)
{
  return this->ptr_;
}

ACE_INLINE CORBA_ExceptionDef_ptr &
CORBA_ExceptionDef_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = CORBA_ExceptionDef::_nil ();
  return this->ptr_;
}

ACE_INLINE CORBA_ExceptionDef_ptr 
CORBA_ExceptionDef_var::_retn (void)
{
  // yield ownership of managed obj reference
  CORBA_ExceptionDef_ptr val = this->ptr_;
  this->ptr_ = CORBA_ExceptionDef::_nil ();
  return val;
}


#endif /* end #if !defined */


#if !defined (_CORBA_EXCEPTIONDEF___OUT_CI_)
#define _CORBA_EXCEPTIONDEF___OUT_CI_

// *************************************************************
// Inline operations for class CORBA_ExceptionDef_out
// *************************************************************

ACE_INLINE
CORBA_ExceptionDef_out::CORBA_ExceptionDef_out (CORBA_ExceptionDef_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = CORBA_ExceptionDef::_nil ();
}

ACE_INLINE
CORBA_ExceptionDef_out::CORBA_ExceptionDef_out (CORBA_ExceptionDef_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = CORBA_ExceptionDef::_nil ();
}

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

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

ACE_INLINE CORBA_ExceptionDef_out &
CORBA_ExceptionDef_out::operator= (const CORBA_ExceptionDef_var &p)
{
  this->ptr_ = CORBA_ExceptionDef::_duplicate (p.ptr ());
  return *this;
}

ACE_INLINE CORBA_ExceptionDef_out &
CORBA_ExceptionDef_out::operator= (CORBA_ExceptionDef_ptr p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE 
CORBA_ExceptionDef_out::operator CORBA_ExceptionDef_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE CORBA_ExceptionDef_ptr &
CORBA_ExceptionDef_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE CORBA_ExceptionDef_ptr 
CORBA_ExceptionDef_out::operator-> (void)
{
  return this->ptr_;
}


#endif /* end #if !defined */

// *************************************************************
// Inline operations for class CORBA_ExceptionDescription_var
// *************************************************************

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

ACE_INLINE
CORBA_ExceptionDescription_var::CORBA_ExceptionDescription_var (CORBA_ExceptionDescription *p)
  : ptr_ (p)
{}

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

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

ACE_INLINE CORBA_ExceptionDescription_var &
CORBA_ExceptionDescription_var::operator= (CORBA_ExceptionDescription *p)
{
  delete this->ptr_;
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE const CORBA_ExceptionDescription *
CORBA_ExceptionDescription_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_ExceptionDescription *
CORBA_ExceptionDescription_var::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE 
CORBA_ExceptionDescription_var::operator const CORBA_ExceptionDescription &() const // cast
{
  return *this->ptr_;
}

ACE_INLINE 
CORBA_ExceptionDescription_var::operator CORBA_ExceptionDescription &() // cast 
{
  return *this->ptr_;
}

ACE_INLINE 
CORBA_ExceptionDescription_var::operator CORBA_ExceptionDescription &() const// cast 
{
  return *this->ptr_;
}

ACE_INLINE const CORBA_ExceptionDescription &
CORBA_ExceptionDescription_var::in (void) const
{
  return *this->ptr_;
}

ACE_INLINE CORBA_ExceptionDescription &
CORBA_ExceptionDescription_var::inout (void)
{
  return *this->ptr_;
}

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

ACE_INLINE CORBA_ExceptionDescription *
CORBA_ExceptionDescription_var::_retn (void)
{
  CORBA_ExceptionDescription *tmp = this->ptr_;
  this->ptr_ = 0;
  return tmp;
}

ACE_INLINE CORBA_ExceptionDescription *
CORBA_ExceptionDescription_var::ptr (void) const
{
  return this->ptr_;
}

// *************************************************************
// Inline operations for class CORBA_ExceptionDescription_out
// *************************************************************

ACE_INLINE
CORBA_ExceptionDescription_out::CORBA_ExceptionDescription_out (CORBA_ExceptionDescription *&p)
  : ptr_ (p)
{
  this->ptr_ = 0;
}

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

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

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

ACE_INLINE CORBA_ExceptionDescription_out &
CORBA_ExceptionDescription_out::operator= (CORBA_ExceptionDescription *p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE 
CORBA_ExceptionDescription_out::operator CORBA_ExceptionDescription *&() // cast
{
  return this->ptr_;
}

ACE_INLINE CORBA_ExceptionDescription *&
CORBA_ExceptionDescription_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE CORBA_ExceptionDescription *
CORBA_ExceptionDescription_out::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE
CORBA_AttributeDef::CORBA_AttributeDef (void) // default constructor
{}

ACE_INLINE
CORBA_AttributeDef::CORBA_AttributeDef (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
  : CORBA_Object (objref, _tao_servant, _tao_collocated)
{}

ACE_INLINE
CORBA_AttributeDef::~CORBA_AttributeDef (void) // destructor
{}


#if !defined (_CORBA_ATTRIBUTEDEF___VAR_CI_)
#define _CORBA_ATTRIBUTEDEF___VAR_CI_

// *************************************************************
// Inline operations for class CORBA_AttributeDef_var
// *************************************************************

ACE_INLINE
CORBA_AttributeDef_var::CORBA_AttributeDef_var (void) // default constructor
  : ptr_ (CORBA_AttributeDef::_nil ())
{}

ACE_INLINE
CORBA_AttributeDef_var::CORBA_AttributeDef_var (CORBA_AttributeDef_ptr p)
  : ptr_ (p)
{}

ACE_INLINE CORBA_AttributeDef_ptr 
CORBA_AttributeDef_var::ptr (void) const
{
  return this->ptr_;
}

ACE_INLINE
CORBA_AttributeDef_var::CORBA_AttributeDef_var (const CORBA_AttributeDef_var &p) // copy constructor
  : ptr_ (CORBA_AttributeDef::_duplicate (p.ptr ()))
{}

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

ACE_INLINE CORBA_AttributeDef_var &
CORBA_AttributeDef_var::operator= (CORBA_AttributeDef_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE 
CORBA_AttributeDef_var::operator const CORBA_AttributeDef_ptr &() const // cast
{
  return this->ptr_;
}

ACE_INLINE 
CORBA_AttributeDef_var::operator CORBA_AttributeDef_ptr &() // cast 
{
  return this->ptr_;
}

ACE_INLINE CORBA_AttributeDef_ptr 
CORBA_AttributeDef_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_AttributeDef_ptr
CORBA_AttributeDef_var::in (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_AttributeDef_ptr &
CORBA_AttributeDef_var::inout (void)
{
  return this->ptr_;
}

ACE_INLINE CORBA_AttributeDef_ptr &
CORBA_AttributeDef_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = CORBA_AttributeDef::_nil ();
  return this->ptr_;
}

ACE_INLINE CORBA_AttributeDef_ptr 
CORBA_AttributeDef_var::_retn (void)
{
  // yield ownership of managed obj reference
  CORBA_AttributeDef_ptr val = this->ptr_;
  this->ptr_ = CORBA_AttributeDef::_nil ();
  return val;
}


#endif /* end #if !defined */


#if !defined (_CORBA_ATTRIBUTEDEF___OUT_CI_)
#define _CORBA_ATTRIBUTEDEF___OUT_CI_

// *************************************************************
// Inline operations for class CORBA_AttributeDef_out
// *************************************************************

ACE_INLINE
CORBA_AttributeDef_out::CORBA_AttributeDef_out (CORBA_AttributeDef_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = CORBA_AttributeDef::_nil ();
}

ACE_INLINE
CORBA_AttributeDef_out::CORBA_AttributeDef_out (CORBA_AttributeDef_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = CORBA_AttributeDef::_nil ();
}

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

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

ACE_INLINE CORBA_AttributeDef_out &
CORBA_AttributeDef_out::operator= (const CORBA_AttributeDef_var &p)
{
  this->ptr_ = CORBA_AttributeDef::_duplicate (p.ptr ());
  return *this;
}

ACE_INLINE CORBA_AttributeDef_out &
CORBA_AttributeDef_out::operator= (CORBA_AttributeDef_ptr p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE 
CORBA_AttributeDef_out::operator CORBA_AttributeDef_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE CORBA_AttributeDef_ptr &
CORBA_AttributeDef_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE CORBA_AttributeDef_ptr 
CORBA_AttributeDef_out::operator-> (void)
{
  return this->ptr_;
}


#endif /* end #if !defined */

// *************************************************************
// Inline operations for class CORBA_AttributeDescription_var
// *************************************************************

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

ACE_INLINE
CORBA_AttributeDescription_var::CORBA_AttributeDescription_var (CORBA_AttributeDescription *p)
  : ptr_ (p)
{}

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

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

ACE_INLINE CORBA_AttributeDescription_var &
CORBA_AttributeDescription_var::operator= (CORBA_AttributeDescription *p)
{
  delete this->ptr_;
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE const CORBA_AttributeDescription *
CORBA_AttributeDescription_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_AttributeDescription *
CORBA_AttributeDescription_var::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE 
CORBA_AttributeDescription_var::operator const CORBA_AttributeDescription &() const // cast
{
  return *this->ptr_;
}

ACE_INLINE 
CORBA_AttributeDescription_var::operator CORBA_AttributeDescription &() // cast 
{
  return *this->ptr_;
}

ACE_INLINE 
CORBA_AttributeDescription_var::operator CORBA_AttributeDescription &() const// cast 
{
  return *this->ptr_;
}

ACE_INLINE const CORBA_AttributeDescription &
CORBA_AttributeDescription_var::in (void) const
{
  return *this->ptr_;
}

ACE_INLINE CORBA_AttributeDescription &
CORBA_AttributeDescription_var::inout (void)
{
  return *this->ptr_;
}

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

ACE_INLINE CORBA_AttributeDescription *
CORBA_AttributeDescription_var::_retn (void)
{
  CORBA_AttributeDescription *tmp = this->ptr_;
  this->ptr_ = 0;
  return tmp;
}

ACE_INLINE CORBA_AttributeDescription *
CORBA_AttributeDescription_var::ptr (void) const
{
  return this->ptr_;
}

// *************************************************************
// Inline operations for class CORBA_AttributeDescription_out
// *************************************************************

ACE_INLINE
CORBA_AttributeDescription_out::CORBA_AttributeDescription_out (CORBA_AttributeDescription *&p)
  : ptr_ (p)
{
  this->ptr_ = 0;
}

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

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

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

ACE_INLINE CORBA_AttributeDescription_out &
CORBA_AttributeDescription_out::operator= (CORBA_AttributeDescription *p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE 
CORBA_AttributeDescription_out::operator CORBA_AttributeDescription *&() // cast
{
  return this->ptr_;
}

ACE_INLINE CORBA_AttributeDescription *&
CORBA_AttributeDescription_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE CORBA_AttributeDescription *
CORBA_AttributeDescription_out::operator-> (void)
{
  return this->ptr_;
}

// *************************************************************
// Inline operations for class CORBA_ParameterDescription_var
// *************************************************************

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

ACE_INLINE
CORBA_ParameterDescription_var::CORBA_ParameterDescription_var (CORBA_ParameterDescription *p)
  : ptr_ (p)
{}

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

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

ACE_INLINE CORBA_ParameterDescription_var &
CORBA_ParameterDescription_var::operator= (CORBA_ParameterDescription *p)
{
  delete this->ptr_;
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE const CORBA_ParameterDescription *
CORBA_ParameterDescription_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_ParameterDescription *
CORBA_ParameterDescription_var::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE 
CORBA_ParameterDescription_var::operator const CORBA_ParameterDescription &() const // cast
{
  return *this->ptr_;
}

ACE_INLINE 
CORBA_ParameterDescription_var::operator CORBA_ParameterDescription &() // cast 
{
  return *this->ptr_;
}

ACE_INLINE 
CORBA_ParameterDescription_var::operator CORBA_ParameterDescription &() const// cast 
{
  return *this->ptr_;
}

ACE_INLINE const CORBA_ParameterDescription &
CORBA_ParameterDescription_var::in (void) const
{
  return *this->ptr_;
}

ACE_INLINE CORBA_ParameterDescription &
CORBA_ParameterDescription_var::inout (void)
{
  return *this->ptr_;
}

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

ACE_INLINE CORBA_ParameterDescription *
CORBA_ParameterDescription_var::_retn (void)
{
  CORBA_ParameterDescription *tmp = this->ptr_;
  this->ptr_ = 0;
  return tmp;
}

ACE_INLINE CORBA_ParameterDescription *
CORBA_ParameterDescription_var::ptr (void) const
{
  return this->ptr_;
}

// *************************************************************
// Inline operations for class CORBA_ParameterDescription_out
// *************************************************************

ACE_INLINE
CORBA_ParameterDescription_out::CORBA_ParameterDescription_out (CORBA_ParameterDescription *&p)
  : ptr_ (p)
{
  this->ptr_ = 0;
}

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

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

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

ACE_INLINE CORBA_ParameterDescription_out &
CORBA_ParameterDescription_out::operator= (CORBA_ParameterDescription *p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE 
CORBA_ParameterDescription_out::operator CORBA_ParameterDescription *&() // cast
{
  return this->ptr_;
}

ACE_INLINE CORBA_ParameterDescription *&
CORBA_ParameterDescription_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE CORBA_ParameterDescription *
CORBA_ParameterDescription_out::operator-> (void)
{
  return this->ptr_;
}


#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
  
#if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_PARDESCRIPTIONSEQ_CI_)
#define __TAO_UNBOUNDED_SEQUENCE_CORBA_PARDESCRIPTIONSEQ_CI_

  // = Static operations.
  ACE_INLINE CORBA_ParameterDescription *
  _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::allocbuf (CORBA::ULong size)
  // Allocate storage for the sequence.
  {
    CORBA_ParameterDescription *retval = 0;
    ACE_NEW_RETURN (retval,
                    CORBA_ParameterDescription[size],
		    0);
    return retval;
  }
  
  ACE_INLINE void _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::freebuf (CORBA_ParameterDescription *buffer)
  // Free the sequence.
  {
    delete [] buffer;
  }
  
  ACE_INLINE
  _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq (void) // Default constructor.
  {
  }
  
  ACE_INLINE
  _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq (CORBA::ULong maximum) // Constructor using a maximum length value.
    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::allocbuf (maximum))
  {
  }
  
  ACE_INLINE
  _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq (CORBA::ULong maximum,
    CORBA::ULong length,
    CORBA_ParameterDescription *data,
    CORBA::Boolean release)
  : TAO_Unbounded_Base_Sequence (maximum, length, data, release)
  {
  }
  
  ACE_INLINE
  _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq (const _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq &rhs)
  // Copy constructor.
    : TAO_Unbounded_Base_Sequence (rhs)
  {
    CORBA_ParameterDescription *tmp1 = _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::allocbuf (this->maximum_);
    CORBA_ParameterDescription * const tmp2 = ACE_reinterpret_cast (CORBA_ParameterDescription * ACE_CAST_CONST, rhs.buffer_);
    
    for (CORBA::ULong i = 0; i < this->length_; ++i)
      tmp1[i] = tmp2[i];
    
    this->buffer_ = tmp1;
  }
  
  ACE_INLINE _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq &
  _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::operator= (const _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq &rhs)
  // Assignment operator.
  {
    if (this == &rhs)
      return *this;
    
    if (this->release_)
    {
      if (this->maximum_ < rhs.maximum_)
      {
        // free the old buffer
        CORBA_ParameterDescription *tmp = ACE_reinterpret_cast (CORBA_ParameterDescription *, this->buffer_);
        _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::freebuf (tmp);
        this->buffer_ = _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::allocbuf (rhs.maximum_);
      }
    }
    else
      this->buffer_ = _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::allocbuf (rhs.maximum_);
    
    TAO_Unbounded_Base_Sequence::operator= (rhs);
    
    CORBA_ParameterDescription *tmp1 = ACE_reinterpret_cast (CORBA_ParameterDescription *, this->buffer_);
    CORBA_ParameterDescription * const tmp2 = ACE_reinterpret_cast (CORBA_ParameterDescription * ACE_CAST_CONST, rhs.buffer_);
    
    for (CORBA::ULong i = 0; i < this->length_; ++i)
      tmp1[i] = tmp2[i];
    
    return *this;
  }
  
  // = Accessors.
  ACE_INLINE CORBA_ParameterDescription &
  _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::operator[] (CORBA::ULong i)
  // operator []
  {
    ACE_ASSERT (i < this->maximum_);
    CORBA_ParameterDescription* tmp = ACE_reinterpret_cast(CORBA_ParameterDescription*,this->buffer_);
    return tmp[i];
  }
  
  ACE_INLINE const CORBA_ParameterDescription &
  _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::operator[] (CORBA::ULong i) const
  // operator []
  {
    ACE_ASSERT (i < this->maximum_);
    CORBA_ParameterDescription * const tmp = ACE_reinterpret_cast (CORBA_ParameterDescription* ACE_CAST_CONST, this->buffer_);
    return tmp[i];
  }
  
  // Implement the TAO_Base_Sequence methods (see Sequence.h)
  
  ACE_INLINE CORBA_ParameterDescription *
  _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::get_buffer (CORBA::Boolean orphan)
  {
    CORBA_ParameterDescription *result = 0;
    if (orphan == 0)
    {
      // We retain ownership.
      if (this->buffer_ == 0)
      {
        result = _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::allocbuf (this->length_);
        this->buffer_ = result;
      }
      else
      {
        result = ACE_reinterpret_cast (CORBA_ParameterDescription*, this->buffer_);
      }
    }
    else // if (orphan == 1)
    {
      if (this->release_ != 0)
      {
        // We set the state back to default and relinquish
        // ownership.
        result = ACE_reinterpret_cast(CORBA_ParameterDescription*,this->buffer_);
        this->maximum_ = 0;
        this->length_ = 0;
        this->buffer_ = 0;
        this->release_ = 0;
      }
    }
    return result;
  }
  
  ACE_INLINE const CORBA_ParameterDescription *
  _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::get_buffer (void) const
  {
    return ACE_reinterpret_cast(const CORBA_ParameterDescription * ACE_CAST_CONST, this->buffer_);
  }
  
  ACE_INLINE void
  _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::replace (CORBA::ULong max,
  CORBA::ULong length,
  CORBA_ParameterDescription *data,
  CORBA::Boolean release)
  {
    this->maximum_ = max;
    this->length_ = length;
    if (this->buffer_ && this->release_ == 1)
    {
      CORBA_ParameterDescription *tmp = ACE_reinterpret_cast(CORBA_ParameterDescription*,this->buffer_);
      _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::freebuf (tmp);
    }
    this->buffer_ = data;
    this->release_ = release;
  }
  
#endif /* end #if !defined */


#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 

#if !defined (_CORBA_PARDESCRIPTIONSEQ_CI_)
#define _CORBA_PARDESCRIPTIONSEQ_CI_

// *************************************************************
// Inline operations for class CORBA_ParDescriptionSeq_var
// *************************************************************

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

ACE_INLINE
CORBA_ParDescriptionSeq_var::CORBA_ParDescriptionSeq_var (CORBA_ParDescriptionSeq *p)
  : ptr_ (p)
{}

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

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

ACE_INLINE CORBA_ParDescriptionSeq_var &
CORBA_ParDescriptionSeq_var::operator= (CORBA_ParDescriptionSeq *p)
{
  delete this->ptr_;
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE const CORBA_ParDescriptionSeq *
CORBA_ParDescriptionSeq_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_ParDescriptionSeq *
CORBA_ParDescriptionSeq_var::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE 
CORBA_ParDescriptionSeq_var::operator const CORBA_ParDescriptionSeq &() const // cast
{
  return *this->ptr_;
}

ACE_INLINE 
CORBA_ParDescriptionSeq_var::operator CORBA_ParDescriptionSeq &() // cast 
{
  return *this->ptr_;
}

ACE_INLINE 
CORBA_ParDescriptionSeq_var::operator CORBA_ParDescriptionSeq &() const// cast 
{
  return *this->ptr_;
}

ACE_INLINE CORBA_ParameterDescription &
CORBA_ParDescriptionSeq_var::operator[] (CORBA::ULong index)
{
  return this->ptr_->operator[] (index);
}

ACE_INLINE const CORBA_ParDescriptionSeq &
CORBA_ParDescriptionSeq_var::in (void) const
{
  return *this->ptr_;
}

ACE_INLINE CORBA_ParDescriptionSeq &
CORBA_ParDescriptionSeq_var::inout (void)
{
  return *this->ptr_;
}

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

ACE_INLINE CORBA_ParDescriptionSeq *
CORBA_ParDescriptionSeq_var::_retn (void)
{
  CORBA_ParDescriptionSeq *tmp = this->ptr_;
  this->ptr_ = 0;
  return tmp;
}

ACE_INLINE CORBA_ParDescriptionSeq *
CORBA_ParDescriptionSeq_var::ptr (void) const
{
  return this->ptr_;
}

// *************************************************************
// Inline operations for class CORBA_ParDescriptionSeq_out
// *************************************************************

ACE_INLINE
CORBA_ParDescriptionSeq_out::CORBA_ParDescriptionSeq_out (CORBA_ParDescriptionSeq *&p)
  : ptr_ (p)
{
  this->ptr_ = 0;
}

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

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

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

ACE_INLINE CORBA_ParDescriptionSeq_out &
CORBA_ParDescriptionSeq_out::operator= (CORBA_ParDescriptionSeq *p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE 
CORBA_ParDescriptionSeq_out::operator CORBA_ParDescriptionSeq *&() // cast
{
  return this->ptr_;
}

ACE_INLINE CORBA_ParDescriptionSeq *&
CORBA_ParDescriptionSeq_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE CORBA_ParDescriptionSeq *
CORBA_ParDescriptionSeq_out::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE CORBA_ParameterDescription &
CORBA_ParDescriptionSeq_out::operator[] (CORBA::ULong index)
{
  return this->ptr_->operator[] (index);
}


#endif /* end #if !defined */


#if !defined (_CORBA_CONTEXTIDSEQ_CI_)
#define _CORBA_CONTEXTIDSEQ_CI_

// *************************************************************
// Inline operations for class CORBA_ContextIdSeq_var
// *************************************************************

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

ACE_INLINE
CORBA_ContextIdSeq_var::CORBA_ContextIdSeq_var (CORBA_ContextIdSeq *p)
  : ptr_ (p)
{}

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

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

ACE_INLINE CORBA_ContextIdSeq_var &
CORBA_ContextIdSeq_var::operator= (CORBA_ContextIdSeq *p)
{
  delete this->ptr_;
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE const CORBA_ContextIdSeq *
CORBA_ContextIdSeq_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_ContextIdSeq *
CORBA_ContextIdSeq_var::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE 
CORBA_ContextIdSeq_var::operator const CORBA_ContextIdSeq &() const // cast
{
  return *this->ptr_;
}

ACE_INLINE 
CORBA_ContextIdSeq_var::operator CORBA_ContextIdSeq &() // cast 
{
  return *this->ptr_;
}

ACE_INLINE 
CORBA_ContextIdSeq_var::operator CORBA_ContextIdSeq &() const// cast 
{
  return *this->ptr_;
}

ACE_INLINE TAO_SeqElem_String_Manager 
CORBA_ContextIdSeq_var::operator[] (CORBA::ULong index)
{
  return this->ptr_->operator[] (index);
}

ACE_INLINE const CORBA_ContextIdSeq &
CORBA_ContextIdSeq_var::in (void) const
{
  return *this->ptr_;
}

ACE_INLINE CORBA_ContextIdSeq &
CORBA_ContextIdSeq_var::inout (void)
{
  return *this->ptr_;
}

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

ACE_INLINE CORBA_ContextIdSeq *
CORBA_ContextIdSeq_var::_retn (void)
{
  CORBA_ContextIdSeq *tmp = this->ptr_;
  this->ptr_ = 0;
  return tmp;
}

ACE_INLINE CORBA_ContextIdSeq *
CORBA_ContextIdSeq_var::ptr (void) const
{
  return this->ptr_;
}

// *************************************************************
// Inline operations for class CORBA_ContextIdSeq_out
// *************************************************************

ACE_INLINE
CORBA_ContextIdSeq_out::CORBA_ContextIdSeq_out (CORBA_ContextIdSeq *&p)
  : ptr_ (p)
{
  this->ptr_ = 0;
}

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

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

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

ACE_INLINE CORBA_ContextIdSeq_out &
CORBA_ContextIdSeq_out::operator= (CORBA_ContextIdSeq *p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE 
CORBA_ContextIdSeq_out::operator CORBA_ContextIdSeq *&() // cast
{
  return this->ptr_;
}

ACE_INLINE CORBA_ContextIdSeq *&
CORBA_ContextIdSeq_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE CORBA_ContextIdSeq *
CORBA_ContextIdSeq_out::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE TAO_SeqElem_String_Manager 
CORBA_ContextIdSeq_out::operator[] (CORBA::ULong index)
{
  return this->ptr_->operator[] (index);
}


#endif /* end #if !defined */


#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
  
#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_EXCEPTIONDEFSEQ_CI_)
#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_EXCEPTIONDEFSEQ_CI_

  ACE_INLINE CORBA_ExceptionDef **
  _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::allocbuf (CORBA::ULong nelems)
  {
    CORBA_ExceptionDef **buf = 0;
    
    ACE_NEW_RETURN (buf, CORBA_ExceptionDef*[nelems], 0);
    
    for (CORBA::ULong i = 0; i < nelems; i++)
      buf[i] = CORBA_ExceptionDef::_nil ();
    
    return buf;
  }
  
  ACE_INLINE void 
  _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::freebuf (CORBA_ExceptionDef **buffer)
  {
    if (buffer == 0)
      return;
    delete[] buffer;
  }
  
  ACE_INLINE
  _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq (void)
  {
  }
  
  ACE_INLINE
  _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq (CORBA::ULong maximum)
    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::allocbuf (maximum))
  {
  }
  
  ACE_INLINE
  _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq (CORBA::ULong maximum,
    CORBA::ULong length,
    CORBA_ExceptionDef* *value,
    CORBA::Boolean release)
  : TAO_Unbounded_Base_Sequence (maximum, length, value, release)
  {
  }
  
  ACE_INLINE
  _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq(const _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq &rhs)
    : TAO_Unbounded_Base_Sequence (rhs)
  {
    CORBA_ExceptionDef **tmp1 = _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::allocbuf (this->maximum_);
    CORBA_ExceptionDef ** const tmp2 = ACE_reinterpret_cast (CORBA_ExceptionDef ** ACE_CAST_CONST, rhs.buffer_);
    
    for (CORBA::ULong i = 0; i < rhs.length_; ++i)
      tmp1[i] = CORBA_ExceptionDef::_duplicate (tmp2[i]);
    
    this->buffer_ = tmp1;
  }
  
  ACE_INLINE _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq &
  _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::operator= (const _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq &rhs)
  {
    if (this == &rhs)
      return *this;
    
    if (this->release_)
    {
      CORBA_ExceptionDef **tmp = ACE_reinterpret_cast (CORBA_ExceptionDef **, this->buffer_);
      
      for (CORBA::ULong i = 0; i < this->length_; ++i)
      {
        CORBA::release (tmp[i]);
        tmp[i] = CORBA_ExceptionDef::_nil ();
      }
      if (this->maximum_ < rhs.maximum_)
      {
        _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::freebuf (tmp);
        this->buffer_ = _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::allocbuf (rhs.maximum_);
      }
    }
    else
      this->buffer_ = _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::allocbuf (rhs.maximum_);
    
    TAO_Unbounded_Base_Sequence::operator= (rhs);
    
    CORBA_ExceptionDef **tmp1 = ACE_reinterpret_cast (CORBA_ExceptionDef **, this->buffer_);
    CORBA_ExceptionDef ** const tmp2 = ACE_reinterpret_cast (CORBA_ExceptionDef ** ACE_CAST_CONST, rhs.buffer_);
    
    for (CORBA::ULong i = 0; i < rhs.length_; ++i)
      tmp1[i] = CORBA_ExceptionDef::_duplicate (tmp2[i]);
    
    return *this;
  }
  
  ACE_INLINE TAO_Object_Manager<CORBA_ExceptionDef,CORBA_ExceptionDef_var>
  _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::operator[] (CORBA::ULong index) const
  // read-write accessor
  {
    ACE_ASSERT (index < this->maximum_);
    CORBA_ExceptionDef ** const tmp = ACE_reinterpret_cast (CORBA_ExceptionDef ** ACE_CAST_CONST, this->buffer_);
    return TAO_Object_Manager<CORBA_ExceptionDef,CORBA_ExceptionDef_var> (tmp + index, this->release_);
  }
  
  ACE_INLINE CORBA_ExceptionDef* *
  _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::get_buffer (CORBA::Boolean orphan)
  {
    CORBA_ExceptionDef **result = 0;
    if (orphan == 0)
    {
      // We retain ownership.
      if (this->buffer_ == 0)
      {
        result = _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::allocbuf (this->maximum_);
        this->buffer_ = result;
      }
      else
      {
        result = ACE_reinterpret_cast (CORBA_ExceptionDef**, this->buffer_);
      }
    }
    else // if (orphan == 1)
    {
      if (this->release_ != 0)
      {
        // We set the state back to default and relinquish
        // ownership.
        result = ACE_reinterpret_cast(CORBA_ExceptionDef**,this->buffer_);
        this->maximum_ = 0;
        this->length_ = 0;
        this->buffer_ = 0;
        this->release_ = 0;
      }
    }
    return result;
  }
  
  ACE_INLINE const CORBA_ExceptionDef* *
  _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::get_buffer (void) const
  {
    return ACE_reinterpret_cast(const CORBA_ExceptionDef ** ACE_CAST_CONST, this->buffer_);
  }
  
  
#endif /* end #if !defined */


#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 

#if !defined (_CORBA_EXCEPTIONDEFSEQ_CI_)
#define _CORBA_EXCEPTIONDEFSEQ_CI_

// *************************************************************
// Inline operations for class CORBA_ExceptionDefSeq_var
// *************************************************************

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

ACE_INLINE
CORBA_ExceptionDefSeq_var::CORBA_ExceptionDefSeq_var (CORBA_ExceptionDefSeq *p)
  : ptr_ (p)
{}

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

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

ACE_INLINE CORBA_ExceptionDefSeq_var &
CORBA_ExceptionDefSeq_var::operator= (CORBA_ExceptionDefSeq *p)
{
  delete this->ptr_;
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE const CORBA_ExceptionDefSeq *
CORBA_ExceptionDefSeq_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_ExceptionDefSeq *
CORBA_ExceptionDefSeq_var::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE 
CORBA_ExceptionDefSeq_var::operator const CORBA_ExceptionDefSeq &() const // cast
{
  return *this->ptr_;
}

ACE_INLINE 
CORBA_ExceptionDefSeq_var::operator CORBA_ExceptionDefSeq &() // cast 
{
  return *this->ptr_;
}

ACE_INLINE 
CORBA_ExceptionDefSeq_var::operator CORBA_ExceptionDefSeq &() const// cast 
{
  return *this->ptr_;
}

ACE_INLINE TAO_Object_Manager<CORBA_ExceptionDef,CORBA_ExceptionDef_var> 
CORBA_ExceptionDefSeq_var::operator[] (CORBA::ULong index)
{
  return this->ptr_->operator[] (index);
}

ACE_INLINE const CORBA_ExceptionDefSeq &
CORBA_ExceptionDefSeq_var::in (void) const
{
  return *this->ptr_;
}

ACE_INLINE CORBA_ExceptionDefSeq &
CORBA_ExceptionDefSeq_var::inout (void)
{
  return *this->ptr_;
}

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

ACE_INLINE CORBA_ExceptionDefSeq *
CORBA_ExceptionDefSeq_var::_retn (void)
{
  CORBA_ExceptionDefSeq *tmp = this->ptr_;
  this->ptr_ = 0;
  return tmp;
}

ACE_INLINE CORBA_ExceptionDefSeq *
CORBA_ExceptionDefSeq_var::ptr (void) const
{
  return this->ptr_;
}

// *************************************************************
// Inline operations for class CORBA_ExceptionDefSeq_out
// *************************************************************

ACE_INLINE
CORBA_ExceptionDefSeq_out::CORBA_ExceptionDefSeq_out (CORBA_ExceptionDefSeq *&p)
  : ptr_ (p)
{
  this->ptr_ = 0;
}

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

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

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

ACE_INLINE CORBA_ExceptionDefSeq_out &
CORBA_ExceptionDefSeq_out::operator= (CORBA_ExceptionDefSeq *p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE 
CORBA_ExceptionDefSeq_out::operator CORBA_ExceptionDefSeq *&() // cast
{
  return this->ptr_;
}

ACE_INLINE CORBA_ExceptionDefSeq *&
CORBA_ExceptionDefSeq_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE CORBA_ExceptionDefSeq *
CORBA_ExceptionDefSeq_out::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE TAO_Object_Manager<CORBA_ExceptionDef,CORBA_ExceptionDef_var> 
CORBA_ExceptionDefSeq_out::operator[] (CORBA::ULong index)
{
  return this->ptr_->operator[] (index);
}


#endif /* end #if !defined */


#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
  
#if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_EXCDESCRIPTIONSEQ_CI_)
#define __TAO_UNBOUNDED_SEQUENCE_CORBA_EXCDESCRIPTIONSEQ_CI_

  // = Static operations.
  ACE_INLINE CORBA_ExceptionDescription *
  _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::allocbuf (CORBA::ULong size)
  // Allocate storage for the sequence.
  {
    CORBA_ExceptionDescription *retval = 0;
    ACE_NEW_RETURN (retval,
                    CORBA_ExceptionDescription[size],
		    0);
    return retval;
  }
  
  ACE_INLINE void _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::freebuf (CORBA_ExceptionDescription *buffer)
  // Free the sequence.
  {
    delete [] buffer;
  }
  
  ACE_INLINE
  _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq (void) // Default constructor.
  {
  }
  
  ACE_INLINE
  _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq (CORBA::ULong maximum) // Constructor using a maximum length value.
    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::allocbuf (maximum))
  {
  }
  
  ACE_INLINE
  _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq (CORBA::ULong maximum,
    CORBA::ULong length,
    CORBA_ExceptionDescription *data,
    CORBA::Boolean release)
  : TAO_Unbounded_Base_Sequence (maximum, length, data, release)
  {
  }
  
  ACE_INLINE
  _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq (const _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq &rhs)
  // Copy constructor.
    : TAO_Unbounded_Base_Sequence (rhs)
  {
    CORBA_ExceptionDescription *tmp1 = _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::allocbuf (this->maximum_);
    CORBA_ExceptionDescription * const tmp2 = ACE_reinterpret_cast (CORBA_ExceptionDescription * ACE_CAST_CONST, rhs.buffer_);
    
    for (CORBA::ULong i = 0; i < this->length_; ++i)
      tmp1[i] = tmp2[i];
    
    this->buffer_ = tmp1;
  }
  
  ACE_INLINE _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq &
  _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::operator= (const _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq &rhs)
  // Assignment operator.
  {
    if (this == &rhs)
      return *this;
    
    if (this->release_)
    {
      if (this->maximum_ < rhs.maximum_)
      {
        // free the old buffer
        CORBA_ExceptionDescription *tmp = ACE_reinterpret_cast (CORBA_ExceptionDescription *, this->buffer_);
        _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::freebuf (tmp);
        this->buffer_ = _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::allocbuf (rhs.maximum_);
      }
    }
    else
      this->buffer_ = _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::allocbuf (rhs.maximum_);
    
    TAO_Unbounded_Base_Sequence::operator= (rhs);
    
    CORBA_ExceptionDescription *tmp1 = ACE_reinterpret_cast (CORBA_ExceptionDescription *, this->buffer_);
    CORBA_ExceptionDescription * const tmp2 = ACE_reinterpret_cast (CORBA_ExceptionDescription * ACE_CAST_CONST, rhs.buffer_);
    
    for (CORBA::ULong i = 0; i < this->length_; ++i)
      tmp1[i] = tmp2[i];
    
    return *this;
  }
  
  // = Accessors.
  ACE_INLINE CORBA_ExceptionDescription &
  _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::operator[] (CORBA::ULong i)
  // operator []
  {
    ACE_ASSERT (i < this->maximum_);
    CORBA_ExceptionDescription* tmp = ACE_reinterpret_cast(CORBA_ExceptionDescription*,this->buffer_);
    return tmp[i];
  }
  
  ACE_INLINE const CORBA_ExceptionDescription &
  _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::operator[] (CORBA::ULong i) const
  // operator []
  {
    ACE_ASSERT (i < this->maximum_);
    CORBA_ExceptionDescription * const tmp = ACE_reinterpret_cast (CORBA_ExceptionDescription* ACE_CAST_CONST, this->buffer_);
    return tmp[i];
  }
  
  // Implement the TAO_Base_Sequence methods (see Sequence.h)
  
  ACE_INLINE CORBA_ExceptionDescription *
  _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::get_buffer (CORBA::Boolean orphan)
  {
    CORBA_ExceptionDescription *result = 0;
    if (orphan == 0)
    {
      // We retain ownership.
      if (this->buffer_ == 0)
      {
        result = _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::allocbuf (this->length_);
        this->buffer_ = result;
      }
      else
      {
        result = ACE_reinterpret_cast (CORBA_ExceptionDescription*, this->buffer_);
      }
    }
    else // if (orphan == 1)
    {
      if (this->release_ != 0)
      {
        // We set the state back to default and relinquish
        // ownership.
        result = ACE_reinterpret_cast(CORBA_ExceptionDescription*,this->buffer_);
        this->maximum_ = 0;
        this->length_ = 0;
        this->buffer_ = 0;
        this->release_ = 0;
      }
    }
    return result;
  }
  
  ACE_INLINE const CORBA_ExceptionDescription *
  _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::get_buffer (void) const
  {
    return ACE_reinterpret_cast(const CORBA_ExceptionDescription * ACE_CAST_CONST, this->buffer_);
  }
  
  ACE_INLINE void
  _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::replace (CORBA::ULong max,
  CORBA::ULong length,
  CORBA_ExceptionDescription *data,
  CORBA::Boolean release)
  {
    this->maximum_ = max;
    this->length_ = length;
    if (this->buffer_ && this->release_ == 1)
    {
      CORBA_ExceptionDescription *tmp = ACE_reinterpret_cast(CORBA_ExceptionDescription*,this->buffer_);
      _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::freebuf (tmp);
    }
    this->buffer_ = data;
    this->release_ = release;
  }
  
#endif /* end #if !defined */


#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 

#if !defined (_CORBA_EXCDESCRIPTIONSEQ_CI_)
#define _CORBA_EXCDESCRIPTIONSEQ_CI_

// *************************************************************
// Inline operations for class CORBA_ExcDescriptionSeq_var
// *************************************************************

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

ACE_INLINE
CORBA_ExcDescriptionSeq_var::CORBA_ExcDescriptionSeq_var (CORBA_ExcDescriptionSeq *p)
  : ptr_ (p)
{}

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

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

ACE_INLINE CORBA_ExcDescriptionSeq_var &
CORBA_ExcDescriptionSeq_var::operator= (CORBA_ExcDescriptionSeq *p)
{
  delete this->ptr_;
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE const CORBA_ExcDescriptionSeq *
CORBA_ExcDescriptionSeq_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_ExcDescriptionSeq *
CORBA_ExcDescriptionSeq_var::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE 
CORBA_ExcDescriptionSeq_var::operator const CORBA_ExcDescriptionSeq &() const // cast
{
  return *this->ptr_;
}

ACE_INLINE 
CORBA_ExcDescriptionSeq_var::operator CORBA_ExcDescriptionSeq &() // cast 
{
  return *this->ptr_;
}

ACE_INLINE 
CORBA_ExcDescriptionSeq_var::operator CORBA_ExcDescriptionSeq &() const// cast 
{
  return *this->ptr_;
}

ACE_INLINE CORBA_ExceptionDescription &
CORBA_ExcDescriptionSeq_var::operator[] (CORBA::ULong index)
{
  return this->ptr_->operator[] (index);
}

ACE_INLINE const CORBA_ExcDescriptionSeq &
CORBA_ExcDescriptionSeq_var::in (void) const
{
  return *this->ptr_;
}

ACE_INLINE CORBA_ExcDescriptionSeq &
CORBA_ExcDescriptionSeq_var::inout (void)
{
  return *this->ptr_;
}

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

ACE_INLINE CORBA_ExcDescriptionSeq *
CORBA_ExcDescriptionSeq_var::_retn (void)
{
  CORBA_ExcDescriptionSeq *tmp = this->ptr_;
  this->ptr_ = 0;
  return tmp;
}

ACE_INLINE CORBA_ExcDescriptionSeq *
CORBA_ExcDescriptionSeq_var::ptr (void) const
{
  return this->ptr_;
}

// *************************************************************
// Inline operations for class CORBA_ExcDescriptionSeq_out
// *************************************************************

ACE_INLINE
CORBA_ExcDescriptionSeq_out::CORBA_ExcDescriptionSeq_out (CORBA_ExcDescriptionSeq *&p)
  : ptr_ (p)
{
  this->ptr_ = 0;
}

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

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

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

ACE_INLINE CORBA_ExcDescriptionSeq_out &
CORBA_ExcDescriptionSeq_out::operator= (CORBA_ExcDescriptionSeq *p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE 
CORBA_ExcDescriptionSeq_out::operator CORBA_ExcDescriptionSeq *&() // cast
{
  return this->ptr_;
}

ACE_INLINE CORBA_ExcDescriptionSeq *&
CORBA_ExcDescriptionSeq_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE CORBA_ExcDescriptionSeq *
CORBA_ExcDescriptionSeq_out::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE CORBA_ExceptionDescription &
CORBA_ExcDescriptionSeq_out::operator[] (CORBA::ULong index)
{
  return this->ptr_->operator[] (index);
}


#endif /* end #if !defined */

ACE_INLINE
CORBA_OperationDef::CORBA_OperationDef (void) // default constructor
{}

ACE_INLINE
CORBA_OperationDef::CORBA_OperationDef (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
  : CORBA_Object (objref, _tao_servant, _tao_collocated)
{}

ACE_INLINE
CORBA_OperationDef::~CORBA_OperationDef (void) // destructor
{}


#if !defined (_CORBA_OPERATIONDEF___VAR_CI_)
#define _CORBA_OPERATIONDEF___VAR_CI_

// *************************************************************
// Inline operations for class CORBA_OperationDef_var
// *************************************************************

ACE_INLINE
CORBA_OperationDef_var::CORBA_OperationDef_var (void) // default constructor
  : ptr_ (CORBA_OperationDef::_nil ())
{}

ACE_INLINE
CORBA_OperationDef_var::CORBA_OperationDef_var (CORBA_OperationDef_ptr p)
  : ptr_ (p)
{}

ACE_INLINE CORBA_OperationDef_ptr 
CORBA_OperationDef_var::ptr (void) const
{
  return this->ptr_;
}

ACE_INLINE
CORBA_OperationDef_var::CORBA_OperationDef_var (const CORBA_OperationDef_var &p) // copy constructor
  : ptr_ (CORBA_OperationDef::_duplicate (p.ptr ()))
{}

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

ACE_INLINE CORBA_OperationDef_var &
CORBA_OperationDef_var::operator= (CORBA_OperationDef_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE 
CORBA_OperationDef_var::operator const CORBA_OperationDef_ptr &() const // cast
{
  return this->ptr_;
}

ACE_INLINE 
CORBA_OperationDef_var::operator CORBA_OperationDef_ptr &() // cast 
{
  return this->ptr_;
}

ACE_INLINE CORBA_OperationDef_ptr 
CORBA_OperationDef_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_OperationDef_ptr
CORBA_OperationDef_var::in (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_OperationDef_ptr &
CORBA_OperationDef_var::inout (void)
{
  return this->ptr_;
}

ACE_INLINE CORBA_OperationDef_ptr &
CORBA_OperationDef_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = CORBA_OperationDef::_nil ();
  return this->ptr_;
}

ACE_INLINE CORBA_OperationDef_ptr 
CORBA_OperationDef_var::_retn (void)
{
  // yield ownership of managed obj reference
  CORBA_OperationDef_ptr val = this->ptr_;
  this->ptr_ = CORBA_OperationDef::_nil ();
  return val;
}


#endif /* end #if !defined */


#if !defined (_CORBA_OPERATIONDEF___OUT_CI_)
#define _CORBA_OPERATIONDEF___OUT_CI_

// *************************************************************
// Inline operations for class CORBA_OperationDef_out
// *************************************************************

ACE_INLINE
CORBA_OperationDef_out::CORBA_OperationDef_out (CORBA_OperationDef_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = CORBA_OperationDef::_nil ();
}

ACE_INLINE
CORBA_OperationDef_out::CORBA_OperationDef_out (CORBA_OperationDef_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = CORBA_OperationDef::_nil ();
}

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

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

ACE_INLINE CORBA_OperationDef_out &
CORBA_OperationDef_out::operator= (const CORBA_OperationDef_var &p)
{
  this->ptr_ = CORBA_OperationDef::_duplicate (p.ptr ());
  return *this;
}

ACE_INLINE CORBA_OperationDef_out &
CORBA_OperationDef_out::operator= (CORBA_OperationDef_ptr p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE 
CORBA_OperationDef_out::operator CORBA_OperationDef_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE CORBA_OperationDef_ptr &
CORBA_OperationDef_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE CORBA_OperationDef_ptr 
CORBA_OperationDef_out::operator-> (void)
{
  return this->ptr_;
}


#endif /* end #if !defined */

// *************************************************************
// Inline operations for class CORBA_OperationDescription_var
// *************************************************************

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

ACE_INLINE
CORBA_OperationDescription_var::CORBA_OperationDescription_var (CORBA_OperationDescription *p)
  : ptr_ (p)
{}

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

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

ACE_INLINE CORBA_OperationDescription_var &
CORBA_OperationDescription_var::operator= (CORBA_OperationDescription *p)
{
  delete this->ptr_;
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE const CORBA_OperationDescription *
CORBA_OperationDescription_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_OperationDescription *
CORBA_OperationDescription_var::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE 
CORBA_OperationDescription_var::operator const CORBA_OperationDescription &() const // cast
{
  return *this->ptr_;
}

ACE_INLINE 
CORBA_OperationDescription_var::operator CORBA_OperationDescription &() // cast 
{
  return *this->ptr_;
}

ACE_INLINE 
CORBA_OperationDescription_var::operator CORBA_OperationDescription &() const// cast 
{
  return *this->ptr_;
}

ACE_INLINE const CORBA_OperationDescription &
CORBA_OperationDescription_var::in (void) const
{
  return *this->ptr_;
}

ACE_INLINE CORBA_OperationDescription &
CORBA_OperationDescription_var::inout (void)
{
  return *this->ptr_;
}

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

ACE_INLINE CORBA_OperationDescription *
CORBA_OperationDescription_var::_retn (void)
{
  CORBA_OperationDescription *tmp = this->ptr_;
  this->ptr_ = 0;
  return tmp;
}

ACE_INLINE CORBA_OperationDescription *
CORBA_OperationDescription_var::ptr (void) const
{
  return this->ptr_;
}

// *************************************************************
// Inline operations for class CORBA_OperationDescription_out
// *************************************************************

ACE_INLINE
CORBA_OperationDescription_out::CORBA_OperationDescription_out (CORBA_OperationDescription *&p)
  : ptr_ (p)
{
  this->ptr_ = 0;
}

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

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

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

ACE_INLINE CORBA_OperationDescription_out &
CORBA_OperationDescription_out::operator= (CORBA_OperationDescription *p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE 
CORBA_OperationDescription_out::operator CORBA_OperationDescription *&() // cast
{
  return this->ptr_;
}

ACE_INLINE CORBA_OperationDescription *&
CORBA_OperationDescription_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE CORBA_OperationDescription *
CORBA_OperationDescription_out::operator-> (void)
{
  return this->ptr_;
}


#if !defined (_CORBA_REPOSITORYIDSEQ_CI_)
#define _CORBA_REPOSITORYIDSEQ_CI_

// *************************************************************
// Inline operations for class CORBA_RepositoryIdSeq_var
// *************************************************************

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

ACE_INLINE
CORBA_RepositoryIdSeq_var::CORBA_RepositoryIdSeq_var (CORBA_RepositoryIdSeq *p)
  : ptr_ (p)
{}

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

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

ACE_INLINE CORBA_RepositoryIdSeq_var &
CORBA_RepositoryIdSeq_var::operator= (CORBA_RepositoryIdSeq *p)
{
  delete this->ptr_;
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE const CORBA_RepositoryIdSeq *
CORBA_RepositoryIdSeq_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_RepositoryIdSeq *
CORBA_RepositoryIdSeq_var::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE 
CORBA_RepositoryIdSeq_var::operator const CORBA_RepositoryIdSeq &() const // cast
{
  return *this->ptr_;
}

ACE_INLINE 
CORBA_RepositoryIdSeq_var::operator CORBA_RepositoryIdSeq &() // cast 
{
  return *this->ptr_;
}

ACE_INLINE 
CORBA_RepositoryIdSeq_var::operator CORBA_RepositoryIdSeq &() const// cast 
{
  return *this->ptr_;
}

ACE_INLINE TAO_SeqElem_String_Manager 
CORBA_RepositoryIdSeq_var::operator[] (CORBA::ULong index)
{
  return this->ptr_->operator[] (index);
}

ACE_INLINE const CORBA_RepositoryIdSeq &
CORBA_RepositoryIdSeq_var::in (void) const
{
  return *this->ptr_;
}

ACE_INLINE CORBA_RepositoryIdSeq &
CORBA_RepositoryIdSeq_var::inout (void)
{
  return *this->ptr_;
}

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

ACE_INLINE CORBA_RepositoryIdSeq *
CORBA_RepositoryIdSeq_var::_retn (void)
{
  CORBA_RepositoryIdSeq *tmp = this->ptr_;
  this->ptr_ = 0;
  return tmp;
}

ACE_INLINE CORBA_RepositoryIdSeq *
CORBA_RepositoryIdSeq_var::ptr (void) const
{
  return this->ptr_;
}

// *************************************************************
// Inline operations for class CORBA_RepositoryIdSeq_out
// *************************************************************

ACE_INLINE
CORBA_RepositoryIdSeq_out::CORBA_RepositoryIdSeq_out (CORBA_RepositoryIdSeq *&p)
  : ptr_ (p)
{
  this->ptr_ = 0;
}

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

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

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

ACE_INLINE CORBA_RepositoryIdSeq_out &
CORBA_RepositoryIdSeq_out::operator= (CORBA_RepositoryIdSeq *p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE 
CORBA_RepositoryIdSeq_out::operator CORBA_RepositoryIdSeq *&() // cast
{
  return this->ptr_;
}

ACE_INLINE CORBA_RepositoryIdSeq *&
CORBA_RepositoryIdSeq_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE CORBA_RepositoryIdSeq *
CORBA_RepositoryIdSeq_out::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE TAO_SeqElem_String_Manager 
CORBA_RepositoryIdSeq_out::operator[] (CORBA::ULong index)
{
  return this->ptr_->operator[] (index);
}


#endif /* end #if !defined */


#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
  
#if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_OPDESCRIPTIONSEQ_CI_)
#define __TAO_UNBOUNDED_SEQUENCE_CORBA_OPDESCRIPTIONSEQ_CI_

  // = Static operations.
  ACE_INLINE CORBA_OperationDescription *
  _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::allocbuf (CORBA::ULong size)
  // Allocate storage for the sequence.
  {
    CORBA_OperationDescription *retval = 0;
    ACE_NEW_RETURN (retval,
                    CORBA_OperationDescription[size],
		    0);
    return retval;
  }
  
  ACE_INLINE void _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::freebuf (CORBA_OperationDescription *buffer)
  // Free the sequence.
  {
    delete [] buffer;
  }
  
  ACE_INLINE
  _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq (void) // Default constructor.
  {
  }
  
  ACE_INLINE
  _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq (CORBA::ULong maximum) // Constructor using a maximum length value.
    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::allocbuf (maximum))
  {
  }
  
  ACE_INLINE
  _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq (CORBA::ULong maximum,
    CORBA::ULong length,
    CORBA_OperationDescription *data,
    CORBA::Boolean release)
  : TAO_Unbounded_Base_Sequence (maximum, length, data, release)
  {
  }
  
  ACE_INLINE
  _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq (const _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq &rhs)
  // Copy constructor.
    : TAO_Unbounded_Base_Sequence (rhs)
  {
    CORBA_OperationDescription *tmp1 = _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::allocbuf (this->maximum_);
    CORBA_OperationDescription * const tmp2 = ACE_reinterpret_cast (CORBA_OperationDescription * ACE_CAST_CONST, rhs.buffer_);
    
    for (CORBA::ULong i = 0; i < this->length_; ++i)
      tmp1[i] = tmp2[i];
    
    this->buffer_ = tmp1;
  }
  
  ACE_INLINE _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq &
  _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::operator= (const _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq &rhs)
  // Assignment operator.
  {
    if (this == &rhs)
      return *this;
    
    if (this->release_)
    {
      if (this->maximum_ < rhs.maximum_)
      {
        // free the old buffer
        CORBA_OperationDescription *tmp = ACE_reinterpret_cast (CORBA_OperationDescription *, this->buffer_);
        _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::freebuf (tmp);
        this->buffer_ = _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::allocbuf (rhs.maximum_);
      }
    }
    else
      this->buffer_ = _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::allocbuf (rhs.maximum_);
    
    TAO_Unbounded_Base_Sequence::operator= (rhs);
    
    CORBA_OperationDescription *tmp1 = ACE_reinterpret_cast (CORBA_OperationDescription *, this->buffer_);
    CORBA_OperationDescription * const tmp2 = ACE_reinterpret_cast (CORBA_OperationDescription * ACE_CAST_CONST, rhs.buffer_);
    
    for (CORBA::ULong i = 0; i < this->length_; ++i)
      tmp1[i] = tmp2[i];
    
    return *this;
  }
  
  // = Accessors.
  ACE_INLINE CORBA_OperationDescription &
  _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::operator[] (CORBA::ULong i)
  // operator []
  {
    ACE_ASSERT (i < this->maximum_);
    CORBA_OperationDescription* tmp = ACE_reinterpret_cast(CORBA_OperationDescription*,this->buffer_);
    return tmp[i];
  }
  
  ACE_INLINE const CORBA_OperationDescription &
  _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::operator[] (CORBA::ULong i) const
  // operator []
  {
    ACE_ASSERT (i < this->maximum_);
    CORBA_OperationDescription * const tmp = ACE_reinterpret_cast (CORBA_OperationDescription* ACE_CAST_CONST, this->buffer_);
    return tmp[i];
  }
  
  // Implement the TAO_Base_Sequence methods (see Sequence.h)
  
  ACE_INLINE CORBA_OperationDescription *
  _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::get_buffer (CORBA::Boolean orphan)
  {
    CORBA_OperationDescription *result = 0;
    if (orphan == 0)
    {
      // We retain ownership.
      if (this->buffer_ == 0)
      {
        result = _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::allocbuf (this->length_);
        this->buffer_ = result;
      }
      else
      {
        result = ACE_reinterpret_cast (CORBA_OperationDescription*, this->buffer_);
      }
    }
    else // if (orphan == 1)
    {
      if (this->release_ != 0)
      {
        // We set the state back to default and relinquish
        // ownership.
        result = ACE_reinterpret_cast(CORBA_OperationDescription*,this->buffer_);
        this->maximum_ = 0;
        this->length_ = 0;
        this->buffer_ = 0;
        this->release_ = 0;
      }
    }
    return result;
  }
  
  ACE_INLINE const CORBA_OperationDescription *
  _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::get_buffer (void) const
  {
    return ACE_reinterpret_cast(const CORBA_OperationDescription * ACE_CAST_CONST, this->buffer_);
  }
  
  ACE_INLINE void
  _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::replace (CORBA::ULong max,
  CORBA::ULong length,
  CORBA_OperationDescription *data,
  CORBA::Boolean release)
  {
    this->maximum_ = max;
    this->length_ = length;
    if (this->buffer_ && this->release_ == 1)
    {
      CORBA_OperationDescription *tmp = ACE_reinterpret_cast(CORBA_OperationDescription*,this->buffer_);
      _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::freebuf (tmp);
    }
    this->buffer_ = data;
    this->release_ = release;
  }
  
#endif /* end #if !defined */


#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 

#if !defined (_CORBA_OPDESCRIPTIONSEQ_CI_)
#define _CORBA_OPDESCRIPTIONSEQ_CI_

// *************************************************************
// Inline operations for class CORBA_OpDescriptionSeq_var
// *************************************************************

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

ACE_INLINE
CORBA_OpDescriptionSeq_var::CORBA_OpDescriptionSeq_var (CORBA_OpDescriptionSeq *p)
  : ptr_ (p)
{}

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

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

ACE_INLINE CORBA_OpDescriptionSeq_var &
CORBA_OpDescriptionSeq_var::operator= (CORBA_OpDescriptionSeq *p)
{
  delete this->ptr_;
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE const CORBA_OpDescriptionSeq *
CORBA_OpDescriptionSeq_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_OpDescriptionSeq *
CORBA_OpDescriptionSeq_var::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE 
CORBA_OpDescriptionSeq_var::operator const CORBA_OpDescriptionSeq &() const // cast
{
  return *this->ptr_;
}

ACE_INLINE 
CORBA_OpDescriptionSeq_var::operator CORBA_OpDescriptionSeq &() // cast 
{
  return *this->ptr_;
}

ACE_INLINE 
CORBA_OpDescriptionSeq_var::operator CORBA_OpDescriptionSeq &() const// cast 
{
  return *this->ptr_;
}

ACE_INLINE CORBA_OperationDescription &
CORBA_OpDescriptionSeq_var::operator[] (CORBA::ULong index)
{
  return this->ptr_->operator[] (index);
}

ACE_INLINE const CORBA_OpDescriptionSeq &
CORBA_OpDescriptionSeq_var::in (void) const
{
  return *this->ptr_;
}

ACE_INLINE CORBA_OpDescriptionSeq &
CORBA_OpDescriptionSeq_var::inout (void)
{
  return *this->ptr_;
}

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

ACE_INLINE CORBA_OpDescriptionSeq *
CORBA_OpDescriptionSeq_var::_retn (void)
{
  CORBA_OpDescriptionSeq *tmp = this->ptr_;
  this->ptr_ = 0;
  return tmp;
}

ACE_INLINE CORBA_OpDescriptionSeq *
CORBA_OpDescriptionSeq_var::ptr (void) const
{
  return this->ptr_;
}

// *************************************************************
// Inline operations for class CORBA_OpDescriptionSeq_out
// *************************************************************

ACE_INLINE
CORBA_OpDescriptionSeq_out::CORBA_OpDescriptionSeq_out (CORBA_OpDescriptionSeq *&p)
  : ptr_ (p)
{
  this->ptr_ = 0;
}

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

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

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

ACE_INLINE CORBA_OpDescriptionSeq_out &
CORBA_OpDescriptionSeq_out::operator= (CORBA_OpDescriptionSeq *p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE 
CORBA_OpDescriptionSeq_out::operator CORBA_OpDescriptionSeq *&() // cast
{
  return this->ptr_;
}

ACE_INLINE CORBA_OpDescriptionSeq *&
CORBA_OpDescriptionSeq_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE CORBA_OpDescriptionSeq *
CORBA_OpDescriptionSeq_out::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE CORBA_OperationDescription &
CORBA_OpDescriptionSeq_out::operator[] (CORBA::ULong index)
{
  return this->ptr_->operator[] (index);
}


#endif /* end #if !defined */


#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
  
#if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_ATTRDESCRIPTIONSEQ_CI_)
#define __TAO_UNBOUNDED_SEQUENCE_CORBA_ATTRDESCRIPTIONSEQ_CI_

  // = Static operations.
  ACE_INLINE CORBA_AttributeDescription *
  _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::allocbuf (CORBA::ULong size)
  // Allocate storage for the sequence.
  {
    CORBA_AttributeDescription *retval = 0;
    ACE_NEW_RETURN (retval,
                    CORBA_AttributeDescription[size],
		    0);
    return retval;
  }
  
  ACE_INLINE void _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::freebuf (CORBA_AttributeDescription *buffer)
  // Free the sequence.
  {
    delete [] buffer;
  }
  
  ACE_INLINE
  _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq (void) // Default constructor.
  {
  }
  
  ACE_INLINE
  _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq (CORBA::ULong maximum) // Constructor using a maximum length value.
    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::allocbuf (maximum))
  {
  }
  
  ACE_INLINE
  _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq (CORBA::ULong maximum,
    CORBA::ULong length,
    CORBA_AttributeDescription *data,
    CORBA::Boolean release)
  : TAO_Unbounded_Base_Sequence (maximum, length, data, release)
  {
  }
  
  ACE_INLINE
  _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq (const _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq &rhs)
  // Copy constructor.
    : TAO_Unbounded_Base_Sequence (rhs)
  {
    CORBA_AttributeDescription *tmp1 = _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::allocbuf (this->maximum_);
    CORBA_AttributeDescription * const tmp2 = ACE_reinterpret_cast (CORBA_AttributeDescription * ACE_CAST_CONST, rhs.buffer_);
    
    for (CORBA::ULong i = 0; i < this->length_; ++i)
      tmp1[i] = tmp2[i];
    
    this->buffer_ = tmp1;
  }
  
  ACE_INLINE _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq &
  _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::operator= (const _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq &rhs)
  // Assignment operator.
  {
    if (this == &rhs)
      return *this;
    
    if (this->release_)
    {
      if (this->maximum_ < rhs.maximum_)
      {
        // free the old buffer
        CORBA_AttributeDescription *tmp = ACE_reinterpret_cast (CORBA_AttributeDescription *, this->buffer_);
        _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::freebuf (tmp);
        this->buffer_ = _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::allocbuf (rhs.maximum_);
      }
    }
    else
      this->buffer_ = _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::allocbuf (rhs.maximum_);
    
    TAO_Unbounded_Base_Sequence::operator= (rhs);
    
    CORBA_AttributeDescription *tmp1 = ACE_reinterpret_cast (CORBA_AttributeDescription *, this->buffer_);
    CORBA_AttributeDescription * const tmp2 = ACE_reinterpret_cast (CORBA_AttributeDescription * ACE_CAST_CONST, rhs.buffer_);
    
    for (CORBA::ULong i = 0; i < this->length_; ++i)
      tmp1[i] = tmp2[i];
    
    return *this;
  }
  
  // = Accessors.
  ACE_INLINE CORBA_AttributeDescription &
  _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::operator[] (CORBA::ULong i)
  // operator []
  {
    ACE_ASSERT (i < this->maximum_);
    CORBA_AttributeDescription* tmp = ACE_reinterpret_cast(CORBA_AttributeDescription*,this->buffer_);
    return tmp[i];
  }
  
  ACE_INLINE const CORBA_AttributeDescription &
  _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::operator[] (CORBA::ULong i) const
  // operator []
  {
    ACE_ASSERT (i < this->maximum_);
    CORBA_AttributeDescription * const tmp = ACE_reinterpret_cast (CORBA_AttributeDescription* ACE_CAST_CONST, this->buffer_);
    return tmp[i];
  }
  
  // Implement the TAO_Base_Sequence methods (see Sequence.h)
  
  ACE_INLINE CORBA_AttributeDescription *
  _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::get_buffer (CORBA::Boolean orphan)
  {
    CORBA_AttributeDescription *result = 0;
    if (orphan == 0)
    {
      // We retain ownership.
      if (this->buffer_ == 0)
      {
        result = _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::allocbuf (this->length_);
        this->buffer_ = result;
      }
      else
      {
        result = ACE_reinterpret_cast (CORBA_AttributeDescription*, this->buffer_);
      }
    }
    else // if (orphan == 1)
    {
      if (this->release_ != 0)
      {
        // We set the state back to default and relinquish
        // ownership.
        result = ACE_reinterpret_cast(CORBA_AttributeDescription*,this->buffer_);
        this->maximum_ = 0;
        this->length_ = 0;
        this->buffer_ = 0;
        this->release_ = 0;
      }
    }
    return result;
  }
  
  ACE_INLINE const CORBA_AttributeDescription *
  _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::get_buffer (void) const
  {
    return ACE_reinterpret_cast(const CORBA_AttributeDescription * ACE_CAST_CONST, this->buffer_);
  }
  
  ACE_INLINE void
  _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::replace (CORBA::ULong max,
  CORBA::ULong length,
  CORBA_AttributeDescription *data,
  CORBA::Boolean release)
  {
    this->maximum_ = max;
    this->length_ = length;
    if (this->buffer_ && this->release_ == 1)
    {
      CORBA_AttributeDescription *tmp = ACE_reinterpret_cast(CORBA_AttributeDescription*,this->buffer_);
      _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::freebuf (tmp);
    }
    this->buffer_ = data;
    this->release_ = release;
  }
  
#endif /* end #if !defined */


#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 

#if !defined (_CORBA_ATTRDESCRIPTIONSEQ_CI_)
#define _CORBA_ATTRDESCRIPTIONSEQ_CI_

// *************************************************************
// Inline operations for class CORBA_AttrDescriptionSeq_var
// *************************************************************

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

ACE_INLINE
CORBA_AttrDescriptionSeq_var::CORBA_AttrDescriptionSeq_var (CORBA_AttrDescriptionSeq *p)
  : ptr_ (p)
{}

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

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

ACE_INLINE CORBA_AttrDescriptionSeq_var &
CORBA_AttrDescriptionSeq_var::operator= (CORBA_AttrDescriptionSeq *p)
{
  delete this->ptr_;
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE const CORBA_AttrDescriptionSeq *
CORBA_AttrDescriptionSeq_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_AttrDescriptionSeq *
CORBA_AttrDescriptionSeq_var::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE 
CORBA_AttrDescriptionSeq_var::operator const CORBA_AttrDescriptionSeq &() const // cast
{
  return *this->ptr_;
}

ACE_INLINE 
CORBA_AttrDescriptionSeq_var::operator CORBA_AttrDescriptionSeq &() // cast 
{
  return *this->ptr_;
}

ACE_INLINE 
CORBA_AttrDescriptionSeq_var::operator CORBA_AttrDescriptionSeq &() const// cast 
{
  return *this->ptr_;
}

ACE_INLINE CORBA_AttributeDescription &
CORBA_AttrDescriptionSeq_var::operator[] (CORBA::ULong index)
{
  return this->ptr_->operator[] (index);
}

ACE_INLINE const CORBA_AttrDescriptionSeq &
CORBA_AttrDescriptionSeq_var::in (void) const
{
  return *this->ptr_;
}

ACE_INLINE CORBA_AttrDescriptionSeq &
CORBA_AttrDescriptionSeq_var::inout (void)
{
  return *this->ptr_;
}

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

ACE_INLINE CORBA_AttrDescriptionSeq *
CORBA_AttrDescriptionSeq_var::_retn (void)
{
  CORBA_AttrDescriptionSeq *tmp = this->ptr_;
  this->ptr_ = 0;
  return tmp;
}

ACE_INLINE CORBA_AttrDescriptionSeq *
CORBA_AttrDescriptionSeq_var::ptr (void) const
{
  return this->ptr_;
}

// *************************************************************
// Inline operations for class CORBA_AttrDescriptionSeq_out
// *************************************************************

ACE_INLINE
CORBA_AttrDescriptionSeq_out::CORBA_AttrDescriptionSeq_out (CORBA_AttrDescriptionSeq *&p)
  : ptr_ (p)
{
  this->ptr_ = 0;
}

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

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

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

ACE_INLINE CORBA_AttrDescriptionSeq_out &
CORBA_AttrDescriptionSeq_out::operator= (CORBA_AttrDescriptionSeq *p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE 
CORBA_AttrDescriptionSeq_out::operator CORBA_AttrDescriptionSeq *&() // cast
{
  return this->ptr_;
}

ACE_INLINE CORBA_AttrDescriptionSeq *&
CORBA_AttrDescriptionSeq_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE CORBA_AttrDescriptionSeq *
CORBA_AttrDescriptionSeq_out::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE CORBA_AttributeDescription &
CORBA_AttrDescriptionSeq_out::operator[] (CORBA::ULong index)
{
  return this->ptr_->operator[] (index);
}


#endif /* end #if !defined */

ACE_INLINE
CORBA_InterfaceDef::CORBA_InterfaceDef (void) // default constructor
{}

ACE_INLINE
CORBA_InterfaceDef::CORBA_InterfaceDef (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
  : CORBA_Object (objref, _tao_servant, _tao_collocated)
{}

ACE_INLINE
CORBA_InterfaceDef::~CORBA_InterfaceDef (void) // destructor
{}


#if !defined (_CORBA_INTERFACEDEF___VAR_CI_)
#define _CORBA_INTERFACEDEF___VAR_CI_

// *************************************************************
// Inline operations for class CORBA_InterfaceDef_var
// *************************************************************

ACE_INLINE
CORBA_InterfaceDef_var::CORBA_InterfaceDef_var (void) // default constructor
  : ptr_ (CORBA_InterfaceDef::_nil ())
{}

ACE_INLINE
CORBA_InterfaceDef_var::CORBA_InterfaceDef_var (CORBA_InterfaceDef_ptr p)
  : ptr_ (p)
{}

ACE_INLINE CORBA_InterfaceDef_ptr 
CORBA_InterfaceDef_var::ptr (void) const
{
  return this->ptr_;
}

ACE_INLINE
CORBA_InterfaceDef_var::CORBA_InterfaceDef_var (const CORBA_InterfaceDef_var &p) // copy constructor
  : ptr_ (CORBA_InterfaceDef::_duplicate (p.ptr ()))
{}

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

ACE_INLINE CORBA_InterfaceDef_var &
CORBA_InterfaceDef_var::operator= (CORBA_InterfaceDef_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE 
CORBA_InterfaceDef_var::operator const CORBA_InterfaceDef_ptr &() const // cast
{
  return this->ptr_;
}

ACE_INLINE 
CORBA_InterfaceDef_var::operator CORBA_InterfaceDef_ptr &() // cast 
{
  return this->ptr_;
}

ACE_INLINE CORBA_InterfaceDef_ptr 
CORBA_InterfaceDef_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_InterfaceDef_ptr
CORBA_InterfaceDef_var::in (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_InterfaceDef_ptr &
CORBA_InterfaceDef_var::inout (void)
{
  return this->ptr_;
}

ACE_INLINE CORBA_InterfaceDef_ptr &
CORBA_InterfaceDef_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = CORBA_InterfaceDef::_nil ();
  return this->ptr_;
}

ACE_INLINE CORBA_InterfaceDef_ptr 
CORBA_InterfaceDef_var::_retn (void)
{
  // yield ownership of managed obj reference
  CORBA_InterfaceDef_ptr val = this->ptr_;
  this->ptr_ = CORBA_InterfaceDef::_nil ();
  return val;
}


#endif /* end #if !defined */


#if !defined (_CORBA_INTERFACEDEF___OUT_CI_)
#define _CORBA_INTERFACEDEF___OUT_CI_

// *************************************************************
// Inline operations for class CORBA_InterfaceDef_out
// *************************************************************

ACE_INLINE
CORBA_InterfaceDef_out::CORBA_InterfaceDef_out (CORBA_InterfaceDef_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = CORBA_InterfaceDef::_nil ();
}

ACE_INLINE
CORBA_InterfaceDef_out::CORBA_InterfaceDef_out (CORBA_InterfaceDef_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = CORBA_InterfaceDef::_nil ();
}

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

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

ACE_INLINE CORBA_InterfaceDef_out &
CORBA_InterfaceDef_out::operator= (const CORBA_InterfaceDef_var &p)
{
  this->ptr_ = CORBA_InterfaceDef::_duplicate (p.ptr ());
  return *this;
}

ACE_INLINE CORBA_InterfaceDef_out &
CORBA_InterfaceDef_out::operator= (CORBA_InterfaceDef_ptr p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE 
CORBA_InterfaceDef_out::operator CORBA_InterfaceDef_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE CORBA_InterfaceDef_ptr &
CORBA_InterfaceDef_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE CORBA_InterfaceDef_ptr 
CORBA_InterfaceDef_out::operator-> (void)
{
  return this->ptr_;
}


#endif /* end #if !defined */

// *************************************************************
// Inline operations for class CORBA_InterfaceDef::FullInterfaceDescription_var
// *************************************************************

ACE_INLINE
CORBA_InterfaceDef::FullInterfaceDescription_var::FullInterfaceDescription_var (void) // default constructor
  : ptr_ (0)
{}

ACE_INLINE
CORBA_InterfaceDef::FullInterfaceDescription_var::FullInterfaceDescription_var (CORBA_InterfaceDef::FullInterfaceDescription *p)
  : ptr_ (p)
{}

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

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

ACE_INLINE CORBA_InterfaceDef::FullInterfaceDescription_var &
CORBA_InterfaceDef::FullInterfaceDescription_var::operator= (CORBA_InterfaceDef::FullInterfaceDescription *p)
{
  delete this->ptr_;
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE const CORBA_InterfaceDef::FullInterfaceDescription *
CORBA_InterfaceDef::FullInterfaceDescription_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_InterfaceDef::FullInterfaceDescription *
CORBA_InterfaceDef::FullInterfaceDescription_var::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE 
CORBA_InterfaceDef::FullInterfaceDescription_var::operator const CORBA_InterfaceDef::FullInterfaceDescription &() const // cast
{
  return *this->ptr_;
}

ACE_INLINE 
CORBA_InterfaceDef::FullInterfaceDescription_var::operator CORBA_InterfaceDef::FullInterfaceDescription &() // cast 
{
  return *this->ptr_;
}

ACE_INLINE 
CORBA_InterfaceDef::FullInterfaceDescription_var::operator CORBA_InterfaceDef::FullInterfaceDescription &() const// cast 
{
  return *this->ptr_;
}

ACE_INLINE const CORBA_InterfaceDef::FullInterfaceDescription &
CORBA_InterfaceDef::FullInterfaceDescription_var::in (void) const
{
  return *this->ptr_;
}

ACE_INLINE CORBA_InterfaceDef::FullInterfaceDescription &
CORBA_InterfaceDef::FullInterfaceDescription_var::inout (void)
{
  return *this->ptr_;
}

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

ACE_INLINE CORBA_InterfaceDef::FullInterfaceDescription *
CORBA_InterfaceDef::FullInterfaceDescription_var::_retn (void)
{
  CORBA_InterfaceDef::FullInterfaceDescription *tmp = this->ptr_;
  this->ptr_ = 0;
  return tmp;
}

ACE_INLINE CORBA_InterfaceDef::FullInterfaceDescription *
CORBA_InterfaceDef::FullInterfaceDescription_var::ptr (void) const
{
  return this->ptr_;
}

// *************************************************************
// Inline operations for class CORBA_InterfaceDef::FullInterfaceDescription_out
// *************************************************************

ACE_INLINE
CORBA_InterfaceDef::FullInterfaceDescription_out::FullInterfaceDescription_out (CORBA_InterfaceDef::FullInterfaceDescription *&p)
  : ptr_ (p)
{
  this->ptr_ = 0;
}

ACE_INLINE
CORBA_InterfaceDef::FullInterfaceDescription_out::FullInterfaceDescription_out (CORBA_InterfaceDef::FullInterfaceDescription_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  delete this->ptr_;
  this->ptr_ = 0;
}

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

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

ACE_INLINE CORBA_InterfaceDef::FullInterfaceDescription_out &
CORBA_InterfaceDef::FullInterfaceDescription_out::operator= (CORBA_InterfaceDef::FullInterfaceDescription *p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE 
CORBA_InterfaceDef::FullInterfaceDescription_out::operator CORBA_InterfaceDef::FullInterfaceDescription *&() // cast
{
  return this->ptr_;
}

ACE_INLINE CORBA_InterfaceDef::FullInterfaceDescription *&
CORBA_InterfaceDef::FullInterfaceDescription_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE CORBA_InterfaceDef::FullInterfaceDescription *
CORBA_InterfaceDef::FullInterfaceDescription_out::operator-> (void)
{
  return this->ptr_;
}

// *************************************************************
// Inline operations for class CORBA_InterfaceDescription_var
// *************************************************************

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

ACE_INLINE
CORBA_InterfaceDescription_var::CORBA_InterfaceDescription_var (CORBA_InterfaceDescription *p)
  : ptr_ (p)
{}

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

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

ACE_INLINE CORBA_InterfaceDescription_var &
CORBA_InterfaceDescription_var::operator= (CORBA_InterfaceDescription *p)
{
  delete this->ptr_;
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE const CORBA_InterfaceDescription *
CORBA_InterfaceDescription_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_InterfaceDescription *
CORBA_InterfaceDescription_var::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE 
CORBA_InterfaceDescription_var::operator const CORBA_InterfaceDescription &() const // cast
{
  return *this->ptr_;
}

ACE_INLINE 
CORBA_InterfaceDescription_var::operator CORBA_InterfaceDescription &() // cast 
{
  return *this->ptr_;
}

ACE_INLINE 
CORBA_InterfaceDescription_var::operator CORBA_InterfaceDescription &() const// cast 
{
  return *this->ptr_;
}

ACE_INLINE const CORBA_InterfaceDescription &
CORBA_InterfaceDescription_var::in (void) const
{
  return *this->ptr_;
}

ACE_INLINE CORBA_InterfaceDescription &
CORBA_InterfaceDescription_var::inout (void)
{
  return *this->ptr_;
}

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

ACE_INLINE CORBA_InterfaceDescription *
CORBA_InterfaceDescription_var::_retn (void)
{
  CORBA_InterfaceDescription *tmp = this->ptr_;
  this->ptr_ = 0;
  return tmp;
}

ACE_INLINE CORBA_InterfaceDescription *
CORBA_InterfaceDescription_var::ptr (void) const
{
  return this->ptr_;
}

// *************************************************************
// Inline operations for class CORBA_InterfaceDescription_out
// *************************************************************

ACE_INLINE
CORBA_InterfaceDescription_out::CORBA_InterfaceDescription_out (CORBA_InterfaceDescription *&p)
  : ptr_ (p)
{
  this->ptr_ = 0;
}

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

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

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

ACE_INLINE CORBA_InterfaceDescription_out &
CORBA_InterfaceDescription_out::operator= (CORBA_InterfaceDescription *p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE 
CORBA_InterfaceDescription_out::operator CORBA_InterfaceDescription *&() // cast
{
  return this->ptr_;
}

ACE_INLINE CORBA_InterfaceDescription *&
CORBA_InterfaceDescription_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE CORBA_InterfaceDescription *
CORBA_InterfaceDescription_out::operator-> (void)
{
  return this->ptr_;
}

// *************************************************************
// Inline operations for class CORBA_ValueMember_var
// *************************************************************

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

ACE_INLINE
CORBA_ValueMember_var::CORBA_ValueMember_var (CORBA_ValueMember *p)
  : ptr_ (p)
{}

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

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

ACE_INLINE CORBA_ValueMember_var &
CORBA_ValueMember_var::operator= (CORBA_ValueMember *p)
{
  delete this->ptr_;
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE const CORBA_ValueMember *
CORBA_ValueMember_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_ValueMember *
CORBA_ValueMember_var::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE 
CORBA_ValueMember_var::operator const CORBA_ValueMember &() const // cast
{
  return *this->ptr_;
}

ACE_INLINE 
CORBA_ValueMember_var::operator CORBA_ValueMember &() // cast 
{
  return *this->ptr_;
}

ACE_INLINE 
CORBA_ValueMember_var::operator CORBA_ValueMember &() const// cast 
{
  return *this->ptr_;
}

ACE_INLINE const CORBA_ValueMember &
CORBA_ValueMember_var::in (void) const
{
  return *this->ptr_;
}

ACE_INLINE CORBA_ValueMember &
CORBA_ValueMember_var::inout (void)
{
  return *this->ptr_;
}

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

ACE_INLINE CORBA_ValueMember *
CORBA_ValueMember_var::_retn (void)
{
  CORBA_ValueMember *tmp = this->ptr_;
  this->ptr_ = 0;
  return tmp;
}

ACE_INLINE CORBA_ValueMember *
CORBA_ValueMember_var::ptr (void) const
{
  return this->ptr_;
}

// *************************************************************
// Inline operations for class CORBA_ValueMember_out
// *************************************************************

ACE_INLINE
CORBA_ValueMember_out::CORBA_ValueMember_out (CORBA_ValueMember *&p)
  : ptr_ (p)
{
  this->ptr_ = 0;
}

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

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

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

ACE_INLINE CORBA_ValueMember_out &
CORBA_ValueMember_out::operator= (CORBA_ValueMember *p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE 
CORBA_ValueMember_out::operator CORBA_ValueMember *&() // cast
{
  return this->ptr_;
}

ACE_INLINE CORBA_ValueMember *&
CORBA_ValueMember_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE CORBA_ValueMember *
CORBA_ValueMember_out::operator-> (void)
{
  return this->ptr_;
}


#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
  
#if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_VALUEMEMBERSEQ_CI_)
#define __TAO_UNBOUNDED_SEQUENCE_CORBA_VALUEMEMBERSEQ_CI_

  // = Static operations.
  ACE_INLINE CORBA_ValueMember *
  _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::allocbuf (CORBA::ULong size)
  // Allocate storage for the sequence.
  {
    CORBA_ValueMember *retval = 0;
    ACE_NEW_RETURN (retval,
                    CORBA_ValueMember[size],
		    0);
    return retval;
  }
  
  ACE_INLINE void _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::freebuf (CORBA_ValueMember *buffer)
  // Free the sequence.
  {
    delete [] buffer;
  }
  
  ACE_INLINE
  _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq (void) // Default constructor.
  {
  }
  
  ACE_INLINE
  _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq (CORBA::ULong maximum) // Constructor using a maximum length value.
    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::allocbuf (maximum))
  {
  }
  
  ACE_INLINE
  _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq (CORBA::ULong maximum,
    CORBA::ULong length,
    CORBA_ValueMember *data,
    CORBA::Boolean release)
  : TAO_Unbounded_Base_Sequence (maximum, length, data, release)
  {
  }
  
  ACE_INLINE
  _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq (const _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq &rhs)
  // Copy constructor.
    : TAO_Unbounded_Base_Sequence (rhs)
  {
    CORBA_ValueMember *tmp1 = _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::allocbuf (this->maximum_);
    CORBA_ValueMember * const tmp2 = ACE_reinterpret_cast (CORBA_ValueMember * ACE_CAST_CONST, rhs.buffer_);
    
    for (CORBA::ULong i = 0; i < this->length_; ++i)
      tmp1[i] = tmp2[i];
    
    this->buffer_ = tmp1;
  }
  
  ACE_INLINE _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq &
  _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::operator= (const _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq &rhs)
  // Assignment operator.
  {
    if (this == &rhs)
      return *this;
    
    if (this->release_)
    {
      if (this->maximum_ < rhs.maximum_)
      {
        // free the old buffer
        CORBA_ValueMember *tmp = ACE_reinterpret_cast (CORBA_ValueMember *, this->buffer_);
        _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::freebuf (tmp);
        this->buffer_ = _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::allocbuf (rhs.maximum_);
      }
    }
    else
      this->buffer_ = _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::allocbuf (rhs.maximum_);
    
    TAO_Unbounded_Base_Sequence::operator= (rhs);
    
    CORBA_ValueMember *tmp1 = ACE_reinterpret_cast (CORBA_ValueMember *, this->buffer_);
    CORBA_ValueMember * const tmp2 = ACE_reinterpret_cast (CORBA_ValueMember * ACE_CAST_CONST, rhs.buffer_);
    
    for (CORBA::ULong i = 0; i < this->length_; ++i)
      tmp1[i] = tmp2[i];
    
    return *this;
  }
  
  // = Accessors.
  ACE_INLINE CORBA_ValueMember &
  _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::operator[] (CORBA::ULong i)
  // operator []
  {
    ACE_ASSERT (i < this->maximum_);
    CORBA_ValueMember* tmp = ACE_reinterpret_cast(CORBA_ValueMember*,this->buffer_);
    return tmp[i];
  }
  
  ACE_INLINE const CORBA_ValueMember &
  _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::operator[] (CORBA::ULong i) const
  // operator []
  {
    ACE_ASSERT (i < this->maximum_);
    CORBA_ValueMember * const tmp = ACE_reinterpret_cast (CORBA_ValueMember* ACE_CAST_CONST, this->buffer_);
    return tmp[i];
  }
  
  // Implement the TAO_Base_Sequence methods (see Sequence.h)
  
  ACE_INLINE CORBA_ValueMember *
  _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::get_buffer (CORBA::Boolean orphan)
  {
    CORBA_ValueMember *result = 0;
    if (orphan == 0)
    {
      // We retain ownership.
      if (this->buffer_ == 0)
      {
        result = _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::allocbuf (this->length_);
        this->buffer_ = result;
      }
      else
      {
        result = ACE_reinterpret_cast (CORBA_ValueMember*, this->buffer_);
      }
    }
    else // if (orphan == 1)
    {
      if (this->release_ != 0)
      {
        // We set the state back to default and relinquish
        // ownership.
        result = ACE_reinterpret_cast(CORBA_ValueMember*,this->buffer_);
        this->maximum_ = 0;
        this->length_ = 0;
        this->buffer_ = 0;
        this->release_ = 0;
      }
    }
    return result;
  }
  
  ACE_INLINE const CORBA_ValueMember *
  _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::get_buffer (void) const
  {
    return ACE_reinterpret_cast(const CORBA_ValueMember * ACE_CAST_CONST, this->buffer_);
  }
  
  ACE_INLINE void
  _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::replace (CORBA::ULong max,
  CORBA::ULong length,
  CORBA_ValueMember *data,
  CORBA::Boolean release)
  {
    this->maximum_ = max;
    this->length_ = length;
    if (this->buffer_ && this->release_ == 1)
    {
      CORBA_ValueMember *tmp = ACE_reinterpret_cast(CORBA_ValueMember*,this->buffer_);
      _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::freebuf (tmp);
    }
    this->buffer_ = data;
    this->release_ = release;
  }
  
#endif /* end #if !defined */


#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 

#if !defined (_CORBA_VALUEMEMBERSEQ_CI_)
#define _CORBA_VALUEMEMBERSEQ_CI_

// *************************************************************
// Inline operations for class CORBA_ValueMemberSeq_var
// *************************************************************

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

ACE_INLINE
CORBA_ValueMemberSeq_var::CORBA_ValueMemberSeq_var (CORBA_ValueMemberSeq *p)
  : ptr_ (p)
{}

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

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

ACE_INLINE CORBA_ValueMemberSeq_var &
CORBA_ValueMemberSeq_var::operator= (CORBA_ValueMemberSeq *p)
{
  delete this->ptr_;
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE const CORBA_ValueMemberSeq *
CORBA_ValueMemberSeq_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_ValueMemberSeq *
CORBA_ValueMemberSeq_var::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE 
CORBA_ValueMemberSeq_var::operator const CORBA_ValueMemberSeq &() const // cast
{
  return *this->ptr_;
}

ACE_INLINE 
CORBA_ValueMemberSeq_var::operator CORBA_ValueMemberSeq &() // cast 
{
  return *this->ptr_;
}

ACE_INLINE 
CORBA_ValueMemberSeq_var::operator CORBA_ValueMemberSeq &() const// cast 
{
  return *this->ptr_;
}

ACE_INLINE CORBA_ValueMember &
CORBA_ValueMemberSeq_var::operator[] (CORBA::ULong index)
{
  return this->ptr_->operator[] (index);
}

ACE_INLINE const CORBA_ValueMemberSeq &
CORBA_ValueMemberSeq_var::in (void) const
{
  return *this->ptr_;
}

ACE_INLINE CORBA_ValueMemberSeq &
CORBA_ValueMemberSeq_var::inout (void)
{
  return *this->ptr_;
}

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

ACE_INLINE CORBA_ValueMemberSeq *
CORBA_ValueMemberSeq_var::_retn (void)
{
  CORBA_ValueMemberSeq *tmp = this->ptr_;
  this->ptr_ = 0;
  return tmp;
}

ACE_INLINE CORBA_ValueMemberSeq *
CORBA_ValueMemberSeq_var::ptr (void) const
{
  return this->ptr_;
}

// *************************************************************
// Inline operations for class CORBA_ValueMemberSeq_out
// *************************************************************

ACE_INLINE
CORBA_ValueMemberSeq_out::CORBA_ValueMemberSeq_out (CORBA_ValueMemberSeq *&p)
  : ptr_ (p)
{
  this->ptr_ = 0;
}

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

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

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

ACE_INLINE CORBA_ValueMemberSeq_out &
CORBA_ValueMemberSeq_out::operator= (CORBA_ValueMemberSeq *p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE 
CORBA_ValueMemberSeq_out::operator CORBA_ValueMemberSeq *&() // cast
{
  return this->ptr_;
}

ACE_INLINE CORBA_ValueMemberSeq *&
CORBA_ValueMemberSeq_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE CORBA_ValueMemberSeq *
CORBA_ValueMemberSeq_out::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE CORBA_ValueMember &
CORBA_ValueMemberSeq_out::operator[] (CORBA::ULong index)
{
  return this->ptr_->operator[] (index);
}


#endif /* end #if !defined */

ACE_INLINE
CORBA_ValueMemberDef::CORBA_ValueMemberDef (void) // default constructor
{}

ACE_INLINE
CORBA_ValueMemberDef::CORBA_ValueMemberDef (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
  : CORBA_Object (objref, _tao_servant, _tao_collocated)
{}

ACE_INLINE
CORBA_ValueMemberDef::~CORBA_ValueMemberDef (void) // destructor
{}


#if !defined (_CORBA_VALUEMEMBERDEF___VAR_CI_)
#define _CORBA_VALUEMEMBERDEF___VAR_CI_

// *************************************************************
// Inline operations for class CORBA_ValueMemberDef_var
// *************************************************************

ACE_INLINE
CORBA_ValueMemberDef_var::CORBA_ValueMemberDef_var (void) // default constructor
  : ptr_ (CORBA_ValueMemberDef::_nil ())
{}

ACE_INLINE
CORBA_ValueMemberDef_var::CORBA_ValueMemberDef_var (CORBA_ValueMemberDef_ptr p)
  : ptr_ (p)
{}

ACE_INLINE CORBA_ValueMemberDef_ptr 
CORBA_ValueMemberDef_var::ptr (void) const
{
  return this->ptr_;
}

ACE_INLINE
CORBA_ValueMemberDef_var::CORBA_ValueMemberDef_var (const CORBA_ValueMemberDef_var &p) // copy constructor
  : ptr_ (CORBA_ValueMemberDef::_duplicate (p.ptr ()))
{}

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

ACE_INLINE CORBA_ValueMemberDef_var &
CORBA_ValueMemberDef_var::operator= (CORBA_ValueMemberDef_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE 
CORBA_ValueMemberDef_var::operator const CORBA_ValueMemberDef_ptr &() const // cast
{
  return this->ptr_;
}

ACE_INLINE 
CORBA_ValueMemberDef_var::operator CORBA_ValueMemberDef_ptr &() // cast 
{
  return this->ptr_;
}

ACE_INLINE CORBA_ValueMemberDef_ptr 
CORBA_ValueMemberDef_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_ValueMemberDef_ptr
CORBA_ValueMemberDef_var::in (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_ValueMemberDef_ptr &
CORBA_ValueMemberDef_var::inout (void)
{
  return this->ptr_;
}

ACE_INLINE CORBA_ValueMemberDef_ptr &
CORBA_ValueMemberDef_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = CORBA_ValueMemberDef::_nil ();
  return this->ptr_;
}

ACE_INLINE CORBA_ValueMemberDef_ptr 
CORBA_ValueMemberDef_var::_retn (void)
{
  // yield ownership of managed obj reference
  CORBA_ValueMemberDef_ptr val = this->ptr_;
  this->ptr_ = CORBA_ValueMemberDef::_nil ();
  return val;
}


#endif /* end #if !defined */


#if !defined (_CORBA_VALUEMEMBERDEF___OUT_CI_)
#define _CORBA_VALUEMEMBERDEF___OUT_CI_

// *************************************************************
// Inline operations for class CORBA_ValueMemberDef_out
// *************************************************************

ACE_INLINE
CORBA_ValueMemberDef_out::CORBA_ValueMemberDef_out (CORBA_ValueMemberDef_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = CORBA_ValueMemberDef::_nil ();
}

ACE_INLINE
CORBA_ValueMemberDef_out::CORBA_ValueMemberDef_out (CORBA_ValueMemberDef_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = CORBA_ValueMemberDef::_nil ();
}

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

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

ACE_INLINE CORBA_ValueMemberDef_out &
CORBA_ValueMemberDef_out::operator= (const CORBA_ValueMemberDef_var &p)
{
  this->ptr_ = CORBA_ValueMemberDef::_duplicate (p.ptr ());
  return *this;
}

ACE_INLINE CORBA_ValueMemberDef_out &
CORBA_ValueMemberDef_out::operator= (CORBA_ValueMemberDef_ptr p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE 
CORBA_ValueMemberDef_out::operator CORBA_ValueMemberDef_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE CORBA_ValueMemberDef_ptr &
CORBA_ValueMemberDef_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE CORBA_ValueMemberDef_ptr 
CORBA_ValueMemberDef_out::operator-> (void)
{
  return this->ptr_;
}


#endif /* end #if !defined */

ACE_INLINE
CORBA_ValueDef::CORBA_ValueDef (void) // default constructor
{}

ACE_INLINE
CORBA_ValueDef::CORBA_ValueDef (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
  : CORBA_Object (objref, _tao_servant, _tao_collocated)
{}

ACE_INLINE
CORBA_ValueDef::~CORBA_ValueDef (void) // destructor
{}


#if !defined (_CORBA_VALUEDEF___VAR_CI_)
#define _CORBA_VALUEDEF___VAR_CI_

// *************************************************************
// Inline operations for class CORBA_ValueDef_var
// *************************************************************

ACE_INLINE
CORBA_ValueDef_var::CORBA_ValueDef_var (void) // default constructor
  : ptr_ (CORBA_ValueDef::_nil ())
{}

ACE_INLINE
CORBA_ValueDef_var::CORBA_ValueDef_var (CORBA_ValueDef_ptr p)
  : ptr_ (p)
{}

ACE_INLINE CORBA_ValueDef_ptr 
CORBA_ValueDef_var::ptr (void) const
{
  return this->ptr_;
}

ACE_INLINE
CORBA_ValueDef_var::CORBA_ValueDef_var (const CORBA_ValueDef_var &p) // copy constructor
  : ptr_ (CORBA_ValueDef::_duplicate (p.ptr ()))
{}

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

ACE_INLINE CORBA_ValueDef_var &
CORBA_ValueDef_var::operator= (CORBA_ValueDef_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE 
CORBA_ValueDef_var::operator const CORBA_ValueDef_ptr &() const // cast
{
  return this->ptr_;
}

ACE_INLINE 
CORBA_ValueDef_var::operator CORBA_ValueDef_ptr &() // cast 
{
  return this->ptr_;
}

ACE_INLINE CORBA_ValueDef_ptr 
CORBA_ValueDef_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_ValueDef_ptr
CORBA_ValueDef_var::in (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_ValueDef_ptr &
CORBA_ValueDef_var::inout (void)
{
  return this->ptr_;
}

ACE_INLINE CORBA_ValueDef_ptr &
CORBA_ValueDef_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = CORBA_ValueDef::_nil ();
  return this->ptr_;
}

ACE_INLINE CORBA_ValueDef_ptr 
CORBA_ValueDef_var::_retn (void)
{
  // yield ownership of managed obj reference
  CORBA_ValueDef_ptr val = this->ptr_;
  this->ptr_ = CORBA_ValueDef::_nil ();
  return val;
}


#endif /* end #if !defined */


#if !defined (_CORBA_VALUEDEF___OUT_CI_)
#define _CORBA_VALUEDEF___OUT_CI_

// *************************************************************
// Inline operations for class CORBA_ValueDef_out
// *************************************************************

ACE_INLINE
CORBA_ValueDef_out::CORBA_ValueDef_out (CORBA_ValueDef_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = CORBA_ValueDef::_nil ();
}

ACE_INLINE
CORBA_ValueDef_out::CORBA_ValueDef_out (CORBA_ValueDef_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = CORBA_ValueDef::_nil ();
}

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

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

ACE_INLINE CORBA_ValueDef_out &
CORBA_ValueDef_out::operator= (const CORBA_ValueDef_var &p)
{
  this->ptr_ = CORBA_ValueDef::_duplicate (p.ptr ());
  return *this;
}

ACE_INLINE CORBA_ValueDef_out &
CORBA_ValueDef_out::operator= (CORBA_ValueDef_ptr p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE 
CORBA_ValueDef_out::operator CORBA_ValueDef_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE CORBA_ValueDef_ptr &
CORBA_ValueDef_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE CORBA_ValueDef_ptr 
CORBA_ValueDef_out::operator-> (void)
{
  return this->ptr_;
}


#endif /* end #if !defined */

// *************************************************************
// Inline operations for class CORBA_ValueDef::FullValueDescription_var
// *************************************************************

ACE_INLINE
CORBA_ValueDef::FullValueDescription_var::FullValueDescription_var (void) // default constructor
  : ptr_ (0)
{}

ACE_INLINE
CORBA_ValueDef::FullValueDescription_var::FullValueDescription_var (CORBA_ValueDef::FullValueDescription *p)
  : ptr_ (p)
{}

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

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

ACE_INLINE CORBA_ValueDef::FullValueDescription_var &
CORBA_ValueDef::FullValueDescription_var::operator= (CORBA_ValueDef::FullValueDescription *p)
{
  delete this->ptr_;
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE const CORBA_ValueDef::FullValueDescription *
CORBA_ValueDef::FullValueDescription_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_ValueDef::FullValueDescription *
CORBA_ValueDef::FullValueDescription_var::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE 
CORBA_ValueDef::FullValueDescription_var::operator const CORBA_ValueDef::FullValueDescription &() const // cast
{
  return *this->ptr_;
}

ACE_INLINE 
CORBA_ValueDef::FullValueDescription_var::operator CORBA_ValueDef::FullValueDescription &() // cast 
{
  return *this->ptr_;
}

ACE_INLINE 
CORBA_ValueDef::FullValueDescription_var::operator CORBA_ValueDef::FullValueDescription &() const// cast 
{
  return *this->ptr_;
}

ACE_INLINE const CORBA_ValueDef::FullValueDescription &
CORBA_ValueDef::FullValueDescription_var::in (void) const
{
  return *this->ptr_;
}

ACE_INLINE CORBA_ValueDef::FullValueDescription &
CORBA_ValueDef::FullValueDescription_var::inout (void)
{
  return *this->ptr_;
}

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

ACE_INLINE CORBA_ValueDef::FullValueDescription *
CORBA_ValueDef::FullValueDescription_var::_retn (void)
{
  CORBA_ValueDef::FullValueDescription *tmp = this->ptr_;
  this->ptr_ = 0;
  return tmp;
}

ACE_INLINE CORBA_ValueDef::FullValueDescription *
CORBA_ValueDef::FullValueDescription_var::ptr (void) const
{
  return this->ptr_;
}

// *************************************************************
// Inline operations for class CORBA_ValueDef::FullValueDescription_out
// *************************************************************

ACE_INLINE
CORBA_ValueDef::FullValueDescription_out::FullValueDescription_out (CORBA_ValueDef::FullValueDescription *&p)
  : ptr_ (p)
{
  this->ptr_ = 0;
}

ACE_INLINE
CORBA_ValueDef::FullValueDescription_out::FullValueDescription_out (CORBA_ValueDef::FullValueDescription_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  delete this->ptr_;
  this->ptr_ = 0;
}

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

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

ACE_INLINE CORBA_ValueDef::FullValueDescription_out &
CORBA_ValueDef::FullValueDescription_out::operator= (CORBA_ValueDef::FullValueDescription *p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE 
CORBA_ValueDef::FullValueDescription_out::operator CORBA_ValueDef::FullValueDescription *&() // cast
{
  return this->ptr_;
}

ACE_INLINE CORBA_ValueDef::FullValueDescription *&
CORBA_ValueDef::FullValueDescription_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE CORBA_ValueDef::FullValueDescription *
CORBA_ValueDef::FullValueDescription_out::operator-> (void)
{
  return this->ptr_;
}

// *************************************************************
// Inline operations for class CORBA_ValueDescription_var
// *************************************************************

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

ACE_INLINE
CORBA_ValueDescription_var::CORBA_ValueDescription_var (CORBA_ValueDescription *p)
  : ptr_ (p)
{}

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

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

ACE_INLINE CORBA_ValueDescription_var &
CORBA_ValueDescription_var::operator= (CORBA_ValueDescription *p)
{
  delete this->ptr_;
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE const CORBA_ValueDescription *
CORBA_ValueDescription_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_ValueDescription *
CORBA_ValueDescription_var::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE 
CORBA_ValueDescription_var::operator const CORBA_ValueDescription &() const // cast
{
  return *this->ptr_;
}

ACE_INLINE 
CORBA_ValueDescription_var::operator CORBA_ValueDescription &() // cast 
{
  return *this->ptr_;
}

ACE_INLINE 
CORBA_ValueDescription_var::operator CORBA_ValueDescription &() const// cast 
{
  return *this->ptr_;
}

ACE_INLINE const CORBA_ValueDescription &
CORBA_ValueDescription_var::in (void) const
{
  return *this->ptr_;
}

ACE_INLINE CORBA_ValueDescription &
CORBA_ValueDescription_var::inout (void)
{
  return *this->ptr_;
}

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

ACE_INLINE CORBA_ValueDescription *
CORBA_ValueDescription_var::_retn (void)
{
  CORBA_ValueDescription *tmp = this->ptr_;
  this->ptr_ = 0;
  return tmp;
}

ACE_INLINE CORBA_ValueDescription *
CORBA_ValueDescription_var::ptr (void) const
{
  return this->ptr_;
}

// *************************************************************
// Inline operations for class CORBA_ValueDescription_out
// *************************************************************

ACE_INLINE
CORBA_ValueDescription_out::CORBA_ValueDescription_out (CORBA_ValueDescription *&p)
  : ptr_ (p)
{
  this->ptr_ = 0;
}

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

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

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

ACE_INLINE CORBA_ValueDescription_out &
CORBA_ValueDescription_out::operator= (CORBA_ValueDescription *p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE 
CORBA_ValueDescription_out::operator CORBA_ValueDescription *&() // cast
{
  return this->ptr_;
}

ACE_INLINE CORBA_ValueDescription *&
CORBA_ValueDescription_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE CORBA_ValueDescription *
CORBA_ValueDescription_out::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE
CORBA_ValueBoxDef::CORBA_ValueBoxDef (void) // default constructor
{}

ACE_INLINE
CORBA_ValueBoxDef::CORBA_ValueBoxDef (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
  : CORBA_Object (objref, _tao_servant, _tao_collocated)
{}

ACE_INLINE
CORBA_ValueBoxDef::~CORBA_ValueBoxDef (void) // destructor
{}


#if !defined (_CORBA_VALUEBOXDEF___VAR_CI_)
#define _CORBA_VALUEBOXDEF___VAR_CI_

// *************************************************************
// Inline operations for class CORBA_ValueBoxDef_var
// *************************************************************

ACE_INLINE
CORBA_ValueBoxDef_var::CORBA_ValueBoxDef_var (void) // default constructor
  : ptr_ (CORBA_ValueBoxDef::_nil ())
{}

ACE_INLINE
CORBA_ValueBoxDef_var::CORBA_ValueBoxDef_var (CORBA_ValueBoxDef_ptr p)
  : ptr_ (p)
{}

ACE_INLINE CORBA_ValueBoxDef_ptr 
CORBA_ValueBoxDef_var::ptr (void) const
{
  return this->ptr_;
}

ACE_INLINE
CORBA_ValueBoxDef_var::CORBA_ValueBoxDef_var (const CORBA_ValueBoxDef_var &p) // copy constructor
  : ptr_ (CORBA_ValueBoxDef::_duplicate (p.ptr ()))
{}

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

ACE_INLINE CORBA_ValueBoxDef_var &
CORBA_ValueBoxDef_var::operator= (CORBA_ValueBoxDef_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE 
CORBA_ValueBoxDef_var::operator const CORBA_ValueBoxDef_ptr &() const // cast
{
  return this->ptr_;
}

ACE_INLINE 
CORBA_ValueBoxDef_var::operator CORBA_ValueBoxDef_ptr &() // cast 
{
  return this->ptr_;
}

ACE_INLINE CORBA_ValueBoxDef_ptr 
CORBA_ValueBoxDef_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_ValueBoxDef_ptr
CORBA_ValueBoxDef_var::in (void) const
{
  return this->ptr_;
}

ACE_INLINE CORBA_ValueBoxDef_ptr &
CORBA_ValueBoxDef_var::inout (void)
{
  return this->ptr_;
}

ACE_INLINE CORBA_ValueBoxDef_ptr &
CORBA_ValueBoxDef_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = CORBA_ValueBoxDef::_nil ();
  return this->ptr_;
}

ACE_INLINE CORBA_ValueBoxDef_ptr 
CORBA_ValueBoxDef_var::_retn (void)
{
  // yield ownership of managed obj reference
  CORBA_ValueBoxDef_ptr val = this->ptr_;
  this->ptr_ = CORBA_ValueBoxDef::_nil ();
  return val;
}


#endif /* end #if !defined */


#if !defined (_CORBA_VALUEBOXDEF___OUT_CI_)
#define _CORBA_VALUEBOXDEF___OUT_CI_

// *************************************************************
// Inline operations for class CORBA_ValueBoxDef_out
// *************************************************************

ACE_INLINE
CORBA_ValueBoxDef_out::CORBA_ValueBoxDef_out (CORBA_ValueBoxDef_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = CORBA_ValueBoxDef::_nil ();
}

ACE_INLINE
CORBA_ValueBoxDef_out::CORBA_ValueBoxDef_out (CORBA_ValueBoxDef_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = CORBA_ValueBoxDef::_nil ();
}

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

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

ACE_INLINE CORBA_ValueBoxDef_out &
CORBA_ValueBoxDef_out::operator= (const CORBA_ValueBoxDef_var &p)
{
  this->ptr_ = CORBA_ValueBoxDef::_duplicate (p.ptr ());
  return *this;
}

ACE_INLINE CORBA_ValueBoxDef_out &
CORBA_ValueBoxDef_out::operator= (CORBA_ValueBoxDef_ptr p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE 
CORBA_ValueBoxDef_out::operator CORBA_ValueBoxDef_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE CORBA_ValueBoxDef_ptr &
CORBA_ValueBoxDef_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE CORBA_ValueBoxDef_ptr 
CORBA_ValueBoxDef_out::operator-> (void)
{
  return this->ptr_;
}


#endif /* end #if !defined */

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

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

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

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

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

ACE_INLINE CORBA::Boolean
operator<< (
    TAO_OutputCDR &,
    const CORBA_Contained_ptr
  );
ACE_INLINE CORBA::Boolean
operator>> (
    TAO_InputCDR &,
    CORBA_Contained_ptr &
  );
ACE_INLINE CORBA::Boolean
operator<< (
    TAO_OutputCDR &,
    const CORBA_Repository_ptr
  );
ACE_INLINE CORBA::Boolean
operator>> (
    TAO_InputCDR &,
    CORBA_Repository_ptr &
  );
ACE_INLINE CORBA::Boolean
operator<< (
    TAO_OutputCDR &,
    const CORBA_Container_ptr
  );
ACE_INLINE CORBA::Boolean
operator>> (
    TAO_InputCDR &,
    CORBA_Container_ptr &
  );
ACE_INLINE CORBA::Boolean
operator<< (
    TAO_OutputCDR &,
    const CORBA_Contained_ptr
  );
ACE_INLINE CORBA::Boolean
operator>> (
    TAO_InputCDR &,
    CORBA_Contained_ptr &
  );

ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA_Contained::Description &_tao_aggregate)
{
  if (
    (strm << _tao_aggregate.kind) &&
    (strm << _tao_aggregate.value)
  )
    return 1;
  else
    return 0;
  
}

ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA_Contained::Description &_tao_aggregate)
{
  if (
    (strm >> _tao_aggregate.kind) &&
    (strm >> _tao_aggregate.value)
  )
    return 1;
  else
    return 0;
  
}

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

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

ACE_INLINE CORBA::Boolean
operator<< (
    TAO_OutputCDR &,
    const CORBA_ModuleDef_ptr
  );
ACE_INLINE CORBA::Boolean
operator>> (
    TAO_InputCDR &,
    CORBA_ModuleDef_ptr &
  );
ACE_INLINE CORBA::Boolean
operator<< (
    TAO_OutputCDR &,
    const CORBA_ConstantDef_ptr
  );
ACE_INLINE CORBA::Boolean
operator>> (
    TAO_InputCDR &,
    CORBA_ConstantDef_ptr &
  );
ACE_INLINE CORBA::Boolean
operator<< (
    TAO_OutputCDR &,
    const CORBA_IDLType_ptr
  );
ACE_INLINE CORBA::Boolean
operator>> (
    TAO_InputCDR &,
    CORBA_IDLType_ptr &
  );
ACE_INLINE CORBA::Boolean
operator<< (
    TAO_OutputCDR &,
    const CORBA_StructDef_ptr
  );
ACE_INLINE CORBA::Boolean
operator>> (
    TAO_InputCDR &,
    CORBA_StructDef_ptr &
  );
ACE_INLINE CORBA::Boolean
operator<< (
    TAO_OutputCDR &,
    const CORBA_UnionDef_ptr
  );
ACE_INLINE CORBA::Boolean
operator>> (
    TAO_InputCDR &,
    CORBA_UnionDef_ptr &
  );
ACE_INLINE CORBA::Boolean
operator<< (
    TAO_OutputCDR &,
    const CORBA_EnumDef_ptr
  );
ACE_INLINE CORBA::Boolean
operator>> (
    TAO_InputCDR &,
    CORBA_EnumDef_ptr &
  );
ACE_INLINE CORBA::Boolean
operator<< (
    TAO_OutputCDR &,
    const CORBA_AliasDef_ptr
  );
ACE_INLINE CORBA::Boolean
operator>> (
    TAO_InputCDR &,
    CORBA_AliasDef_ptr &
  );
ACE_INLINE CORBA::Boolean
operator<< (
    TAO_OutputCDR &,
    const CORBA_InterfaceDef_ptr
  );
ACE_INLINE CORBA::Boolean
operator>> (
    TAO_InputCDR &,
    CORBA_InterfaceDef_ptr &
  );
ACE_INLINE CORBA::Boolean
operator<< (
    TAO_OutputCDR &,
    const CORBA_ExceptionDef_ptr
  );
ACE_INLINE CORBA::Boolean
operator>> (
    TAO_InputCDR &,
    CORBA_ExceptionDef_ptr &
  );
ACE_INLINE CORBA::Boolean
operator<< (
    TAO_OutputCDR &,
    const CORBA_NativeDef_ptr
  );
ACE_INLINE CORBA::Boolean
operator>> (
    TAO_InputCDR &,
    CORBA_NativeDef_ptr &
  );
CORBA::Boolean  operator<< (
    TAO_OutputCDR &,
    const CORBA_InterfaceDefSeq &
  );
CORBA::Boolean  operator>> (
    TAO_InputCDR &,
    CORBA_InterfaceDefSeq &
  );

ACE_INLINE CORBA::Boolean
operator<< (
    TAO_OutputCDR &,
    const CORBA_ValueDef_ptr
  );
ACE_INLINE CORBA::Boolean
operator>> (
    TAO_InputCDR &,
    CORBA_ValueDef_ptr &
  );
CORBA::Boolean  operator<< (
    TAO_OutputCDR &,
    const CORBA_ValueDefSeq &
  );
CORBA::Boolean  operator>> (
    TAO_InputCDR &,
    CORBA_ValueDefSeq &
  );

ACE_INLINE CORBA::Boolean
operator<< (
    TAO_OutputCDR &,
    const CORBA_ValueBoxDef_ptr
  );
ACE_INLINE CORBA::Boolean
operator>> (
    TAO_InputCDR &,
    CORBA_ValueBoxDef_ptr &
  );
CORBA::Boolean  operator<< (
    TAO_OutputCDR &,
    const CORBA_ContainedSeq &
  );
CORBA::Boolean  operator>> (
    TAO_InputCDR &,
    CORBA_ContainedSeq &
  );

ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA_StructMember &_tao_aggregate)
{
  if (
    (strm << _tao_aggregate.name.in ()) &&
    (strm << _tao_aggregate.type.in ()) &&
    (strm << _tao_aggregate.type_def.in ())
  )
    return 1;
  else
    return 0;
  
}

ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA_StructMember &_tao_aggregate)
{
  if (
    (strm >> _tao_aggregate.name.out ()) &&
    (strm >> _tao_aggregate.type.out ()) &&
    (strm >> _tao_aggregate.type_def.out ())
  )
    return 1;
  else
    return 0;
  
}

CORBA::Boolean  operator<< (
    TAO_OutputCDR &,
    const CORBA_StructMemberSeq &
  );
CORBA::Boolean  operator>> (
    TAO_InputCDR &,
    CORBA_StructMemberSeq &
  );

ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA_Initializer &_tao_aggregate)
{
  if (
    (strm << _tao_aggregate.members)
  )
    return 1;
  else
    return 0;
  
}

ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA_Initializer &_tao_aggregate)
{
  if (
    (strm >> _tao_aggregate.members)
  )
    return 1;
  else
    return 0;
  
}

CORBA::Boolean  operator<< (
    TAO_OutputCDR &,
    const CORBA_InitializerSeq &
  );
CORBA::Boolean  operator>> (
    TAO_InputCDR &,
    CORBA_InitializerSeq &
  );

ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA_UnionMember &_tao_aggregate)
{
  if (
    (strm << _tao_aggregate.name.in ()) &&
    (strm << _tao_aggregate.label) &&
    (strm << _tao_aggregate.type.in ()) &&
    (strm << _tao_aggregate.type_def.in ())
  )
    return 1;
  else
    return 0;
  
}

ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA_UnionMember &_tao_aggregate)
{
  if (
    (strm >> _tao_aggregate.name.out ()) &&
    (strm >> _tao_aggregate.label) &&
    (strm >> _tao_aggregate.type.out ()) &&
    (strm >> _tao_aggregate.type_def.out ())
  )
    return 1;
  else
    return 0;
  
}

CORBA::Boolean  operator<< (
    TAO_OutputCDR &,
    const CORBA_UnionMemberSeq &
  );
CORBA::Boolean  operator>> (
    TAO_InputCDR &,
    CORBA_UnionMemberSeq &
  );

CORBA::Boolean  operator<< (
    TAO_OutputCDR &,
    const CORBA_EnumMemberSeq &
  );
CORBA::Boolean  operator>> (
    TAO_InputCDR &,
    CORBA_EnumMemberSeq &
  );

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

ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA_Container::Description &_tao_aggregate)
{
  if (
    (strm << _tao_aggregate.contained_object.in ()) &&
    (strm << _tao_aggregate.kind) &&
    (strm << _tao_aggregate.value)
  )
    return 1;
  else
    return 0;
  
}

ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA_Container::Description &_tao_aggregate)
{
  if (
    (strm >> _tao_aggregate.contained_object.out ()) &&
    (strm >> _tao_aggregate.kind) &&
    (strm >> _tao_aggregate.value)
  )
    return 1;
  else
    return 0;
  
}

CORBA::Boolean  operator<< (
    TAO_OutputCDR &,
    const CORBA_Container::DescriptionSeq &
  );
CORBA::Boolean  operator>> (
    TAO_InputCDR &,
    CORBA_Container::DescriptionSeq &
  );

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

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

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

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

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

ACE_INLINE CORBA::Boolean
operator<< (
    TAO_OutputCDR &,
    const CORBA_PrimitiveDef_ptr
  );
ACE_INLINE CORBA::Boolean
operator>> (
    TAO_InputCDR &,
    CORBA_PrimitiveDef_ptr &
  );
ACE_INLINE CORBA::Boolean
operator<< (
    TAO_OutputCDR &,
    const CORBA_StringDef_ptr
  );
ACE_INLINE CORBA::Boolean
operator>> (
    TAO_InputCDR &,
    CORBA_StringDef_ptr &
  );
ACE_INLINE CORBA::Boolean
operator<< (
    TAO_OutputCDR &,
    const CORBA_SequenceDef_ptr
  );
ACE_INLINE CORBA::Boolean
operator>> (
    TAO_InputCDR &,
    CORBA_SequenceDef_ptr &
  );
ACE_INLINE CORBA::Boolean
operator<< (
    TAO_OutputCDR &,
    const CORBA_ArrayDef_ptr
  );
ACE_INLINE CORBA::Boolean
operator>> (
    TAO_InputCDR &,
    CORBA_ArrayDef_ptr &
  );
ACE_INLINE CORBA::Boolean
operator<< (
    TAO_OutputCDR &,
    const CORBA_WstringDef_ptr
  );
ACE_INLINE CORBA::Boolean
operator>> (
    TAO_InputCDR &,
    CORBA_WstringDef_ptr &
  );
ACE_INLINE CORBA::Boolean
operator<< (
    TAO_OutputCDR &,
    const CORBA_FixedDef_ptr
  );
ACE_INLINE CORBA::Boolean
operator>> (
    TAO_InputCDR &,
    CORBA_FixedDef_ptr &
  );
ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA::PrimitiveKind &_tao_enumval)
{
  return strm.write_ulong ((CORBA::ULong) _tao_enumval);
}

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

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

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

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

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

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

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

ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA_ModuleDescription &_tao_aggregate)
{
  if (
    (strm << _tao_aggregate.name.in ()) &&
    (strm << _tao_aggregate.id.in ()) &&
    (strm << _tao_aggregate.defined_in.in ()) &&
    (strm << _tao_aggregate.version.in ())
  )
    return 1;
  else
    return 0;
  
}

ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA_ModuleDescription &_tao_aggregate)
{
  if (
    (strm >> _tao_aggregate.name.out ()) &&
    (strm >> _tao_aggregate.id.out ()) &&
    (strm >> _tao_aggregate.defined_in.out ()) &&
    (strm >> _tao_aggregate.version.out ())
  )
    return 1;
  else
    return 0;
  
}

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

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

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

ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA_ConstantDescription &_tao_aggregate)
{
  if (
    (strm << _tao_aggregate.name.in ()) &&
    (strm << _tao_aggregate.id.in ()) &&
    (strm << _tao_aggregate.defined_in.in ()) &&
    (strm << _tao_aggregate.version.in ()) &&
    (strm << _tao_aggregate.type.in ()) &&
    (strm << _tao_aggregate.value)
  )
    return 1;
  else
    return 0;
  
}

ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA_ConstantDescription &_tao_aggregate)
{
  if (
    (strm >> _tao_aggregate.name.out ()) &&
    (strm >> _tao_aggregate.id.out ()) &&
    (strm >> _tao_aggregate.defined_in.out ()) &&
    (strm >> _tao_aggregate.version.out ()) &&
    (strm >> _tao_aggregate.type.out ()) &&
    (strm >> _tao_aggregate.value)
  )
    return 1;
  else
    return 0;
  
}

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

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

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

ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA_TypeDescription &_tao_aggregate)
{
  if (
    (strm << _tao_aggregate.name.in ()) &&
    (strm << _tao_aggregate.id.in ()) &&
    (strm << _tao_aggregate.defined_in.in ()) &&
    (strm << _tao_aggregate.version.in ()) &&
    (strm << _tao_aggregate.type.in ())
  )
    return 1;
  else
    return 0;
  
}

ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA_TypeDescription &_tao_aggregate)
{
  if (
    (strm >> _tao_aggregate.name.out ()) &&
    (strm >> _tao_aggregate.id.out ()) &&
    (strm >> _tao_aggregate.defined_in.out ()) &&
    (strm >> _tao_aggregate.version.out ()) &&
    (strm >> _tao_aggregate.type.out ())
  )
    return 1;
  else
    return 0;
  
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA_ExceptionDescription &_tao_aggregate)
{
  if (
    (strm << _tao_aggregate.name.in ()) &&
    (strm << _tao_aggregate.id.in ()) &&
    (strm << _tao_aggregate.defined_in.in ()) &&
    (strm << _tao_aggregate.version.in ()) &&
    (strm << _tao_aggregate.type.in ())
  )
    return 1;
  else
    return 0;
  
}

ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA::ExceptionDescription &_tao_aggregate)
{
  if (
    (strm >> _tao_aggregate.name.out ()) &&
    (strm >> _tao_aggregate.id.out ()) &&
    (strm >> _tao_aggregate.defined_in.out ()) &&
    (strm >> _tao_aggregate.version.out ()) &&
    (strm >> _tao_aggregate.type.out ())
  )
    return 1;
  else
    return 0;
  
}

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

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

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

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

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

ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA::AttributeDescription &_tao_aggregate)
{
  if (
    (strm << _tao_aggregate.name.in ()) &&
    (strm << _tao_aggregate.id.in ()) &&
    (strm << _tao_aggregate.defined_in.in ()) &&
    (strm << _tao_aggregate.version.in ()) &&
    (strm << _tao_aggregate.type.in ()) &&
    (strm << _tao_aggregate.mode)
  )
    return 1;
  else
    return 0;
  
}

ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA::AttributeDescription &_tao_aggregate)
{
  if (
    (strm >> _tao_aggregate.name.out ()) &&
    (strm >> _tao_aggregate.id.out ()) &&
    (strm >> _tao_aggregate.defined_in.out ()) &&
    (strm >> _tao_aggregate.version.out ()) &&
    (strm >> _tao_aggregate.type.out ()) &&
    (strm >> _tao_aggregate.mode)
  )
    return 1;
  else
    return 0;
  
}

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

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

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

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

ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA_ParameterDescription &_tao_aggregate)
{
  if (
    (strm << _tao_aggregate.name.in ()) &&
    (strm << _tao_aggregate.type.in ()) &&
    (strm << _tao_aggregate.type_def.in ()) &&
    (strm << _tao_aggregate.mode)
  )
    return 1;
  else
    return 0;
  
}

ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA_ParameterDescription &_tao_aggregate)
{
  if (
    (strm >> _tao_aggregate.name.out ()) &&
    (strm >> _tao_aggregate.type.out ()) &&
    (strm >> _tao_aggregate.type_def.out ()) &&
    (strm >> _tao_aggregate.mode)
  )
    return 1;
  else
    return 0;
  
}

CORBA::Boolean  operator<< (
    TAO_OutputCDR &,
    const CORBA_ParDescriptionSeq &
  );
CORBA::Boolean  operator>> (
    TAO_InputCDR &,
    CORBA_ParDescriptionSeq &
  );

CORBA::Boolean  operator<< (
    TAO_OutputCDR &,
    const CORBA_ContextIdSeq &
  );
CORBA::Boolean  operator>> (
    TAO_InputCDR &,
    CORBA_ContextIdSeq &
  );

CORBA::Boolean  operator<< (
    TAO_OutputCDR &,
    const CORBA_ExceptionDefSeq &
  );
CORBA::Boolean  operator>> (
    TAO_InputCDR &,
    CORBA_ExceptionDefSeq &
  );

CORBA::Boolean  operator<< (
    TAO_OutputCDR &,
    const CORBA_ExcDescriptionSeq &
  );
CORBA::Boolean  operator>> (
    TAO_InputCDR &,
    CORBA_ExcDescriptionSeq &
  );

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

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

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

ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA_OperationDescription &_tao_aggregate)
{
  if (
    (strm << _tao_aggregate.name.in ()) &&
    (strm << _tao_aggregate.id.in ()) &&
    (strm << _tao_aggregate.defined_in.in ()) &&
    (strm << _tao_aggregate.version.in ()) &&
    (strm << _tao_aggregate.result.in ()) &&
    (strm << _tao_aggregate.mode) &&
    (strm << _tao_aggregate.contexts) &&
    (strm << _tao_aggregate.parameters) &&
    (strm << _tao_aggregate.exceptions)
  )
    return 1;
  else
    return 0;
  
}

ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA_OperationDescription &_tao_aggregate)
{
  if (
    (strm >> _tao_aggregate.name.out ()) &&
    (strm >> _tao_aggregate.id.out ()) &&
    (strm >> _tao_aggregate.defined_in.out ()) &&
    (strm >> _tao_aggregate.version.out ()) &&
    (strm >> _tao_aggregate.result.out ()) &&
    (strm >> _tao_aggregate.mode) &&
    (strm >> _tao_aggregate.contexts) &&
    (strm >> _tao_aggregate.parameters) &&
    (strm >> _tao_aggregate.exceptions)
  )
    return 1;
  else
    return 0;
  
}

CORBA::Boolean  operator<< (
    TAO_OutputCDR &,
    const CORBA_RepositoryIdSeq &
  );
CORBA::Boolean  operator>> (
    TAO_InputCDR &,
    CORBA_RepositoryIdSeq &
  );

CORBA::Boolean  operator<< (
    TAO_OutputCDR &,
    const CORBA_OpDescriptionSeq &
  );
CORBA::Boolean  operator>> (
    TAO_InputCDR &,
    CORBA_OpDescriptionSeq &
  );

CORBA::Boolean  operator<< (
    TAO_OutputCDR &,
    const CORBA_AttrDescriptionSeq &
  );
CORBA::Boolean  operator>> (
    TAO_InputCDR &,
    CORBA_AttrDescriptionSeq &
  );

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

ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA_InterfaceDef::FullInterfaceDescription &_tao_aggregate)
{
  if (
    (strm << _tao_aggregate.name.in ()) &&
    (strm << _tao_aggregate.id.in ()) &&
    (strm << _tao_aggregate.defined_in.in ()) &&
    (strm << _tao_aggregate.version.in ()) &&
    (strm << _tao_aggregate.operations) &&
    (strm << _tao_aggregate.attributes) &&
    (strm << _tao_aggregate.base_interfaces) &&
    (strm << _tao_aggregate.type.in ()) &&
    (strm << CORBA_Any::from_boolean (_tao_aggregate.is_abstract))
  )
    return 1;
  else
    return 0;
  
}

ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA_InterfaceDef::FullInterfaceDescription &_tao_aggregate)
{
  if (
    (strm >> _tao_aggregate.name.out ()) &&
    (strm >> _tao_aggregate.id.out ()) &&
    (strm >> _tao_aggregate.defined_in.out ()) &&
    (strm >> _tao_aggregate.version.out ()) &&
    (strm >> _tao_aggregate.operations) &&
    (strm >> _tao_aggregate.attributes) &&
    (strm >> _tao_aggregate.base_interfaces) &&
    (strm >> _tao_aggregate.type.out ()) &&
    (strm >> CORBA_Any::to_boolean (_tao_aggregate.is_abstract))
  )
    return 1;
  else
    return 0;
  
}

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

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

ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA_InterfaceDescription &_tao_aggregate)
{
  if (
    (strm << _tao_aggregate.name.in ()) &&
    (strm << _tao_aggregate.id.in ()) &&
    (strm << _tao_aggregate.defined_in.in ()) &&
    (strm << _tao_aggregate.version.in ()) &&
    (strm << _tao_aggregate.base_interfaces) &&
    (strm << CORBA_Any::from_boolean (_tao_aggregate.is_abstract))
  )
    return 1;
  else
    return 0;
  
}

ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA_InterfaceDescription &_tao_aggregate)
{
  if (
    (strm >> _tao_aggregate.name.out ()) &&
    (strm >> _tao_aggregate.id.out ()) &&
    (strm >> _tao_aggregate.defined_in.out ()) &&
    (strm >> _tao_aggregate.version.out ()) &&
    (strm >> _tao_aggregate.base_interfaces) &&
    (strm >> CORBA_Any::to_boolean (_tao_aggregate.is_abstract))
  )
    return 1;
  else
    return 0;
  
}

ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA_ValueMember &_tao_aggregate)
{
  if (
    (strm << _tao_aggregate.name.in ()) &&
    (strm << _tao_aggregate.id.in ()) &&
    (strm << _tao_aggregate.defined_in.in ()) &&
    (strm << _tao_aggregate.version.in ()) &&
    (strm << _tao_aggregate.type.in ()) &&
    (strm << _tao_aggregate.type_def.in ()) &&
    (strm << _tao_aggregate.access)
  )
    return 1;
  else
    return 0;
  
}

ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA_ValueMember &_tao_aggregate)
{
  if (
    (strm >> _tao_aggregate.name.out ()) &&
    (strm >> _tao_aggregate.id.out ()) &&
    (strm >> _tao_aggregate.defined_in.out ()) &&
    (strm >> _tao_aggregate.version.out ()) &&
    (strm >> _tao_aggregate.type.out ()) &&
    (strm >> _tao_aggregate.type_def.out ()) &&
    (strm >> _tao_aggregate.access)
  )
    return 1;
  else
    return 0;
  
}

CORBA::Boolean  operator<< (
    TAO_OutputCDR &,
    const CORBA_ValueMemberSeq &
  );
CORBA::Boolean  operator>> (
    TAO_InputCDR &,
    CORBA_ValueMemberSeq &
  );

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

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

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

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

ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA_ValueDef::FullValueDescription &_tao_aggregate)
{
  if (
    (strm << _tao_aggregate.name.in ()) &&
    (strm << _tao_aggregate.id.in ()) &&
    (strm << CORBA_Any::from_boolean (_tao_aggregate.is_abstract)) &&
    (strm << CORBA_Any::from_boolean (_tao_aggregate.is_custom)) &&
    (strm << _tao_aggregate.defined_in.in ()) &&
    (strm << _tao_aggregate.version.in ()) &&
    (strm << _tao_aggregate.operations) &&
    (strm << _tao_aggregate.attributes) &&
    (strm << _tao_aggregate.members) &&
    (strm << _tao_aggregate.initializers) &&
    (strm << _tao_aggregate.supported_interfaces) &&
    (strm << _tao_aggregate.abstract_base_values) &&
    (strm << CORBA_Any::from_boolean (_tao_aggregate.is_truncatable)) &&
    (strm << _tao_aggregate.base_value.in ()) &&
    (strm << _tao_aggregate.type.in ())
  )
    return 1;
  else
    return 0;
  
}

ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA_ValueDef::FullValueDescription &_tao_aggregate)
{
  if (
    (strm >> _tao_aggregate.name.out ()) &&
    (strm >> _tao_aggregate.id.out ()) &&
    (strm >> CORBA_Any::to_boolean (_tao_aggregate.is_abstract)) &&
    (strm >> CORBA_Any::to_boolean (_tao_aggregate.is_custom)) &&
    (strm >> _tao_aggregate.defined_in.out ()) &&
    (strm >> _tao_aggregate.version.out ()) &&
    (strm >> _tao_aggregate.operations) &&
    (strm >> _tao_aggregate.attributes) &&
    (strm >> _tao_aggregate.members) &&
    (strm >> _tao_aggregate.initializers) &&
    (strm >> _tao_aggregate.supported_interfaces) &&
    (strm >> _tao_aggregate.abstract_base_values) &&
    (strm >> CORBA_Any::to_boolean (_tao_aggregate.is_truncatable)) &&
    (strm >> _tao_aggregate.base_value.out ()) &&
    (strm >> _tao_aggregate.type.out ())
  )
    return 1;
  else
    return 0;
  
}

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

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

ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA_ValueDescription &_tao_aggregate)
{
  if (
    (strm << _tao_aggregate.name.in ()) &&
    (strm << _tao_aggregate.id.in ()) &&
    (strm << CORBA_Any::from_boolean (_tao_aggregate.is_abstract)) &&
    (strm << CORBA_Any::from_boolean (_tao_aggregate.is_custom)) &&
    (strm << _tao_aggregate.defined_in.in ()) &&
    (strm << _tao_aggregate.version.in ()) &&
    (strm << _tao_aggregate.supported_interface.in ()) &&
    (strm << _tao_aggregate.abstract_base_values) &&
    (strm << CORBA_Any::from_boolean (_tao_aggregate.is_truncatable)) &&
    (strm << _tao_aggregate.base_value.in ())
  )
    return 1;
  else
    return 0;
  
}

ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA_ValueDescription &_tao_aggregate)
{
  if (
    (strm >> _tao_aggregate.name.out ()) &&
    (strm >> _tao_aggregate.id.out ()) &&
    (strm >> CORBA_Any::to_boolean (_tao_aggregate.is_abstract)) &&
    (strm >> CORBA_Any::to_boolean (_tao_aggregate.is_custom)) &&
    (strm >> _tao_aggregate.defined_in.out ()) &&
    (strm >> _tao_aggregate.version.out ()) &&
    (strm >> _tao_aggregate.supported_interface.out ()) &&
    (strm >> _tao_aggregate.abstract_base_values) &&
    (strm >> CORBA_Any::to_boolean (_tao_aggregate.is_truncatable)) &&
    (strm >> _tao_aggregate.base_value.out ())
  )
    return 1;
  else
    return 0;
  
}

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

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

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