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

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

ACE_INLINE
ImplementationRepository::ServerObject::ServerObject (void) // default constructor
{}

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

ACE_INLINE
ImplementationRepository::ServerObject::~ServerObject (void) // destructor
{}


#if !defined (_IMPLEMENTATIONREPOSITORY_SERVEROBJECT___VAR_CI_)
#define _IMPLEMENTATIONREPOSITORY_SERVEROBJECT___VAR_CI_

// *************************************************************
// Inline operations for class ImplementationRepository::ServerObject_var
// *************************************************************

ACE_INLINE
ImplementationRepository::ServerObject_var::ServerObject_var (void) // default constructor
  : ptr_ (ImplementationRepository::ServerObject::_nil ())
{}

ACE_INLINE
ImplementationRepository::ServerObject_var::ServerObject_var (ImplementationRepository::ServerObject_ptr p)
  : ptr_ (p)
{}

ACE_INLINE ImplementationRepository::ServerObject_ptr
ImplementationRepository::ServerObject_var::ptr (void) const
{
  return this->ptr_;
}

ACE_INLINE
ImplementationRepository::ServerObject_var::ServerObject_var (const ImplementationRepository::ServerObject_var &p) // copy constructor
  : ptr_ (ImplementationRepository::ServerObject::_duplicate (p.ptr ()))
{}

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

ACE_INLINE ImplementationRepository::ServerObject_var &
ImplementationRepository::ServerObject_var::operator= (ImplementationRepository::ServerObject_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE
ImplementationRepository::ServerObject_var::operator const ImplementationRepository::ServerObject_ptr &() const // cast
{
  return this->ptr_;
}

ACE_INLINE
ImplementationRepository::ServerObject_var::operator ImplementationRepository::ServerObject_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE ImplementationRepository::ServerObject_ptr
ImplementationRepository::ServerObject_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE ImplementationRepository::ServerObject_ptr
ImplementationRepository::ServerObject_var::in (void) const
{
  return this->ptr_;
}

ACE_INLINE ImplementationRepository::ServerObject_ptr &
ImplementationRepository::ServerObject_var::inout (void)
{
  return this->ptr_;
}

ACE_INLINE ImplementationRepository::ServerObject_ptr &
ImplementationRepository::ServerObject_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ImplementationRepository::ServerObject::_nil ();
  return this->ptr_;
}

ACE_INLINE ImplementationRepository::ServerObject_ptr
ImplementationRepository::ServerObject_var::_retn (void)
{
  // yield ownership of managed obj reference
  ImplementationRepository::ServerObject_ptr val = this->ptr_;
  this->ptr_ = ImplementationRepository::ServerObject::_nil ();
  return val;
}


#endif /* end #if !defined */


#if !defined (_IMPLEMENTATIONREPOSITORY_SERVEROBJECT___OUT_CI_)
#define _IMPLEMENTATIONREPOSITORY_SERVEROBJECT___OUT_CI_

// *************************************************************
// Inline operations for class ImplementationRepository::ServerObject_out
// *************************************************************

ACE_INLINE
ImplementationRepository::ServerObject_out::ServerObject_out (ImplementationRepository::ServerObject_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ImplementationRepository::ServerObject::_nil ();
}

ACE_INLINE
ImplementationRepository::ServerObject_out::ServerObject_out (ImplementationRepository::ServerObject_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ImplementationRepository::ServerObject::_nil ();
}

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

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

ACE_INLINE ImplementationRepository::ServerObject_out &
ImplementationRepository::ServerObject_out::operator= (const ImplementationRepository::ServerObject_var &p)
{
  this->ptr_ = ImplementationRepository::ServerObject::_duplicate (p.ptr ());
  return *this;
}

ACE_INLINE ImplementationRepository::ServerObject_out &
ImplementationRepository::ServerObject_out::operator= (ImplementationRepository::ServerObject_ptr p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE
ImplementationRepository::ServerObject_out::operator ImplementationRepository::ServerObject_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE ImplementationRepository::ServerObject_ptr &
ImplementationRepository::ServerObject_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE ImplementationRepository::ServerObject_ptr
ImplementationRepository::ServerObject_out::operator-> (void)
{
  return this->ptr_;
}


#endif /* end #if !defined */

// *************************************************************
// Inline operations for class ImplementationRepository::EnvironmentVariable_var
// *************************************************************

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

ACE_INLINE
ImplementationRepository::EnvironmentVariable_var::EnvironmentVariable_var (ImplementationRepository::EnvironmentVariable *p)
  : ptr_ (p)
{}

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

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

ACE_INLINE ImplementationRepository::EnvironmentVariable_var &
ImplementationRepository::EnvironmentVariable_var::operator= (ImplementationRepository::EnvironmentVariable *p)
{
  delete this->ptr_;
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE const ImplementationRepository::EnvironmentVariable *
ImplementationRepository::EnvironmentVariable_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE ImplementationRepository::EnvironmentVariable *
ImplementationRepository::EnvironmentVariable_var::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE
ImplementationRepository::EnvironmentVariable_var::operator const ImplementationRepository::EnvironmentVariable &() const // cast
{
  return *this->ptr_;
}

ACE_INLINE
ImplementationRepository::EnvironmentVariable_var::operator ImplementationRepository::EnvironmentVariable &() // cast
{
  return *this->ptr_;
}

ACE_INLINE
ImplementationRepository::EnvironmentVariable_var::operator ImplementationRepository::EnvironmentVariable &() const// cast
{
  return *this->ptr_;
}

ACE_INLINE const ImplementationRepository::EnvironmentVariable &
ImplementationRepository::EnvironmentVariable_var::in (void) const
{
  return *this->ptr_;
}

ACE_INLINE ImplementationRepository::EnvironmentVariable &
ImplementationRepository::EnvironmentVariable_var::inout (void)
{
  return *this->ptr_;
}

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

ACE_INLINE ImplementationRepository::EnvironmentVariable *
ImplementationRepository::EnvironmentVariable_var::_retn (void)
{
  ImplementationRepository::EnvironmentVariable *tmp = this->ptr_;
  this->ptr_ = 0;
  return tmp;
}

ACE_INLINE ImplementationRepository::EnvironmentVariable *
ImplementationRepository::EnvironmentVariable_var::ptr (void) const
{
  return this->ptr_;
}

// *************************************************************
// Inline operations for class ImplementationRepository::EnvironmentVariable_out
// *************************************************************

ACE_INLINE
ImplementationRepository::EnvironmentVariable_out::EnvironmentVariable_out (ImplementationRepository::EnvironmentVariable *&p)
  : ptr_ (p)
{
  this->ptr_ = 0;
}

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

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

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

ACE_INLINE ImplementationRepository::EnvironmentVariable_out &
ImplementationRepository::EnvironmentVariable_out::operator= (ImplementationRepository::EnvironmentVariable *p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE
ImplementationRepository::EnvironmentVariable_out::operator ImplementationRepository::EnvironmentVariable *&() // cast
{
  return this->ptr_;
}

ACE_INLINE ImplementationRepository::EnvironmentVariable *&
ImplementationRepository::EnvironmentVariable_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE ImplementationRepository::EnvironmentVariable *
ImplementationRepository::EnvironmentVariable_out::operator-> (void)
{
  return this->ptr_;
}


#if !defined (TAO_USE_SEQUENCE_TEMPLATES)

#if !defined (__TAO_UNBOUNDED_SEQUENCE_IMPLEMENTATIONREPOSITORY_ENVIRONMENTLIST_CI_)
#define __TAO_UNBOUNDED_SEQUENCE_IMPLEMENTATIONREPOSITORY_ENVIRONMENTLIST_CI_

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

  ACE_INLINE void ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList::freebuf (ImplementationRepository::EnvironmentVariable *buffer)
  // Free the sequence.
  {
    delete [] buffer;
  }

  ACE_INLINE
  ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList::_TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList (void) // Default constructor.
  {
  }

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

  ACE_INLINE
  ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList::_TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList (CORBA::ULong maximum,
    CORBA::ULong length,
    ImplementationRepository::EnvironmentVariable *data,
    CORBA::Boolean release)
  : TAO_Unbounded_Base_Sequence (maximum, length, data, release)
  {
  }

  ACE_INLINE
  ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList::_TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList (const ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList &rhs)
  // Copy constructor.
    : TAO_Unbounded_Base_Sequence (rhs)
  {
    if (rhs.buffer_ != 0)
    {
      ImplementationRepository::EnvironmentVariable *tmp1 = ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList::allocbuf (this->maximum_);
      ImplementationRepository::EnvironmentVariable * const tmp2 = ACE_reinterpret_cast (ImplementationRepository::EnvironmentVariable * 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 ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList &
  ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList::operator= (const ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList &rhs)
  // Assignment operator.
  {
    if (this == &rhs)
      return *this;

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

    TAO_Unbounded_Base_Sequence::operator= (rhs);

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

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

    return *this;
  }

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

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

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

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

  ACE_INLINE const ImplementationRepository::EnvironmentVariable *
  ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList::get_buffer (void) const
  {
    return ACE_reinterpret_cast(const ImplementationRepository::EnvironmentVariable * ACE_CAST_CONST, this->buffer_);
  }

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

#endif /* end #if !defined */


#endif /* !TAO_USE_SEQUENCE_TEMPLATES */

#if !defined (_IMPLEMENTATIONREPOSITORY_ENVIRONMENTLIST_CI_)
#define _IMPLEMENTATIONREPOSITORY_ENVIRONMENTLIST_CI_

// *************************************************************
// Inline operations for class ImplementationRepository::EnvironmentList_var
// *************************************************************

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

ACE_INLINE
ImplementationRepository::EnvironmentList_var::EnvironmentList_var (ImplementationRepository::EnvironmentList *p)
  : ptr_ (p)
{}

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

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

ACE_INLINE ImplementationRepository::EnvironmentList_var &
ImplementationRepository::EnvironmentList_var::operator= (ImplementationRepository::EnvironmentList *p)
{
  delete this->ptr_;
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE const ImplementationRepository::EnvironmentList *
ImplementationRepository::EnvironmentList_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE ImplementationRepository::EnvironmentList *
ImplementationRepository::EnvironmentList_var::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE
ImplementationRepository::EnvironmentList_var::operator const ImplementationRepository::EnvironmentList &() const // cast
{
  return *this->ptr_;
}

ACE_INLINE
ImplementationRepository::EnvironmentList_var::operator ImplementationRepository::EnvironmentList &() // cast
{
  return *this->ptr_;
}

ACE_INLINE
ImplementationRepository::EnvironmentList_var::operator ImplementationRepository::EnvironmentList &() const// cast
{
  return *this->ptr_;
}

ACE_INLINE ImplementationRepository::EnvironmentVariable &
ImplementationRepository::EnvironmentList_var::operator[] (CORBA::ULong index)
{
  return this->ptr_->operator[] (index);
}

ACE_INLINE const ImplementationRepository::EnvironmentList &
ImplementationRepository::EnvironmentList_var::in (void) const
{
  return *this->ptr_;
}

ACE_INLINE ImplementationRepository::EnvironmentList &
ImplementationRepository::EnvironmentList_var::inout (void)
{
  return *this->ptr_;
}

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

ACE_INLINE ImplementationRepository::EnvironmentList *
ImplementationRepository::EnvironmentList_var::_retn (void)
{
  ImplementationRepository::EnvironmentList *tmp = this->ptr_;
  this->ptr_ = 0;
  return tmp;
}

ACE_INLINE ImplementationRepository::EnvironmentList *
ImplementationRepository::EnvironmentList_var::ptr (void) const
{
  return this->ptr_;
}

// *************************************************************
// Inline operations for class ImplementationRepository::EnvironmentList_out
// *************************************************************

ACE_INLINE
ImplementationRepository::EnvironmentList_out::EnvironmentList_out (ImplementationRepository::EnvironmentList *&p)
  : ptr_ (p)
{
  this->ptr_ = 0;
}

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

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

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

ACE_INLINE ImplementationRepository::EnvironmentList_out &
ImplementationRepository::EnvironmentList_out::operator= (ImplementationRepository::EnvironmentList *p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE
ImplementationRepository::EnvironmentList_out::operator ImplementationRepository::EnvironmentList *&() // cast
{
  return this->ptr_;
}

ACE_INLINE ImplementationRepository::EnvironmentList *&
ImplementationRepository::EnvironmentList_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE ImplementationRepository::EnvironmentList *
ImplementationRepository::EnvironmentList_out::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE ImplementationRepository::EnvironmentVariable &
ImplementationRepository::EnvironmentList_out::operator[] (CORBA::ULong index)
{
  return this->ptr_->operator[] (index);
}


#endif /* end #if !defined */

// *************************************************************
// Inline operations for class ImplementationRepository::StartupOptions_var
// *************************************************************

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

ACE_INLINE
ImplementationRepository::StartupOptions_var::StartupOptions_var (ImplementationRepository::StartupOptions *p)
  : ptr_ (p)
{}

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

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

ACE_INLINE ImplementationRepository::StartupOptions_var &
ImplementationRepository::StartupOptions_var::operator= (ImplementationRepository::StartupOptions *p)
{
  delete this->ptr_;
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE const ImplementationRepository::StartupOptions *
ImplementationRepository::StartupOptions_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE ImplementationRepository::StartupOptions *
ImplementationRepository::StartupOptions_var::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE
ImplementationRepository::StartupOptions_var::operator const ImplementationRepository::StartupOptions &() const // cast
{
  return *this->ptr_;
}

ACE_INLINE
ImplementationRepository::StartupOptions_var::operator ImplementationRepository::StartupOptions &() // cast
{
  return *this->ptr_;
}

ACE_INLINE
ImplementationRepository::StartupOptions_var::operator ImplementationRepository::StartupOptions &() const// cast
{
  return *this->ptr_;
}

ACE_INLINE const ImplementationRepository::StartupOptions &
ImplementationRepository::StartupOptions_var::in (void) const
{
  return *this->ptr_;
}

ACE_INLINE ImplementationRepository::StartupOptions &
ImplementationRepository::StartupOptions_var::inout (void)
{
  return *this->ptr_;
}

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

ACE_INLINE ImplementationRepository::StartupOptions *
ImplementationRepository::StartupOptions_var::_retn (void)
{
  ImplementationRepository::StartupOptions *tmp = this->ptr_;
  this->ptr_ = 0;
  return tmp;
}

ACE_INLINE ImplementationRepository::StartupOptions *
ImplementationRepository::StartupOptions_var::ptr (void) const
{
  return this->ptr_;
}

// *************************************************************
// Inline operations for class ImplementationRepository::StartupOptions_out
// *************************************************************

ACE_INLINE
ImplementationRepository::StartupOptions_out::StartupOptions_out (ImplementationRepository::StartupOptions *&p)
  : ptr_ (p)
{
  this->ptr_ = 0;
}

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

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

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

ACE_INLINE ImplementationRepository::StartupOptions_out &
ImplementationRepository::StartupOptions_out::operator= (ImplementationRepository::StartupOptions *p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE
ImplementationRepository::StartupOptions_out::operator ImplementationRepository::StartupOptions *&() // cast
{
  return this->ptr_;
}

ACE_INLINE ImplementationRepository::StartupOptions *&
ImplementationRepository::StartupOptions_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE ImplementationRepository::StartupOptions *
ImplementationRepository::StartupOptions_out::operator-> (void)
{
  return this->ptr_;
}

// *************************************************************
// Inline operations for class ImplementationRepository::ServerInformation_var
// *************************************************************

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

ACE_INLINE
ImplementationRepository::ServerInformation_var::ServerInformation_var (ImplementationRepository::ServerInformation *p)
  : ptr_ (p)
{}

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

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

ACE_INLINE ImplementationRepository::ServerInformation_var &
ImplementationRepository::ServerInformation_var::operator= (ImplementationRepository::ServerInformation *p)
{
  delete this->ptr_;
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE const ImplementationRepository::ServerInformation *
ImplementationRepository::ServerInformation_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE ImplementationRepository::ServerInformation *
ImplementationRepository::ServerInformation_var::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE
ImplementationRepository::ServerInformation_var::operator const ImplementationRepository::ServerInformation &() const // cast
{
  return *this->ptr_;
}

ACE_INLINE
ImplementationRepository::ServerInformation_var::operator ImplementationRepository::ServerInformation &() // cast
{
  return *this->ptr_;
}

ACE_INLINE
ImplementationRepository::ServerInformation_var::operator ImplementationRepository::ServerInformation &() const// cast
{
  return *this->ptr_;
}

ACE_INLINE const ImplementationRepository::ServerInformation &
ImplementationRepository::ServerInformation_var::in (void) const
{
  return *this->ptr_;
}

ACE_INLINE ImplementationRepository::ServerInformation &
ImplementationRepository::ServerInformation_var::inout (void)
{
  return *this->ptr_;
}

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

ACE_INLINE ImplementationRepository::ServerInformation *
ImplementationRepository::ServerInformation_var::_retn (void)
{
  ImplementationRepository::ServerInformation *tmp = this->ptr_;
  this->ptr_ = 0;
  return tmp;
}

ACE_INLINE ImplementationRepository::ServerInformation *
ImplementationRepository::ServerInformation_var::ptr (void) const
{
  return this->ptr_;
}

// *************************************************************
// Inline operations for class ImplementationRepository::ServerInformation_out
// *************************************************************

ACE_INLINE
ImplementationRepository::ServerInformation_out::ServerInformation_out (ImplementationRepository::ServerInformation *&p)
  : ptr_ (p)
{
  this->ptr_ = 0;
}

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

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

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

ACE_INLINE ImplementationRepository::ServerInformation_out &
ImplementationRepository::ServerInformation_out::operator= (ImplementationRepository::ServerInformation *p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE
ImplementationRepository::ServerInformation_out::operator ImplementationRepository::ServerInformation *&() // cast
{
  return this->ptr_;
}

ACE_INLINE ImplementationRepository::ServerInformation *&
ImplementationRepository::ServerInformation_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE ImplementationRepository::ServerInformation *
ImplementationRepository::ServerInformation_out::operator-> (void)
{
  return this->ptr_;
}


#if !defined (TAO_USE_SEQUENCE_TEMPLATES)

#if !defined (__TAO_UNBOUNDED_SEQUENCE_IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONLIST_CI_)
#define __TAO_UNBOUNDED_SEQUENCE_IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONLIST_CI_

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

  ACE_INLINE void ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList::freebuf (ImplementationRepository::ServerInformation *buffer)
  // Free the sequence.
  {
    delete [] buffer;
  }

  ACE_INLINE
  ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList::_TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList (void) // Default constructor.
  {
  }

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

  ACE_INLINE
  ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList::_TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList (CORBA::ULong maximum,
    CORBA::ULong length,
    ImplementationRepository::ServerInformation *data,
    CORBA::Boolean release)
  : TAO_Unbounded_Base_Sequence (maximum, length, data, release)
  {
  }

  ACE_INLINE
  ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList::_TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList (const ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList &rhs)
  // Copy constructor.
    : TAO_Unbounded_Base_Sequence (rhs)
  {
    if (rhs.buffer_ != 0)
    {
      ImplementationRepository::ServerInformation *tmp1 = ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList::allocbuf (this->maximum_);
      ImplementationRepository::ServerInformation * const tmp2 = ACE_reinterpret_cast (ImplementationRepository::ServerInformation * 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 ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList &
  ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList::operator= (const ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList &rhs)
  // Assignment operator.
  {
    if (this == &rhs)
      return *this;

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

    TAO_Unbounded_Base_Sequence::operator= (rhs);

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

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

    return *this;
  }

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

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

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

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

  ACE_INLINE const ImplementationRepository::ServerInformation *
  ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList::get_buffer (void) const
  {
    return ACE_reinterpret_cast(const ImplementationRepository::ServerInformation * ACE_CAST_CONST, this->buffer_);
  }

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

#endif /* end #if !defined */


#endif /* !TAO_USE_SEQUENCE_TEMPLATES */

#if !defined (_IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONLIST_CI_)
#define _IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONLIST_CI_

// *************************************************************
// Inline operations for class ImplementationRepository::ServerInformationList_var
// *************************************************************

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

ACE_INLINE
ImplementationRepository::ServerInformationList_var::ServerInformationList_var (ImplementationRepository::ServerInformationList *p)
  : ptr_ (p)
{}

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

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

ACE_INLINE ImplementationRepository::ServerInformationList_var &
ImplementationRepository::ServerInformationList_var::operator= (ImplementationRepository::ServerInformationList *p)
{
  delete this->ptr_;
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE const ImplementationRepository::ServerInformationList *
ImplementationRepository::ServerInformationList_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE ImplementationRepository::ServerInformationList *
ImplementationRepository::ServerInformationList_var::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE
ImplementationRepository::ServerInformationList_var::operator const ImplementationRepository::ServerInformationList &() const // cast
{
  return *this->ptr_;
}

ACE_INLINE
ImplementationRepository::ServerInformationList_var::operator ImplementationRepository::ServerInformationList &() // cast
{
  return *this->ptr_;
}

ACE_INLINE
ImplementationRepository::ServerInformationList_var::operator ImplementationRepository::ServerInformationList &() const// cast
{
  return *this->ptr_;
}

ACE_INLINE ImplementationRepository::ServerInformation &
ImplementationRepository::ServerInformationList_var::operator[] (CORBA::ULong index)
{
  return this->ptr_->operator[] (index);
}

ACE_INLINE const ImplementationRepository::ServerInformationList &
ImplementationRepository::ServerInformationList_var::in (void) const
{
  return *this->ptr_;
}

ACE_INLINE ImplementationRepository::ServerInformationList &
ImplementationRepository::ServerInformationList_var::inout (void)
{
  return *this->ptr_;
}

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

ACE_INLINE ImplementationRepository::ServerInformationList *
ImplementationRepository::ServerInformationList_var::_retn (void)
{
  ImplementationRepository::ServerInformationList *tmp = this->ptr_;
  this->ptr_ = 0;
  return tmp;
}

ACE_INLINE ImplementationRepository::ServerInformationList *
ImplementationRepository::ServerInformationList_var::ptr (void) const
{
  return this->ptr_;
}

// *************************************************************
// Inline operations for class ImplementationRepository::ServerInformationList_out
// *************************************************************

ACE_INLINE
ImplementationRepository::ServerInformationList_out::ServerInformationList_out (ImplementationRepository::ServerInformationList *&p)
  : ptr_ (p)
{
  this->ptr_ = 0;
}

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

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

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

ACE_INLINE ImplementationRepository::ServerInformationList_out &
ImplementationRepository::ServerInformationList_out::operator= (ImplementationRepository::ServerInformationList *p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE
ImplementationRepository::ServerInformationList_out::operator ImplementationRepository::ServerInformationList *&() // cast
{
  return this->ptr_;
}

ACE_INLINE ImplementationRepository::ServerInformationList *&
ImplementationRepository::ServerInformationList_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE ImplementationRepository::ServerInformationList *
ImplementationRepository::ServerInformationList_out::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE ImplementationRepository::ServerInformation &
ImplementationRepository::ServerInformationList_out::operator[] (CORBA::ULong index)
{
  return this->ptr_->operator[] (index);
}


#endif /* end #if !defined */

ACE_INLINE
ImplementationRepository::Administration::Administration (void) // default constructor
{}

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

ACE_INLINE
ImplementationRepository::Administration::~Administration (void) // destructor
{}


#if !defined (_IMPLEMENTATIONREPOSITORY_ADMINISTRATION___VAR_CI_)
#define _IMPLEMENTATIONREPOSITORY_ADMINISTRATION___VAR_CI_

// *************************************************************
// Inline operations for class ImplementationRepository::Administration_var
// *************************************************************

ACE_INLINE
ImplementationRepository::Administration_var::Administration_var (void) // default constructor
  : ptr_ (ImplementationRepository::Administration::_nil ())
{}

ACE_INLINE
ImplementationRepository::Administration_var::Administration_var (ImplementationRepository::Administration_ptr p)
  : ptr_ (p)
{}

ACE_INLINE ImplementationRepository::Administration_ptr
ImplementationRepository::Administration_var::ptr (void) const
{
  return this->ptr_;
}

ACE_INLINE
ImplementationRepository::Administration_var::Administration_var (const ImplementationRepository::Administration_var &p) // copy constructor
  : ptr_ (ImplementationRepository::Administration::_duplicate (p.ptr ()))
{}

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

ACE_INLINE ImplementationRepository::Administration_var &
ImplementationRepository::Administration_var::operator= (ImplementationRepository::Administration_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE
ImplementationRepository::Administration_var::operator const ImplementationRepository::Administration_ptr &() const // cast
{
  return this->ptr_;
}

ACE_INLINE
ImplementationRepository::Administration_var::operator ImplementationRepository::Administration_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE ImplementationRepository::Administration_ptr
ImplementationRepository::Administration_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE ImplementationRepository::Administration_ptr
ImplementationRepository::Administration_var::in (void) const
{
  return this->ptr_;
}

ACE_INLINE ImplementationRepository::Administration_ptr &
ImplementationRepository::Administration_var::inout (void)
{
  return this->ptr_;
}

ACE_INLINE ImplementationRepository::Administration_ptr &
ImplementationRepository::Administration_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ImplementationRepository::Administration::_nil ();
  return this->ptr_;
}

ACE_INLINE ImplementationRepository::Administration_ptr
ImplementationRepository::Administration_var::_retn (void)
{
  // yield ownership of managed obj reference
  ImplementationRepository::Administration_ptr val = this->ptr_;
  this->ptr_ = ImplementationRepository::Administration::_nil ();
  return val;
}


#endif /* end #if !defined */


#if !defined (_IMPLEMENTATIONREPOSITORY_ADMINISTRATION___OUT_CI_)
#define _IMPLEMENTATIONREPOSITORY_ADMINISTRATION___OUT_CI_

// *************************************************************
// Inline operations for class ImplementationRepository::Administration_out
// *************************************************************

ACE_INLINE
ImplementationRepository::Administration_out::Administration_out (ImplementationRepository::Administration_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ImplementationRepository::Administration::_nil ();
}

ACE_INLINE
ImplementationRepository::Administration_out::Administration_out (ImplementationRepository::Administration_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ImplementationRepository::Administration::_nil ();
}

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

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

ACE_INLINE ImplementationRepository::Administration_out &
ImplementationRepository::Administration_out::operator= (const ImplementationRepository::Administration_var &p)
{
  this->ptr_ = ImplementationRepository::Administration::_duplicate (p.ptr ());
  return *this;
}

ACE_INLINE ImplementationRepository::Administration_out &
ImplementationRepository::Administration_out::operator= (ImplementationRepository::Administration_ptr p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE
ImplementationRepository::Administration_out::operator ImplementationRepository::Administration_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE ImplementationRepository::Administration_ptr &
ImplementationRepository::Administration_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE ImplementationRepository::Administration_ptr
ImplementationRepository::Administration_out::operator-> (void)
{
  return this->ptr_;
}


#endif /* end #if !defined */

// *************************************************************
// Inline operations for exception ImplementationRepository::Administration::AlreadyRegistered
// *************************************************************

// *************************************************************
// Inline operations for exception ImplementationRepository::Administration::CannotActivate
// *************************************************************

// *************************************************************
// Inline operations for exception ImplementationRepository::Administration::NotFound
// *************************************************************

ACE_INLINE
ImplementationRepository::ServerInformationIterator::ServerInformationIterator (void) // default constructor
{}

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

ACE_INLINE
ImplementationRepository::ServerInformationIterator::~ServerInformationIterator (void) // destructor
{}


#if !defined (_IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONITERATOR___VAR_CI_)
#define _IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONITERATOR___VAR_CI_

// *************************************************************
// Inline operations for class ImplementationRepository::ServerInformationIterator_var
// *************************************************************

ACE_INLINE
ImplementationRepository::ServerInformationIterator_var::ServerInformationIterator_var (void) // default constructor
  : ptr_ (ImplementationRepository::ServerInformationIterator::_nil ())
{}

ACE_INLINE
ImplementationRepository::ServerInformationIterator_var::ServerInformationIterator_var (ImplementationRepository::ServerInformationIterator_ptr p)
  : ptr_ (p)
{}

ACE_INLINE ImplementationRepository::ServerInformationIterator_ptr
ImplementationRepository::ServerInformationIterator_var::ptr (void) const
{
  return this->ptr_;
}

ACE_INLINE
ImplementationRepository::ServerInformationIterator_var::ServerInformationIterator_var (const ImplementationRepository::ServerInformationIterator_var &p) // copy constructor
  : ptr_ (ImplementationRepository::ServerInformationIterator::_duplicate (p.ptr ()))
{}

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

ACE_INLINE ImplementationRepository::ServerInformationIterator_var &
ImplementationRepository::ServerInformationIterator_var::operator= (ImplementationRepository::ServerInformationIterator_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE
ImplementationRepository::ServerInformationIterator_var::operator const ImplementationRepository::ServerInformationIterator_ptr &() const // cast
{
  return this->ptr_;
}

ACE_INLINE
ImplementationRepository::ServerInformationIterator_var::operator ImplementationRepository::ServerInformationIterator_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE ImplementationRepository::ServerInformationIterator_ptr
ImplementationRepository::ServerInformationIterator_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE ImplementationRepository::ServerInformationIterator_ptr
ImplementationRepository::ServerInformationIterator_var::in (void) const
{
  return this->ptr_;
}

ACE_INLINE ImplementationRepository::ServerInformationIterator_ptr &
ImplementationRepository::ServerInformationIterator_var::inout (void)
{
  return this->ptr_;
}

ACE_INLINE ImplementationRepository::ServerInformationIterator_ptr &
ImplementationRepository::ServerInformationIterator_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ImplementationRepository::ServerInformationIterator::_nil ();
  return this->ptr_;
}

ACE_INLINE ImplementationRepository::ServerInformationIterator_ptr
ImplementationRepository::ServerInformationIterator_var::_retn (void)
{
  // yield ownership of managed obj reference
  ImplementationRepository::ServerInformationIterator_ptr val = this->ptr_;
  this->ptr_ = ImplementationRepository::ServerInformationIterator::_nil ();
  return val;
}


#endif /* end #if !defined */


#if !defined (_IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONITERATOR___OUT_CI_)
#define _IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONITERATOR___OUT_CI_

// *************************************************************
// Inline operations for class ImplementationRepository::ServerInformationIterator_out
// *************************************************************

ACE_INLINE
ImplementationRepository::ServerInformationIterator_out::ServerInformationIterator_out (ImplementationRepository::ServerInformationIterator_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ImplementationRepository::ServerInformationIterator::_nil ();
}

ACE_INLINE
ImplementationRepository::ServerInformationIterator_out::ServerInformationIterator_out (ImplementationRepository::ServerInformationIterator_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ImplementationRepository::ServerInformationIterator::_nil ();
}

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

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

ACE_INLINE ImplementationRepository::ServerInformationIterator_out &
ImplementationRepository::ServerInformationIterator_out::operator= (const ImplementationRepository::ServerInformationIterator_var &p)
{
  this->ptr_ = ImplementationRepository::ServerInformationIterator::_duplicate (p.ptr ());
  return *this;
}

ACE_INLINE ImplementationRepository::ServerInformationIterator_out &
ImplementationRepository::ServerInformationIterator_out::operator= (ImplementationRepository::ServerInformationIterator_ptr p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE
ImplementationRepository::ServerInformationIterator_out::operator ImplementationRepository::ServerInformationIterator_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE ImplementationRepository::ServerInformationIterator_ptr &
ImplementationRepository::ServerInformationIterator_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE ImplementationRepository::ServerInformationIterator_ptr
ImplementationRepository::ServerInformationIterator_out::operator-> (void)
{
  return this->ptr_;
}


#endif /* end #if !defined */

ACE_INLINE CORBA::Boolean
operator<< (
    TAO_OutputCDR &,
    const ImplementationRepository::ServerObject_ptr
  );
ACE_INLINE CORBA::Boolean
operator>> (
    TAO_InputCDR &,
    ImplementationRepository::ServerObject_ptr &
  );

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

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

ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const ImplementationRepository::EnvironmentVariable &_tao_aggregate)
{
  if (
    (strm << _tao_aggregate.name.in ()) &&
    (strm << _tao_aggregate.value.in ())
  )
    return 1;
  else
    return 0;

}

ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, ImplementationRepository::EnvironmentVariable &_tao_aggregate)
{
  if (
    (strm >> _tao_aggregate.name.out ()) &&
    (strm >> _tao_aggregate.value.out ())
  )
    return 1;
  else
    return 0;

}


#if !defined _TAO_CDR_OP_ImplementationRepository_EnvironmentList_I_
#define _TAO_CDR_OP_ImplementationRepository_EnvironmentList_I_

CORBA::Boolean TAO_Export operator<< (
    TAO_OutputCDR &,
    const ImplementationRepository::EnvironmentList &
  );
CORBA::Boolean TAO_Export operator>> (
    TAO_InputCDR &,
    ImplementationRepository::EnvironmentList &
  );

#endif /* _TAO_CDR_OP_ImplementationRepository_EnvironmentList_I_ */

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

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

ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const ImplementationRepository::StartupOptions &_tao_aggregate)
{
  if (
    (strm << _tao_aggregate.command_line.in ()) &&
    (strm << _tao_aggregate.environment) &&
    (strm << _tao_aggregate.working_directory.in ()) &&
    (strm << _tao_aggregate.activation)
  )
    return 1;
  else
    return 0;

}

ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, ImplementationRepository::StartupOptions &_tao_aggregate)
{
  if (
    (strm >> _tao_aggregate.command_line.out ()) &&
    (strm >> _tao_aggregate.environment) &&
    (strm >> _tao_aggregate.working_directory.out ()) &&
    (strm >> _tao_aggregate.activation)
  )
    return 1;
  else
    return 0;

}

ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const ImplementationRepository::ServerInformation &_tao_aggregate)
{
  if (
    (strm << _tao_aggregate.logical_server.in ()) &&
    (strm << _tao_aggregate.server.in ()) &&
    (strm << _tao_aggregate.startup) &&
    (strm << _tao_aggregate.location.in ())
  )
    return 1;
  else
    return 0;

}

ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, ImplementationRepository::ServerInformation &_tao_aggregate)
{
  if (
    (strm >> _tao_aggregate.logical_server.out ()) &&
    (strm >> _tao_aggregate.server.out ()) &&
    (strm >> _tao_aggregate.startup) &&
    (strm >> _tao_aggregate.location.out ())
  )
    return 1;
  else
    return 0;

}


#if !defined _TAO_CDR_OP_ImplementationRepository_ServerInformationList_I_
#define _TAO_CDR_OP_ImplementationRepository_ServerInformationList_I_

CORBA::Boolean TAO_Export operator<< (
    TAO_OutputCDR &,
    const ImplementationRepository::ServerInformationList &
  );
CORBA::Boolean TAO_Export operator>> (
    TAO_InputCDR &,
    ImplementationRepository::ServerInformationList &
  );

#endif /* _TAO_CDR_OP_ImplementationRepository_ServerInformationList_I_ */

ACE_INLINE CORBA::Boolean
operator<< (
    TAO_OutputCDR &,
    const ImplementationRepository::ServerInformationIterator_ptr
  );
ACE_INLINE CORBA::Boolean
operator>> (
    TAO_InputCDR &,
    ImplementationRepository::ServerInformationIterator_ptr &
  );
ACE_INLINE CORBA::Boolean
operator<< (
    TAO_OutputCDR &,
    const ImplementationRepository::Administration_ptr
  );
ACE_INLINE CORBA::Boolean
operator>> (
    TAO_InputCDR &,
    ImplementationRepository::Administration_ptr &
  );

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

ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &, ImplementationRepository::Administration::AlreadyRegistered &)
{
  return 1;
}

#if !defined (ACE_LACKS_IOSTREAM_TOTALLY)

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

#endif /* ACE_LACKS_IOSTREAM_TOTALLY */

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

ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, ImplementationRepository::Administration::CannotActivate &_tao_aggregate)
{
  // now marshal the members
  if (
      (strm >> _tao_aggregate.reason.out ())
      )
    return 1;
  return 0;
}

#if !defined (ACE_LACKS_IOSTREAM_TOTALLY)

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

#endif /* ACE_LACKS_IOSTREAM_TOTALLY */

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

ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &, ImplementationRepository::Administration::NotFound &)
{
  return 1;
}

#if !defined (ACE_LACKS_IOSTREAM_TOTALLY)

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

#endif /* ACE_LACKS_IOSTREAM_TOTALLY */

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

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

ACE_INLINE CORBA::Boolean
operator<< (
    TAO_OutputCDR &,
    const ImplementationRepository::ServerInformationIterator_ptr
  );
ACE_INLINE CORBA::Boolean
operator>> (
    TAO_InputCDR &,
    ImplementationRepository::ServerInformationIterator_ptr &
  );

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

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