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

#if (TAO_HAS_REBIND_POLICY == 1)

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

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


#if !defined (_MESSAGING_REBINDPOLICY___VAR_CI_)
#define _MESSAGING_REBINDPOLICY___VAR_CI_

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

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

ACE_INLINE
Messaging::RebindPolicy_var::RebindPolicy_var (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
  : TAO_Base_var (),
    ptr_ (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= (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;
}


#endif /* end #if !defined */


#if !defined (_MESSAGING_REBINDPOLICY___OUT_CI_)
#define _MESSAGING_REBINDPOLICY___OUT_CI_

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

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

ACE_INLINE
Messaging::RebindPolicy_out::RebindPolicy_out (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 (RebindPolicy_out &, p).ptr_)
{}

ACE_INLINE ::Messaging::RebindPolicy_out &
Messaging::RebindPolicy_out::operator= (const ::Messaging::RebindPolicy_out &p)
{
  this->ptr_ = ACE_const_cast (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= (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_;
}


#endif /* end #if !defined */

#endif /* TAO_HAS_REBIND_POLICY == 1 */

#if (TAO_HAS_SYNC_SCOPE_POLICY == 1)

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

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


#if !defined (_MESSAGING_SYNCSCOPEPOLICY___VAR_CI_)
#define _MESSAGING_SYNCSCOPEPOLICY___VAR_CI_

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

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

ACE_INLINE
Messaging::SyncScopePolicy_var::SyncScopePolicy_var (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
  : TAO_Base_var (),
    ptr_ (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= (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;
}


#endif /* end #if !defined */


#if !defined (_MESSAGING_SYNCSCOPEPOLICY___OUT_CI_)
#define _MESSAGING_SYNCSCOPEPOLICY___OUT_CI_

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

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

ACE_INLINE
Messaging::SyncScopePolicy_out::SyncScopePolicy_out (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 (SyncScopePolicy_out &, p).ptr_)
{}

ACE_INLINE ::Messaging::SyncScopePolicy_out &
Messaging::SyncScopePolicy_out::operator= (const ::Messaging::SyncScopePolicy_out &p)
{
  this->ptr_ = ACE_const_cast (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= (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_;
}


#endif /* end #if !defined */

#endif /* TAO_HAS_SYNC_SCOPE_POLICY == 1 */

#if (TAO_HAS_PRIORITY_POLICIES == 1)

// *************************************************************
// 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 (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;
}

// fixed-size types only
ACE_INLINE
Messaging::PriorityRange_var::PriorityRange_var (const ::Messaging::PriorityRange &p)
{
  ACE_NEW (this->ptr_, ::Messaging::PriorityRange (p));
}

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

ACE_INLINE Messaging::PriorityRange_var &
Messaging::PriorityRange_var::operator= (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;
}

// fixed-size types only
ACE_INLINE Messaging::PriorityRange_var &
Messaging::PriorityRange_var::operator= (const ::Messaging::PriorityRange &p)
{
  if (this->ptr_ != &p)
  {
    delete this->ptr_;
    ACE_NEW_RETURN (this->ptr_, ::Messaging::PriorityRange (p), *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 (void) // destructor
{}


#if !defined (_MESSAGING_REQUESTPRIORITYPOLICY___VAR_CI_)
#define _MESSAGING_REQUESTPRIORITYPOLICY___VAR_CI_

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

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

ACE_INLINE
Messaging::RequestPriorityPolicy_var::RequestPriorityPolicy_var (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
  : TAO_Base_var (),
    ptr_ (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= (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;
}


#endif /* end #if !defined */


#if !defined (_MESSAGING_REQUESTPRIORITYPOLICY___OUT_CI_)
#define _MESSAGING_REQUESTPRIORITYPOLICY___OUT_CI_

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

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

ACE_INLINE
Messaging::RequestPriorityPolicy_out::RequestPriorityPolicy_out (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 (RequestPriorityPolicy_out &, p).ptr_)
{}

ACE_INLINE ::Messaging::RequestPriorityPolicy_out &
Messaging::RequestPriorityPolicy_out::operator= (const ::Messaging::RequestPriorityPolicy_out &p)
{
  this->ptr_ = ACE_const_cast (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= (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_;
}


#endif /* end #if !defined */

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

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


#if !defined (_MESSAGING_REPLYPRIORITYPOLICY___VAR_CI_)
#define _MESSAGING_REPLYPRIORITYPOLICY___VAR_CI_

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

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

ACE_INLINE
Messaging::ReplyPriorityPolicy_var::ReplyPriorityPolicy_var (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
  : TAO_Base_var (),
    ptr_ (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= (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;
}


#endif /* end #if !defined */


#if !defined (_MESSAGING_REPLYPRIORITYPOLICY___OUT_CI_)
#define _MESSAGING_REPLYPRIORITYPOLICY___OUT_CI_

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

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

ACE_INLINE
Messaging::ReplyPriorityPolicy_out::ReplyPriorityPolicy_out (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 (ReplyPriorityPolicy_out &, p).ptr_)
{}

ACE_INLINE ::Messaging::ReplyPriorityPolicy_out &
Messaging::ReplyPriorityPolicy_out::operator= (const ::Messaging::ReplyPriorityPolicy_out &p)
{
  this->ptr_ = ACE_const_cast (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= (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_;
}


#endif /* end #if !defined */

#endif /* TAO_HAS_PRIORITY_POLICIES == 1 */

#if (TAO_HAS_REQUEST_START_TIME_POLICY == 1)

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

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


#if !defined (_MESSAGING_REQUESTSTARTTIMEPOLICY___VAR_CI_)
#define _MESSAGING_REQUESTSTARTTIMEPOLICY___VAR_CI_

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

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

ACE_INLINE
Messaging::RequestStartTimePolicy_var::RequestStartTimePolicy_var (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
  : TAO_Base_var (),
    ptr_ (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= (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;
}


#endif /* end #if !defined */


#if !defined (_MESSAGING_REQUESTSTARTTIMEPOLICY___OUT_CI_)
#define _MESSAGING_REQUESTSTARTTIMEPOLICY___OUT_CI_

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

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

ACE_INLINE
Messaging::RequestStartTimePolicy_out::RequestStartTimePolicy_out (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 (RequestStartTimePolicy_out &, p).ptr_)
{}

ACE_INLINE ::Messaging::RequestStartTimePolicy_out &
Messaging::RequestStartTimePolicy_out::operator= (const ::Messaging::RequestStartTimePolicy_out &p)
{
  this->ptr_ = ACE_const_cast (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= (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_;
}


#endif /* end #if !defined */

#endif /* TAO_HAS_REQUEST_START_TIME_POLICY == 1 */

#if (TAO_HAS_REQUEST_END_TIME_POLICY == 1)

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

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


#if !defined (_MESSAGING_REQUESTENDTIMEPOLICY___VAR_CI_)
#define _MESSAGING_REQUESTENDTIMEPOLICY___VAR_CI_

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

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

ACE_INLINE
Messaging::RequestEndTimePolicy_var::RequestEndTimePolicy_var (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
  : TAO_Base_var (),
    ptr_ (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= (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;
}


#endif /* end #if !defined */


#if !defined (_MESSAGING_REQUESTENDTIMEPOLICY___OUT_CI_)
#define _MESSAGING_REQUESTENDTIMEPOLICY___OUT_CI_

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

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

ACE_INLINE
Messaging::RequestEndTimePolicy_out::RequestEndTimePolicy_out (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 (RequestEndTimePolicy_out &, p).ptr_)
{}

ACE_INLINE ::Messaging::RequestEndTimePolicy_out &
Messaging::RequestEndTimePolicy_out::operator= (const ::Messaging::RequestEndTimePolicy_out &p)
{
  this->ptr_ = ACE_const_cast (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= (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_;
}


#endif /* end #if !defined */

#endif /* TAO_HAS_REQUEST_END_TIME_POLICY == 1 */

#if (TAO_HAS_REPLY_START_TIME_POLICY == 1)

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

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


#if !defined (_MESSAGING_REPLYSTARTTIMEPOLICY___VAR_CI_)
#define _MESSAGING_REPLYSTARTTIMEPOLICY___VAR_CI_

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

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

ACE_INLINE
Messaging::ReplyStartTimePolicy_var::ReplyStartTimePolicy_var (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
  : TAO_Base_var (),
    ptr_ (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= (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;
}


#endif /* end #if !defined */


#if !defined (_MESSAGING_REPLYSTARTTIMEPOLICY___OUT_CI_)
#define _MESSAGING_REPLYSTARTTIMEPOLICY___OUT_CI_

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

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

ACE_INLINE
Messaging::ReplyStartTimePolicy_out::ReplyStartTimePolicy_out (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 (ReplyStartTimePolicy_out &, p).ptr_)
{}

ACE_INLINE ::Messaging::ReplyStartTimePolicy_out &
Messaging::ReplyStartTimePolicy_out::operator= (const ::Messaging::ReplyStartTimePolicy_out &p)
{
  this->ptr_ = ACE_const_cast (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= (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_;
}


#endif /* end #if !defined */

#endif /* TAO_HAS_REPLY_START_TIME_POLICY == 1 */

#if (TAO_HAS_REPLY_END_TIME_POLICY == 1)

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

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


#if !defined (_MESSAGING_REPLYENDTIMEPOLICY___VAR_CI_)
#define _MESSAGING_REPLYENDTIMEPOLICY___VAR_CI_

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

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

ACE_INLINE
Messaging::ReplyEndTimePolicy_var::ReplyEndTimePolicy_var (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
  : TAO_Base_var (),
    ptr_ (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= (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;
}


#endif /* end #if !defined */


#if !defined (_MESSAGING_REPLYENDTIMEPOLICY___OUT_CI_)
#define _MESSAGING_REPLYENDTIMEPOLICY___OUT_CI_

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

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

ACE_INLINE
Messaging::ReplyEndTimePolicy_out::ReplyEndTimePolicy_out (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 (ReplyEndTimePolicy_out &, p).ptr_)
{}

ACE_INLINE ::Messaging::ReplyEndTimePolicy_out &
Messaging::ReplyEndTimePolicy_out::operator= (const ::Messaging::ReplyEndTimePolicy_out &p)
{
  this->ptr_ = ACE_const_cast (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= (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_;
}


#endif /* end #if !defined */

#endif /* TAO_HAS_REPLY_END_TIME_POLICY == 1 */

#if (TAO_HAS_RELATIVE_REQUEST_TIMEOUT_POLICY == 1)

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

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


#if !defined (_MESSAGING_RELATIVEREQUESTTIMEOUTPOLICY___VAR_CI_)
#define _MESSAGING_RELATIVEREQUESTTIMEOUTPOLICY___VAR_CI_

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

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

ACE_INLINE
Messaging::RelativeRequestTimeoutPolicy_var::RelativeRequestTimeoutPolicy_var (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
  : TAO_Base_var (),
    ptr_ (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= (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;
}


#endif /* end #if !defined */


#if !defined (_MESSAGING_RELATIVEREQUESTTIMEOUTPOLICY___OUT_CI_)
#define _MESSAGING_RELATIVEREQUESTTIMEOUTPOLICY___OUT_CI_

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

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

ACE_INLINE
Messaging::RelativeRequestTimeoutPolicy_out::RelativeRequestTimeoutPolicy_out (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 (RelativeRequestTimeoutPolicy_out &, p).ptr_)
{}

ACE_INLINE ::Messaging::RelativeRequestTimeoutPolicy_out &
Messaging::RelativeRequestTimeoutPolicy_out::operator= (const ::Messaging::RelativeRequestTimeoutPolicy_out &p)
{
  this->ptr_ = ACE_const_cast (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= (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_;
}


#endif /* end #if !defined */

#endif /* TAO_HAS_RELATIVE_REQUEST_TIMEOUT_POLICY == 1 */

#if (TAO_HAS_RELATIVE_ROUNDTRIP_TIMEOUT_POLICY == 1)

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

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


#if !defined (_MESSAGING_RELATIVEROUNDTRIPTIMEOUTPOLICY___VAR_CI_)
#define _MESSAGING_RELATIVEROUNDTRIPTIMEOUTPOLICY___VAR_CI_

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

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

ACE_INLINE
Messaging::RelativeRoundtripTimeoutPolicy_var::RelativeRoundtripTimeoutPolicy_var (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
  : TAO_Base_var (),
    ptr_ (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= (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;
}


#endif /* end #if !defined */


#if !defined (_MESSAGING_RELATIVEROUNDTRIPTIMEOUTPOLICY___OUT_CI_)
#define _MESSAGING_RELATIVEROUNDTRIPTIMEOUTPOLICY___OUT_CI_

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

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

ACE_INLINE
Messaging::RelativeRoundtripTimeoutPolicy_out::RelativeRoundtripTimeoutPolicy_out (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 (RelativeRoundtripTimeoutPolicy_out &, p).ptr_)
{}

ACE_INLINE ::Messaging::RelativeRoundtripTimeoutPolicy_out &
Messaging::RelativeRoundtripTimeoutPolicy_out::operator= (const ::Messaging::RelativeRoundtripTimeoutPolicy_out &p)
{
  this->ptr_ = ACE_const_cast (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= (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_;
}


#endif /* end #if !defined */

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

#endif /* TAO_HAS_RELATIVE_ROUNDTRIP_TIMEOUT_POLICY == 1 */

#if (TAO_HAS_ROUTING_POLICY == 1)

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

ACE_INLINE
Messaging::RoutingTypeRange_var::RoutingTypeRange_var (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;
}

// fixed-size types only
ACE_INLINE
Messaging::RoutingTypeRange_var::RoutingTypeRange_var (const ::Messaging::RoutingTypeRange &p)
{
  ACE_NEW (this->ptr_, ::Messaging::RoutingTypeRange (p));
}

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

ACE_INLINE Messaging::RoutingTypeRange_var &
Messaging::RoutingTypeRange_var::operator= (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;
}

// fixed-size types only
ACE_INLINE Messaging::RoutingTypeRange_var &
Messaging::RoutingTypeRange_var::operator= (const ::Messaging::RoutingTypeRange &p)
{
  if (this->ptr_ != &p)
  {
    delete this->ptr_;
    ACE_NEW_RETURN (this->ptr_, ::Messaging::RoutingTypeRange (p), *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 (void) // destructor
{}


#if !defined (_MESSAGING_ROUTINGPOLICY___VAR_CI_)
#define _MESSAGING_ROUTINGPOLICY___VAR_CI_

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

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

ACE_INLINE
Messaging::RoutingPolicy_var::RoutingPolicy_var (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
  : TAO_Base_var (),
    ptr_ (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= (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;
}


#endif /* end #if !defined */


#if !defined (_MESSAGING_ROUTINGPOLICY___OUT_CI_)
#define _MESSAGING_ROUTINGPOLICY___OUT_CI_

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

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

ACE_INLINE
Messaging::RoutingPolicy_out::RoutingPolicy_out (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 (RoutingPolicy_out &, p).ptr_)
{}

ACE_INLINE ::Messaging::RoutingPolicy_out &
Messaging::RoutingPolicy_out::operator= (const ::Messaging::RoutingPolicy_out &p)
{
  this->ptr_ = ACE_const_cast (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= (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_;
}


#endif /* end #if !defined */

#endif /* TAO_HAS_ROUTING_POLICY == 1 */

#if (TAO_HAS_MAX_HOPS_POLICY == 1)

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

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


#if !defined (_MESSAGING_MAXHOPSPOLICY___VAR_CI_)
#define _MESSAGING_MAXHOPSPOLICY___VAR_CI_

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

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

ACE_INLINE
Messaging::MaxHopsPolicy_var::MaxHopsPolicy_var (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
  : TAO_Base_var (),
    ptr_ (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= (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;
}


#endif /* end #if !defined */


#if !defined (_MESSAGING_MAXHOPSPOLICY___OUT_CI_)
#define _MESSAGING_MAXHOPSPOLICY___OUT_CI_

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

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

ACE_INLINE
Messaging::MaxHopsPolicy_out::MaxHopsPolicy_out (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 (MaxHopsPolicy_out &, p).ptr_)
{}

ACE_INLINE ::Messaging::MaxHopsPolicy_out &
Messaging::MaxHopsPolicy_out::operator= (const ::Messaging::MaxHopsPolicy_out &p)
{
  this->ptr_ = ACE_const_cast (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= (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_;
}


#endif /* end #if !defined */

#endif /* TAO_HAS_MAX_HOPS_POLICY == 1 */

#if (TAO_HAS_QUEUE_ORDER_POLICY == 1)

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

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


#if !defined (_MESSAGING_QUEUEORDERPOLICY___VAR_CI_)
#define _MESSAGING_QUEUEORDERPOLICY___VAR_CI_

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

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

ACE_INLINE
Messaging::QueueOrderPolicy_var::QueueOrderPolicy_var (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
  : TAO_Base_var (),
    ptr_ (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= (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;
}


#endif /* end #if !defined */


#if !defined (_MESSAGING_QUEUEORDERPOLICY___OUT_CI_)
#define _MESSAGING_QUEUEORDERPOLICY___OUT_CI_

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

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

ACE_INLINE
Messaging::QueueOrderPolicy_out::QueueOrderPolicy_out (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 (QueueOrderPolicy_out &, p).ptr_)
{}

ACE_INLINE ::Messaging::QueueOrderPolicy_out &
Messaging::QueueOrderPolicy_out::operator= (const ::Messaging::QueueOrderPolicy_out &p)
{
  this->ptr_ = ACE_const_cast (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= (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_;
}


#endif /* end #if !defined */

#endif /* TAO_HAS_QUEUE_ORDER_POLICY == 1 */

// *************************************************************
// 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 (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= (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_;
}

// variable-size types only
ACE_INLINE
Messaging::PolicyValue_var::operator ::Messaging::PolicyValue *&() // 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 (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 (PolicyValue_out&, p).ptr_)
{}

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

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


#if !defined (_MESSAGING_POLICYVALUE__TAO_SEQ_OCTET_CI_)
#define _MESSAGING_POLICYVALUE__TAO_SEQ_OCTET_CI_

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

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

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

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

// fixed-size base types only
ACE_INLINE
Messaging::PolicyValue::_tao_seq_Octet_var::_tao_seq_Octet_var (const ::Messaging::PolicyValue::_tao_seq_Octet &p)
{
  ACE_NEW (this->ptr_, ::Messaging::PolicyValue::_tao_seq_Octet (p));
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


#endif /* end #if !defined */


#if !defined (TAO_USE_SEQUENCE_TEMPLATES)

#if !defined (__TAO_UNBOUNDED_SEQUENCE_MESSAGING_POLICYVALUESEQ_CI_)
#define __TAO_UNBOUNDED_SEQUENCE_MESSAGING_POLICYVALUESEQ_CI_

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

  ACE_INLINE void Messaging::_TAO_Unbounded_Sequence_Messaging_PolicyValueSeq::freebuf (Messaging::PolicyValue *buffer)
  // Free the sequence.
  {
    delete [] buffer;
  }

  ACE_INLINE
  Messaging::_TAO_Unbounded_Sequence_Messaging_PolicyValueSeq::_TAO_Unbounded_Sequence_Messaging_PolicyValueSeq (void) // Default constructor.
  {
  }

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

  ACE_INLINE
  Messaging::_TAO_Unbounded_Sequence_Messaging_PolicyValueSeq::_TAO_Unbounded_Sequence_Messaging_PolicyValueSeq (CORBA::ULong maximum,
    CORBA::ULong length,
    Messaging::PolicyValue *data,
    CORBA::Boolean release)
  : TAO_Unbounded_Base_Sequence (maximum, length, data, release)
  {
  }

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

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

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

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

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

    TAO_Unbounded_Base_Sequence::operator= (rhs);

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

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

    return *this;
  }

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

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

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

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

  ACE_INLINE const Messaging::PolicyValue *
  Messaging::_TAO_Unbounded_Sequence_Messaging_PolicyValueSeq::get_buffer (void) const
  {
    return ACE_reinterpret_cast(const Messaging::PolicyValue * ACE_CAST_CONST, this->buffer_);
  }

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

#endif /* end #if !defined */


#endif /* !TAO_USE_SEQUENCE_TEMPLATES */

#if !defined (_MESSAGING_POLICYVALUESEQ_CI_)
#define _MESSAGING_POLICYVALUESEQ_CI_

// *************************************************************
// 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 (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= (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_;
}

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

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

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 (PolicyValueSeq *&p)
  : ptr_ (p)
{
  this->ptr_ = 0;
}

ACE_INLINE
Messaging::PolicyValueSeq_out::PolicyValueSeq_out (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 (PolicyValueSeq_out&, p).ptr_)
{}

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

ACE_INLINE ::Messaging::PolicyValueSeq_out &
Messaging::PolicyValueSeq_out::operator= (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 index)
{
  return this->ptr_->operator[] (index);
}


#endif /* end #if !defined */

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

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

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

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


#if !defined (_MESSAGING_EXCEPTIONHOLDER___VAR_CI_)
#define _MESSAGING_EXCEPTIONHOLDER___VAR_CI_

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


#endif /* end #if !defined */


#if !defined (_MESSAGING_EXCEPTIONHOLDER___OUT_CI_)
#define _MESSAGING_EXCEPTIONHOLDER___OUT_CI_

// *************************************************************
// 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_;
}

#if !defined (_MESSAGING_EXCEPTIONHOLDER__TAO_SEQ_OCTET_CI_)
#define _MESSAGING_EXCEPTIONHOLDER__TAO_SEQ_OCTET_CI_

// *************************************************************
// 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 (_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;
}

// fixed-size base types only
ACE_INLINE
Messaging::ExceptionHolder::_tao_seq_Octet_var::_tao_seq_Octet_var (const ::Messaging::ExceptionHolder::_tao_seq_Octet &p)
{
  ACE_NEW (this->ptr_, ::Messaging::ExceptionHolder::_tao_seq_Octet (p));
}

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= (_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;
}

// fixed-size types only
ACE_INLINE ::Messaging::ExceptionHolder::_tao_seq_Octet_var &
Messaging::ExceptionHolder::_tao_seq_Octet_var::operator= (const ::Messaging::ExceptionHolder::_tao_seq_Octet &p)
{
  if (this->ptr_ != &p)
  {
    delete this->ptr_;
    ACE_NEW_RETURN (this->ptr_, ::Messaging::ExceptionHolder::_tao_seq_Octet (p), *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 (_tao_seq_Octet *&p)
  : ptr_ (p)
{
  this->ptr_ = 0;
}

ACE_INLINE
Messaging::ExceptionHolder::_tao_seq_Octet_out::_tao_seq_Octet_out (_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 (_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 (_tao_seq_Octet_out&, p).ptr_;
  return *this;
}

ACE_INLINE ::Messaging::ExceptionHolder::_tao_seq_Octet_out &
Messaging::ExceptionHolder::_tao_seq_Octet_out::operator= (_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);
}


#endif /* end #if !defined */



#endif /* end #if !defined */

ACE_INLINE
Messaging::ReplyHandler::ReplyHandler (
  TAO_Stub *objref,
  CORBA::Boolean _tao_collocated,
  TAO_Abstract_ServantBase *servant
  )
    : CORBA_Object (objref, _tao_collocated, servant)
  {

      this->_tao_setup_collocation (_tao_collocated);
    }

#if !defined (_MESSAGING_REPLYHANDLER___VAR_CI_)
#define _MESSAGING_REPLYHANDLER___VAR_CI_

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

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

ACE_INLINE
Messaging::ReplyHandler_var::ReplyHandler_var (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
  : TAO_Base_var (),
    ptr_ (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= (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;
}


#endif /* end #if !defined */


#if !defined (_MESSAGING_REPLYHANDLER___OUT_CI_)
#define _MESSAGING_REPLYHANDLER___OUT_CI_

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

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

ACE_INLINE
Messaging::ReplyHandler_out::ReplyHandler_out (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 (ReplyHandler_out &, p).ptr_)
{}

ACE_INLINE ::Messaging::ReplyHandler_out &
Messaging::ReplyHandler_out::operator= (const ::Messaging::ReplyHandler_out &p)
{
  this->ptr_ = ACE_const_cast (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= (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 /* end #if !defined */

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

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

}


#if !defined _TAO_CDR_OP_Messaging_PolicyValue__tao_seq_Octet_I_
#define _TAO_CDR_OP_Messaging_PolicyValue__tao_seq_Octet_I_

CORBA::Boolean TAO_Export operator<< (
    TAO_OutputCDR &,
    const Messaging::PolicyValue::_tao_seq_Octet &
  );
CORBA::Boolean TAO_Export operator>> (
    TAO_InputCDR &,
    Messaging::PolicyValue::_tao_seq_Octet &
  );

#endif /* _TAO_CDR_OP_Messaging_PolicyValue__tao_seq_Octet_I_ */

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;

}


#if !defined _TAO_CDR_OP_Messaging_PolicyValueSeq_I_
#define _TAO_CDR_OP_Messaging_PolicyValueSeq_I_

CORBA::Boolean TAO_Export operator<< (
    TAO_OutputCDR &,
    const Messaging::PolicyValueSeq &
  );
CORBA::Boolean TAO_Export operator>> (
    TAO_InputCDR &,
    Messaging::PolicyValueSeq &
  );

#endif /* _TAO_CDR_OP_Messaging_PolicyValueSeq_I_ */

#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 &,
    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::_unchecked_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 || TAO_HAS_AMI_POLLER == 1 */