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

// ****  Code generated by the The ACE ORB (TAO) IDL Compiler ****
// TAO and the TAO IDL Compiler have been developed by:
//       Center for Distributed Object Computing
//       Washington University
//       St. Louis, MO
//       USA
//       http://www.cs.wustl.edu/~schmidt/doc-center.html
// and
//       Distributed Object Computing Laboratory
//       University of California at Irvine
//       Irvine, CA
//       USA
//       http://doc.ece.uci.edu/
//
// Information about TAO is available at:
//     http://www.cs.wustl.edu/~schmidt/TAO.html


#if !defined (_CORBA_REPOSITORY___CI_)
#define _CORBA_REPOSITORY___CI_

ACE_INLINE
CORBA_Repository::CORBA_Repository (
    TAO_Stub *objref,
    CORBA::Boolean _tao_collocated,
    TAO_Abstract_ServantBase *servant
  )
  : CORBA_Object (objref, _tao_collocated, servant)
{
  this->CORBA_Repository_setup_collocation (_tao_collocated);
}


#endif /* end #if !defined */


#if !defined (_CORBA_MODULEDEF___CI_)
#define _CORBA_MODULEDEF___CI_

ACE_INLINE
CORBA_ModuleDef::CORBA_ModuleDef (
    TAO_Stub *objref,
    CORBA::Boolean _tao_collocated,
    TAO_Abstract_ServantBase *servant
  )
  : CORBA_Object (objref, _tao_collocated, servant)
{
  this->CORBA_ModuleDef_setup_collocation (_tao_collocated);
}


#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)
    {
      if (p.ptr_ == 0)
        {
          delete this->ptr_;
          this->ptr_ = 0;
        }
      else
        {
          CORBA_ModuleDescription *deep_copy =
            new CORBA_ModuleDescription (*p.ptr_);
          
          if (deep_copy != 0)
            {
              CORBA_ModuleDescription *tmp = deep_copy;
              deep_copy = this->ptr_;
              this->ptr_ = tmp;
              delete deep_copy;
            }
        }
    }
  
  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_;
}

// variable-size types only
ACE_INLINE
CORBA_ModuleDescription_var::operator ::CORBA_ModuleDescription *&() // 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_;
}


#if !defined (_CORBA_CONSTANTDEF___CI_)
#define _CORBA_CONSTANTDEF___CI_

ACE_INLINE
CORBA_ConstantDef::CORBA_ConstantDef (
    TAO_Stub *objref,
    CORBA::Boolean _tao_collocated,
    TAO_Abstract_ServantBase *servant
  )
  : CORBA_Object (objref, _tao_collocated, servant)
{
  this->CORBA_ConstantDef_setup_collocation (_tao_collocated);
}


#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)
    {
      if (p.ptr_ == 0)
        {
          delete this->ptr_;
          this->ptr_ = 0;
        }
      else
        {
          CORBA_ConstantDescription *deep_copy =
            new CORBA_ConstantDescription (*p.ptr_);
          
          if (deep_copy != 0)
            {
              CORBA_ConstantDescription *tmp = deep_copy;
              deep_copy = this->ptr_;
              this->ptr_ = tmp;
              delete deep_copy;
            }
        }
    }
  
  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_;
}

// variable-size types only
ACE_INLINE
CORBA_ConstantDescription_var::operator ::CORBA_ConstantDescription *&() // 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_;
}


#if !defined (_CORBA_STRUCTDEF___CI_)
#define _CORBA_STRUCTDEF___CI_

ACE_INLINE
CORBA_StructDef::CORBA_StructDef (
    TAO_Stub *objref,
    CORBA::Boolean _tao_collocated,
    TAO_Abstract_ServantBase *servant
  )
  : CORBA_Object (objref, _tao_collocated, servant)
{
  this->CORBA_StructDef_setup_collocation (_tao_collocated);
}


#endif /* end #if !defined */


#if !defined (_CORBA_UNIONDEF___CI_)
#define _CORBA_UNIONDEF___CI_

ACE_INLINE
CORBA_UnionDef::CORBA_UnionDef (
    TAO_Stub *objref,
    CORBA::Boolean _tao_collocated,
    TAO_Abstract_ServantBase *servant
  )
  : CORBA_Object (objref, _tao_collocated, servant)
{
  this->CORBA_UnionDef_setup_collocation (_tao_collocated);
}


#endif /* end #if !defined */


#if !defined (_CORBA_ENUMDEF___CI_)
#define _CORBA_ENUMDEF___CI_

ACE_INLINE
CORBA_EnumDef::CORBA_EnumDef (
    TAO_Stub *objref,
    CORBA::Boolean _tao_collocated,
    TAO_Abstract_ServantBase *servant
  )
  : CORBA_Object (objref, _tao_collocated, servant)
{
  this->CORBA_EnumDef_setup_collocation (_tao_collocated);
}


#endif /* end #if !defined */


#if !defined (_CORBA_ALIASDEF___CI_)
#define _CORBA_ALIASDEF___CI_

ACE_INLINE
CORBA_AliasDef::CORBA_AliasDef (
    TAO_Stub *objref,
    CORBA::Boolean _tao_collocated,
    TAO_Abstract_ServantBase *servant
  )
  : CORBA_Object (objref, _tao_collocated, servant)
{
  this->CORBA_AliasDef_setup_collocation (_tao_collocated);
}


#endif /* end #if !defined */


#if !defined (_CORBA_NATIVEDEF___CI_)
#define _CORBA_NATIVEDEF___CI_

ACE_INLINE
CORBA_NativeDef::CORBA_NativeDef (
    TAO_Stub *objref,
    CORBA::Boolean _tao_collocated,
    TAO_Abstract_ServantBase *servant
  )
  : CORBA_Object (objref, _tao_collocated, servant)
{
  this->CORBA_NativeDef_setup_collocation (_tao_collocated);
}


#endif /* end #if !defined */


#if !defined (_CORBA_PRIMITIVEDEF___CI_)
#define _CORBA_PRIMITIVEDEF___CI_

ACE_INLINE
CORBA_PrimitiveDef::CORBA_PrimitiveDef (
    TAO_Stub *objref,
    CORBA::Boolean _tao_collocated,
    TAO_Abstract_ServantBase *servant
  )
  : CORBA_Object (objref, _tao_collocated, servant)
{
  this->CORBA_PrimitiveDef_setup_collocation (_tao_collocated);
}


#endif /* end #if !defined */


#if !defined (_CORBA_STRINGDEF___CI_)
#define _CORBA_STRINGDEF___CI_

ACE_INLINE
CORBA_StringDef::CORBA_StringDef (
    TAO_Stub *objref,
    CORBA::Boolean _tao_collocated,
    TAO_Abstract_ServantBase *servant
  )
  : CORBA_Object (objref, _tao_collocated, servant)
{
  this->CORBA_StringDef_setup_collocation (_tao_collocated);
}


#endif /* end #if !defined */


#if !defined (_CORBA_WSTRINGDEF___CI_)
#define _CORBA_WSTRINGDEF___CI_

ACE_INLINE
CORBA_WstringDef::CORBA_WstringDef (
    TAO_Stub *objref,
    CORBA::Boolean _tao_collocated,
    TAO_Abstract_ServantBase *servant
  )
  : CORBA_Object (objref, _tao_collocated, servant)
{
  this->CORBA_WstringDef_setup_collocation (_tao_collocated);
}


#endif /* end #if !defined */


#if !defined (_CORBA_SEQUENCEDEF___CI_)
#define _CORBA_SEQUENCEDEF___CI_

ACE_INLINE
CORBA_SequenceDef::CORBA_SequenceDef (
    TAO_Stub *objref,
    CORBA::Boolean _tao_collocated,
    TAO_Abstract_ServantBase *servant
  )
  : CORBA_Object (objref, _tao_collocated, servant)
{
  this->CORBA_SequenceDef_setup_collocation (_tao_collocated);
}


#endif /* end #if !defined */


#if !defined (_CORBA_ARRAYDEF___CI_)
#define _CORBA_ARRAYDEF___CI_

ACE_INLINE
CORBA_ArrayDef::CORBA_ArrayDef (
    TAO_Stub *objref,
    CORBA::Boolean _tao_collocated,
    TAO_Abstract_ServantBase *servant
  )
  : CORBA_Object (objref, _tao_collocated, servant)
{
  this->CORBA_ArrayDef_setup_collocation (_tao_collocated);
}


#endif /* end #if !defined */


#if !defined (_CORBA_EXCEPTIONDEF___CI_)
#define _CORBA_EXCEPTIONDEF___CI_

ACE_INLINE
CORBA_ExceptionDef::CORBA_ExceptionDef (
    TAO_Stub *objref,
    CORBA::Boolean _tao_collocated,
    TAO_Abstract_ServantBase *servant
  )
  : CORBA_Object (objref, _tao_collocated, servant)
{
  this->CORBA_ExceptionDef_setup_collocation (_tao_collocated);
}


#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)
    {
      if (p.ptr_ == 0)
        {
          delete this->ptr_;
          this->ptr_ = 0;
        }
      else
        {
          CORBA_ExceptionDescription *deep_copy =
            new CORBA_ExceptionDescription (*p.ptr_);
          
          if (deep_copy != 0)
            {
              CORBA_ExceptionDescription *tmp = deep_copy;
              deep_copy = this->ptr_;
              this->ptr_ = tmp;
              delete deep_copy;
            }
        }
    }
  
  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_;
}

// variable-size types only
ACE_INLINE
CORBA_ExceptionDescription_var::operator ::CORBA_ExceptionDescription *&() // 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_;
}


#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)
  {
    if (rhs.buffer_ != 0)
    {
      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;
    }
    else
    {
      this->buffer_ = 0;
    }
  }
  
  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;
        this->release_ = 1;
      }
      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)
{
  if (this != &p)
    {
      if (p.ptr_ == 0)
        {
          delete this->ptr_;
          this->ptr_ = 0;
        }
      else
        {
          CORBA_ExceptionDefSeq *deep_copy =
            new CORBA_ExceptionDefSeq (*p.ptr_);
          
          if (deep_copy != 0)
            {
              CORBA_ExceptionDefSeq *tmp = deep_copy;
              deep_copy = this->ptr_;
              this->ptr_ = tmp;
              delete deep_copy;
            }
        }
    }
  
  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_;
}

// variable-size types only
ACE_INLINE
CORBA_ExceptionDefSeq_var::operator ::CORBA_ExceptionDefSeq *&() // 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)
  {
    if (rhs.buffer_ != 0)
    {
      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;
    }
    else
    {
      this->buffer_ = 0;
    }
  }
  
  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;
        this->release_ = 1;
      }
      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)
{
  if (this != &p)
    {
      if (p.ptr_ == 0)
        {
          delete this->ptr_;
          this->ptr_ = 0;
        }
      else
        {
          CORBA_ExcDescriptionSeq *deep_copy =
            new CORBA_ExcDescriptionSeq (*p.ptr_);
          
          if (deep_copy != 0)
            {
              CORBA_ExcDescriptionSeq *tmp = deep_copy;
              deep_copy = this->ptr_;
              this->ptr_ = tmp;
              delete deep_copy;
            }
        }
    }
  
  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_;
}

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

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

ACE_INLINE const CORBA_ExceptionDescription &
CORBA_ExcDescriptionSeq_var::operator[] (CORBA::ULong index) const
{
  return ACE_const_cast (const CORBA_ExceptionDescription &, 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 */


#if !defined (_CORBA_ATTRIBUTEDEF___CI_)
#define _CORBA_ATTRIBUTEDEF___CI_

ACE_INLINE
CORBA_AttributeDef::CORBA_AttributeDef (
    TAO_Stub *objref,
    CORBA::Boolean _tao_collocated,
    TAO_Abstract_ServantBase *servant
  )
  : CORBA_Object (objref, _tao_collocated, servant)
{
  this->CORBA_AttributeDef_setup_collocation (_tao_collocated);
}


#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)
    {
      if (p.ptr_ == 0)
        {
          delete this->ptr_;
          this->ptr_ = 0;
        }
      else
        {
          CORBA_AttributeDescription *deep_copy =
            new CORBA_AttributeDescription (*p.ptr_);
          
          if (deep_copy != 0)
            {
              CORBA_AttributeDescription *tmp = deep_copy;
              deep_copy = this->ptr_;
              this->ptr_ = tmp;
              delete deep_copy;
            }
        }
    }
  
  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_;
}

// variable-size types only
ACE_INLINE
CORBA_AttributeDescription_var::operator ::CORBA_AttributeDescription *&() // 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)
    {
      if (p.ptr_ == 0)
        {
          delete this->ptr_;
          this->ptr_ = 0;
        }
      else
        {
          CORBA_ParameterDescription *deep_copy =
            new CORBA_ParameterDescription (*p.ptr_);
          
          if (deep_copy != 0)
            {
              CORBA_ParameterDescription *tmp = deep_copy;
              deep_copy = this->ptr_;
              this->ptr_ = tmp;
              delete deep_copy;
            }
        }
    }
  
  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_;
}

// variable-size types only
ACE_INLINE
CORBA_ParameterDescription_var::operator ::CORBA_ParameterDescription *&() // 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)
  {
    if (rhs.buffer_ != 0)
    {
      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;
    }
    else
    {
      this->buffer_ = 0;
    }
  }
  
  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;
        this->release_ = 1;
      }
      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)
{
  if (this != &p)
    {
      if (p.ptr_ == 0)
        {
          delete this->ptr_;
          this->ptr_ = 0;
        }
      else
        {
          CORBA_ParDescriptionSeq *deep_copy =
            new CORBA_ParDescriptionSeq (*p.ptr_);
          
          if (deep_copy != 0)
            {
              CORBA_ParDescriptionSeq *tmp = deep_copy;
              deep_copy = this->ptr_;
              this->ptr_ = tmp;
              delete deep_copy;
            }
        }
    }
  
  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_;
}

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

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

ACE_INLINE const CORBA_ParameterDescription &
CORBA_ParDescriptionSeq_var::operator[] (CORBA::ULong index) const
{
  return ACE_const_cast (const CORBA_ParameterDescription &, 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)
{
  if (this != &p)
    {
      if (p.ptr_ == 0)
        {
          delete this->ptr_;
          this->ptr_ = 0;
        }
      else
        {
          CORBA_ContextIdSeq *deep_copy =
            new CORBA_ContextIdSeq (*p.ptr_);
          
          if (deep_copy != 0)
            {
              CORBA_ContextIdSeq *tmp = deep_copy;
              deep_copy = this->ptr_;
              this->ptr_ = tmp;
              delete deep_copy;
            }
        }
    }
  
  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_;
}

// variable-size types only
ACE_INLINE
CORBA_ContextIdSeq_var::operator ::CORBA_ContextIdSeq *&() // 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 (_CORBA_OPERATIONDEF___CI_)
#define _CORBA_OPERATIONDEF___CI_

ACE_INLINE
CORBA_OperationDef::CORBA_OperationDef (
    TAO_Stub *objref,
    CORBA::Boolean _tao_collocated,
    TAO_Abstract_ServantBase *servant
  )
  : CORBA_Object (objref, _tao_collocated, servant)
{
  this->CORBA_OperationDef_setup_collocation (_tao_collocated);
}


#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)
    {
      if (p.ptr_ == 0)
        {
          delete this->ptr_;
          this->ptr_ = 0;
        }
      else
        {
          CORBA_OperationDescription *deep_copy =
            new CORBA_OperationDescription (*p.ptr_);
          
          if (deep_copy != 0)
            {
              CORBA_OperationDescription *tmp = deep_copy;
              deep_copy = this->ptr_;
              this->ptr_ = tmp;
              delete deep_copy;
            }
        }
    }
  
  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_;
}

// variable-size types only
ACE_INLINE
CORBA_OperationDescription_var::operator ::CORBA_OperationDescription *&() // 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)
{
  if (this != &p)
    {
      if (p.ptr_ == 0)
        {
          delete this->ptr_;
          this->ptr_ = 0;
        }
      else
        {
          CORBA_RepositoryIdSeq *deep_copy =
            new CORBA_RepositoryIdSeq (*p.ptr_);
          
          if (deep_copy != 0)
            {
              CORBA_RepositoryIdSeq *tmp = deep_copy;
              deep_copy = this->ptr_;
              this->ptr_ = tmp;
              delete deep_copy;
            }
        }
    }
  
  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_;
}

// variable-size types only
ACE_INLINE
CORBA_RepositoryIdSeq_var::operator ::CORBA_RepositoryIdSeq *&() // 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)
  {
    if (rhs.buffer_ != 0)
    {
      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;
    }
    else
    {
      this->buffer_ = 0;
    }
  }
  
  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;
        this->release_ = 1;
      }
      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)
{
  if (this != &p)
    {
      if (p.ptr_ == 0)
        {
          delete this->ptr_;
          this->ptr_ = 0;
        }
      else
        {
          CORBA_OpDescriptionSeq *deep_copy =
            new CORBA_OpDescriptionSeq (*p.ptr_);
          
          if (deep_copy != 0)
            {
              CORBA_OpDescriptionSeq *tmp = deep_copy;
              deep_copy = this->ptr_;
              this->ptr_ = tmp;
              delete deep_copy;
            }
        }
    }
  
  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_;
}

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

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

ACE_INLINE const CORBA_OperationDescription &
CORBA_OpDescriptionSeq_var::operator[] (CORBA::ULong index) const
{
  return ACE_const_cast (const CORBA_OperationDescription &, 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)
  {
    if (rhs.buffer_ != 0)
    {
      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;
    }
    else
    {
      this->buffer_ = 0;
    }
  }
  
  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;
        this->release_ = 1;
      }
      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)
{
  if (this != &p)
    {
      if (p.ptr_ == 0)
        {
          delete this->ptr_;
          this->ptr_ = 0;
        }
      else
        {
          CORBA_AttrDescriptionSeq *deep_copy =
            new CORBA_AttrDescriptionSeq (*p.ptr_);
          
          if (deep_copy != 0)
            {
              CORBA_AttrDescriptionSeq *tmp = deep_copy;
              deep_copy = this->ptr_;
              this->ptr_ = tmp;
              delete deep_copy;
            }
        }
    }
  
  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_;
}

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

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

ACE_INLINE const CORBA_AttributeDescription &
CORBA_AttrDescriptionSeq_var::operator[] (CORBA::ULong index) const
{
  return ACE_const_cast (const CORBA_AttributeDescription &, 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 */

// *************************************************************
// 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 (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= (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)
    {
      if (p.ptr_ == 0)
        {
          delete this->ptr_;
          this->ptr_ = 0;
        }
      else
        {
          FullInterfaceDescription *deep_copy =
            new FullInterfaceDescription (*p.ptr_);
          
          if (deep_copy != 0)
            {
              FullInterfaceDescription *tmp = deep_copy;
              deep_copy = this->ptr_;
              this->ptr_ = tmp;
              delete deep_copy;
            }
        }
    }
  
  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_;
}

// variable-size types only
ACE_INLINE
CORBA_InterfaceDef::FullInterfaceDescription_var::operator ::CORBA_InterfaceDef::FullInterfaceDescription *&() // 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 (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 (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 (FullInterfaceDescription_out&, p).ptr_;
  return *this;
}

ACE_INLINE CORBA_InterfaceDef::FullInterfaceDescription_out &
CORBA_InterfaceDef::FullInterfaceDescription_out::operator= (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_;
}


#if !defined (_CORBA_INTERFACEDEF___CI_)
#define _CORBA_INTERFACEDEF___CI_

ACE_INLINE
CORBA_InterfaceDef::CORBA_InterfaceDef (
    TAO_Stub *objref,
    CORBA::Boolean _tao_collocated,
    TAO_Abstract_ServantBase *servant
  )
  : CORBA_Object (objref, _tao_collocated, servant)
{
  this->CORBA_InterfaceDef_setup_collocation (_tao_collocated);
}


#endif /* end #if !defined */

// *************************************************************
// 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)
    {
      if (p.ptr_ == 0)
        {
          delete this->ptr_;
          this->ptr_ = 0;
        }
      else
        {
          CORBA_InterfaceDescription *deep_copy =
            new CORBA_InterfaceDescription (*p.ptr_);
          
          if (deep_copy != 0)
            {
              CORBA_InterfaceDescription *tmp = deep_copy;
              deep_copy = this->ptr_;
              this->ptr_ = tmp;
              delete deep_copy;
            }
        }
    }
  
  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_;
}

// variable-size types only
ACE_INLINE
CORBA_InterfaceDescription_var::operator ::CORBA_InterfaceDescription *&() // 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_;
}


#if !defined (_CORBA_ABSTRACTINTERFACEDEF___CI_)
#define _CORBA_ABSTRACTINTERFACEDEF___CI_

ACE_INLINE
CORBA_AbstractInterfaceDef::CORBA_AbstractInterfaceDef (
    TAO_Stub *objref,
    CORBA::Boolean _tao_collocated,
    TAO_Abstract_ServantBase *servant
  )
  : CORBA_Object (objref, _tao_collocated, servant)
{
  this->CORBA_AbstractInterfaceDef_setup_collocation (_tao_collocated);
}


#endif /* end #if !defined */


#if !defined (_CORBA_LOCALINTERFACEDEF___CI_)
#define _CORBA_LOCALINTERFACEDEF___CI_

ACE_INLINE
CORBA_LocalInterfaceDef::CORBA_LocalInterfaceDef (
    TAO_Stub *objref,
    CORBA::Boolean _tao_collocated,
    TAO_Abstract_ServantBase *servant
  )
  : CORBA_Object (objref, _tao_collocated, servant)
{
  this->CORBA_LocalInterfaceDef_setup_collocation (_tao_collocated);
}


#endif /* end #if !defined */

TAO_IFR_Client_Export CORBA::Boolean operator<< (
    TAO_OutputCDR &,
    const CORBA_PrimitiveDef_ptr
  );

TAO_IFR_Client_Export CORBA::Boolean operator>> (
    TAO_InputCDR &,
    CORBA_PrimitiveDef_ptr &
  );

TAO_IFR_Client_Export CORBA::Boolean operator<< (
    TAO_OutputCDR &,
    const CORBA_StringDef_ptr
  );

TAO_IFR_Client_Export CORBA::Boolean operator>> (
    TAO_InputCDR &,
    CORBA_StringDef_ptr &
  );

TAO_IFR_Client_Export CORBA::Boolean operator<< (
    TAO_OutputCDR &,
    const CORBA_SequenceDef_ptr
  );

TAO_IFR_Client_Export CORBA::Boolean operator>> (
    TAO_InputCDR &,
    CORBA_SequenceDef_ptr &
  );

TAO_IFR_Client_Export CORBA::Boolean operator<< (
    TAO_OutputCDR &,
    const CORBA_ArrayDef_ptr
  );

TAO_IFR_Client_Export CORBA::Boolean operator>> (
    TAO_InputCDR &,
    CORBA_ArrayDef_ptr &
  );

TAO_IFR_Client_Export CORBA::Boolean operator<< (
    TAO_OutputCDR &,
    const CORBA_WstringDef_ptr
  );

TAO_IFR_Client_Export CORBA::Boolean operator>> (
    TAO_InputCDR &,
    CORBA_WstringDef_ptr &
  );

TAO_IFR_Client_Export CORBA::Boolean operator<< (
    TAO_OutputCDR &,
    const CORBA_FixedDef_ptr
  );

TAO_IFR_Client_Export CORBA::Boolean operator>> (
    TAO_InputCDR &,
    CORBA_FixedDef_ptr &
  );

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

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

TAO_IFR_Client_Export CORBA::Boolean operator<< (
    TAO_OutputCDR &,
    const CORBA_Repository_ptr
  );

TAO_IFR_Client_Export CORBA::Boolean operator>> (
    TAO_InputCDR &,
    CORBA_Repository_ptr &
  );

TAO_IFR_Client_Export CORBA::Boolean operator<< (
    TAO_OutputCDR &,
    const CORBA_ModuleDef_ptr
  );

TAO_IFR_Client_Export CORBA::Boolean operator>> (
    TAO_InputCDR &,
    CORBA_ModuleDef_ptr &
  );

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

TAO_IFR_Client_Export CORBA::Boolean operator<< (
    TAO_OutputCDR &,
    const CORBA_ConstantDef_ptr
  );

TAO_IFR_Client_Export CORBA::Boolean operator>> (
    TAO_InputCDR &,
    CORBA_ConstantDef_ptr &
  );

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

TAO_IFR_Client_Export CORBA::Boolean operator<< (
    TAO_OutputCDR &,
    const CORBA_StructDef_ptr
  );

TAO_IFR_Client_Export CORBA::Boolean operator>> (
    TAO_InputCDR &,
    CORBA_StructDef_ptr &
  );

TAO_IFR_Client_Export CORBA::Boolean operator<< (
    TAO_OutputCDR &,
    const CORBA_UnionDef_ptr
  );

TAO_IFR_Client_Export CORBA::Boolean operator>> (
    TAO_InputCDR &,
    CORBA_UnionDef_ptr &
  );

TAO_IFR_Client_Export CORBA::Boolean operator<< (
    TAO_OutputCDR &,
    const CORBA_EnumDef_ptr
  );

TAO_IFR_Client_Export CORBA::Boolean operator>> (
    TAO_InputCDR &,
    CORBA_EnumDef_ptr &
  );

TAO_IFR_Client_Export CORBA::Boolean operator<< (
    TAO_OutputCDR &,
    const CORBA_AliasDef_ptr
  );

TAO_IFR_Client_Export CORBA::Boolean operator>> (
    TAO_InputCDR &,
    CORBA_AliasDef_ptr &
  );

TAO_IFR_Client_Export CORBA::Boolean operator<< (
    TAO_OutputCDR &,
    const CORBA_NativeDef_ptr
  );

TAO_IFR_Client_Export CORBA::Boolean operator>> (
    TAO_InputCDR &,
    CORBA_NativeDef_ptr &
  );

TAO_IFR_Client_Export CORBA::Boolean operator<< (
    TAO_OutputCDR &,
    const CORBA_ExceptionDef_ptr
  );

TAO_IFR_Client_Export CORBA::Boolean operator>> (
    TAO_InputCDR &,
    CORBA_ExceptionDef_ptr &
  );

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


#if !defined _TAO_CDR_OP_CORBA_ExceptionDefSeq_I_
#define _TAO_CDR_OP_CORBA_ExceptionDefSeq_I_

CORBA::Boolean TAO_IFR_Client_Export operator<< (
    TAO_OutputCDR &,
    const CORBA_ExceptionDefSeq &
  );
CORBA::Boolean TAO_IFR_Client_Export operator>> (
    TAO_InputCDR &,
    CORBA_ExceptionDefSeq &
  );

#endif /* _TAO_CDR_OP_CORBA_ExceptionDefSeq_I_ */


#if !defined _TAO_CDR_OP_CORBA_ExcDescriptionSeq_I_
#define _TAO_CDR_OP_CORBA_ExcDescriptionSeq_I_

CORBA::Boolean TAO_IFR_Client_Export operator<< (
    TAO_OutputCDR &,
    const CORBA_ExcDescriptionSeq &
  );
CORBA::Boolean TAO_IFR_Client_Export operator>> (
    TAO_InputCDR &,
    CORBA_ExcDescriptionSeq &
  );

#endif /* _TAO_CDR_OP_CORBA_ExcDescriptionSeq_I_ */

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

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

TAO_IFR_Client_Export CORBA::Boolean operator<< (
    TAO_OutputCDR &,
    const CORBA_AttributeDef_ptr
  );

TAO_IFR_Client_Export CORBA::Boolean operator>> (
    TAO_InputCDR &,
    CORBA_AttributeDef_ptr &
  );

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)
{
  CORBA::ULong _tao_temp = _tao_enumval;
  return strm << _tao_temp;
}

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

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


#if !defined _TAO_CDR_OP_CORBA_ParDescriptionSeq_I_
#define _TAO_CDR_OP_CORBA_ParDescriptionSeq_I_

CORBA::Boolean TAO_IFR_Client_Export operator<< (
    TAO_OutputCDR &,
    const CORBA_ParDescriptionSeq &
  );
CORBA::Boolean TAO_IFR_Client_Export operator>> (
    TAO_InputCDR &,
    CORBA_ParDescriptionSeq &
  );

#endif /* _TAO_CDR_OP_CORBA_ParDescriptionSeq_I_ */


#if !defined _TAO_CDR_OP_CORBA_ContextIdSeq_I_
#define _TAO_CDR_OP_CORBA_ContextIdSeq_I_

CORBA::Boolean TAO_IFR_Client_Export operator<< (
    TAO_OutputCDR &,
    const CORBA_ContextIdSeq &
  );
CORBA::Boolean TAO_IFR_Client_Export operator>> (
    TAO_InputCDR &,
    CORBA_ContextIdSeq &
  );

#endif /* _TAO_CDR_OP_CORBA_ContextIdSeq_I_ */

TAO_IFR_Client_Export CORBA::Boolean operator<< (
    TAO_OutputCDR &,
    const CORBA_OperationDef_ptr
  );

TAO_IFR_Client_Export CORBA::Boolean operator>> (
    TAO_InputCDR &,
    CORBA_OperationDef_ptr &
  );

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


#if !defined _TAO_CDR_OP_CORBA_RepositoryIdSeq_I_
#define _TAO_CDR_OP_CORBA_RepositoryIdSeq_I_

CORBA::Boolean TAO_IFR_Client_Export operator<< (
    TAO_OutputCDR &,
    const CORBA_RepositoryIdSeq &
  );
CORBA::Boolean TAO_IFR_Client_Export operator>> (
    TAO_InputCDR &,
    CORBA_RepositoryIdSeq &
  );

#endif /* _TAO_CDR_OP_CORBA_RepositoryIdSeq_I_ */


#if !defined _TAO_CDR_OP_CORBA_OpDescriptionSeq_I_
#define _TAO_CDR_OP_CORBA_OpDescriptionSeq_I_

CORBA::Boolean TAO_IFR_Client_Export operator<< (
    TAO_OutputCDR &,
    const CORBA_OpDescriptionSeq &
  );
CORBA::Boolean TAO_IFR_Client_Export operator>> (
    TAO_InputCDR &,
    CORBA_OpDescriptionSeq &
  );

#endif /* _TAO_CDR_OP_CORBA_OpDescriptionSeq_I_ */


#if !defined _TAO_CDR_OP_CORBA_AttrDescriptionSeq_I_
#define _TAO_CDR_OP_CORBA_AttrDescriptionSeq_I_

CORBA::Boolean TAO_IFR_Client_Export operator<< (
    TAO_OutputCDR &,
    const CORBA_AttrDescriptionSeq &
  );
CORBA::Boolean TAO_IFR_Client_Export operator>> (
    TAO_InputCDR &,
    CORBA_AttrDescriptionSeq &
  );

#endif /* _TAO_CDR_OP_CORBA_AttrDescriptionSeq_I_ */

TAO_IFR_Client_Export CORBA::Boolean operator<< (
    TAO_OutputCDR &,
    const CORBA_InterfaceDef_ptr
  );

TAO_IFR_Client_Export 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 ())
  )
    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 ())
  )
    return 1;
  else
    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)
  )
    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)
  )
    return 1;
  else
    return 0;
  
}

TAO_IFR_Client_Export CORBA::Boolean operator<< (
    TAO_OutputCDR &,
    const CORBA_AbstractInterfaceDef_ptr
  );

TAO_IFR_Client_Export CORBA::Boolean operator>> (
    TAO_InputCDR &,
    CORBA_AbstractInterfaceDef_ptr &
  );

TAO_IFR_Client_Export CORBA::Boolean operator<< (
    TAO_OutputCDR &,
    const CORBA_LocalInterfaceDef_ptr
  );

TAO_IFR_Client_Export CORBA::Boolean operator>> (
    TAO_InputCDR &,
    CORBA_LocalInterfaceDef_ptr &
  );