/* -*- 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
Messaging::RebindPolicy::RebindPolicy (void) // default constructor
{}

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

ACE_INLINE
Messaging::RebindPolicy::~RebindPolicy (void) // destructor
{}

ACE_INLINE Messaging::RebindPolicy_ptr
Messaging::RebindPolicy::_duplicate (Messaging::RebindPolicy_ptr obj)
{
  if (!CORBA::is_nil (obj))
    obj->_incr_refcnt ();
  return obj;
}

ACE_INLINE Messaging::RebindPolicy_ptr
Messaging::RebindPolicy::_nil (void)
{
  return (Messaging::RebindPolicy_ptr)0;
}

// *************************************************************
// Inline operations for class Messaging::RebindPolicy_var
// *************************************************************

ACE_INLINE
Messaging::RebindPolicy_var::RebindPolicy_var (void) // default constructor
  : ptr_ (Messaging::RebindPolicy::_nil ())
{}

ACE_INLINE
Messaging::RebindPolicy_var::RebindPolicy_var (Messaging::RebindPolicy_ptr p)
  : ptr_ (p)
{}

ACE_INLINE Messaging::RebindPolicy_ptr
Messaging::RebindPolicy_var::ptr (void) const
{
  return this->ptr_;
}

ACE_INLINE
Messaging::RebindPolicy_var::RebindPolicy_var (const Messaging::RebindPolicy_var &p) // copy constructor
  : ptr_ (Messaging::RebindPolicy::_duplicate (p.ptr ()))
{}

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

ACE_INLINE Messaging::RebindPolicy_var &
Messaging::RebindPolicy_var::operator= (Messaging::RebindPolicy_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE
Messaging::RebindPolicy_var::operator const Messaging::RebindPolicy_ptr &() const // cast
{
  return this->ptr_;
}

ACE_INLINE
Messaging::RebindPolicy_var::operator Messaging::RebindPolicy_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE Messaging::RebindPolicy_ptr
Messaging::RebindPolicy_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE Messaging::RebindPolicy_ptr
Messaging::RebindPolicy_var::in (void) const
{
  return this->ptr_;
}

ACE_INLINE Messaging::RebindPolicy_ptr &
Messaging::RebindPolicy_var::inout (void)
{
  return this->ptr_;
}

ACE_INLINE Messaging::RebindPolicy_ptr &
Messaging::RebindPolicy_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = Messaging::RebindPolicy::_nil ();
  return this->ptr_;
}

ACE_INLINE Messaging::RebindPolicy_ptr
Messaging::RebindPolicy_var::_retn (void)
{
  // yield ownership of managed obj reference
  Messaging::RebindPolicy_ptr val = this->ptr_;
  this->ptr_ = Messaging::RebindPolicy::_nil ();
  return val;
}

// *************************************************************
// Inline operations for class Messaging::RebindPolicy_out
// *************************************************************

ACE_INLINE
Messaging::RebindPolicy_out::RebindPolicy_out (Messaging::RebindPolicy_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = Messaging::RebindPolicy::_nil ();
}

ACE_INLINE
Messaging::RebindPolicy_out::RebindPolicy_out (Messaging::RebindPolicy_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = Messaging::RebindPolicy::_nil ();
}

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

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

ACE_INLINE Messaging::RebindPolicy_out &
Messaging::RebindPolicy_out::operator= (const Messaging::RebindPolicy_var &p)
{
  this->ptr_ = Messaging::RebindPolicy::_duplicate (p.ptr ());
  return *this;
}

ACE_INLINE Messaging::RebindPolicy_out &
Messaging::RebindPolicy_out::operator= (Messaging::RebindPolicy_ptr p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE
Messaging::RebindPolicy_out::operator Messaging::RebindPolicy_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE Messaging::RebindPolicy_ptr &
Messaging::RebindPolicy_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE Messaging::RebindPolicy_ptr
Messaging::RebindPolicy_out::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE
Messaging::SyncScopePolicy::SyncScopePolicy (void) // default constructor
{}

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

ACE_INLINE
Messaging::SyncScopePolicy::~SyncScopePolicy (void) // destructor
{}

ACE_INLINE Messaging::SyncScopePolicy_ptr
Messaging::SyncScopePolicy::_duplicate (Messaging::SyncScopePolicy_ptr obj)
{
  if (!CORBA::is_nil (obj))
    obj->_incr_refcnt ();
  return obj;
}

ACE_INLINE Messaging::SyncScopePolicy_ptr
Messaging::SyncScopePolicy::_nil (void)
{
  return (Messaging::SyncScopePolicy_ptr)0;
}

// *************************************************************
// Inline operations for class Messaging::SyncScopePolicy_var
// *************************************************************

ACE_INLINE
Messaging::SyncScopePolicy_var::SyncScopePolicy_var (void) // default constructor
  : ptr_ (Messaging::SyncScopePolicy::_nil ())
{}

ACE_INLINE
Messaging::SyncScopePolicy_var::SyncScopePolicy_var (Messaging::SyncScopePolicy_ptr p)
  : ptr_ (p)
{}

ACE_INLINE Messaging::SyncScopePolicy_ptr
Messaging::SyncScopePolicy_var::ptr (void) const
{
  return this->ptr_;
}

ACE_INLINE
Messaging::SyncScopePolicy_var::SyncScopePolicy_var (const Messaging::SyncScopePolicy_var &p) // copy constructor
  : ptr_ (Messaging::SyncScopePolicy::_duplicate (p.ptr ()))
{}

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

ACE_INLINE Messaging::SyncScopePolicy_var &
Messaging::SyncScopePolicy_var::operator= (Messaging::SyncScopePolicy_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE
Messaging::SyncScopePolicy_var::operator const Messaging::SyncScopePolicy_ptr &() const // cast
{
  return this->ptr_;
}

ACE_INLINE
Messaging::SyncScopePolicy_var::operator Messaging::SyncScopePolicy_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE Messaging::SyncScopePolicy_ptr
Messaging::SyncScopePolicy_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE Messaging::SyncScopePolicy_ptr
Messaging::SyncScopePolicy_var::in (void) const
{
  return this->ptr_;
}

ACE_INLINE Messaging::SyncScopePolicy_ptr &
Messaging::SyncScopePolicy_var::inout (void)
{
  return this->ptr_;
}

ACE_INLINE Messaging::SyncScopePolicy_ptr &
Messaging::SyncScopePolicy_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = Messaging::SyncScopePolicy::_nil ();
  return this->ptr_;
}

ACE_INLINE Messaging::SyncScopePolicy_ptr
Messaging::SyncScopePolicy_var::_retn (void)
{
  // yield ownership of managed obj reference
  Messaging::SyncScopePolicy_ptr val = this->ptr_;
  this->ptr_ = Messaging::SyncScopePolicy::_nil ();
  return val;
}

// *************************************************************
// Inline operations for class Messaging::SyncScopePolicy_out
// *************************************************************

ACE_INLINE
Messaging::SyncScopePolicy_out::SyncScopePolicy_out (Messaging::SyncScopePolicy_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = Messaging::SyncScopePolicy::_nil ();
}

ACE_INLINE
Messaging::SyncScopePolicy_out::SyncScopePolicy_out (Messaging::SyncScopePolicy_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = Messaging::SyncScopePolicy::_nil ();
}

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

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

ACE_INLINE Messaging::SyncScopePolicy_out &
Messaging::SyncScopePolicy_out::operator= (const Messaging::SyncScopePolicy_var &p)
{
  this->ptr_ = Messaging::SyncScopePolicy::_duplicate (p.ptr ());
  return *this;
}

ACE_INLINE Messaging::SyncScopePolicy_out &
Messaging::SyncScopePolicy_out::operator= (Messaging::SyncScopePolicy_ptr p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE
Messaging::SyncScopePolicy_out::operator Messaging::SyncScopePolicy_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE Messaging::SyncScopePolicy_ptr &
Messaging::SyncScopePolicy_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE Messaging::SyncScopePolicy_ptr
Messaging::SyncScopePolicy_out::operator-> (void)
{
  return this->ptr_;
}

// *************************************************************
// Inline operations for class Messaging::PriorityRange_var
// *************************************************************

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

ACE_INLINE
Messaging::PriorityRange_var::PriorityRange_var (Messaging::PriorityRange *p)
  : ptr_ (p)
{}

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

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

ACE_INLINE Messaging::PriorityRange_var &
Messaging::PriorityRange_var::operator= (Messaging::PriorityRange *p)
{
  delete this->ptr_;
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE const Messaging::PriorityRange *
Messaging::PriorityRange_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE Messaging::PriorityRange *
Messaging::PriorityRange_var::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE
Messaging::PriorityRange_var::operator const Messaging::PriorityRange &() const // cast
{
  return *this->ptr_;
}

ACE_INLINE
Messaging::PriorityRange_var::operator Messaging::PriorityRange &() // cast
{
  return *this->ptr_;
}

ACE_INLINE
Messaging::PriorityRange_var::operator Messaging::PriorityRange &() const// cast
{
  return *this->ptr_;
}

ACE_INLINE const Messaging::PriorityRange &
Messaging::PriorityRange_var::in (void) const
{
  return *this->ptr_;
}

ACE_INLINE Messaging::PriorityRange &
Messaging::PriorityRange_var::inout (void)
{
  return *this->ptr_;
}

// mapping for fixed size
ACE_INLINE Messaging::PriorityRange &
Messaging::PriorityRange_var::out (void)
{
  return *this->ptr_;
}

ACE_INLINE Messaging::PriorityRange
Messaging::PriorityRange_var::_retn (void)
{
  return *this->ptr_;
}

ACE_INLINE Messaging::PriorityRange *
Messaging::PriorityRange_var::ptr (void) const
{
  return this->ptr_;
}

ACE_INLINE
Messaging::RequestPriorityPolicy::RequestPriorityPolicy (void) // default constructor
{}

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

ACE_INLINE
Messaging::RequestPriorityPolicy::~RequestPriorityPolicy (void) // destructor
{}

ACE_INLINE Messaging::RequestPriorityPolicy_ptr
Messaging::RequestPriorityPolicy::_duplicate (Messaging::RequestPriorityPolicy_ptr obj)
{
  if (!CORBA::is_nil (obj))
    obj->_incr_refcnt ();
  return obj;
}

ACE_INLINE Messaging::RequestPriorityPolicy_ptr
Messaging::RequestPriorityPolicy::_nil (void)
{
  return (Messaging::RequestPriorityPolicy_ptr)0;
}

// *************************************************************
// Inline operations for class Messaging::RequestPriorityPolicy_var
// *************************************************************

ACE_INLINE
Messaging::RequestPriorityPolicy_var::RequestPriorityPolicy_var (void) // default constructor
  : ptr_ (Messaging::RequestPriorityPolicy::_nil ())
{}

ACE_INLINE
Messaging::RequestPriorityPolicy_var::RequestPriorityPolicy_var (Messaging::RequestPriorityPolicy_ptr p)
  : ptr_ (p)
{}

ACE_INLINE Messaging::RequestPriorityPolicy_ptr
Messaging::RequestPriorityPolicy_var::ptr (void) const
{
  return this->ptr_;
}

ACE_INLINE
Messaging::RequestPriorityPolicy_var::RequestPriorityPolicy_var (const Messaging::RequestPriorityPolicy_var &p) // copy constructor
  : ptr_ (Messaging::RequestPriorityPolicy::_duplicate (p.ptr ()))
{}

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

ACE_INLINE Messaging::RequestPriorityPolicy_var &
Messaging::RequestPriorityPolicy_var::operator= (Messaging::RequestPriorityPolicy_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE
Messaging::RequestPriorityPolicy_var::operator const Messaging::RequestPriorityPolicy_ptr &() const // cast
{
  return this->ptr_;
}

ACE_INLINE
Messaging::RequestPriorityPolicy_var::operator Messaging::RequestPriorityPolicy_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE Messaging::RequestPriorityPolicy_ptr
Messaging::RequestPriorityPolicy_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE Messaging::RequestPriorityPolicy_ptr
Messaging::RequestPriorityPolicy_var::in (void) const
{
  return this->ptr_;
}

ACE_INLINE Messaging::RequestPriorityPolicy_ptr &
Messaging::RequestPriorityPolicy_var::inout (void)
{
  return this->ptr_;
}

ACE_INLINE Messaging::RequestPriorityPolicy_ptr &
Messaging::RequestPriorityPolicy_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = Messaging::RequestPriorityPolicy::_nil ();
  return this->ptr_;
}

ACE_INLINE Messaging::RequestPriorityPolicy_ptr
Messaging::RequestPriorityPolicy_var::_retn (void)
{
  // yield ownership of managed obj reference
  Messaging::RequestPriorityPolicy_ptr val = this->ptr_;
  this->ptr_ = Messaging::RequestPriorityPolicy::_nil ();
  return val;
}

// *************************************************************
// Inline operations for class Messaging::RequestPriorityPolicy_out
// *************************************************************

ACE_INLINE
Messaging::RequestPriorityPolicy_out::RequestPriorityPolicy_out (Messaging::RequestPriorityPolicy_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = Messaging::RequestPriorityPolicy::_nil ();
}

ACE_INLINE
Messaging::RequestPriorityPolicy_out::RequestPriorityPolicy_out (Messaging::RequestPriorityPolicy_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = Messaging::RequestPriorityPolicy::_nil ();
}

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

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

ACE_INLINE Messaging::RequestPriorityPolicy_out &
Messaging::RequestPriorityPolicy_out::operator= (const Messaging::RequestPriorityPolicy_var &p)
{
  this->ptr_ = Messaging::RequestPriorityPolicy::_duplicate (p.ptr ());
  return *this;
}

ACE_INLINE Messaging::RequestPriorityPolicy_out &
Messaging::RequestPriorityPolicy_out::operator= (Messaging::RequestPriorityPolicy_ptr p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE
Messaging::RequestPriorityPolicy_out::operator Messaging::RequestPriorityPolicy_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE Messaging::RequestPriorityPolicy_ptr &
Messaging::RequestPriorityPolicy_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE Messaging::RequestPriorityPolicy_ptr
Messaging::RequestPriorityPolicy_out::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE
Messaging::ReplyPriorityPolicy::ReplyPriorityPolicy (void) // default constructor
{}

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

ACE_INLINE
Messaging::ReplyPriorityPolicy::~ReplyPriorityPolicy (void) // destructor
{}

ACE_INLINE Messaging::ReplyPriorityPolicy_ptr
Messaging::ReplyPriorityPolicy::_duplicate (Messaging::ReplyPriorityPolicy_ptr obj)
{
  if (!CORBA::is_nil (obj))
    obj->_incr_refcnt ();
  return obj;
}

ACE_INLINE Messaging::ReplyPriorityPolicy_ptr
Messaging::ReplyPriorityPolicy::_nil (void)
{
  return (Messaging::ReplyPriorityPolicy_ptr)0;
}

// *************************************************************
// Inline operations for class Messaging::ReplyPriorityPolicy_var
// *************************************************************

ACE_INLINE
Messaging::ReplyPriorityPolicy_var::ReplyPriorityPolicy_var (void) // default constructor
  : ptr_ (Messaging::ReplyPriorityPolicy::_nil ())
{}

ACE_INLINE
Messaging::ReplyPriorityPolicy_var::ReplyPriorityPolicy_var (Messaging::ReplyPriorityPolicy_ptr p)
  : ptr_ (p)
{}

ACE_INLINE Messaging::ReplyPriorityPolicy_ptr
Messaging::ReplyPriorityPolicy_var::ptr (void) const
{
  return this->ptr_;
}

ACE_INLINE
Messaging::ReplyPriorityPolicy_var::ReplyPriorityPolicy_var (const Messaging::ReplyPriorityPolicy_var &p) // copy constructor
  : ptr_ (Messaging::ReplyPriorityPolicy::_duplicate (p.ptr ()))
{}

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

ACE_INLINE Messaging::ReplyPriorityPolicy_var &
Messaging::ReplyPriorityPolicy_var::operator= (Messaging::ReplyPriorityPolicy_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE
Messaging::ReplyPriorityPolicy_var::operator const Messaging::ReplyPriorityPolicy_ptr &() const // cast
{
  return this->ptr_;
}

ACE_INLINE
Messaging::ReplyPriorityPolicy_var::operator Messaging::ReplyPriorityPolicy_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE Messaging::ReplyPriorityPolicy_ptr
Messaging::ReplyPriorityPolicy_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE Messaging::ReplyPriorityPolicy_ptr
Messaging::ReplyPriorityPolicy_var::in (void) const
{
  return this->ptr_;
}

ACE_INLINE Messaging::ReplyPriorityPolicy_ptr &
Messaging::ReplyPriorityPolicy_var::inout (void)
{
  return this->ptr_;
}

ACE_INLINE Messaging::ReplyPriorityPolicy_ptr &
Messaging::ReplyPriorityPolicy_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = Messaging::ReplyPriorityPolicy::_nil ();
  return this->ptr_;
}

ACE_INLINE Messaging::ReplyPriorityPolicy_ptr
Messaging::ReplyPriorityPolicy_var::_retn (void)
{
  // yield ownership of managed obj reference
  Messaging::ReplyPriorityPolicy_ptr val = this->ptr_;
  this->ptr_ = Messaging::ReplyPriorityPolicy::_nil ();
  return val;
}

// *************************************************************
// Inline operations for class Messaging::ReplyPriorityPolicy_out
// *************************************************************

ACE_INLINE
Messaging::ReplyPriorityPolicy_out::ReplyPriorityPolicy_out (Messaging::ReplyPriorityPolicy_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = Messaging::ReplyPriorityPolicy::_nil ();
}

ACE_INLINE
Messaging::ReplyPriorityPolicy_out::ReplyPriorityPolicy_out (Messaging::ReplyPriorityPolicy_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = Messaging::ReplyPriorityPolicy::_nil ();
}

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

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

ACE_INLINE Messaging::ReplyPriorityPolicy_out &
Messaging::ReplyPriorityPolicy_out::operator= (const Messaging::ReplyPriorityPolicy_var &p)
{
  this->ptr_ = Messaging::ReplyPriorityPolicy::_duplicate (p.ptr ());
  return *this;
}

ACE_INLINE Messaging::ReplyPriorityPolicy_out &
Messaging::ReplyPriorityPolicy_out::operator= (Messaging::ReplyPriorityPolicy_ptr p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE
Messaging::ReplyPriorityPolicy_out::operator Messaging::ReplyPriorityPolicy_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE Messaging::ReplyPriorityPolicy_ptr &
Messaging::ReplyPriorityPolicy_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE Messaging::ReplyPriorityPolicy_ptr
Messaging::ReplyPriorityPolicy_out::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE
Messaging::RequestStartTimePolicy::RequestStartTimePolicy (void) // default constructor
{}

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

ACE_INLINE
Messaging::RequestStartTimePolicy::~RequestStartTimePolicy (void) // destructor
{}

ACE_INLINE Messaging::RequestStartTimePolicy_ptr
Messaging::RequestStartTimePolicy::_duplicate (Messaging::RequestStartTimePolicy_ptr obj)
{
  if (!CORBA::is_nil (obj))
    obj->_incr_refcnt ();
  return obj;
}

ACE_INLINE Messaging::RequestStartTimePolicy_ptr
Messaging::RequestStartTimePolicy::_nil (void)
{
  return (Messaging::RequestStartTimePolicy_ptr)0;
}

// *************************************************************
// Inline operations for class Messaging::RequestStartTimePolicy_var
// *************************************************************

ACE_INLINE
Messaging::RequestStartTimePolicy_var::RequestStartTimePolicy_var (void) // default constructor
  : ptr_ (Messaging::RequestStartTimePolicy::_nil ())
{}

ACE_INLINE
Messaging::RequestStartTimePolicy_var::RequestStartTimePolicy_var (Messaging::RequestStartTimePolicy_ptr p)
  : ptr_ (p)
{}

ACE_INLINE Messaging::RequestStartTimePolicy_ptr
Messaging::RequestStartTimePolicy_var::ptr (void) const
{
  return this->ptr_;
}

ACE_INLINE
Messaging::RequestStartTimePolicy_var::RequestStartTimePolicy_var (const Messaging::RequestStartTimePolicy_var &p) // copy constructor
  : ptr_ (Messaging::RequestStartTimePolicy::_duplicate (p.ptr ()))
{}

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

ACE_INLINE Messaging::RequestStartTimePolicy_var &
Messaging::RequestStartTimePolicy_var::operator= (Messaging::RequestStartTimePolicy_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE
Messaging::RequestStartTimePolicy_var::operator const Messaging::RequestStartTimePolicy_ptr &() const // cast
{
  return this->ptr_;
}

ACE_INLINE
Messaging::RequestStartTimePolicy_var::operator Messaging::RequestStartTimePolicy_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE Messaging::RequestStartTimePolicy_ptr
Messaging::RequestStartTimePolicy_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE Messaging::RequestStartTimePolicy_ptr
Messaging::RequestStartTimePolicy_var::in (void) const
{
  return this->ptr_;
}

ACE_INLINE Messaging::RequestStartTimePolicy_ptr &
Messaging::RequestStartTimePolicy_var::inout (void)
{
  return this->ptr_;
}

ACE_INLINE Messaging::RequestStartTimePolicy_ptr &
Messaging::RequestStartTimePolicy_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = Messaging::RequestStartTimePolicy::_nil ();
  return this->ptr_;
}

ACE_INLINE Messaging::RequestStartTimePolicy_ptr
Messaging::RequestStartTimePolicy_var::_retn (void)
{
  // yield ownership of managed obj reference
  Messaging::RequestStartTimePolicy_ptr val = this->ptr_;
  this->ptr_ = Messaging::RequestStartTimePolicy::_nil ();
  return val;
}

// *************************************************************
// Inline operations for class Messaging::RequestStartTimePolicy_out
// *************************************************************

ACE_INLINE
Messaging::RequestStartTimePolicy_out::RequestStartTimePolicy_out (Messaging::RequestStartTimePolicy_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = Messaging::RequestStartTimePolicy::_nil ();
}

ACE_INLINE
Messaging::RequestStartTimePolicy_out::RequestStartTimePolicy_out (Messaging::RequestStartTimePolicy_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = Messaging::RequestStartTimePolicy::_nil ();
}

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

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

ACE_INLINE Messaging::RequestStartTimePolicy_out &
Messaging::RequestStartTimePolicy_out::operator= (const Messaging::RequestStartTimePolicy_var &p)
{
  this->ptr_ = Messaging::RequestStartTimePolicy::_duplicate (p.ptr ());
  return *this;
}

ACE_INLINE Messaging::RequestStartTimePolicy_out &
Messaging::RequestStartTimePolicy_out::operator= (Messaging::RequestStartTimePolicy_ptr p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE
Messaging::RequestStartTimePolicy_out::operator Messaging::RequestStartTimePolicy_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE Messaging::RequestStartTimePolicy_ptr &
Messaging::RequestStartTimePolicy_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE Messaging::RequestStartTimePolicy_ptr
Messaging::RequestStartTimePolicy_out::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE
Messaging::RequestEndTimePolicy::RequestEndTimePolicy (void) // default constructor
{}

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

ACE_INLINE
Messaging::RequestEndTimePolicy::~RequestEndTimePolicy (void) // destructor
{}

ACE_INLINE Messaging::RequestEndTimePolicy_ptr
Messaging::RequestEndTimePolicy::_duplicate (Messaging::RequestEndTimePolicy_ptr obj)
{
  if (!CORBA::is_nil (obj))
    obj->_incr_refcnt ();
  return obj;
}

ACE_INLINE Messaging::RequestEndTimePolicy_ptr
Messaging::RequestEndTimePolicy::_nil (void)
{
  return (Messaging::RequestEndTimePolicy_ptr)0;
}

// *************************************************************
// Inline operations for class Messaging::RequestEndTimePolicy_var
// *************************************************************

ACE_INLINE
Messaging::RequestEndTimePolicy_var::RequestEndTimePolicy_var (void) // default constructor
  : ptr_ (Messaging::RequestEndTimePolicy::_nil ())
{}

ACE_INLINE
Messaging::RequestEndTimePolicy_var::RequestEndTimePolicy_var (Messaging::RequestEndTimePolicy_ptr p)
  : ptr_ (p)
{}

ACE_INLINE Messaging::RequestEndTimePolicy_ptr
Messaging::RequestEndTimePolicy_var::ptr (void) const
{
  return this->ptr_;
}

ACE_INLINE
Messaging::RequestEndTimePolicy_var::RequestEndTimePolicy_var (const Messaging::RequestEndTimePolicy_var &p) // copy constructor
  : ptr_ (Messaging::RequestEndTimePolicy::_duplicate (p.ptr ()))
{}

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

ACE_INLINE Messaging::RequestEndTimePolicy_var &
Messaging::RequestEndTimePolicy_var::operator= (Messaging::RequestEndTimePolicy_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE
Messaging::RequestEndTimePolicy_var::operator const Messaging::RequestEndTimePolicy_ptr &() const // cast
{
  return this->ptr_;
}

ACE_INLINE
Messaging::RequestEndTimePolicy_var::operator Messaging::RequestEndTimePolicy_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE Messaging::RequestEndTimePolicy_ptr
Messaging::RequestEndTimePolicy_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE Messaging::RequestEndTimePolicy_ptr
Messaging::RequestEndTimePolicy_var::in (void) const
{
  return this->ptr_;
}

ACE_INLINE Messaging::RequestEndTimePolicy_ptr &
Messaging::RequestEndTimePolicy_var::inout (void)
{
  return this->ptr_;
}

ACE_INLINE Messaging::RequestEndTimePolicy_ptr &
Messaging::RequestEndTimePolicy_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = Messaging::RequestEndTimePolicy::_nil ();
  return this->ptr_;
}

ACE_INLINE Messaging::RequestEndTimePolicy_ptr
Messaging::RequestEndTimePolicy_var::_retn (void)
{
  // yield ownership of managed obj reference
  Messaging::RequestEndTimePolicy_ptr val = this->ptr_;
  this->ptr_ = Messaging::RequestEndTimePolicy::_nil ();
  return val;
}

// *************************************************************
// Inline operations for class Messaging::RequestEndTimePolicy_out
// *************************************************************

ACE_INLINE
Messaging::RequestEndTimePolicy_out::RequestEndTimePolicy_out (Messaging::RequestEndTimePolicy_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = Messaging::RequestEndTimePolicy::_nil ();
}

ACE_INLINE
Messaging::RequestEndTimePolicy_out::RequestEndTimePolicy_out (Messaging::RequestEndTimePolicy_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = Messaging::RequestEndTimePolicy::_nil ();
}

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

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

ACE_INLINE Messaging::RequestEndTimePolicy_out &
Messaging::RequestEndTimePolicy_out::operator= (const Messaging::RequestEndTimePolicy_var &p)
{
  this->ptr_ = Messaging::RequestEndTimePolicy::_duplicate (p.ptr ());
  return *this;
}

ACE_INLINE Messaging::RequestEndTimePolicy_out &
Messaging::RequestEndTimePolicy_out::operator= (Messaging::RequestEndTimePolicy_ptr p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE
Messaging::RequestEndTimePolicy_out::operator Messaging::RequestEndTimePolicy_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE Messaging::RequestEndTimePolicy_ptr &
Messaging::RequestEndTimePolicy_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE Messaging::RequestEndTimePolicy_ptr
Messaging::RequestEndTimePolicy_out::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE
Messaging::ReplyStartTimePolicy::ReplyStartTimePolicy (void) // default constructor
{}

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

ACE_INLINE
Messaging::ReplyStartTimePolicy::~ReplyStartTimePolicy (void) // destructor
{}

ACE_INLINE Messaging::ReplyStartTimePolicy_ptr
Messaging::ReplyStartTimePolicy::_duplicate (Messaging::ReplyStartTimePolicy_ptr obj)
{
  if (!CORBA::is_nil (obj))
    obj->_incr_refcnt ();
  return obj;
}

ACE_INLINE Messaging::ReplyStartTimePolicy_ptr
Messaging::ReplyStartTimePolicy::_nil (void)
{
  return (Messaging::ReplyStartTimePolicy_ptr)0;
}

// *************************************************************
// Inline operations for class Messaging::ReplyStartTimePolicy_var
// *************************************************************

ACE_INLINE
Messaging::ReplyStartTimePolicy_var::ReplyStartTimePolicy_var (void) // default constructor
  : ptr_ (Messaging::ReplyStartTimePolicy::_nil ())
{}

ACE_INLINE
Messaging::ReplyStartTimePolicy_var::ReplyStartTimePolicy_var (Messaging::ReplyStartTimePolicy_ptr p)
  : ptr_ (p)
{}

ACE_INLINE Messaging::ReplyStartTimePolicy_ptr
Messaging::ReplyStartTimePolicy_var::ptr (void) const
{
  return this->ptr_;
}

ACE_INLINE
Messaging::ReplyStartTimePolicy_var::ReplyStartTimePolicy_var (const Messaging::ReplyStartTimePolicy_var &p) // copy constructor
  : ptr_ (Messaging::ReplyStartTimePolicy::_duplicate (p.ptr ()))
{}

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

ACE_INLINE Messaging::ReplyStartTimePolicy_var &
Messaging::ReplyStartTimePolicy_var::operator= (Messaging::ReplyStartTimePolicy_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE
Messaging::ReplyStartTimePolicy_var::operator const Messaging::ReplyStartTimePolicy_ptr &() const // cast
{
  return this->ptr_;
}

ACE_INLINE
Messaging::ReplyStartTimePolicy_var::operator Messaging::ReplyStartTimePolicy_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE Messaging::ReplyStartTimePolicy_ptr
Messaging::ReplyStartTimePolicy_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE Messaging::ReplyStartTimePolicy_ptr
Messaging::ReplyStartTimePolicy_var::in (void) const
{
  return this->ptr_;
}

ACE_INLINE Messaging::ReplyStartTimePolicy_ptr &
Messaging::ReplyStartTimePolicy_var::inout (void)
{
  return this->ptr_;
}

ACE_INLINE Messaging::ReplyStartTimePolicy_ptr &
Messaging::ReplyStartTimePolicy_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = Messaging::ReplyStartTimePolicy::_nil ();
  return this->ptr_;
}

ACE_INLINE Messaging::ReplyStartTimePolicy_ptr
Messaging::ReplyStartTimePolicy_var::_retn (void)
{
  // yield ownership of managed obj reference
  Messaging::ReplyStartTimePolicy_ptr val = this->ptr_;
  this->ptr_ = Messaging::ReplyStartTimePolicy::_nil ();
  return val;
}

// *************************************************************
// Inline operations for class Messaging::ReplyStartTimePolicy_out
// *************************************************************

ACE_INLINE
Messaging::ReplyStartTimePolicy_out::ReplyStartTimePolicy_out (Messaging::ReplyStartTimePolicy_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = Messaging::ReplyStartTimePolicy::_nil ();
}

ACE_INLINE
Messaging::ReplyStartTimePolicy_out::ReplyStartTimePolicy_out (Messaging::ReplyStartTimePolicy_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = Messaging::ReplyStartTimePolicy::_nil ();
}

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

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

ACE_INLINE Messaging::ReplyStartTimePolicy_out &
Messaging::ReplyStartTimePolicy_out::operator= (const Messaging::ReplyStartTimePolicy_var &p)
{
  this->ptr_ = Messaging::ReplyStartTimePolicy::_duplicate (p.ptr ());
  return *this;
}

ACE_INLINE Messaging::ReplyStartTimePolicy_out &
Messaging::ReplyStartTimePolicy_out::operator= (Messaging::ReplyStartTimePolicy_ptr p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE
Messaging::ReplyStartTimePolicy_out::operator Messaging::ReplyStartTimePolicy_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE Messaging::ReplyStartTimePolicy_ptr &
Messaging::ReplyStartTimePolicy_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE Messaging::ReplyStartTimePolicy_ptr
Messaging::ReplyStartTimePolicy_out::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE
Messaging::ReplyEndTimePolicy::ReplyEndTimePolicy (void) // default constructor
{}

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

ACE_INLINE
Messaging::ReplyEndTimePolicy::~ReplyEndTimePolicy (void) // destructor
{}

ACE_INLINE Messaging::ReplyEndTimePolicy_ptr
Messaging::ReplyEndTimePolicy::_duplicate (Messaging::ReplyEndTimePolicy_ptr obj)
{
  if (!CORBA::is_nil (obj))
    obj->_incr_refcnt ();
  return obj;
}

ACE_INLINE Messaging::ReplyEndTimePolicy_ptr
Messaging::ReplyEndTimePolicy::_nil (void)
{
  return (Messaging::ReplyEndTimePolicy_ptr)0;
}

// *************************************************************
// Inline operations for class Messaging::ReplyEndTimePolicy_var
// *************************************************************

ACE_INLINE
Messaging::ReplyEndTimePolicy_var::ReplyEndTimePolicy_var (void) // default constructor
  : ptr_ (Messaging::ReplyEndTimePolicy::_nil ())
{}

ACE_INLINE
Messaging::ReplyEndTimePolicy_var::ReplyEndTimePolicy_var (Messaging::ReplyEndTimePolicy_ptr p)
  : ptr_ (p)
{}

ACE_INLINE Messaging::ReplyEndTimePolicy_ptr
Messaging::ReplyEndTimePolicy_var::ptr (void) const
{
  return this->ptr_;
}

ACE_INLINE
Messaging::ReplyEndTimePolicy_var::ReplyEndTimePolicy_var (const Messaging::ReplyEndTimePolicy_var &p) // copy constructor
  : ptr_ (Messaging::ReplyEndTimePolicy::_duplicate (p.ptr ()))
{}

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

ACE_INLINE Messaging::ReplyEndTimePolicy_var &
Messaging::ReplyEndTimePolicy_var::operator= (Messaging::ReplyEndTimePolicy_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE
Messaging::ReplyEndTimePolicy_var::operator const Messaging::ReplyEndTimePolicy_ptr &() const // cast
{
  return this->ptr_;
}

ACE_INLINE
Messaging::ReplyEndTimePolicy_var::operator Messaging::ReplyEndTimePolicy_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE Messaging::ReplyEndTimePolicy_ptr
Messaging::ReplyEndTimePolicy_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE Messaging::ReplyEndTimePolicy_ptr
Messaging::ReplyEndTimePolicy_var::in (void) const
{
  return this->ptr_;
}

ACE_INLINE Messaging::ReplyEndTimePolicy_ptr &
Messaging::ReplyEndTimePolicy_var::inout (void)
{
  return this->ptr_;
}

ACE_INLINE Messaging::ReplyEndTimePolicy_ptr &
Messaging::ReplyEndTimePolicy_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = Messaging::ReplyEndTimePolicy::_nil ();
  return this->ptr_;
}

ACE_INLINE Messaging::ReplyEndTimePolicy_ptr
Messaging::ReplyEndTimePolicy_var::_retn (void)
{
  // yield ownership of managed obj reference
  Messaging::ReplyEndTimePolicy_ptr val = this->ptr_;
  this->ptr_ = Messaging::ReplyEndTimePolicy::_nil ();
  return val;
}

// *************************************************************
// Inline operations for class Messaging::ReplyEndTimePolicy_out
// *************************************************************

ACE_INLINE
Messaging::ReplyEndTimePolicy_out::ReplyEndTimePolicy_out (Messaging::ReplyEndTimePolicy_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = Messaging::ReplyEndTimePolicy::_nil ();
}

ACE_INLINE
Messaging::ReplyEndTimePolicy_out::ReplyEndTimePolicy_out (Messaging::ReplyEndTimePolicy_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = Messaging::ReplyEndTimePolicy::_nil ();
}

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

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

ACE_INLINE Messaging::ReplyEndTimePolicy_out &
Messaging::ReplyEndTimePolicy_out::operator= (const Messaging::ReplyEndTimePolicy_var &p)
{
  this->ptr_ = Messaging::ReplyEndTimePolicy::_duplicate (p.ptr ());
  return *this;
}

ACE_INLINE Messaging::ReplyEndTimePolicy_out &
Messaging::ReplyEndTimePolicy_out::operator= (Messaging::ReplyEndTimePolicy_ptr p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE
Messaging::ReplyEndTimePolicy_out::operator Messaging::ReplyEndTimePolicy_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE Messaging::ReplyEndTimePolicy_ptr &
Messaging::ReplyEndTimePolicy_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE Messaging::ReplyEndTimePolicy_ptr
Messaging::ReplyEndTimePolicy_out::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE
Messaging::RelativeRequestTimeoutPolicy::RelativeRequestTimeoutPolicy (void) // default constructor
{}

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

ACE_INLINE
Messaging::RelativeRequestTimeoutPolicy::~RelativeRequestTimeoutPolicy (void) // destructor
{}

ACE_INLINE Messaging::RelativeRequestTimeoutPolicy_ptr
Messaging::RelativeRequestTimeoutPolicy::_duplicate (Messaging::RelativeRequestTimeoutPolicy_ptr obj)
{
  if (!CORBA::is_nil (obj))
    obj->_incr_refcnt ();
  return obj;
}

ACE_INLINE Messaging::RelativeRequestTimeoutPolicy_ptr
Messaging::RelativeRequestTimeoutPolicy::_nil (void)
{
  return (Messaging::RelativeRequestTimeoutPolicy_ptr)0;
}

// *************************************************************
// Inline operations for class Messaging::RelativeRequestTimeoutPolicy_var
// *************************************************************

ACE_INLINE
Messaging::RelativeRequestTimeoutPolicy_var::RelativeRequestTimeoutPolicy_var (void) // default constructor
  : ptr_ (Messaging::RelativeRequestTimeoutPolicy::_nil ())
{}

ACE_INLINE
Messaging::RelativeRequestTimeoutPolicy_var::RelativeRequestTimeoutPolicy_var (Messaging::RelativeRequestTimeoutPolicy_ptr p)
  : ptr_ (p)
{}

ACE_INLINE Messaging::RelativeRequestTimeoutPolicy_ptr
Messaging::RelativeRequestTimeoutPolicy_var::ptr (void) const
{
  return this->ptr_;
}

ACE_INLINE
Messaging::RelativeRequestTimeoutPolicy_var::RelativeRequestTimeoutPolicy_var (const Messaging::RelativeRequestTimeoutPolicy_var &p) // copy constructor
  : ptr_ (Messaging::RelativeRequestTimeoutPolicy::_duplicate (p.ptr ()))
{}

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

ACE_INLINE Messaging::RelativeRequestTimeoutPolicy_var &
Messaging::RelativeRequestTimeoutPolicy_var::operator= (Messaging::RelativeRequestTimeoutPolicy_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE
Messaging::RelativeRequestTimeoutPolicy_var::operator const Messaging::RelativeRequestTimeoutPolicy_ptr &() const // cast
{
  return this->ptr_;
}

ACE_INLINE
Messaging::RelativeRequestTimeoutPolicy_var::operator Messaging::RelativeRequestTimeoutPolicy_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE Messaging::RelativeRequestTimeoutPolicy_ptr
Messaging::RelativeRequestTimeoutPolicy_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE Messaging::RelativeRequestTimeoutPolicy_ptr
Messaging::RelativeRequestTimeoutPolicy_var::in (void) const
{
  return this->ptr_;
}

ACE_INLINE Messaging::RelativeRequestTimeoutPolicy_ptr &
Messaging::RelativeRequestTimeoutPolicy_var::inout (void)
{
  return this->ptr_;
}

ACE_INLINE Messaging::RelativeRequestTimeoutPolicy_ptr &
Messaging::RelativeRequestTimeoutPolicy_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = Messaging::RelativeRequestTimeoutPolicy::_nil ();
  return this->ptr_;
}

ACE_INLINE Messaging::RelativeRequestTimeoutPolicy_ptr
Messaging::RelativeRequestTimeoutPolicy_var::_retn (void)
{
  // yield ownership of managed obj reference
  Messaging::RelativeRequestTimeoutPolicy_ptr val = this->ptr_;
  this->ptr_ = Messaging::RelativeRequestTimeoutPolicy::_nil ();
  return val;
}

// *************************************************************
// Inline operations for class Messaging::RelativeRequestTimeoutPolicy_out
// *************************************************************

ACE_INLINE
Messaging::RelativeRequestTimeoutPolicy_out::RelativeRequestTimeoutPolicy_out (Messaging::RelativeRequestTimeoutPolicy_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = Messaging::RelativeRequestTimeoutPolicy::_nil ();
}

ACE_INLINE
Messaging::RelativeRequestTimeoutPolicy_out::RelativeRequestTimeoutPolicy_out (Messaging::RelativeRequestTimeoutPolicy_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = Messaging::RelativeRequestTimeoutPolicy::_nil ();
}

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

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

ACE_INLINE Messaging::RelativeRequestTimeoutPolicy_out &
Messaging::RelativeRequestTimeoutPolicy_out::operator= (const Messaging::RelativeRequestTimeoutPolicy_var &p)
{
  this->ptr_ = Messaging::RelativeRequestTimeoutPolicy::_duplicate (p.ptr ());
  return *this;
}

ACE_INLINE Messaging::RelativeRequestTimeoutPolicy_out &
Messaging::RelativeRequestTimeoutPolicy_out::operator= (Messaging::RelativeRequestTimeoutPolicy_ptr p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE
Messaging::RelativeRequestTimeoutPolicy_out::operator Messaging::RelativeRequestTimeoutPolicy_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE Messaging::RelativeRequestTimeoutPolicy_ptr &
Messaging::RelativeRequestTimeoutPolicy_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE Messaging::RelativeRequestTimeoutPolicy_ptr
Messaging::RelativeRequestTimeoutPolicy_out::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE
Messaging::RelativeRoundtripTimeoutPolicy::RelativeRoundtripTimeoutPolicy (void) // default constructor
{}

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

ACE_INLINE
Messaging::RelativeRoundtripTimeoutPolicy::~RelativeRoundtripTimeoutPolicy (void) // destructor
{}

ACE_INLINE Messaging::RelativeRoundtripTimeoutPolicy_ptr
Messaging::RelativeRoundtripTimeoutPolicy::_duplicate (Messaging::RelativeRoundtripTimeoutPolicy_ptr obj)
{
  if (!CORBA::is_nil (obj))
    obj->_incr_refcnt ();
  return obj;
}

ACE_INLINE Messaging::RelativeRoundtripTimeoutPolicy_ptr
Messaging::RelativeRoundtripTimeoutPolicy::_nil (void)
{
  return (Messaging::RelativeRoundtripTimeoutPolicy_ptr)0;
}

// *************************************************************
// Inline operations for class Messaging::RelativeRoundtripTimeoutPolicy_var
// *************************************************************

ACE_INLINE
Messaging::RelativeRoundtripTimeoutPolicy_var::RelativeRoundtripTimeoutPolicy_var (void) // default constructor
  : ptr_ (Messaging::RelativeRoundtripTimeoutPolicy::_nil ())
{}

ACE_INLINE
Messaging::RelativeRoundtripTimeoutPolicy_var::RelativeRoundtripTimeoutPolicy_var (Messaging::RelativeRoundtripTimeoutPolicy_ptr p)
  : ptr_ (p)
{}

ACE_INLINE Messaging::RelativeRoundtripTimeoutPolicy_ptr
Messaging::RelativeRoundtripTimeoutPolicy_var::ptr (void) const
{
  return this->ptr_;
}

ACE_INLINE
Messaging::RelativeRoundtripTimeoutPolicy_var::RelativeRoundtripTimeoutPolicy_var (const Messaging::RelativeRoundtripTimeoutPolicy_var &p) // copy constructor
  : ptr_ (Messaging::RelativeRoundtripTimeoutPolicy::_duplicate (p.ptr ()))
{}

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

ACE_INLINE Messaging::RelativeRoundtripTimeoutPolicy_var &
Messaging::RelativeRoundtripTimeoutPolicy_var::operator= (Messaging::RelativeRoundtripTimeoutPolicy_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE
Messaging::RelativeRoundtripTimeoutPolicy_var::operator const Messaging::RelativeRoundtripTimeoutPolicy_ptr &() const // cast
{
  return this->ptr_;
}

ACE_INLINE
Messaging::RelativeRoundtripTimeoutPolicy_var::operator Messaging::RelativeRoundtripTimeoutPolicy_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE Messaging::RelativeRoundtripTimeoutPolicy_ptr
Messaging::RelativeRoundtripTimeoutPolicy_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE Messaging::RelativeRoundtripTimeoutPolicy_ptr
Messaging::RelativeRoundtripTimeoutPolicy_var::in (void) const
{
  return this->ptr_;
}

ACE_INLINE Messaging::RelativeRoundtripTimeoutPolicy_ptr &
Messaging::RelativeRoundtripTimeoutPolicy_var::inout (void)
{
  return this->ptr_;
}

ACE_INLINE Messaging::RelativeRoundtripTimeoutPolicy_ptr &
Messaging::RelativeRoundtripTimeoutPolicy_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = Messaging::RelativeRoundtripTimeoutPolicy::_nil ();
  return this->ptr_;
}

ACE_INLINE Messaging::RelativeRoundtripTimeoutPolicy_ptr
Messaging::RelativeRoundtripTimeoutPolicy_var::_retn (void)
{
  // yield ownership of managed obj reference
  Messaging::RelativeRoundtripTimeoutPolicy_ptr val = this->ptr_;
  this->ptr_ = Messaging::RelativeRoundtripTimeoutPolicy::_nil ();
  return val;
}

// *************************************************************
// Inline operations for class Messaging::RelativeRoundtripTimeoutPolicy_out
// *************************************************************

ACE_INLINE
Messaging::RelativeRoundtripTimeoutPolicy_out::RelativeRoundtripTimeoutPolicy_out (Messaging::RelativeRoundtripTimeoutPolicy_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = Messaging::RelativeRoundtripTimeoutPolicy::_nil ();
}

ACE_INLINE
Messaging::RelativeRoundtripTimeoutPolicy_out::RelativeRoundtripTimeoutPolicy_out (Messaging::RelativeRoundtripTimeoutPolicy_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = Messaging::RelativeRoundtripTimeoutPolicy::_nil ();
}

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

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

ACE_INLINE Messaging::RelativeRoundtripTimeoutPolicy_out &
Messaging::RelativeRoundtripTimeoutPolicy_out::operator= (const Messaging::RelativeRoundtripTimeoutPolicy_var &p)
{
  this->ptr_ = Messaging::RelativeRoundtripTimeoutPolicy::_duplicate (p.ptr ());
  return *this;
}

ACE_INLINE Messaging::RelativeRoundtripTimeoutPolicy_out &
Messaging::RelativeRoundtripTimeoutPolicy_out::operator= (Messaging::RelativeRoundtripTimeoutPolicy_ptr p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE
Messaging::RelativeRoundtripTimeoutPolicy_out::operator Messaging::RelativeRoundtripTimeoutPolicy_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE Messaging::RelativeRoundtripTimeoutPolicy_ptr &
Messaging::RelativeRoundtripTimeoutPolicy_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE Messaging::RelativeRoundtripTimeoutPolicy_ptr
Messaging::RelativeRoundtripTimeoutPolicy_out::operator-> (void)
{
  return this->ptr_;
}

// *************************************************************
// Inline operations for class Messaging::RoutingTypeRange_var
// *************************************************************

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

ACE_INLINE
Messaging::RoutingTypeRange_var::RoutingTypeRange_var (Messaging::RoutingTypeRange *p)
  : ptr_ (p)
{}

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

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

ACE_INLINE Messaging::RoutingTypeRange_var &
Messaging::RoutingTypeRange_var::operator= (Messaging::RoutingTypeRange *p)
{
  delete this->ptr_;
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE const Messaging::RoutingTypeRange *
Messaging::RoutingTypeRange_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE Messaging::RoutingTypeRange *
Messaging::RoutingTypeRange_var::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE
Messaging::RoutingTypeRange_var::operator const Messaging::RoutingTypeRange &() const // cast
{
  return *this->ptr_;
}

ACE_INLINE
Messaging::RoutingTypeRange_var::operator Messaging::RoutingTypeRange &() // cast
{
  return *this->ptr_;
}

ACE_INLINE
Messaging::RoutingTypeRange_var::operator Messaging::RoutingTypeRange &() const// cast
{
  return *this->ptr_;
}

ACE_INLINE const Messaging::RoutingTypeRange &
Messaging::RoutingTypeRange_var::in (void) const
{
  return *this->ptr_;
}

ACE_INLINE Messaging::RoutingTypeRange &
Messaging::RoutingTypeRange_var::inout (void)
{
  return *this->ptr_;
}

// mapping for fixed size
ACE_INLINE Messaging::RoutingTypeRange &
Messaging::RoutingTypeRange_var::out (void)
{
  return *this->ptr_;
}

ACE_INLINE Messaging::RoutingTypeRange
Messaging::RoutingTypeRange_var::_retn (void)
{
  return *this->ptr_;
}

ACE_INLINE Messaging::RoutingTypeRange *
Messaging::RoutingTypeRange_var::ptr (void) const
{
  return this->ptr_;
}

ACE_INLINE
Messaging::RoutingPolicy::RoutingPolicy (void) // default constructor
{}

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

ACE_INLINE
Messaging::RoutingPolicy::~RoutingPolicy (void) // destructor
{}

ACE_INLINE Messaging::RoutingPolicy_ptr
Messaging::RoutingPolicy::_duplicate (Messaging::RoutingPolicy_ptr obj)
{
  if (!CORBA::is_nil (obj))
    obj->_incr_refcnt ();
  return obj;
}

ACE_INLINE Messaging::RoutingPolicy_ptr
Messaging::RoutingPolicy::_nil (void)
{
  return (Messaging::RoutingPolicy_ptr)0;
}

// *************************************************************
// Inline operations for class Messaging::RoutingPolicy_var
// *************************************************************

ACE_INLINE
Messaging::RoutingPolicy_var::RoutingPolicy_var (void) // default constructor
  : ptr_ (Messaging::RoutingPolicy::_nil ())
{}

ACE_INLINE
Messaging::RoutingPolicy_var::RoutingPolicy_var (Messaging::RoutingPolicy_ptr p)
  : ptr_ (p)
{}

ACE_INLINE Messaging::RoutingPolicy_ptr
Messaging::RoutingPolicy_var::ptr (void) const
{
  return this->ptr_;
}

ACE_INLINE
Messaging::RoutingPolicy_var::RoutingPolicy_var (const Messaging::RoutingPolicy_var &p) // copy constructor
  : ptr_ (Messaging::RoutingPolicy::_duplicate (p.ptr ()))
{}

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

ACE_INLINE Messaging::RoutingPolicy_var &
Messaging::RoutingPolicy_var::operator= (Messaging::RoutingPolicy_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE
Messaging::RoutingPolicy_var::operator const Messaging::RoutingPolicy_ptr &() const // cast
{
  return this->ptr_;
}

ACE_INLINE
Messaging::RoutingPolicy_var::operator Messaging::RoutingPolicy_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE Messaging::RoutingPolicy_ptr
Messaging::RoutingPolicy_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE Messaging::RoutingPolicy_ptr
Messaging::RoutingPolicy_var::in (void) const
{
  return this->ptr_;
}

ACE_INLINE Messaging::RoutingPolicy_ptr &
Messaging::RoutingPolicy_var::inout (void)
{
  return this->ptr_;
}

ACE_INLINE Messaging::RoutingPolicy_ptr &
Messaging::RoutingPolicy_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = Messaging::RoutingPolicy::_nil ();
  return this->ptr_;
}

ACE_INLINE Messaging::RoutingPolicy_ptr
Messaging::RoutingPolicy_var::_retn (void)
{
  // yield ownership of managed obj reference
  Messaging::RoutingPolicy_ptr val = this->ptr_;
  this->ptr_ = Messaging::RoutingPolicy::_nil ();
  return val;
}

// *************************************************************
// Inline operations for class Messaging::RoutingPolicy_out
// *************************************************************

ACE_INLINE
Messaging::RoutingPolicy_out::RoutingPolicy_out (Messaging::RoutingPolicy_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = Messaging::RoutingPolicy::_nil ();
}

ACE_INLINE
Messaging::RoutingPolicy_out::RoutingPolicy_out (Messaging::RoutingPolicy_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = Messaging::RoutingPolicy::_nil ();
}

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

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

ACE_INLINE Messaging::RoutingPolicy_out &
Messaging::RoutingPolicy_out::operator= (const Messaging::RoutingPolicy_var &p)
{
  this->ptr_ = Messaging::RoutingPolicy::_duplicate (p.ptr ());
  return *this;
}

ACE_INLINE Messaging::RoutingPolicy_out &
Messaging::RoutingPolicy_out::operator= (Messaging::RoutingPolicy_ptr p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE
Messaging::RoutingPolicy_out::operator Messaging::RoutingPolicy_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE Messaging::RoutingPolicy_ptr &
Messaging::RoutingPolicy_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE Messaging::RoutingPolicy_ptr
Messaging::RoutingPolicy_out::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE
Messaging::MaxHopsPolicy::MaxHopsPolicy (void) // default constructor
{}

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

ACE_INLINE
Messaging::MaxHopsPolicy::~MaxHopsPolicy (void) // destructor
{}

ACE_INLINE Messaging::MaxHopsPolicy_ptr
Messaging::MaxHopsPolicy::_duplicate (Messaging::MaxHopsPolicy_ptr obj)
{
  if (!CORBA::is_nil (obj))
    obj->_incr_refcnt ();
  return obj;
}

ACE_INLINE Messaging::MaxHopsPolicy_ptr
Messaging::MaxHopsPolicy::_nil (void)
{
  return (Messaging::MaxHopsPolicy_ptr)0;
}

// *************************************************************
// Inline operations for class Messaging::MaxHopsPolicy_var
// *************************************************************

ACE_INLINE
Messaging::MaxHopsPolicy_var::MaxHopsPolicy_var (void) // default constructor
  : ptr_ (Messaging::MaxHopsPolicy::_nil ())
{}

ACE_INLINE
Messaging::MaxHopsPolicy_var::MaxHopsPolicy_var (Messaging::MaxHopsPolicy_ptr p)
  : ptr_ (p)
{}

ACE_INLINE Messaging::MaxHopsPolicy_ptr
Messaging::MaxHopsPolicy_var::ptr (void) const
{
  return this->ptr_;
}

ACE_INLINE
Messaging::MaxHopsPolicy_var::MaxHopsPolicy_var (const Messaging::MaxHopsPolicy_var &p) // copy constructor
  : ptr_ (Messaging::MaxHopsPolicy::_duplicate (p.ptr ()))
{}

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

ACE_INLINE Messaging::MaxHopsPolicy_var &
Messaging::MaxHopsPolicy_var::operator= (Messaging::MaxHopsPolicy_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE
Messaging::MaxHopsPolicy_var::operator const Messaging::MaxHopsPolicy_ptr &() const // cast
{
  return this->ptr_;
}

ACE_INLINE
Messaging::MaxHopsPolicy_var::operator Messaging::MaxHopsPolicy_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE Messaging::MaxHopsPolicy_ptr
Messaging::MaxHopsPolicy_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE Messaging::MaxHopsPolicy_ptr
Messaging::MaxHopsPolicy_var::in (void) const
{
  return this->ptr_;
}

ACE_INLINE Messaging::MaxHopsPolicy_ptr &
Messaging::MaxHopsPolicy_var::inout (void)
{
  return this->ptr_;
}

ACE_INLINE Messaging::MaxHopsPolicy_ptr &
Messaging::MaxHopsPolicy_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = Messaging::MaxHopsPolicy::_nil ();
  return this->ptr_;
}

ACE_INLINE Messaging::MaxHopsPolicy_ptr
Messaging::MaxHopsPolicy_var::_retn (void)
{
  // yield ownership of managed obj reference
  Messaging::MaxHopsPolicy_ptr val = this->ptr_;
  this->ptr_ = Messaging::MaxHopsPolicy::_nil ();
  return val;
}

// *************************************************************
// Inline operations for class Messaging::MaxHopsPolicy_out
// *************************************************************

ACE_INLINE
Messaging::MaxHopsPolicy_out::MaxHopsPolicy_out (Messaging::MaxHopsPolicy_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = Messaging::MaxHopsPolicy::_nil ();
}

ACE_INLINE
Messaging::MaxHopsPolicy_out::MaxHopsPolicy_out (Messaging::MaxHopsPolicy_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = Messaging::MaxHopsPolicy::_nil ();
}

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

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

ACE_INLINE Messaging::MaxHopsPolicy_out &
Messaging::MaxHopsPolicy_out::operator= (const Messaging::MaxHopsPolicy_var &p)
{
  this->ptr_ = Messaging::MaxHopsPolicy::_duplicate (p.ptr ());
  return *this;
}

ACE_INLINE Messaging::MaxHopsPolicy_out &
Messaging::MaxHopsPolicy_out::operator= (Messaging::MaxHopsPolicy_ptr p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE
Messaging::MaxHopsPolicy_out::operator Messaging::MaxHopsPolicy_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE Messaging::MaxHopsPolicy_ptr &
Messaging::MaxHopsPolicy_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE Messaging::MaxHopsPolicy_ptr
Messaging::MaxHopsPolicy_out::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE
Messaging::QueueOrderPolicy::QueueOrderPolicy (void) // default constructor
{}

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

ACE_INLINE
Messaging::QueueOrderPolicy::~QueueOrderPolicy (void) // destructor
{}

ACE_INLINE Messaging::QueueOrderPolicy_ptr
Messaging::QueueOrderPolicy::_duplicate (Messaging::QueueOrderPolicy_ptr obj)
{
  if (!CORBA::is_nil (obj))
    obj->_incr_refcnt ();
  return obj;
}

ACE_INLINE Messaging::QueueOrderPolicy_ptr
Messaging::QueueOrderPolicy::_nil (void)
{
  return (Messaging::QueueOrderPolicy_ptr)0;
}

// *************************************************************
// Inline operations for class Messaging::QueueOrderPolicy_var
// *************************************************************

ACE_INLINE
Messaging::QueueOrderPolicy_var::QueueOrderPolicy_var (void) // default constructor
  : ptr_ (Messaging::QueueOrderPolicy::_nil ())
{}

ACE_INLINE
Messaging::QueueOrderPolicy_var::QueueOrderPolicy_var (Messaging::QueueOrderPolicy_ptr p)
  : ptr_ (p)
{}

ACE_INLINE Messaging::QueueOrderPolicy_ptr
Messaging::QueueOrderPolicy_var::ptr (void) const
{
  return this->ptr_;
}

ACE_INLINE
Messaging::QueueOrderPolicy_var::QueueOrderPolicy_var (const Messaging::QueueOrderPolicy_var &p) // copy constructor
  : ptr_ (Messaging::QueueOrderPolicy::_duplicate (p.ptr ()))
{}

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

ACE_INLINE Messaging::QueueOrderPolicy_var &
Messaging::QueueOrderPolicy_var::operator= (Messaging::QueueOrderPolicy_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE
Messaging::QueueOrderPolicy_var::operator const Messaging::QueueOrderPolicy_ptr &() const // cast
{
  return this->ptr_;
}

ACE_INLINE
Messaging::QueueOrderPolicy_var::operator Messaging::QueueOrderPolicy_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE Messaging::QueueOrderPolicy_ptr
Messaging::QueueOrderPolicy_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE Messaging::QueueOrderPolicy_ptr
Messaging::QueueOrderPolicy_var::in (void) const
{
  return this->ptr_;
}

ACE_INLINE Messaging::QueueOrderPolicy_ptr &
Messaging::QueueOrderPolicy_var::inout (void)
{
  return this->ptr_;
}

ACE_INLINE Messaging::QueueOrderPolicy_ptr &
Messaging::QueueOrderPolicy_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = Messaging::QueueOrderPolicy::_nil ();
  return this->ptr_;
}

ACE_INLINE Messaging::QueueOrderPolicy_ptr
Messaging::QueueOrderPolicy_var::_retn (void)
{
  // yield ownership of managed obj reference
  Messaging::QueueOrderPolicy_ptr val = this->ptr_;
  this->ptr_ = Messaging::QueueOrderPolicy::_nil ();
  return val;
}

// *************************************************************
// Inline operations for class Messaging::QueueOrderPolicy_out
// *************************************************************

ACE_INLINE
Messaging::QueueOrderPolicy_out::QueueOrderPolicy_out (Messaging::QueueOrderPolicy_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = Messaging::QueueOrderPolicy::_nil ();
}

ACE_INLINE
Messaging::QueueOrderPolicy_out::QueueOrderPolicy_out (Messaging::QueueOrderPolicy_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = Messaging::QueueOrderPolicy::_nil ();
}

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

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

ACE_INLINE Messaging::QueueOrderPolicy_out &
Messaging::QueueOrderPolicy_out::operator= (const Messaging::QueueOrderPolicy_var &p)
{
  this->ptr_ = Messaging::QueueOrderPolicy::_duplicate (p.ptr ());
  return *this;
}

ACE_INLINE Messaging::QueueOrderPolicy_out &
Messaging::QueueOrderPolicy_out::operator= (Messaging::QueueOrderPolicy_ptr p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE
Messaging::QueueOrderPolicy_out::operator Messaging::QueueOrderPolicy_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE Messaging::QueueOrderPolicy_ptr &
Messaging::QueueOrderPolicy_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE Messaging::QueueOrderPolicy_ptr
Messaging::QueueOrderPolicy_out::operator-> (void)
{
  return this->ptr_;
}

// *************************************************************
// Inline operations for class Messaging::PolicyValue_var
// *************************************************************

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

ACE_INLINE
Messaging::PolicyValue_var::PolicyValue_var (Messaging::PolicyValue *p)
  : ptr_ (p)
{}

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

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

ACE_INLINE Messaging::PolicyValue_var &
Messaging::PolicyValue_var::operator= (Messaging::PolicyValue *p)
{
  delete this->ptr_;
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE const Messaging::PolicyValue *
Messaging::PolicyValue_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE Messaging::PolicyValue *
Messaging::PolicyValue_var::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE
Messaging::PolicyValue_var::operator const Messaging::PolicyValue &() const // cast
{
  return *this->ptr_;
}

ACE_INLINE
Messaging::PolicyValue_var::operator Messaging::PolicyValue &() // cast
{
  return *this->ptr_;
}

ACE_INLINE
Messaging::PolicyValue_var::operator Messaging::PolicyValue &() const// cast
{
  return *this->ptr_;
}

ACE_INLINE const Messaging::PolicyValue &
Messaging::PolicyValue_var::in (void) const
{
  return *this->ptr_;
}

ACE_INLINE Messaging::PolicyValue &
Messaging::PolicyValue_var::inout (void)
{
  return *this->ptr_;
}

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

ACE_INLINE Messaging::PolicyValue *
Messaging::PolicyValue_var::_retn (void)
{
  Messaging::PolicyValue *tmp = this->ptr_;
  this->ptr_ = 0;
  return tmp;
}

ACE_INLINE Messaging::PolicyValue *
Messaging::PolicyValue_var::ptr (void) const
{
  return this->ptr_;
}

// *************************************************************
// Inline operations for class Messaging::PolicyValue_out
// *************************************************************

ACE_INLINE
Messaging::PolicyValue_out::PolicyValue_out (Messaging::PolicyValue *&p)
  : ptr_ (p)
{
  this->ptr_ = 0;
}

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

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

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

ACE_INLINE Messaging::PolicyValue_out &
Messaging::PolicyValue_out::operator= (Messaging::PolicyValue *p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE
Messaging::PolicyValue_out::operator Messaging::PolicyValue *&() // cast
{
  return this->ptr_;
}

ACE_INLINE Messaging::PolicyValue *&
Messaging::PolicyValue_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE Messaging::PolicyValue *
Messaging::PolicyValue_out::operator-> (void)
{
  return this->ptr_;
}

// *************************************************************
// Inline operations for class Messaging::PolicyValueSeq_var
// *************************************************************

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

ACE_INLINE
Messaging::PolicyValueSeq_var::PolicyValueSeq_var (Messaging::PolicyValueSeq *p)
  : ptr_ (p)
{}

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

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

ACE_INLINE Messaging::PolicyValueSeq_var &
Messaging::PolicyValueSeq_var::operator= (Messaging::PolicyValueSeq *p)
{
  delete this->ptr_;
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE const Messaging::PolicyValueSeq *
Messaging::PolicyValueSeq_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE Messaging::PolicyValueSeq *
Messaging::PolicyValueSeq_var::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE
Messaging::PolicyValueSeq_var::operator const Messaging::PolicyValueSeq &() const // cast
{
  return *this->ptr_;
}

ACE_INLINE
Messaging::PolicyValueSeq_var::operator Messaging::PolicyValueSeq &() // cast
{
  return *this->ptr_;
}

ACE_INLINE
Messaging::PolicyValueSeq_var::operator Messaging::PolicyValueSeq &() const// cast
{
  return *this->ptr_;
}

ACE_INLINE Messaging::PolicyValue &
Messaging::PolicyValueSeq_var::operator[] (CORBA::ULong slot)
{
  return this->ptr_->operator[] (slot);
}

ACE_INLINE const Messaging::PolicyValueSeq &
Messaging::PolicyValueSeq_var::in (void) const
{
  return *this->ptr_;
}

ACE_INLINE Messaging::PolicyValueSeq &
Messaging::PolicyValueSeq_var::inout (void)
{
  return *this->ptr_;
}

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

ACE_INLINE Messaging::PolicyValueSeq *
Messaging::PolicyValueSeq_var::_retn (void)
{
  Messaging::PolicyValueSeq *tmp = this->ptr_;
  this->ptr_ = 0;
  return tmp;
}

ACE_INLINE Messaging::PolicyValueSeq *
Messaging::PolicyValueSeq_var::ptr (void) const
{
  return this->ptr_;
}

// *************************************************************
// Inline operations for class Messaging::PolicyValueSeq_out
// *************************************************************

ACE_INLINE
Messaging::PolicyValueSeq_out::PolicyValueSeq_out (Messaging::PolicyValueSeq *&p)
  : ptr_ (p)
{
  this->ptr_ = 0;
}

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

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

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

ACE_INLINE Messaging::PolicyValueSeq_out &
Messaging::PolicyValueSeq_out::operator= (Messaging::PolicyValueSeq *p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE
Messaging::PolicyValueSeq_out::operator Messaging::PolicyValueSeq *&() // cast
{
  return this->ptr_;
}

ACE_INLINE Messaging::PolicyValueSeq *&
Messaging::PolicyValueSeq_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE Messaging::PolicyValueSeq *
Messaging::PolicyValueSeq_out::operator-> (void)
{
  return this->ptr_;
}

ACE_INLINE Messaging::PolicyValue &
Messaging::PolicyValueSeq_out::operator[] (CORBA::ULong slot)
{
  return this->ptr_->operator[] (slot);
}


#if (TAO_HAS_AMI_CALLBACK == 1)

// *************************************************************
// Inline operations for class Messaging::ExceptionHolder::_tao_seq_Octet_var
// *************************************************************

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

ACE_INLINE
Messaging::ExceptionHolder::_tao_seq_Octet_var::_tao_seq_Octet_var (Messaging::ExceptionHolder::_tao_seq_Octet *p)
  : ptr_ (p)
{}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// *************************************************************
// Inline operations for class Messaging::ExceptionHolder::_tao_seq_Octet_out
// *************************************************************

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

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

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

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

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

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

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

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

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



ACE_INLINE
Messaging::ExceptionHolder::ExceptionHolder (void) // default constructor
{}

ACE_INLINE
Messaging::ExceptionHolder::~ExceptionHolder (void) // destructor
{}

ACE_INLINE const char* 
Messaging::ExceptionHolder::_tao_obv_static_repository_id ()
{
  return "IDL:Messaging/ExceptionHolder:1.0";
}

// *************************************************************
// Inline operations for class Messaging::ExceptionHolder_var
// *************************************************************

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

ACE_INLINE
Messaging::ExceptionHolder_var::ExceptionHolder_var (Messaging::ExceptionHolder* p)
  : ptr_ (p)
{}

ACE_INLINE
Messaging::ExceptionHolder_var::ExceptionHolder_var (const Messaging::ExceptionHolder* p)
  : ptr_ (ACE_const_cast(Messaging::ExceptionHolder*, p))
{}

ACE_INLINE Messaging::ExceptionHolder* 
Messaging::ExceptionHolder_var::ptr (void) const
{
  return this->ptr_;
}

ACE_INLINE
Messaging::ExceptionHolder_var::ExceptionHolder_var (const Messaging::ExceptionHolder_var &p) // copy constructor
{
  CORBA::add_ref (p.ptr ());
  this->ptr_ = p.ptr ();
}

ACE_INLINE
Messaging::ExceptionHolder_var::~ExceptionHolder_var (void) // destructor
{
  CORBA::remove_ref (this->ptr_);
}

ACE_INLINE Messaging::ExceptionHolder_var &
Messaging::ExceptionHolder_var::operator= (Messaging::ExceptionHolder* p)
{
  CORBA::remove_ref (this->ptr_);
  this->ptr_ = p;
  return *this;
}

ACE_INLINE Messaging::ExceptionHolder_var &
Messaging::ExceptionHolder_var::operator= (const Messaging::ExceptionHolder_var &p)
{
  if (this != &p)
  {
    CORBA::remove_ref (this->ptr_);
    ExceptionHolder* tmp = p.ptr ();
    CORBA::add_ref (tmp);
    this->ptr_ = tmp;
  }
  return *this;
}

ACE_INLINE 
Messaging::ExceptionHolder_var::operator const Messaging::ExceptionHolder* () const // cast
{
  return this->ptr_;
}

ACE_INLINE 
Messaging::ExceptionHolder_var::operator Messaging::ExceptionHolder* () // cast 
{
  return this->ptr_;
}

ACE_INLINE Messaging::ExceptionHolder* 
Messaging::ExceptionHolder_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE Messaging::ExceptionHolder*
Messaging::ExceptionHolder_var::in (void) const
{
  return this->ptr_;
}

ACE_INLINE Messaging::ExceptionHolder* &
Messaging::ExceptionHolder_var::inout (void)
{
  return this->ptr_;
}

ACE_INLINE Messaging::ExceptionHolder* &
Messaging::ExceptionHolder_var::out (void)
{
  CORBA::remove_ref (this->ptr_);
  this->ptr_ = 0;
  return this->ptr_;
}

ACE_INLINE Messaging::ExceptionHolder* 
Messaging::ExceptionHolder_var::_retn (void)
{
  // yield ownership of managed obj reference
  ExceptionHolder* tmp = this->ptr_;
  this->ptr_ = 0;
  return tmp;
}


// *************************************************************
// Inline operations for class Messaging::ExceptionHolder_out
// *************************************************************

ACE_INLINE
Messaging::ExceptionHolder_out::ExceptionHolder_out (Messaging::ExceptionHolder* &p)
  : ptr_ (p)
{
  this->ptr_ = 0;
}

ACE_INLINE
Messaging::ExceptionHolder_out::ExceptionHolder_out (Messaging::ExceptionHolder_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::remove_ref (this->ptr_);
  this->ptr_ = 0;
}

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

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

ACE_INLINE Messaging::ExceptionHolder_out &
Messaging::ExceptionHolder_out::operator= (const Messaging::ExceptionHolder_var &p)
{
  ExceptionHolder* tmp = p.ptr ();
  CORBA::add_ref (tmp);
  this->ptr_ = tmp;
  return *this;
}

ACE_INLINE Messaging::ExceptionHolder_out &
Messaging::ExceptionHolder_out::operator= (Messaging::ExceptionHolder* p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE 
Messaging::ExceptionHolder_out::operator Messaging::ExceptionHolder* &() // cast
{
  return this->ptr_;
}

ACE_INLINE Messaging::ExceptionHolder* &
Messaging::ExceptionHolder_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE Messaging::ExceptionHolder* 
Messaging::ExceptionHolder_out::operator-> (void)
{
  return this->ptr_;
}



// ****************************************************************


ACE_INLINE
Messaging::ReplyHandler::ReplyHandler (void) // default constructor
{}

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

ACE_INLINE
Messaging::ReplyHandler::~ReplyHandler (void) // destructor
{}

ACE_INLINE Messaging::ReplyHandler_ptr
Messaging::ReplyHandler::_duplicate (Messaging::ReplyHandler_ptr obj)
{
  if (!CORBA::is_nil (obj))
    obj->_incr_refcnt ();
  return obj;
}

ACE_INLINE Messaging::ReplyHandler_ptr
Messaging::ReplyHandler::_nil (void)
{
  return (Messaging::ReplyHandler_ptr)0;
}

// *************************************************************
// Inline operations for class Messaging::ReplyHandler_var
// *************************************************************

ACE_INLINE
Messaging::ReplyHandler_var::ReplyHandler_var (void) // default constructor
  : ptr_ (Messaging::ReplyHandler::_nil ())
{}

ACE_INLINE
Messaging::ReplyHandler_var::ReplyHandler_var (Messaging::ReplyHandler_ptr p)
  : ptr_ (p)
{}

ACE_INLINE Messaging::ReplyHandler_ptr
Messaging::ReplyHandler_var::ptr (void) const
{
  return this->ptr_;
}

ACE_INLINE
Messaging::ReplyHandler_var::ReplyHandler_var (const Messaging::ReplyHandler_var &p) // copy constructor
  : ptr_ (Messaging::ReplyHandler::_duplicate (p.ptr ()))
{}

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

ACE_INLINE Messaging::ReplyHandler_var &
Messaging::ReplyHandler_var::operator= (Messaging::ReplyHandler_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE
Messaging::ReplyHandler_var::operator const Messaging::ReplyHandler_ptr &() const // cast
{
  return this->ptr_;
}

ACE_INLINE
Messaging::ReplyHandler_var::operator Messaging::ReplyHandler_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE Messaging::ReplyHandler_ptr
Messaging::ReplyHandler_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE Messaging::ReplyHandler_ptr
Messaging::ReplyHandler_var::in (void) const
{
  return this->ptr_;
}

ACE_INLINE Messaging::ReplyHandler_ptr &
Messaging::ReplyHandler_var::inout (void)
{
  return this->ptr_;
}

ACE_INLINE Messaging::ReplyHandler_ptr &
Messaging::ReplyHandler_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = Messaging::ReplyHandler::_nil ();
  return this->ptr_;
}

ACE_INLINE Messaging::ReplyHandler_ptr
Messaging::ReplyHandler_var::_retn (void)
{
  // yield ownership of managed obj reference
  Messaging::ReplyHandler_ptr val = this->ptr_;
  this->ptr_ = Messaging::ReplyHandler::_nil ();
  return val;
}

// *************************************************************
// Inline operations for class Messaging::ReplyHandler_out
// *************************************************************

ACE_INLINE
Messaging::ReplyHandler_out::ReplyHandler_out (Messaging::ReplyHandler_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = Messaging::ReplyHandler::_nil ();
}

ACE_INLINE
Messaging::ReplyHandler_out::ReplyHandler_out (Messaging::ReplyHandler_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = Messaging::ReplyHandler::_nil ();
}

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

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

ACE_INLINE Messaging::ReplyHandler_out &
Messaging::ReplyHandler_out::operator= (const Messaging::ReplyHandler_var &p)
{
  this->ptr_ = Messaging::ReplyHandler::_duplicate (p.ptr ());
  return *this;
}

ACE_INLINE Messaging::ReplyHandler_out &
Messaging::ReplyHandler_out::operator= (Messaging::ReplyHandler_ptr p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE
Messaging::ReplyHandler_out::operator Messaging::ReplyHandler_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE Messaging::ReplyHandler_ptr &
Messaging::ReplyHandler_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE Messaging::ReplyHandler_ptr
Messaging::ReplyHandler_out::operator-> (void)
{
  return this->ptr_;
}

#endif /* TAO_HAS_AMI_CALLBACK == 1 */

#if (TAO_HAS_AMI_POLLER == 1)

ACE_INLINE
Messaging::Poller::Poller (void) // default constructor
{}

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

ACE_INLINE
Messaging::Poller::~Poller (void) // destructor
{}

ACE_INLINE Messaging::Poller_ptr
Messaging::Poller::_duplicate (Messaging::Poller_ptr obj)
{
  if (!CORBA::is_nil (obj))
    obj->_incr_refcnt ();
  return obj;
}

ACE_INLINE Messaging::Poller_ptr
Messaging::Poller::_nil (void)
{
  return (Messaging::Poller_ptr)0;
}

// *************************************************************
// Inline operations for class Messaging::Poller_var
// *************************************************************

ACE_INLINE
Messaging::Poller_var::Poller_var (void) // default constructor
  : ptr_ (Messaging::Poller::_nil ())
{}

ACE_INLINE
Messaging::Poller_var::Poller_var (Messaging::Poller_ptr p)
  : ptr_ (p)
{}

ACE_INLINE Messaging::Poller_ptr
Messaging::Poller_var::ptr (void) const
{
  return this->ptr_;
}

ACE_INLINE
Messaging::Poller_var::Poller_var (const Messaging::Poller_var &p) // copy constructor
  : ptr_ (Messaging::Poller::_duplicate (p.ptr ()))
{}

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

ACE_INLINE Messaging::Poller_var &
Messaging::Poller_var::operator= (Messaging::Poller_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

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

ACE_INLINE
Messaging::Poller_var::operator const Messaging::Poller_ptr &() const // cast
{
  return this->ptr_;
}

ACE_INLINE
Messaging::Poller_var::operator Messaging::Poller_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE Messaging::Poller_ptr
Messaging::Poller_var::operator-> (void) const
{
  return this->ptr_;
}

ACE_INLINE Messaging::Poller_ptr
Messaging::Poller_var::in (void) const
{
  return this->ptr_;
}

ACE_INLINE Messaging::Poller_ptr &
Messaging::Poller_var::inout (void)
{
  return this->ptr_;
}

ACE_INLINE Messaging::Poller_ptr &
Messaging::Poller_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = Messaging::Poller::_nil ();
  return this->ptr_;
}

ACE_INLINE Messaging::Poller_ptr
Messaging::Poller_var::_retn (void)
{
  // yield ownership of managed obj reference
  Messaging::Poller_ptr val = this->ptr_;
  this->ptr_ = Messaging::Poller::_nil ();
  return val;
}

// *************************************************************
// Inline operations for class Messaging::Poller_out
// *************************************************************

ACE_INLINE
Messaging::Poller_out::Poller_out (Messaging::Poller_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = Messaging::Poller::_nil ();
}

ACE_INLINE
Messaging::Poller_out::Poller_out (Messaging::Poller_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = Messaging::Poller::_nil ();
}

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

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

ACE_INLINE Messaging::Poller_out &
Messaging::Poller_out::operator= (const Messaging::Poller_var &p)
{
  this->ptr_ = Messaging::Poller::_duplicate (p.ptr ());
  return *this;
}

ACE_INLINE Messaging::Poller_out &
Messaging::Poller_out::operator= (Messaging::Poller_ptr p)
{
  this->ptr_ = p;
  return *this;
}

ACE_INLINE
Messaging::Poller_out::operator Messaging::Poller_ptr &() // cast
{
  return this->ptr_;
}

ACE_INLINE Messaging::Poller_ptr &
Messaging::Poller_out::ptr (void) // ptr
{
  return this->ptr_;
}

ACE_INLINE Messaging::Poller_ptr
Messaging::Poller_out::operator-> (void)
{
  return this->ptr_;
}

#endif /* TAO_HAS_AMI_POLLER == 1 */

// ****************************************************************

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

ACE_INLINE CORBA::Boolean
operator>> (
    TAO_InputCDR &strm,
    Messaging::RebindPolicy_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 =
      Messaging::RebindPolicy::_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 Messaging::SyncScopePolicy_ptr
  );
ACE_INLINE CORBA::Boolean
operator>> (
    TAO_InputCDR &,
    Messaging::SyncScopePolicy_ptr &
  );

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

ACE_INLINE CORBA::Boolean
operator>> (
    TAO_InputCDR &strm,
    Messaging::SyncScopePolicy_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 =
      Messaging::SyncScopePolicy::_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 Messaging::PriorityRange &_tao_aggregate
  )
{
  if (
    (strm << _tao_aggregate.min) &&
    (strm << _tao_aggregate.max)
  )
    return 1;
  else
    return 0;

}

ACE_INLINE CORBA::Boolean 
operator>> (
    TAO_InputCDR &strm, 
    Messaging::PriorityRange &_tao_aggregate
  )
{
  if (
    (strm >> _tao_aggregate.min) &&
    (strm >> _tao_aggregate.max)
  )
    return 1;
  else
    return 0;

}

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

ACE_INLINE CORBA::Boolean
operator>> (
    TAO_InputCDR &strm,
    Messaging::RequestPriorityPolicy_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 =
      Messaging::RequestPriorityPolicy::_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 Messaging::ReplyPriorityPolicy_ptr _tao_objref
  )
{
  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
  return (strm << _tao_corba_obj);
}

ACE_INLINE CORBA::Boolean
operator>> (
    TAO_InputCDR &strm,
    Messaging::ReplyPriorityPolicy_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 =
      Messaging::ReplyPriorityPolicy::_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 Messaging::RequestStartTimePolicy_ptr _tao_objref
  )
{
  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
  return (strm << _tao_corba_obj);
}

ACE_INLINE CORBA::Boolean
operator>> (
    TAO_InputCDR &strm,
    Messaging::RequestStartTimePolicy_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 =
      Messaging::RequestStartTimePolicy::_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 Messaging::RequestEndTimePolicy_ptr _tao_objref
  )
{
  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
  return (strm << _tao_corba_obj);
}

ACE_INLINE CORBA::Boolean
operator>> (
    TAO_InputCDR &strm,
    Messaging::RequestEndTimePolicy_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 =
      Messaging::RequestEndTimePolicy::_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 Messaging::ReplyStartTimePolicy_ptr _tao_objref
  )
{
  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
  return (strm << _tao_corba_obj);
}

ACE_INLINE CORBA::Boolean
operator>> (
    TAO_InputCDR &strm,
    Messaging::ReplyStartTimePolicy_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 =
      Messaging::ReplyStartTimePolicy::_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 Messaging::ReplyEndTimePolicy_ptr _tao_objref
  )
{
  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
  return (strm << _tao_corba_obj);
}

ACE_INLINE CORBA::Boolean
operator>> (
    TAO_InputCDR &strm,
    Messaging::ReplyEndTimePolicy_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 =
      Messaging::ReplyEndTimePolicy::_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 Messaging::RelativeRequestTimeoutPolicy_ptr _tao_objref
  )
{
  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
  return (strm << _tao_corba_obj);
}

ACE_INLINE CORBA::Boolean
operator>> (
    TAO_InputCDR &strm,
    Messaging::RelativeRequestTimeoutPolicy_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 =
      Messaging::RelativeRequestTimeoutPolicy::_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 Messaging::RelativeRoundtripTimeoutPolicy_ptr _tao_objref
  )
{
  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
  return (strm << _tao_corba_obj);
}

ACE_INLINE CORBA::Boolean
operator>> (
    TAO_InputCDR &strm,
    Messaging::RelativeRoundtripTimeoutPolicy_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 =
      Messaging::RelativeRoundtripTimeoutPolicy::_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 Messaging::RoutingTypeRange &_tao_aggregate
  )
{
  if (
    (strm << _tao_aggregate.min) &&
    (strm << _tao_aggregate.max)
  )
    return 1;
  else
    return 0;

}

ACE_INLINE CORBA::Boolean 
operator>> (
    TAO_InputCDR &strm, 
    Messaging::RoutingTypeRange &_tao_aggregate
  )
{
  if (
    (strm >> _tao_aggregate.min) &&
    (strm >> _tao_aggregate.max)
  )
    return 1;
  else
    return 0;

}

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

ACE_INLINE CORBA::Boolean
operator>> (
    TAO_InputCDR &strm,
    Messaging::RoutingPolicy_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 =
      Messaging::RoutingPolicy::_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 Messaging::MaxHopsPolicy_ptr _tao_objref
  )
{
  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
  return (strm << _tao_corba_obj);
}

ACE_INLINE CORBA::Boolean
operator>> (
    TAO_InputCDR &strm,
    Messaging::MaxHopsPolicy_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 =
      Messaging::MaxHopsPolicy::_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 Messaging::QueueOrderPolicy_ptr _tao_objref
  )
{
  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
  return (strm << _tao_corba_obj);
}

ACE_INLINE CORBA::Boolean
operator>> (
    TAO_InputCDR &strm,
    Messaging::QueueOrderPolicy_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 =
      Messaging::QueueOrderPolicy::_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 Messaging::PolicyValue::_tao_seq_Octet &_tao_sequence
  )
{
  if (strm << _tao_sequence.length ())
  {
    // encode all elements

#if defined (TAO_NO_COPY_OCTET_SEQUENCES)
    {
      TAO_Unbounded_Sequence<CORBA::Octet> *oseq =
        ACE_dynamic_cast (TAO_Unbounded_Sequence<CORBA::Octet>*, (Messaging::PolicyValue::_tao_seq_Octet *)&_tao_sequence);
      if (oseq->mb ())
        return strm.write_octet_array_mb (oseq->mb ());
      else
        return strm.write_octet_array (_tao_sequence.get_buffer (), _tao_sequence.length ());
    }

#else /* TAO_NO_COPY_OCTET_SEQUENCES */
    return strm.write_octet_array (_tao_sequence.get_buffer (), _tao_sequence.length ());

#endif /* TAO_NO_COPY_OCTET_SEQUENCES */
  }
  return 0; // error
}

ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, Messaging::PolicyValue::_tao_seq_Octet &_tao_sequence)
{
  CORBA::ULong _tao_seq_len;
  if (strm >> _tao_seq_len)
  {
    // set the length of the sequence
    _tao_sequence.length (_tao_seq_len);
    // retrieve all the elements

#if defined (TAO_NO_COPY_OCTET_SEQUENCES)
    if (ACE_BIT_DISABLED (strm.start ()->flags (),ACE_Message_Block::DONT_DELETE))
    {
      TAO_Unbounded_Sequence<CORBA::Octet> *oseq =
        ACE_dynamic_cast(TAO_Unbounded_Sequence<CORBA::Octet>*, &_tao_sequence);
      oseq->replace (_tao_seq_len, strm.start ());
      oseq->mb ()->wr_ptr (oseq->mb()->rd_ptr () + _tao_seq_len);
      strm.skip_bytes (_tao_seq_len);
      return 1;
    }
    else
      return strm.read_octet_array (_tao_sequence.get_buffer (), _tao_seq_len);

#else /* TAO_NO_COPY_OCTET_SEQUENCES */
    return strm.read_octet_array (_tao_sequence.get_buffer (), _tao_sequence.length ());

#endif /* TAO_NO_COPY_OCTET_SEQUENCES */
  }
  return 0; // error
}

// ****************************************************************

ACE_INLINE CORBA::Boolean 
operator<< (
    TAO_OutputCDR &strm, 
    const Messaging::PolicyValue &_tao_aggregate
  )
{
  if (
    (strm << _tao_aggregate.ptype) &&
    (strm << _tao_aggregate.pvalue)
  )
    return 1;
  else
    return 0;

}

ACE_INLINE CORBA::Boolean 
operator>> (
    TAO_InputCDR &strm, 
    Messaging::PolicyValue &_tao_aggregate
  )
{
  if (
    (strm >> _tao_aggregate.ptype) &&
    (strm >> _tao_aggregate.pvalue)
  )
    return 1;
  else
    return 0;

}

// ****************************************************************

ACE_INLINE CORBA::Boolean 
operator<< (
    TAO_OutputCDR &strm,
    const Messaging::PolicyValueSeq &_tao_sequence
  )
{
  if (strm << _tao_sequence.length ())
  {
    // encode all elements
    CORBA::Boolean _tao_marshal_flag = 1;
    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
      _tao_marshal_flag = (strm << _tao_sequence[i]);
    return _tao_marshal_flag;
  }
  return 0; // error
}

ACE_INLINE CORBA::Boolean 
operator>> (
    TAO_InputCDR &strm, 
    Messaging::PolicyValueSeq &_tao_sequence
  )
{
  CORBA::ULong _tao_seq_len;
  if (strm >> _tao_seq_len)
  {
    // set the length of the sequence
    _tao_sequence.length (_tao_seq_len);
    // retrieve all the elements
    CORBA::Boolean _tao_marshal_flag = 1;
    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
      _tao_marshal_flag = (strm >> _tao_sequence[i]);
    return _tao_marshal_flag;
  }
  return 0; // error
}

// ****************************************************************

#if (TAO_HAS_AMI_CALLBACK == 1) || (TAO_HAS_AMI_POLLER == 1)

ACE_INLINE CORBA::Boolean
operator<< (TAO_OutputCDR &strm, const Messaging::ExceptionHolder *_tao_valuetype)
{
  return CORBA_ValueBase::_tao_marshal (strm,
    ACE_const_cast (Messaging::ExceptionHolder*, _tao_valuetype),
    (ptr_arith_t) &Messaging::ExceptionHolder::_downcast);
}

ACE_INLINE CORBA::Boolean
operator>> (TAO_InputCDR &strm, Messaging::ExceptionHolder *&_tao_valuetype)
{
  return Messaging::ExceptionHolder::_tao_unmarshal (strm, _tao_valuetype);
}

ACE_INLINE CORBA::Boolean
OBV_Messaging::ExceptionHolder::_tao_marshal_state (TAO_OutputCDR &strm)
{
  if (
    (strm << CORBA::Any::from_boolean (_pd_is_system_exception)) &&
    (strm << CORBA::Any::from_boolean (_pd_byte_order)) &&
    (strm << *_pd_marshaled_exception)
  )
    return 1;
  else
    return 0;
  
}

ACE_INLINE CORBA::Boolean
OBV_Messaging::ExceptionHolder::_tao_unmarshal_state (TAO_InputCDR &strm)
{
  if (
    (strm >> CORBA::Any::to_boolean (_pd_is_system_exception)) &&
    (strm >> CORBA::Any::to_boolean (_pd_byte_order)) &&
    (strm >> *_pd_marshaled_exception)
  )
    return 1;
  else
    return 0;
  
}



ACE_INLINE CORBA::Boolean operator<< (
    TAO_OutputCDR &strm,
    const Messaging::ExceptionHolder::_tao_seq_Octet &_tao_sequence
  )
{
  if (strm << _tao_sequence.length ())
  {
    // encode all elements

#if defined (TAO_NO_COPY_OCTET_SEQUENCES)
    {
      TAO_Unbounded_Sequence<CORBA::Octet> *oseq =
        ACE_dynamic_cast (TAO_Unbounded_Sequence<CORBA::Octet>*, (Messaging::PolicyValue::_tao_seq_Octet *)&_tao_sequence);
      if (oseq->mb ())
        return strm.write_octet_array_mb (oseq->mb ());
      else
        return strm.write_octet_array (_tao_sequence.get_buffer (), _tao_sequence.length ());
    }

#else /* TAO_NO_COPY_OCTET_SEQUENCES */
    return strm.write_octet_array (_tao_sequence.get_buffer (), _tao_sequence.length ());

#endif /* TAO_NO_COPY_OCTET_SEQUENCES */
  }
  return 0; // error
}

ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, Messaging::ExceptionHolder::_tao_seq_Octet &_tao_sequence)
{
  CORBA::ULong _tao_seq_len;
  if (strm >> _tao_seq_len)
  {
    // set the length of the sequence
    _tao_sequence.length (_tao_seq_len);
    // retrieve all the elements

#if defined (TAO_NO_COPY_OCTET_SEQUENCES)
    if (ACE_BIT_DISABLED (strm.start ()->flags (),ACE_Message_Block::DONT_DELETE))
    {
      TAO_Unbounded_Sequence<CORBA::Octet> *oseq =
        ACE_dynamic_cast(TAO_Unbounded_Sequence<CORBA::Octet>*, &_tao_sequence);
      oseq->replace (_tao_seq_len, strm.start ());
      oseq->mb ()->wr_ptr (oseq->mb()->rd_ptr () + _tao_seq_len);
      strm.skip_bytes (_tao_seq_len);
      return 1;
    }
    else
      return strm.read_octet_array (_tao_sequence.get_buffer (), _tao_seq_len);

#else /* TAO_NO_COPY_OCTET_SEQUENCES */
    return strm.read_octet_array (_tao_sequence.get_buffer (), _tao_sequence.length ());

#endif /* TAO_NO_COPY_OCTET_SEQUENCES */
  }
  return 0; // error
}


#endif /* TAO_HAS_AMI_CALLBACK == 1 || TAO_HAS_AMI_POLLER == 1 */

#if (TAO_HAS_AMI_CALLBACK == 1)

// ****************************************************************

ACE_INLINE CORBA::Boolean
operator<< (
    TAO_OutputCDR &,
    const Messaging::ReplyHandler_ptr
  );
ACE_INLINE CORBA::Boolean
operator>> (
    TAO_InputCDR &,
    Messaging::ReplyHandler_ptr &
  );

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

ACE_INLINE CORBA::Boolean
operator>> (
    TAO_InputCDR &strm,
    Messaging::ReplyHandler_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 =
      Messaging::ReplyHandler::_narrow (
          obj.in (),
          ACE_TRY_ENV
        );
    ACE_TRY_CHECK;
    return 1;
  }
  ACE_CATCHANY
  {
    // do nothing
  }
  ACE_ENDTRY;
  return 0;
}

#endif /* TAO_HAS_AMI_CALLBACK == 1 */

// ****************************************************************

#if (TAO_HAS_AMI_POLLER == 1)

ACE_INLINE CORBA::Boolean
operator<< (
    TAO_OutputCDR &,
    const Messaging::Poller_ptr
  );
ACE_INLINE CORBA::Boolean
operator>> (
    TAO_InputCDR &,
    Messaging::Poller_ptr &
  );

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

ACE_INLINE CORBA::Boolean
operator>> (
    TAO_InputCDR &strm,
    Messaging::Poller_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 =
      Messaging::Poller::_narrow (
          obj.in (),
          ACE_TRY_ENV
        );
    ACE_TRY_CHECK;
    return 1;
  }
  ACE_CATCHANY
  {
    // do nothing
  }
  ACE_ENDTRY;
  return 0;
}

#endif /* TAO_HAS_AMI_POLLER == 1 */