ChangeLogTag:Fri Apr 28 20:09:34 2000 Carlos O'Ryan <coryan@uci.edu>

1 files changed, 1253 insertions, 1797 deletions

diff --git a/TAO/tao/MessagingC.i b/TAO/tao/MessagingC.i
index 92ca400b508..6ae6d573f1a 100644
--- a/TAO/tao/MessagingC.i
+++ b/TAO/tao/MessagingC.i
@@ -1,5 +1,4 @@
-/* -*- C++ -*- */
-// $Id$
+/* -*- 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
@@ -15,27 +14,12 @@ Messaging::RebindPolicy::RebindPolicy (void) // default constructor
 {}
 
 ACE_INLINE
-Messaging::RebindPolicy::RebindPolicy (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
-  : CORBA_Object (objref, _tao_servant, _tao_collocated)
-{}
-
-ACE_INLINE
 Messaging::RebindPolicy::~RebindPolicy (void) // destructor
 {}
 
-ACE_INLINE Messaging::RebindPolicy_ptr
-Messaging::RebindPolicy::_duplicate (Messaging::RebindPolicy_ptr obj)
-{
-  if (!CORBA::is_nil (obj))
-    obj->_add_ref ();
-  return obj;
-}
 
-ACE_INLINE Messaging::RebindPolicy_ptr
-Messaging::RebindPolicy::_nil (void)
-{
-  return (Messaging::RebindPolicy_ptr)0;
-}
+#if !defined (_MESSAGING_REBINDPOLICY___VAR_CI_)
+#define _MESSAGING_REBINDPOLICY___VAR_CI_
 
 // *************************************************************
 // Inline operations for class Messaging::RebindPolicy_var
@@ -43,23 +27,23 @@ Messaging::RebindPolicy::_nil (void)
 
 ACE_INLINE
 Messaging::RebindPolicy_var::RebindPolicy_var (void) // default constructor
-  : ptr_ (Messaging::RebindPolicy::_nil ())
+  : ptr_ (RebindPolicy::_nil ())
 {}
 
 ACE_INLINE
-Messaging::RebindPolicy_var::RebindPolicy_var (Messaging::RebindPolicy_ptr p)
+Messaging::RebindPolicy_var::RebindPolicy_var (RebindPolicy_ptr p)
   : ptr_ (p)
 {}
 
-ACE_INLINE Messaging::RebindPolicy_ptr
+ACE_INLINE ::Messaging::RebindPolicy_ptr
 Messaging::RebindPolicy_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 ACE_INLINE
-Messaging::RebindPolicy_var::RebindPolicy_var (const Messaging::RebindPolicy_var &p) // copy constructor
-  : ptr_ (Messaging::RebindPolicy::_duplicate (p.ptr ()))
+Messaging::RebindPolicy_var::RebindPolicy_var (const ::Messaging::RebindPolicy_var &p) // copy constructor
+  : ptr_ (RebindPolicy::_duplicate (p.ptr ()))
 {}
 
 ACE_INLINE
@@ -69,7 +53,7 @@ Messaging::RebindPolicy_var::~RebindPolicy_var (void) // destructor
 }
 
 ACE_INLINE Messaging::RebindPolicy_var &
-Messaging::RebindPolicy_var::operator= (Messaging::RebindPolicy_ptr p)
+Messaging::RebindPolicy_var::operator= (RebindPolicy_ptr p)
 {
   CORBA::release (this->ptr_);
   this->ptr_ = p;
@@ -77,126 +61,136 @@ Messaging::RebindPolicy_var::operator= (Messaging::RebindPolicy_ptr p)
 }
 
 ACE_INLINE Messaging::RebindPolicy_var &
-Messaging::RebindPolicy_var::operator= (const Messaging::RebindPolicy_var &p)
+Messaging::RebindPolicy_var::operator= (const ::Messaging::RebindPolicy_var &p)
 {
   if (this != &p)
   {
     CORBA::release (this->ptr_);
-    this->ptr_ = Messaging::RebindPolicy::_duplicate (p.ptr ());
+    this->ptr_ = ::Messaging::RebindPolicy::_duplicate (p.ptr ());
   }
   return *this;
 }
 
-ACE_INLINE
-Messaging::RebindPolicy_var::operator const Messaging::RebindPolicy_ptr &() const // cast
+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
+ACE_INLINE 
+Messaging::RebindPolicy_var::operator ::Messaging::RebindPolicy_ptr &() // cast 
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::RebindPolicy_ptr
+ACE_INLINE ::Messaging::RebindPolicy_ptr
 Messaging::RebindPolicy_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::RebindPolicy_ptr
+ACE_INLINE ::Messaging::RebindPolicy_ptr
 Messaging::RebindPolicy_var::in (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::RebindPolicy_ptr &
+ACE_INLINE ::Messaging::RebindPolicy_ptr &
 Messaging::RebindPolicy_var::inout (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::RebindPolicy_ptr &
+ACE_INLINE ::Messaging::RebindPolicy_ptr &
 Messaging::RebindPolicy_var::out (void)
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = Messaging::RebindPolicy::_nil ();
+  this->ptr_ = ::Messaging::RebindPolicy::_nil ();
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::RebindPolicy_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 ();
+  ::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 (Messaging::RebindPolicy_ptr &p)
+Messaging::RebindPolicy_out::RebindPolicy_out (RebindPolicy_ptr &p)
   : ptr_ (p)
 {
-  this->ptr_ = Messaging::RebindPolicy::_nil ();
+  this->ptr_ = ::Messaging::RebindPolicy::_nil ();
 }
 
 ACE_INLINE
-Messaging::RebindPolicy_out::RebindPolicy_out (Messaging::RebindPolicy_var &p) // constructor from _var
+Messaging::RebindPolicy_out::RebindPolicy_out (RebindPolicy_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = Messaging::RebindPolicy::_nil ();
+  this->ptr_ = ::Messaging::RebindPolicy::_nil ();
 }
 
 ACE_INLINE
-Messaging::RebindPolicy_out::RebindPolicy_out (const Messaging::RebindPolicy_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (Messaging::RebindPolicy_out&,p).ptr_)
+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)
+ACE_INLINE ::Messaging::RebindPolicy_out &
+Messaging::RebindPolicy_out::operator= (const ::Messaging::RebindPolicy_out &p)
 {
-  this->ptr_ = ACE_const_cast (Messaging::RebindPolicy_out&,p).ptr_;
+  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)
+Messaging::RebindPolicy_out::operator= (const ::Messaging::RebindPolicy_var &p)
 {
-  this->ptr_ = Messaging::RebindPolicy::_duplicate (p.ptr ());
+  this->ptr_ = ::Messaging::RebindPolicy::_duplicate (p.ptr ());
   return *this;
 }
 
 ACE_INLINE Messaging::RebindPolicy_out &
-Messaging::RebindPolicy_out::operator= (Messaging::RebindPolicy_ptr p)
+Messaging::RebindPolicy_out::operator= (RebindPolicy_ptr p)
 {
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE
-Messaging::RebindPolicy_out::operator Messaging::RebindPolicy_ptr &() // cast
+ACE_INLINE 
+Messaging::RebindPolicy_out::operator ::Messaging::RebindPolicy_ptr &() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::RebindPolicy_ptr &
+ACE_INLINE ::Messaging::RebindPolicy_ptr &
 Messaging::RebindPolicy_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::RebindPolicy_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)
@@ -206,27 +200,12 @@ Messaging::SyncScopePolicy::SyncScopePolicy (void) // default constructor
 {}
 
 ACE_INLINE
-Messaging::SyncScopePolicy::SyncScopePolicy (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
-  : CORBA_Object (objref, _tao_servant, _tao_collocated)
-{}
-
-ACE_INLINE
 Messaging::SyncScopePolicy::~SyncScopePolicy (void) // destructor
 {}
 
-ACE_INLINE Messaging::SyncScopePolicy_ptr
-Messaging::SyncScopePolicy::_duplicate (Messaging::SyncScopePolicy_ptr obj)
-{
-  if (!CORBA::is_nil (obj))
-    obj->_add_ref ();
-  return obj;
-}
 
-ACE_INLINE Messaging::SyncScopePolicy_ptr
-Messaging::SyncScopePolicy::_nil (void)
-{
-  return (Messaging::SyncScopePolicy_ptr)0;
-}
+#if !defined (_MESSAGING_SYNCSCOPEPOLICY___VAR_CI_)
+#define _MESSAGING_SYNCSCOPEPOLICY___VAR_CI_
 
 // *************************************************************
 // Inline operations for class Messaging::SyncScopePolicy_var
@@ -234,23 +213,23 @@ Messaging::SyncScopePolicy::_nil (void)
 
 ACE_INLINE
 Messaging::SyncScopePolicy_var::SyncScopePolicy_var (void) // default constructor
-  : ptr_ (Messaging::SyncScopePolicy::_nil ())
+  : ptr_ (SyncScopePolicy::_nil ())
 {}
 
 ACE_INLINE
-Messaging::SyncScopePolicy_var::SyncScopePolicy_var (Messaging::SyncScopePolicy_ptr p)
+Messaging::SyncScopePolicy_var::SyncScopePolicy_var (SyncScopePolicy_ptr p)
   : ptr_ (p)
 {}
 
-ACE_INLINE Messaging::SyncScopePolicy_ptr
+ACE_INLINE ::Messaging::SyncScopePolicy_ptr
 Messaging::SyncScopePolicy_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 ACE_INLINE
-Messaging::SyncScopePolicy_var::SyncScopePolicy_var (const Messaging::SyncScopePolicy_var &p) // copy constructor
-  : ptr_ (Messaging::SyncScopePolicy::_duplicate (p.ptr ()))
+Messaging::SyncScopePolicy_var::SyncScopePolicy_var (const ::Messaging::SyncScopePolicy_var &p) // copy constructor
+  : ptr_ (SyncScopePolicy::_duplicate (p.ptr ()))
 {}
 
 ACE_INLINE
@@ -260,7 +239,7 @@ Messaging::SyncScopePolicy_var::~SyncScopePolicy_var (void) // destructor
 }
 
 ACE_INLINE Messaging::SyncScopePolicy_var &
-Messaging::SyncScopePolicy_var::operator= (Messaging::SyncScopePolicy_ptr p)
+Messaging::SyncScopePolicy_var::operator= (SyncScopePolicy_ptr p)
 {
   CORBA::release (this->ptr_);
   this->ptr_ = p;
@@ -268,126 +247,136 @@ Messaging::SyncScopePolicy_var::operator= (Messaging::SyncScopePolicy_ptr p)
 }
 
 ACE_INLINE Messaging::SyncScopePolicy_var &
-Messaging::SyncScopePolicy_var::operator= (const Messaging::SyncScopePolicy_var &p)
+Messaging::SyncScopePolicy_var::operator= (const ::Messaging::SyncScopePolicy_var &p)
 {
   if (this != &p)
   {
     CORBA::release (this->ptr_);
-    this->ptr_ = Messaging::SyncScopePolicy::_duplicate (p.ptr ());
+    this->ptr_ = ::Messaging::SyncScopePolicy::_duplicate (p.ptr ());
   }
   return *this;
 }
 
-ACE_INLINE
-Messaging::SyncScopePolicy_var::operator const Messaging::SyncScopePolicy_ptr &() const // cast
+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
+ACE_INLINE 
+Messaging::SyncScopePolicy_var::operator ::Messaging::SyncScopePolicy_ptr &() // cast 
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::SyncScopePolicy_ptr
+ACE_INLINE ::Messaging::SyncScopePolicy_ptr
 Messaging::SyncScopePolicy_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::SyncScopePolicy_ptr
+ACE_INLINE ::Messaging::SyncScopePolicy_ptr
 Messaging::SyncScopePolicy_var::in (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::SyncScopePolicy_ptr &
+ACE_INLINE ::Messaging::SyncScopePolicy_ptr &
 Messaging::SyncScopePolicy_var::inout (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::SyncScopePolicy_ptr &
+ACE_INLINE ::Messaging::SyncScopePolicy_ptr &
 Messaging::SyncScopePolicy_var::out (void)
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = Messaging::SyncScopePolicy::_nil ();
+  this->ptr_ = ::Messaging::SyncScopePolicy::_nil ();
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::SyncScopePolicy_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 ();
+  ::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 (Messaging::SyncScopePolicy_ptr &p)
+Messaging::SyncScopePolicy_out::SyncScopePolicy_out (SyncScopePolicy_ptr &p)
   : ptr_ (p)
 {
-  this->ptr_ = Messaging::SyncScopePolicy::_nil ();
+  this->ptr_ = ::Messaging::SyncScopePolicy::_nil ();
 }
 
 ACE_INLINE
-Messaging::SyncScopePolicy_out::SyncScopePolicy_out (Messaging::SyncScopePolicy_var &p) // constructor from _var
+Messaging::SyncScopePolicy_out::SyncScopePolicy_out (SyncScopePolicy_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = Messaging::SyncScopePolicy::_nil ();
+  this->ptr_ = ::Messaging::SyncScopePolicy::_nil ();
 }
 
 ACE_INLINE
-Messaging::SyncScopePolicy_out::SyncScopePolicy_out (const Messaging::SyncScopePolicy_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (Messaging::SyncScopePolicy_out&,p).ptr_)
+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)
+ACE_INLINE ::Messaging::SyncScopePolicy_out &
+Messaging::SyncScopePolicy_out::operator= (const ::Messaging::SyncScopePolicy_out &p)
 {
-  this->ptr_ = ACE_const_cast (Messaging::SyncScopePolicy_out&,p).ptr_;
+  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)
+Messaging::SyncScopePolicy_out::operator= (const ::Messaging::SyncScopePolicy_var &p)
 {
-  this->ptr_ = Messaging::SyncScopePolicy::_duplicate (p.ptr ());
+  this->ptr_ = ::Messaging::SyncScopePolicy::_duplicate (p.ptr ());
   return *this;
 }
 
 ACE_INLINE Messaging::SyncScopePolicy_out &
-Messaging::SyncScopePolicy_out::operator= (Messaging::SyncScopePolicy_ptr p)
+Messaging::SyncScopePolicy_out::operator= (SyncScopePolicy_ptr p)
 {
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE
-Messaging::SyncScopePolicy_out::operator Messaging::SyncScopePolicy_ptr &() // cast
+ACE_INLINE 
+Messaging::SyncScopePolicy_out::operator ::Messaging::SyncScopePolicy_ptr &() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::SyncScopePolicy_ptr &
+ACE_INLINE ::Messaging::SyncScopePolicy_ptr &
 Messaging::SyncScopePolicy_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::SyncScopePolicy_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)
@@ -402,20 +391,26 @@ Messaging::PriorityRange_var::PriorityRange_var (void) // default constructor
 {}
 
 ACE_INLINE
-Messaging::PriorityRange_var::PriorityRange_var (Messaging::PriorityRange *p)
+Messaging::PriorityRange_var::PriorityRange_var (PriorityRange *p)
   : ptr_ (p)
 {}
 
 ACE_INLINE
-Messaging::PriorityRange_var::PriorityRange_var (const Messaging::PriorityRange_var &p) // copy constructor
+Messaging::PriorityRange_var::PriorityRange_var (const ::Messaging::PriorityRange_var &p) // copy constructor
 {
   if (p.ptr_)
-    ACE_NEW (this->ptr_,
-             Messaging::PriorityRange(*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
 {
@@ -423,82 +418,92 @@ Messaging::PriorityRange_var::~PriorityRange_var (void) // destructor
 }
 
 ACE_INLINE Messaging::PriorityRange_var &
-Messaging::PriorityRange_var::operator= (Messaging::PriorityRange *p)
+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)
+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);
+    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 *
+ACE_INLINE const ::Messaging::PriorityRange *
 Messaging::PriorityRange_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::PriorityRange *
+ACE_INLINE ::Messaging::PriorityRange *
 Messaging::PriorityRange_var::operator-> (void)
 {
   return this->ptr_;
 }
 
 ACE_INLINE
-Messaging::PriorityRange_var::operator const Messaging::PriorityRange &() const // cast
+Messaging::PriorityRange_var::operator const ::Messaging::PriorityRange &() const // cast
 {
   return *this->ptr_;
 }
 
 ACE_INLINE
-Messaging::PriorityRange_var::operator Messaging::PriorityRange &() // cast
+Messaging::PriorityRange_var::operator ::Messaging::PriorityRange &() // cast 
 {
   return *this->ptr_;
 }
 
 ACE_INLINE
-Messaging::PriorityRange_var::operator Messaging::PriorityRange &() const// cast
+Messaging::PriorityRange_var::operator ::Messaging::PriorityRange &() const // cast 
 {
   return *this->ptr_;
 }
 
-ACE_INLINE const Messaging::PriorityRange &
+ACE_INLINE const ::Messaging::PriorityRange &
 Messaging::PriorityRange_var::in (void) const
 {
   return *this->ptr_;
 }
 
-ACE_INLINE Messaging::PriorityRange &
+ACE_INLINE ::Messaging::PriorityRange &
 Messaging::PriorityRange_var::inout (void)
 {
   return *this->ptr_;
 }
 
-// mapping for fixed size
-ACE_INLINE Messaging::PriorityRange &
+// mapping for fixed size 
+ACE_INLINE ::Messaging::PriorityRange &
 Messaging::PriorityRange_var::out (void)
 {
   return *this->ptr_;
 }
 
-ACE_INLINE Messaging::PriorityRange
+ACE_INLINE ::Messaging::PriorityRange
 Messaging::PriorityRange_var::_retn (void)
 {
   return *this->ptr_;
 }
 
-ACE_INLINE Messaging::PriorityRange *
+ACE_INLINE ::Messaging::PriorityRange *
 Messaging::PriorityRange_var::ptr (void) const
 {
   return this->ptr_;
@@ -509,27 +514,12 @@ Messaging::RequestPriorityPolicy::RequestPriorityPolicy (void) // default constr
 {}
 
 ACE_INLINE
-Messaging::RequestPriorityPolicy::RequestPriorityPolicy (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
-  : CORBA_Object (objref, _tao_servant, _tao_collocated)
-{}
-
-ACE_INLINE
 Messaging::RequestPriorityPolicy::~RequestPriorityPolicy (void) // destructor
 {}
 
-ACE_INLINE Messaging::RequestPriorityPolicy_ptr
-Messaging::RequestPriorityPolicy::_duplicate (Messaging::RequestPriorityPolicy_ptr obj)
-{
-  if (!CORBA::is_nil (obj))
-    obj->_add_ref ();
-  return obj;
-}
 
-ACE_INLINE Messaging::RequestPriorityPolicy_ptr
-Messaging::RequestPriorityPolicy::_nil (void)
-{
-  return (Messaging::RequestPriorityPolicy_ptr)0;
-}
+#if !defined (_MESSAGING_REQUESTPRIORITYPOLICY___VAR_CI_)
+#define _MESSAGING_REQUESTPRIORITYPOLICY___VAR_CI_
 
 // *************************************************************
 // Inline operations for class Messaging::RequestPriorityPolicy_var
@@ -537,23 +527,23 @@ Messaging::RequestPriorityPolicy::_nil (void)
 
 ACE_INLINE
 Messaging::RequestPriorityPolicy_var::RequestPriorityPolicy_var (void) // default constructor
-  : ptr_ (Messaging::RequestPriorityPolicy::_nil ())
+  : ptr_ (RequestPriorityPolicy::_nil ())
 {}
 
 ACE_INLINE
-Messaging::RequestPriorityPolicy_var::RequestPriorityPolicy_var (Messaging::RequestPriorityPolicy_ptr p)
+Messaging::RequestPriorityPolicy_var::RequestPriorityPolicy_var (RequestPriorityPolicy_ptr p)
   : ptr_ (p)
 {}
 
-ACE_INLINE Messaging::RequestPriorityPolicy_ptr
+ACE_INLINE ::Messaging::RequestPriorityPolicy_ptr
 Messaging::RequestPriorityPolicy_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 ACE_INLINE
-Messaging::RequestPriorityPolicy_var::RequestPriorityPolicy_var (const Messaging::RequestPriorityPolicy_var &p) // copy constructor
-  : ptr_ (Messaging::RequestPriorityPolicy::_duplicate (p.ptr ()))
+Messaging::RequestPriorityPolicy_var::RequestPriorityPolicy_var (const ::Messaging::RequestPriorityPolicy_var &p) // copy constructor
+  : ptr_ (RequestPriorityPolicy::_duplicate (p.ptr ()))
 {}
 
 ACE_INLINE
@@ -563,7 +553,7 @@ Messaging::RequestPriorityPolicy_var::~RequestPriorityPolicy_var (void) // destr
 }
 
 ACE_INLINE Messaging::RequestPriorityPolicy_var &
-Messaging::RequestPriorityPolicy_var::operator= (Messaging::RequestPriorityPolicy_ptr p)
+Messaging::RequestPriorityPolicy_var::operator= (RequestPriorityPolicy_ptr p)
 {
   CORBA::release (this->ptr_);
   this->ptr_ = p;
@@ -571,152 +561,147 @@ Messaging::RequestPriorityPolicy_var::operator= (Messaging::RequestPriorityPolic
 }
 
 ACE_INLINE Messaging::RequestPriorityPolicy_var &
-Messaging::RequestPriorityPolicy_var::operator= (const Messaging::RequestPriorityPolicy_var &p)
+Messaging::RequestPriorityPolicy_var::operator= (const ::Messaging::RequestPriorityPolicy_var &p)
 {
   if (this != &p)
   {
     CORBA::release (this->ptr_);
-    this->ptr_ = Messaging::RequestPriorityPolicy::_duplicate (p.ptr ());
+    this->ptr_ = ::Messaging::RequestPriorityPolicy::_duplicate (p.ptr ());
   }
   return *this;
 }
 
-ACE_INLINE
-Messaging::RequestPriorityPolicy_var::operator const Messaging::RequestPriorityPolicy_ptr &() const // cast
+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
+ACE_INLINE 
+Messaging::RequestPriorityPolicy_var::operator ::Messaging::RequestPriorityPolicy_ptr &() // cast 
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::RequestPriorityPolicy_ptr
+ACE_INLINE ::Messaging::RequestPriorityPolicy_ptr
 Messaging::RequestPriorityPolicy_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::RequestPriorityPolicy_ptr
+ACE_INLINE ::Messaging::RequestPriorityPolicy_ptr
 Messaging::RequestPriorityPolicy_var::in (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::RequestPriorityPolicy_ptr &
+ACE_INLINE ::Messaging::RequestPriorityPolicy_ptr &
 Messaging::RequestPriorityPolicy_var::inout (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::RequestPriorityPolicy_ptr &
+ACE_INLINE ::Messaging::RequestPriorityPolicy_ptr &
 Messaging::RequestPriorityPolicy_var::out (void)
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = Messaging::RequestPriorityPolicy::_nil ();
+  this->ptr_ = ::Messaging::RequestPriorityPolicy::_nil ();
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::RequestPriorityPolicy_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 ();
+  ::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 (Messaging::RequestPriorityPolicy_ptr &p)
+Messaging::RequestPriorityPolicy_out::RequestPriorityPolicy_out (RequestPriorityPolicy_ptr &p)
   : ptr_ (p)
 {
-  this->ptr_ = Messaging::RequestPriorityPolicy::_nil ();
+  this->ptr_ = ::Messaging::RequestPriorityPolicy::_nil ();
 }
 
 ACE_INLINE
-Messaging::RequestPriorityPolicy_out::RequestPriorityPolicy_out (Messaging::RequestPriorityPolicy_var &p) // constructor from _var
+Messaging::RequestPriorityPolicy_out::RequestPriorityPolicy_out (RequestPriorityPolicy_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = Messaging::RequestPriorityPolicy::_nil ();
+  this->ptr_ = ::Messaging::RequestPriorityPolicy::_nil ();
 }
 
 ACE_INLINE
-Messaging::RequestPriorityPolicy_out::RequestPriorityPolicy_out (const Messaging::RequestPriorityPolicy_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (Messaging::RequestPriorityPolicy_out&,p).ptr_)
+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)
+ACE_INLINE ::Messaging::RequestPriorityPolicy_out &
+Messaging::RequestPriorityPolicy_out::operator= (const ::Messaging::RequestPriorityPolicy_out &p)
 {
-  this->ptr_ = ACE_const_cast (Messaging::RequestPriorityPolicy_out&,p).ptr_;
+  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)
+Messaging::RequestPriorityPolicy_out::operator= (const ::Messaging::RequestPriorityPolicy_var &p)
 {
-  this->ptr_ = Messaging::RequestPriorityPolicy::_duplicate (p.ptr ());
+  this->ptr_ = ::Messaging::RequestPriorityPolicy::_duplicate (p.ptr ());
   return *this;
 }
 
 ACE_INLINE Messaging::RequestPriorityPolicy_out &
-Messaging::RequestPriorityPolicy_out::operator= (Messaging::RequestPriorityPolicy_ptr p)
+Messaging::RequestPriorityPolicy_out::operator= (RequestPriorityPolicy_ptr p)
 {
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE
-Messaging::RequestPriorityPolicy_out::operator Messaging::RequestPriorityPolicy_ptr &() // cast
+ACE_INLINE 
+Messaging::RequestPriorityPolicy_out::operator ::Messaging::RequestPriorityPolicy_ptr &() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::RequestPriorityPolicy_ptr &
+ACE_INLINE ::Messaging::RequestPriorityPolicy_ptr &
 Messaging::RequestPriorityPolicy_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::RequestPriorityPolicy_ptr
+ACE_INLINE ::Messaging::RequestPriorityPolicy_ptr
 Messaging::RequestPriorityPolicy_out::operator-> (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE
-Messaging::ReplyPriorityPolicy::ReplyPriorityPolicy (void) // default constructor
-{}
+
+#endif /* end #if !defined */
 
 ACE_INLINE
-Messaging::ReplyPriorityPolicy::ReplyPriorityPolicy (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
-  : CORBA_Object (objref, _tao_servant, _tao_collocated)
+Messaging::ReplyPriorityPolicy::ReplyPriorityPolicy (void) // default constructor
 {}
 
 ACE_INLINE
 Messaging::ReplyPriorityPolicy::~ReplyPriorityPolicy (void) // destructor
 {}
 
-ACE_INLINE Messaging::ReplyPriorityPolicy_ptr
-Messaging::ReplyPriorityPolicy::_duplicate (Messaging::ReplyPriorityPolicy_ptr obj)
-{
-  if (!CORBA::is_nil (obj))
-    obj->_add_ref ();
-  return obj;
-}
 
-ACE_INLINE Messaging::ReplyPriorityPolicy_ptr
-Messaging::ReplyPriorityPolicy::_nil (void)
-{
-  return (Messaging::ReplyPriorityPolicy_ptr)0;
-}
+#if !defined (_MESSAGING_REPLYPRIORITYPOLICY___VAR_CI_)
+#define _MESSAGING_REPLYPRIORITYPOLICY___VAR_CI_
 
 // *************************************************************
 // Inline operations for class Messaging::ReplyPriorityPolicy_var
@@ -724,23 +709,23 @@ Messaging::ReplyPriorityPolicy::_nil (void)
 
 ACE_INLINE
 Messaging::ReplyPriorityPolicy_var::ReplyPriorityPolicy_var (void) // default constructor
-  : ptr_ (Messaging::ReplyPriorityPolicy::_nil ())
+  : ptr_ (ReplyPriorityPolicy::_nil ())
 {}
 
 ACE_INLINE
-Messaging::ReplyPriorityPolicy_var::ReplyPriorityPolicy_var (Messaging::ReplyPriorityPolicy_ptr p)
+Messaging::ReplyPriorityPolicy_var::ReplyPriorityPolicy_var (ReplyPriorityPolicy_ptr p)
   : ptr_ (p)
 {}
 
-ACE_INLINE Messaging::ReplyPriorityPolicy_ptr
+ACE_INLINE ::Messaging::ReplyPriorityPolicy_ptr
 Messaging::ReplyPriorityPolicy_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 ACE_INLINE
-Messaging::ReplyPriorityPolicy_var::ReplyPriorityPolicy_var (const Messaging::ReplyPriorityPolicy_var &p) // copy constructor
-  : ptr_ (Messaging::ReplyPriorityPolicy::_duplicate (p.ptr ()))
+Messaging::ReplyPriorityPolicy_var::ReplyPriorityPolicy_var (const ::Messaging::ReplyPriorityPolicy_var &p) // copy constructor
+  : ptr_ (ReplyPriorityPolicy::_duplicate (p.ptr ()))
 {}
 
 ACE_INLINE
@@ -750,7 +735,7 @@ Messaging::ReplyPriorityPolicy_var::~ReplyPriorityPolicy_var (void) // destructo
 }
 
 ACE_INLINE Messaging::ReplyPriorityPolicy_var &
-Messaging::ReplyPriorityPolicy_var::operator= (Messaging::ReplyPriorityPolicy_ptr p)
+Messaging::ReplyPriorityPolicy_var::operator= (ReplyPriorityPolicy_ptr p)
 {
   CORBA::release (this->ptr_);
   this->ptr_ = p;
@@ -758,126 +743,136 @@ Messaging::ReplyPriorityPolicy_var::operator= (Messaging::ReplyPriorityPolicy_pt
 }
 
 ACE_INLINE Messaging::ReplyPriorityPolicy_var &
-Messaging::ReplyPriorityPolicy_var::operator= (const Messaging::ReplyPriorityPolicy_var &p)
+Messaging::ReplyPriorityPolicy_var::operator= (const ::Messaging::ReplyPriorityPolicy_var &p)
 {
   if (this != &p)
   {
     CORBA::release (this->ptr_);
-    this->ptr_ = Messaging::ReplyPriorityPolicy::_duplicate (p.ptr ());
+    this->ptr_ = ::Messaging::ReplyPriorityPolicy::_duplicate (p.ptr ());
   }
   return *this;
 }
 
-ACE_INLINE
-Messaging::ReplyPriorityPolicy_var::operator const Messaging::ReplyPriorityPolicy_ptr &() const // cast
+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
+ACE_INLINE 
+Messaging::ReplyPriorityPolicy_var::operator ::Messaging::ReplyPriorityPolicy_ptr &() // cast 
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::ReplyPriorityPolicy_ptr
+ACE_INLINE ::Messaging::ReplyPriorityPolicy_ptr
 Messaging::ReplyPriorityPolicy_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::ReplyPriorityPolicy_ptr
+ACE_INLINE ::Messaging::ReplyPriorityPolicy_ptr
 Messaging::ReplyPriorityPolicy_var::in (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::ReplyPriorityPolicy_ptr &
+ACE_INLINE ::Messaging::ReplyPriorityPolicy_ptr &
 Messaging::ReplyPriorityPolicy_var::inout (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::ReplyPriorityPolicy_ptr &
+ACE_INLINE ::Messaging::ReplyPriorityPolicy_ptr &
 Messaging::ReplyPriorityPolicy_var::out (void)
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = Messaging::ReplyPriorityPolicy::_nil ();
+  this->ptr_ = ::Messaging::ReplyPriorityPolicy::_nil ();
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::ReplyPriorityPolicy_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 ();
+  ::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 (Messaging::ReplyPriorityPolicy_ptr &p)
+Messaging::ReplyPriorityPolicy_out::ReplyPriorityPolicy_out (ReplyPriorityPolicy_ptr &p)
   : ptr_ (p)
 {
-  this->ptr_ = Messaging::ReplyPriorityPolicy::_nil ();
+  this->ptr_ = ::Messaging::ReplyPriorityPolicy::_nil ();
 }
 
 ACE_INLINE
-Messaging::ReplyPriorityPolicy_out::ReplyPriorityPolicy_out (Messaging::ReplyPriorityPolicy_var &p) // constructor from _var
+Messaging::ReplyPriorityPolicy_out::ReplyPriorityPolicy_out (ReplyPriorityPolicy_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = Messaging::ReplyPriorityPolicy::_nil ();
+  this->ptr_ = ::Messaging::ReplyPriorityPolicy::_nil ();
 }
 
 ACE_INLINE
-Messaging::ReplyPriorityPolicy_out::ReplyPriorityPolicy_out (const Messaging::ReplyPriorityPolicy_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (Messaging::ReplyPriorityPolicy_out&,p).ptr_)
+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)
+ACE_INLINE ::Messaging::ReplyPriorityPolicy_out &
+Messaging::ReplyPriorityPolicy_out::operator= (const ::Messaging::ReplyPriorityPolicy_out &p)
 {
-  this->ptr_ = ACE_const_cast (Messaging::ReplyPriorityPolicy_out&,p).ptr_;
+  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)
+Messaging::ReplyPriorityPolicy_out::operator= (const ::Messaging::ReplyPriorityPolicy_var &p)
 {
-  this->ptr_ = Messaging::ReplyPriorityPolicy::_duplicate (p.ptr ());
+  this->ptr_ = ::Messaging::ReplyPriorityPolicy::_duplicate (p.ptr ());
   return *this;
 }
 
 ACE_INLINE Messaging::ReplyPriorityPolicy_out &
-Messaging::ReplyPriorityPolicy_out::operator= (Messaging::ReplyPriorityPolicy_ptr p)
+Messaging::ReplyPriorityPolicy_out::operator= (ReplyPriorityPolicy_ptr p)
 {
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE
-Messaging::ReplyPriorityPolicy_out::operator Messaging::ReplyPriorityPolicy_ptr &() // cast
+ACE_INLINE 
+Messaging::ReplyPriorityPolicy_out::operator ::Messaging::ReplyPriorityPolicy_ptr &() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::ReplyPriorityPolicy_ptr &
+ACE_INLINE ::Messaging::ReplyPriorityPolicy_ptr &
 Messaging::ReplyPriorityPolicy_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::ReplyPriorityPolicy_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)
@@ -887,27 +882,12 @@ Messaging::RequestStartTimePolicy::RequestStartTimePolicy (void) // default cons
 {}
 
 ACE_INLINE
-Messaging::RequestStartTimePolicy::RequestStartTimePolicy (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
-  : CORBA_Object (objref, _tao_servant, _tao_collocated)
-{}
-
-ACE_INLINE
 Messaging::RequestStartTimePolicy::~RequestStartTimePolicy (void) // destructor
 {}
 
-ACE_INLINE Messaging::RequestStartTimePolicy_ptr
-Messaging::RequestStartTimePolicy::_duplicate (Messaging::RequestStartTimePolicy_ptr obj)
-{
-  if (!CORBA::is_nil (obj))
-    obj->_add_ref ();
-  return obj;
-}
 
-ACE_INLINE Messaging::RequestStartTimePolicy_ptr
-Messaging::RequestStartTimePolicy::_nil (void)
-{
-  return (Messaging::RequestStartTimePolicy_ptr)0;
-}
+#if !defined (_MESSAGING_REQUESTSTARTTIMEPOLICY___VAR_CI_)
+#define _MESSAGING_REQUESTSTARTTIMEPOLICY___VAR_CI_
 
 // *************************************************************
 // Inline operations for class Messaging::RequestStartTimePolicy_var
@@ -915,23 +895,23 @@ Messaging::RequestStartTimePolicy::_nil (void)
 
 ACE_INLINE
 Messaging::RequestStartTimePolicy_var::RequestStartTimePolicy_var (void) // default constructor
-  : ptr_ (Messaging::RequestStartTimePolicy::_nil ())
+  : ptr_ (RequestStartTimePolicy::_nil ())
 {}
 
 ACE_INLINE
-Messaging::RequestStartTimePolicy_var::RequestStartTimePolicy_var (Messaging::RequestStartTimePolicy_ptr p)
+Messaging::RequestStartTimePolicy_var::RequestStartTimePolicy_var (RequestStartTimePolicy_ptr p)
   : ptr_ (p)
 {}
 
-ACE_INLINE Messaging::RequestStartTimePolicy_ptr
+ACE_INLINE ::Messaging::RequestStartTimePolicy_ptr
 Messaging::RequestStartTimePolicy_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 ACE_INLINE
-Messaging::RequestStartTimePolicy_var::RequestStartTimePolicy_var (const Messaging::RequestStartTimePolicy_var &p) // copy constructor
-  : ptr_ (Messaging::RequestStartTimePolicy::_duplicate (p.ptr ()))
+Messaging::RequestStartTimePolicy_var::RequestStartTimePolicy_var (const ::Messaging::RequestStartTimePolicy_var &p) // copy constructor
+  : ptr_ (RequestStartTimePolicy::_duplicate (p.ptr ()))
 {}
 
 ACE_INLINE
@@ -941,7 +921,7 @@ Messaging::RequestStartTimePolicy_var::~RequestStartTimePolicy_var (void) // des
 }
 
 ACE_INLINE Messaging::RequestStartTimePolicy_var &
-Messaging::RequestStartTimePolicy_var::operator= (Messaging::RequestStartTimePolicy_ptr p)
+Messaging::RequestStartTimePolicy_var::operator= (RequestStartTimePolicy_ptr p)
 {
   CORBA::release (this->ptr_);
   this->ptr_ = p;
@@ -949,126 +929,136 @@ Messaging::RequestStartTimePolicy_var::operator= (Messaging::RequestStartTimePol
 }
 
 ACE_INLINE Messaging::RequestStartTimePolicy_var &
-Messaging::RequestStartTimePolicy_var::operator= (const Messaging::RequestStartTimePolicy_var &p)
+Messaging::RequestStartTimePolicy_var::operator= (const ::Messaging::RequestStartTimePolicy_var &p)
 {
   if (this != &p)
   {
     CORBA::release (this->ptr_);
-    this->ptr_ = Messaging::RequestStartTimePolicy::_duplicate (p.ptr ());
+    this->ptr_ = ::Messaging::RequestStartTimePolicy::_duplicate (p.ptr ());
   }
   return *this;
 }
 
-ACE_INLINE
-Messaging::RequestStartTimePolicy_var::operator const Messaging::RequestStartTimePolicy_ptr &() const // cast
+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
+ACE_INLINE 
+Messaging::RequestStartTimePolicy_var::operator ::Messaging::RequestStartTimePolicy_ptr &() // cast 
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::RequestStartTimePolicy_ptr
+ACE_INLINE ::Messaging::RequestStartTimePolicy_ptr
 Messaging::RequestStartTimePolicy_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::RequestStartTimePolicy_ptr
+ACE_INLINE ::Messaging::RequestStartTimePolicy_ptr
 Messaging::RequestStartTimePolicy_var::in (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::RequestStartTimePolicy_ptr &
+ACE_INLINE ::Messaging::RequestStartTimePolicy_ptr &
 Messaging::RequestStartTimePolicy_var::inout (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::RequestStartTimePolicy_ptr &
+ACE_INLINE ::Messaging::RequestStartTimePolicy_ptr &
 Messaging::RequestStartTimePolicy_var::out (void)
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = Messaging::RequestStartTimePolicy::_nil ();
+  this->ptr_ = ::Messaging::RequestStartTimePolicy::_nil ();
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::RequestStartTimePolicy_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 ();
+  ::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 (Messaging::RequestStartTimePolicy_ptr &p)
+Messaging::RequestStartTimePolicy_out::RequestStartTimePolicy_out (RequestStartTimePolicy_ptr &p)
   : ptr_ (p)
 {
-  this->ptr_ = Messaging::RequestStartTimePolicy::_nil ();
+  this->ptr_ = ::Messaging::RequestStartTimePolicy::_nil ();
 }
 
 ACE_INLINE
-Messaging::RequestStartTimePolicy_out::RequestStartTimePolicy_out (Messaging::RequestStartTimePolicy_var &p) // constructor from _var
+Messaging::RequestStartTimePolicy_out::RequestStartTimePolicy_out (RequestStartTimePolicy_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = Messaging::RequestStartTimePolicy::_nil ();
+  this->ptr_ = ::Messaging::RequestStartTimePolicy::_nil ();
 }
 
 ACE_INLINE
-Messaging::RequestStartTimePolicy_out::RequestStartTimePolicy_out (const Messaging::RequestStartTimePolicy_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (Messaging::RequestStartTimePolicy_out&,p).ptr_)
+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)
+ACE_INLINE ::Messaging::RequestStartTimePolicy_out &
+Messaging::RequestStartTimePolicy_out::operator= (const ::Messaging::RequestStartTimePolicy_out &p)
 {
-  this->ptr_ = ACE_const_cast (Messaging::RequestStartTimePolicy_out&,p).ptr_;
+  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)
+Messaging::RequestStartTimePolicy_out::operator= (const ::Messaging::RequestStartTimePolicy_var &p)
 {
-  this->ptr_ = Messaging::RequestStartTimePolicy::_duplicate (p.ptr ());
+  this->ptr_ = ::Messaging::RequestStartTimePolicy::_duplicate (p.ptr ());
   return *this;
 }
 
 ACE_INLINE Messaging::RequestStartTimePolicy_out &
-Messaging::RequestStartTimePolicy_out::operator= (Messaging::RequestStartTimePolicy_ptr p)
+Messaging::RequestStartTimePolicy_out::operator= (RequestStartTimePolicy_ptr p)
 {
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE
-Messaging::RequestStartTimePolicy_out::operator Messaging::RequestStartTimePolicy_ptr &() // cast
+ACE_INLINE 
+Messaging::RequestStartTimePolicy_out::operator ::Messaging::RequestStartTimePolicy_ptr &() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::RequestStartTimePolicy_ptr &
+ACE_INLINE ::Messaging::RequestStartTimePolicy_ptr &
 Messaging::RequestStartTimePolicy_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::RequestStartTimePolicy_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)
@@ -1078,27 +1068,12 @@ Messaging::RequestEndTimePolicy::RequestEndTimePolicy (void) // default construc
 {}
 
 ACE_INLINE
-Messaging::RequestEndTimePolicy::RequestEndTimePolicy (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
-  : CORBA_Object (objref, _tao_servant, _tao_collocated)
-{}
-
-ACE_INLINE
 Messaging::RequestEndTimePolicy::~RequestEndTimePolicy (void) // destructor
 {}
 
-ACE_INLINE Messaging::RequestEndTimePolicy_ptr
-Messaging::RequestEndTimePolicy::_duplicate (Messaging::RequestEndTimePolicy_ptr obj)
-{
-  if (!CORBA::is_nil (obj))
-    obj->_add_ref ();
-  return obj;
-}
 
-ACE_INLINE Messaging::RequestEndTimePolicy_ptr
-Messaging::RequestEndTimePolicy::_nil (void)
-{
-  return (Messaging::RequestEndTimePolicy_ptr)0;
-}
+#if !defined (_MESSAGING_REQUESTENDTIMEPOLICY___VAR_CI_)
+#define _MESSAGING_REQUESTENDTIMEPOLICY___VAR_CI_
 
 // *************************************************************
 // Inline operations for class Messaging::RequestEndTimePolicy_var
@@ -1106,23 +1081,23 @@ Messaging::RequestEndTimePolicy::_nil (void)
 
 ACE_INLINE
 Messaging::RequestEndTimePolicy_var::RequestEndTimePolicy_var (void) // default constructor
-  : ptr_ (Messaging::RequestEndTimePolicy::_nil ())
+  : ptr_ (RequestEndTimePolicy::_nil ())
 {}
 
 ACE_INLINE
-Messaging::RequestEndTimePolicy_var::RequestEndTimePolicy_var (Messaging::RequestEndTimePolicy_ptr p)
+Messaging::RequestEndTimePolicy_var::RequestEndTimePolicy_var (RequestEndTimePolicy_ptr p)
   : ptr_ (p)
 {}
 
-ACE_INLINE Messaging::RequestEndTimePolicy_ptr
+ACE_INLINE ::Messaging::RequestEndTimePolicy_ptr
 Messaging::RequestEndTimePolicy_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 ACE_INLINE
-Messaging::RequestEndTimePolicy_var::RequestEndTimePolicy_var (const Messaging::RequestEndTimePolicy_var &p) // copy constructor
-  : ptr_ (Messaging::RequestEndTimePolicy::_duplicate (p.ptr ()))
+Messaging::RequestEndTimePolicy_var::RequestEndTimePolicy_var (const ::Messaging::RequestEndTimePolicy_var &p) // copy constructor
+  : ptr_ (RequestEndTimePolicy::_duplicate (p.ptr ()))
 {}
 
 ACE_INLINE
@@ -1132,7 +1107,7 @@ Messaging::RequestEndTimePolicy_var::~RequestEndTimePolicy_var (void) // destruc
 }
 
 ACE_INLINE Messaging::RequestEndTimePolicy_var &
-Messaging::RequestEndTimePolicy_var::operator= (Messaging::RequestEndTimePolicy_ptr p)
+Messaging::RequestEndTimePolicy_var::operator= (RequestEndTimePolicy_ptr p)
 {
   CORBA::release (this->ptr_);
   this->ptr_ = p;
@@ -1140,126 +1115,136 @@ Messaging::RequestEndTimePolicy_var::operator= (Messaging::RequestEndTimePolicy_
 }
 
 ACE_INLINE Messaging::RequestEndTimePolicy_var &
-Messaging::RequestEndTimePolicy_var::operator= (const Messaging::RequestEndTimePolicy_var &p)
+Messaging::RequestEndTimePolicy_var::operator= (const ::Messaging::RequestEndTimePolicy_var &p)
 {
   if (this != &p)
   {
     CORBA::release (this->ptr_);
-    this->ptr_ = Messaging::RequestEndTimePolicy::_duplicate (p.ptr ());
+    this->ptr_ = ::Messaging::RequestEndTimePolicy::_duplicate (p.ptr ());
   }
   return *this;
 }
 
-ACE_INLINE
-Messaging::RequestEndTimePolicy_var::operator const Messaging::RequestEndTimePolicy_ptr &() const // cast
+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
+ACE_INLINE 
+Messaging::RequestEndTimePolicy_var::operator ::Messaging::RequestEndTimePolicy_ptr &() // cast 
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::RequestEndTimePolicy_ptr
+ACE_INLINE ::Messaging::RequestEndTimePolicy_ptr
 Messaging::RequestEndTimePolicy_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::RequestEndTimePolicy_ptr
+ACE_INLINE ::Messaging::RequestEndTimePolicy_ptr
 Messaging::RequestEndTimePolicy_var::in (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::RequestEndTimePolicy_ptr &
+ACE_INLINE ::Messaging::RequestEndTimePolicy_ptr &
 Messaging::RequestEndTimePolicy_var::inout (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::RequestEndTimePolicy_ptr &
+ACE_INLINE ::Messaging::RequestEndTimePolicy_ptr &
 Messaging::RequestEndTimePolicy_var::out (void)
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = Messaging::RequestEndTimePolicy::_nil ();
+  this->ptr_ = ::Messaging::RequestEndTimePolicy::_nil ();
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::RequestEndTimePolicy_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 ();
+  ::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 (Messaging::RequestEndTimePolicy_ptr &p)
+Messaging::RequestEndTimePolicy_out::RequestEndTimePolicy_out (RequestEndTimePolicy_ptr &p)
   : ptr_ (p)
 {
-  this->ptr_ = Messaging::RequestEndTimePolicy::_nil ();
+  this->ptr_ = ::Messaging::RequestEndTimePolicy::_nil ();
 }
 
 ACE_INLINE
-Messaging::RequestEndTimePolicy_out::RequestEndTimePolicy_out (Messaging::RequestEndTimePolicy_var &p) // constructor from _var
+Messaging::RequestEndTimePolicy_out::RequestEndTimePolicy_out (RequestEndTimePolicy_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = Messaging::RequestEndTimePolicy::_nil ();
+  this->ptr_ = ::Messaging::RequestEndTimePolicy::_nil ();
 }
 
 ACE_INLINE
-Messaging::RequestEndTimePolicy_out::RequestEndTimePolicy_out (const Messaging::RequestEndTimePolicy_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (Messaging::RequestEndTimePolicy_out&,p).ptr_)
+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)
+ACE_INLINE ::Messaging::RequestEndTimePolicy_out &
+Messaging::RequestEndTimePolicy_out::operator= (const ::Messaging::RequestEndTimePolicy_out &p)
 {
-  this->ptr_ = ACE_const_cast (Messaging::RequestEndTimePolicy_out&,p).ptr_;
+  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)
+Messaging::RequestEndTimePolicy_out::operator= (const ::Messaging::RequestEndTimePolicy_var &p)
 {
-  this->ptr_ = Messaging::RequestEndTimePolicy::_duplicate (p.ptr ());
+  this->ptr_ = ::Messaging::RequestEndTimePolicy::_duplicate (p.ptr ());
   return *this;
 }
 
 ACE_INLINE Messaging::RequestEndTimePolicy_out &
-Messaging::RequestEndTimePolicy_out::operator= (Messaging::RequestEndTimePolicy_ptr p)
+Messaging::RequestEndTimePolicy_out::operator= (RequestEndTimePolicy_ptr p)
 {
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE
-Messaging::RequestEndTimePolicy_out::operator Messaging::RequestEndTimePolicy_ptr &() // cast
+ACE_INLINE 
+Messaging::RequestEndTimePolicy_out::operator ::Messaging::RequestEndTimePolicy_ptr &() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::RequestEndTimePolicy_ptr &
+ACE_INLINE ::Messaging::RequestEndTimePolicy_ptr &
 Messaging::RequestEndTimePolicy_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::RequestEndTimePolicy_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)
@@ -1269,27 +1254,12 @@ Messaging::ReplyStartTimePolicy::ReplyStartTimePolicy (void) // default construc
 {}
 
 ACE_INLINE
-Messaging::ReplyStartTimePolicy::ReplyStartTimePolicy (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
-  : CORBA_Object (objref, _tao_servant, _tao_collocated)
-{}
-
-ACE_INLINE
 Messaging::ReplyStartTimePolicy::~ReplyStartTimePolicy (void) // destructor
 {}
 
-ACE_INLINE Messaging::ReplyStartTimePolicy_ptr
-Messaging::ReplyStartTimePolicy::_duplicate (Messaging::ReplyStartTimePolicy_ptr obj)
-{
-  if (!CORBA::is_nil (obj))
-    obj->_add_ref ();
-  return obj;
-}
 
-ACE_INLINE Messaging::ReplyStartTimePolicy_ptr
-Messaging::ReplyStartTimePolicy::_nil (void)
-{
-  return (Messaging::ReplyStartTimePolicy_ptr)0;
-}
+#if !defined (_MESSAGING_REPLYSTARTTIMEPOLICY___VAR_CI_)
+#define _MESSAGING_REPLYSTARTTIMEPOLICY___VAR_CI_
 
 // *************************************************************
 // Inline operations for class Messaging::ReplyStartTimePolicy_var
@@ -1297,23 +1267,23 @@ Messaging::ReplyStartTimePolicy::_nil (void)
 
 ACE_INLINE
 Messaging::ReplyStartTimePolicy_var::ReplyStartTimePolicy_var (void) // default constructor
-  : ptr_ (Messaging::ReplyStartTimePolicy::_nil ())
+  : ptr_ (ReplyStartTimePolicy::_nil ())
 {}
 
 ACE_INLINE
-Messaging::ReplyStartTimePolicy_var::ReplyStartTimePolicy_var (Messaging::ReplyStartTimePolicy_ptr p)
+Messaging::ReplyStartTimePolicy_var::ReplyStartTimePolicy_var (ReplyStartTimePolicy_ptr p)
   : ptr_ (p)
 {}
 
-ACE_INLINE Messaging::ReplyStartTimePolicy_ptr
+ACE_INLINE ::Messaging::ReplyStartTimePolicy_ptr
 Messaging::ReplyStartTimePolicy_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 ACE_INLINE
-Messaging::ReplyStartTimePolicy_var::ReplyStartTimePolicy_var (const Messaging::ReplyStartTimePolicy_var &p) // copy constructor
-  : ptr_ (Messaging::ReplyStartTimePolicy::_duplicate (p.ptr ()))
+Messaging::ReplyStartTimePolicy_var::ReplyStartTimePolicy_var (const ::Messaging::ReplyStartTimePolicy_var &p) // copy constructor
+  : ptr_ (ReplyStartTimePolicy::_duplicate (p.ptr ()))
 {}
 
 ACE_INLINE
@@ -1323,7 +1293,7 @@ Messaging::ReplyStartTimePolicy_var::~ReplyStartTimePolicy_var (void) // destruc
 }
 
 ACE_INLINE Messaging::ReplyStartTimePolicy_var &
-Messaging::ReplyStartTimePolicy_var::operator= (Messaging::ReplyStartTimePolicy_ptr p)
+Messaging::ReplyStartTimePolicy_var::operator= (ReplyStartTimePolicy_ptr p)
 {
   CORBA::release (this->ptr_);
   this->ptr_ = p;
@@ -1331,126 +1301,136 @@ Messaging::ReplyStartTimePolicy_var::operator= (Messaging::ReplyStartTimePolicy_
 }
 
 ACE_INLINE Messaging::ReplyStartTimePolicy_var &
-Messaging::ReplyStartTimePolicy_var::operator= (const Messaging::ReplyStartTimePolicy_var &p)
+Messaging::ReplyStartTimePolicy_var::operator= (const ::Messaging::ReplyStartTimePolicy_var &p)
 {
   if (this != &p)
   {
     CORBA::release (this->ptr_);
-    this->ptr_ = Messaging::ReplyStartTimePolicy::_duplicate (p.ptr ());
+    this->ptr_ = ::Messaging::ReplyStartTimePolicy::_duplicate (p.ptr ());
   }
   return *this;
 }
 
-ACE_INLINE
-Messaging::ReplyStartTimePolicy_var::operator const Messaging::ReplyStartTimePolicy_ptr &() const // cast
+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
+ACE_INLINE 
+Messaging::ReplyStartTimePolicy_var::operator ::Messaging::ReplyStartTimePolicy_ptr &() // cast 
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::ReplyStartTimePolicy_ptr
+ACE_INLINE ::Messaging::ReplyStartTimePolicy_ptr
 Messaging::ReplyStartTimePolicy_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::ReplyStartTimePolicy_ptr
+ACE_INLINE ::Messaging::ReplyStartTimePolicy_ptr
 Messaging::ReplyStartTimePolicy_var::in (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::ReplyStartTimePolicy_ptr &
+ACE_INLINE ::Messaging::ReplyStartTimePolicy_ptr &
 Messaging::ReplyStartTimePolicy_var::inout (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::ReplyStartTimePolicy_ptr &
+ACE_INLINE ::Messaging::ReplyStartTimePolicy_ptr &
 Messaging::ReplyStartTimePolicy_var::out (void)
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = Messaging::ReplyStartTimePolicy::_nil ();
+  this->ptr_ = ::Messaging::ReplyStartTimePolicy::_nil ();
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::ReplyStartTimePolicy_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 ();
+  ::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 (Messaging::ReplyStartTimePolicy_ptr &p)
+Messaging::ReplyStartTimePolicy_out::ReplyStartTimePolicy_out (ReplyStartTimePolicy_ptr &p)
   : ptr_ (p)
 {
-  this->ptr_ = Messaging::ReplyStartTimePolicy::_nil ();
+  this->ptr_ = ::Messaging::ReplyStartTimePolicy::_nil ();
 }
 
 ACE_INLINE
-Messaging::ReplyStartTimePolicy_out::ReplyStartTimePolicy_out (Messaging::ReplyStartTimePolicy_var &p) // constructor from _var
+Messaging::ReplyStartTimePolicy_out::ReplyStartTimePolicy_out (ReplyStartTimePolicy_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = Messaging::ReplyStartTimePolicy::_nil ();
+  this->ptr_ = ::Messaging::ReplyStartTimePolicy::_nil ();
 }
 
 ACE_INLINE
-Messaging::ReplyStartTimePolicy_out::ReplyStartTimePolicy_out (const Messaging::ReplyStartTimePolicy_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (Messaging::ReplyStartTimePolicy_out&,p).ptr_)
+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)
+ACE_INLINE ::Messaging::ReplyStartTimePolicy_out &
+Messaging::ReplyStartTimePolicy_out::operator= (const ::Messaging::ReplyStartTimePolicy_out &p)
 {
-  this->ptr_ = ACE_const_cast (Messaging::ReplyStartTimePolicy_out&,p).ptr_;
+  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)
+Messaging::ReplyStartTimePolicy_out::operator= (const ::Messaging::ReplyStartTimePolicy_var &p)
 {
-  this->ptr_ = Messaging::ReplyStartTimePolicy::_duplicate (p.ptr ());
+  this->ptr_ = ::Messaging::ReplyStartTimePolicy::_duplicate (p.ptr ());
   return *this;
 }
 
 ACE_INLINE Messaging::ReplyStartTimePolicy_out &
-Messaging::ReplyStartTimePolicy_out::operator= (Messaging::ReplyStartTimePolicy_ptr p)
+Messaging::ReplyStartTimePolicy_out::operator= (ReplyStartTimePolicy_ptr p)
 {
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE
-Messaging::ReplyStartTimePolicy_out::operator Messaging::ReplyStartTimePolicy_ptr &() // cast
+ACE_INLINE 
+Messaging::ReplyStartTimePolicy_out::operator ::Messaging::ReplyStartTimePolicy_ptr &() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::ReplyStartTimePolicy_ptr &
+ACE_INLINE ::Messaging::ReplyStartTimePolicy_ptr &
 Messaging::ReplyStartTimePolicy_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::ReplyStartTimePolicy_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)
@@ -1460,27 +1440,12 @@ Messaging::ReplyEndTimePolicy::ReplyEndTimePolicy (void) // default constructor
 {}
 
 ACE_INLINE
-Messaging::ReplyEndTimePolicy::ReplyEndTimePolicy (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
-  : CORBA_Object (objref, _tao_servant, _tao_collocated)
-{}
-
-ACE_INLINE
 Messaging::ReplyEndTimePolicy::~ReplyEndTimePolicy (void) // destructor
 {}
 
-ACE_INLINE Messaging::ReplyEndTimePolicy_ptr
-Messaging::ReplyEndTimePolicy::_duplicate (Messaging::ReplyEndTimePolicy_ptr obj)
-{
-  if (!CORBA::is_nil (obj))
-    obj->_add_ref ();
-  return obj;
-}
 
-ACE_INLINE Messaging::ReplyEndTimePolicy_ptr
-Messaging::ReplyEndTimePolicy::_nil (void)
-{
-  return (Messaging::ReplyEndTimePolicy_ptr)0;
-}
+#if !defined (_MESSAGING_REPLYENDTIMEPOLICY___VAR_CI_)
+#define _MESSAGING_REPLYENDTIMEPOLICY___VAR_CI_
 
 // *************************************************************
 // Inline operations for class Messaging::ReplyEndTimePolicy_var
@@ -1488,23 +1453,23 @@ Messaging::ReplyEndTimePolicy::_nil (void)
 
 ACE_INLINE
 Messaging::ReplyEndTimePolicy_var::ReplyEndTimePolicy_var (void) // default constructor
-  : ptr_ (Messaging::ReplyEndTimePolicy::_nil ())
+  : ptr_ (ReplyEndTimePolicy::_nil ())
 {}
 
 ACE_INLINE
-Messaging::ReplyEndTimePolicy_var::ReplyEndTimePolicy_var (Messaging::ReplyEndTimePolicy_ptr p)
+Messaging::ReplyEndTimePolicy_var::ReplyEndTimePolicy_var (ReplyEndTimePolicy_ptr p)
   : ptr_ (p)
 {}
 
-ACE_INLINE Messaging::ReplyEndTimePolicy_ptr
+ACE_INLINE ::Messaging::ReplyEndTimePolicy_ptr
 Messaging::ReplyEndTimePolicy_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 ACE_INLINE
-Messaging::ReplyEndTimePolicy_var::ReplyEndTimePolicy_var (const Messaging::ReplyEndTimePolicy_var &p) // copy constructor
-  : ptr_ (Messaging::ReplyEndTimePolicy::_duplicate (p.ptr ()))
+Messaging::ReplyEndTimePolicy_var::ReplyEndTimePolicy_var (const ::Messaging::ReplyEndTimePolicy_var &p) // copy constructor
+  : ptr_ (ReplyEndTimePolicy::_duplicate (p.ptr ()))
 {}
 
 ACE_INLINE
@@ -1514,7 +1479,7 @@ Messaging::ReplyEndTimePolicy_var::~ReplyEndTimePolicy_var (void) // destructor
 }
 
 ACE_INLINE Messaging::ReplyEndTimePolicy_var &
-Messaging::ReplyEndTimePolicy_var::operator= (Messaging::ReplyEndTimePolicy_ptr p)
+Messaging::ReplyEndTimePolicy_var::operator= (ReplyEndTimePolicy_ptr p)
 {
   CORBA::release (this->ptr_);
   this->ptr_ = p;
@@ -1522,126 +1487,136 @@ Messaging::ReplyEndTimePolicy_var::operator= (Messaging::ReplyEndTimePolicy_ptr
 }
 
 ACE_INLINE Messaging::ReplyEndTimePolicy_var &
-Messaging::ReplyEndTimePolicy_var::operator= (const Messaging::ReplyEndTimePolicy_var &p)
+Messaging::ReplyEndTimePolicy_var::operator= (const ::Messaging::ReplyEndTimePolicy_var &p)
 {
   if (this != &p)
   {
     CORBA::release (this->ptr_);
-    this->ptr_ = Messaging::ReplyEndTimePolicy::_duplicate (p.ptr ());
+    this->ptr_ = ::Messaging::ReplyEndTimePolicy::_duplicate (p.ptr ());
   }
   return *this;
 }
 
-ACE_INLINE
-Messaging::ReplyEndTimePolicy_var::operator const Messaging::ReplyEndTimePolicy_ptr &() const // cast
+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
+ACE_INLINE 
+Messaging::ReplyEndTimePolicy_var::operator ::Messaging::ReplyEndTimePolicy_ptr &() // cast 
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::ReplyEndTimePolicy_ptr
+ACE_INLINE ::Messaging::ReplyEndTimePolicy_ptr
 Messaging::ReplyEndTimePolicy_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::ReplyEndTimePolicy_ptr
+ACE_INLINE ::Messaging::ReplyEndTimePolicy_ptr
 Messaging::ReplyEndTimePolicy_var::in (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::ReplyEndTimePolicy_ptr &
+ACE_INLINE ::Messaging::ReplyEndTimePolicy_ptr &
 Messaging::ReplyEndTimePolicy_var::inout (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::ReplyEndTimePolicy_ptr &
+ACE_INLINE ::Messaging::ReplyEndTimePolicy_ptr &
 Messaging::ReplyEndTimePolicy_var::out (void)
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = Messaging::ReplyEndTimePolicy::_nil ();
+  this->ptr_ = ::Messaging::ReplyEndTimePolicy::_nil ();
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::ReplyEndTimePolicy_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 ();
+  ::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 (Messaging::ReplyEndTimePolicy_ptr &p)
+Messaging::ReplyEndTimePolicy_out::ReplyEndTimePolicy_out (ReplyEndTimePolicy_ptr &p)
   : ptr_ (p)
 {
-  this->ptr_ = Messaging::ReplyEndTimePolicy::_nil ();
+  this->ptr_ = ::Messaging::ReplyEndTimePolicy::_nil ();
 }
 
 ACE_INLINE
-Messaging::ReplyEndTimePolicy_out::ReplyEndTimePolicy_out (Messaging::ReplyEndTimePolicy_var &p) // constructor from _var
+Messaging::ReplyEndTimePolicy_out::ReplyEndTimePolicy_out (ReplyEndTimePolicy_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = Messaging::ReplyEndTimePolicy::_nil ();
+  this->ptr_ = ::Messaging::ReplyEndTimePolicy::_nil ();
 }
 
 ACE_INLINE
-Messaging::ReplyEndTimePolicy_out::ReplyEndTimePolicy_out (const Messaging::ReplyEndTimePolicy_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (Messaging::ReplyEndTimePolicy_out&,p).ptr_)
+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)
+ACE_INLINE ::Messaging::ReplyEndTimePolicy_out &
+Messaging::ReplyEndTimePolicy_out::operator= (const ::Messaging::ReplyEndTimePolicy_out &p)
 {
-  this->ptr_ = ACE_const_cast (Messaging::ReplyEndTimePolicy_out&,p).ptr_;
+  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)
+Messaging::ReplyEndTimePolicy_out::operator= (const ::Messaging::ReplyEndTimePolicy_var &p)
 {
-  this->ptr_ = Messaging::ReplyEndTimePolicy::_duplicate (p.ptr ());
+  this->ptr_ = ::Messaging::ReplyEndTimePolicy::_duplicate (p.ptr ());
   return *this;
 }
 
 ACE_INLINE Messaging::ReplyEndTimePolicy_out &
-Messaging::ReplyEndTimePolicy_out::operator= (Messaging::ReplyEndTimePolicy_ptr p)
+Messaging::ReplyEndTimePolicy_out::operator= (ReplyEndTimePolicy_ptr p)
 {
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE
-Messaging::ReplyEndTimePolicy_out::operator Messaging::ReplyEndTimePolicy_ptr &() // cast
+ACE_INLINE 
+Messaging::ReplyEndTimePolicy_out::operator ::Messaging::ReplyEndTimePolicy_ptr &() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::ReplyEndTimePolicy_ptr &
+ACE_INLINE ::Messaging::ReplyEndTimePolicy_ptr &
 Messaging::ReplyEndTimePolicy_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::ReplyEndTimePolicy_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)
@@ -1651,27 +1626,12 @@ Messaging::RelativeRequestTimeoutPolicy::RelativeRequestTimeoutPolicy (void) //
 {}
 
 ACE_INLINE
-Messaging::RelativeRequestTimeoutPolicy::RelativeRequestTimeoutPolicy (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
-  : CORBA_Object (objref, _tao_servant, _tao_collocated)
-{}
-
-ACE_INLINE
 Messaging::RelativeRequestTimeoutPolicy::~RelativeRequestTimeoutPolicy (void) // destructor
 {}
 
-ACE_INLINE Messaging::RelativeRequestTimeoutPolicy_ptr
-Messaging::RelativeRequestTimeoutPolicy::_duplicate (Messaging::RelativeRequestTimeoutPolicy_ptr obj)
-{
-  if (!CORBA::is_nil (obj))
-    obj->_add_ref ();
-  return obj;
-}
 
-ACE_INLINE Messaging::RelativeRequestTimeoutPolicy_ptr
-Messaging::RelativeRequestTimeoutPolicy::_nil (void)
-{
-  return (Messaging::RelativeRequestTimeoutPolicy_ptr)0;
-}
+#if !defined (_MESSAGING_RELATIVEREQUESTTIMEOUTPOLICY___VAR_CI_)
+#define _MESSAGING_RELATIVEREQUESTTIMEOUTPOLICY___VAR_CI_
 
 // *************************************************************
 // Inline operations for class Messaging::RelativeRequestTimeoutPolicy_var
@@ -1679,23 +1639,23 @@ Messaging::RelativeRequestTimeoutPolicy::_nil (void)
 
 ACE_INLINE
 Messaging::RelativeRequestTimeoutPolicy_var::RelativeRequestTimeoutPolicy_var (void) // default constructor
-  : ptr_ (Messaging::RelativeRequestTimeoutPolicy::_nil ())
+  : ptr_ (RelativeRequestTimeoutPolicy::_nil ())
 {}
 
 ACE_INLINE
-Messaging::RelativeRequestTimeoutPolicy_var::RelativeRequestTimeoutPolicy_var (Messaging::RelativeRequestTimeoutPolicy_ptr p)
+Messaging::RelativeRequestTimeoutPolicy_var::RelativeRequestTimeoutPolicy_var (RelativeRequestTimeoutPolicy_ptr p)
   : ptr_ (p)
 {}
 
-ACE_INLINE Messaging::RelativeRequestTimeoutPolicy_ptr
+ACE_INLINE ::Messaging::RelativeRequestTimeoutPolicy_ptr
 Messaging::RelativeRequestTimeoutPolicy_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 ACE_INLINE
-Messaging::RelativeRequestTimeoutPolicy_var::RelativeRequestTimeoutPolicy_var (const Messaging::RelativeRequestTimeoutPolicy_var &p) // copy constructor
-  : ptr_ (Messaging::RelativeRequestTimeoutPolicy::_duplicate (p.ptr ()))
+Messaging::RelativeRequestTimeoutPolicy_var::RelativeRequestTimeoutPolicy_var (const ::Messaging::RelativeRequestTimeoutPolicy_var &p) // copy constructor
+  : ptr_ (RelativeRequestTimeoutPolicy::_duplicate (p.ptr ()))
 {}
 
 ACE_INLINE
@@ -1705,7 +1665,7 @@ Messaging::RelativeRequestTimeoutPolicy_var::~RelativeRequestTimeoutPolicy_var (
 }
 
 ACE_INLINE Messaging::RelativeRequestTimeoutPolicy_var &
-Messaging::RelativeRequestTimeoutPolicy_var::operator= (Messaging::RelativeRequestTimeoutPolicy_ptr p)
+Messaging::RelativeRequestTimeoutPolicy_var::operator= (RelativeRequestTimeoutPolicy_ptr p)
 {
   CORBA::release (this->ptr_);
   this->ptr_ = p;
@@ -1713,126 +1673,136 @@ Messaging::RelativeRequestTimeoutPolicy_var::operator= (Messaging::RelativeReque
 }
 
 ACE_INLINE Messaging::RelativeRequestTimeoutPolicy_var &
-Messaging::RelativeRequestTimeoutPolicy_var::operator= (const Messaging::RelativeRequestTimeoutPolicy_var &p)
+Messaging::RelativeRequestTimeoutPolicy_var::operator= (const ::Messaging::RelativeRequestTimeoutPolicy_var &p)
 {
   if (this != &p)
   {
     CORBA::release (this->ptr_);
-    this->ptr_ = Messaging::RelativeRequestTimeoutPolicy::_duplicate (p.ptr ());
+    this->ptr_ = ::Messaging::RelativeRequestTimeoutPolicy::_duplicate (p.ptr ());
   }
   return *this;
 }
 
-ACE_INLINE
-Messaging::RelativeRequestTimeoutPolicy_var::operator const Messaging::RelativeRequestTimeoutPolicy_ptr &() const // cast
+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
+ACE_INLINE 
+Messaging::RelativeRequestTimeoutPolicy_var::operator ::Messaging::RelativeRequestTimeoutPolicy_ptr &() // cast 
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::RelativeRequestTimeoutPolicy_ptr
+ACE_INLINE ::Messaging::RelativeRequestTimeoutPolicy_ptr
 Messaging::RelativeRequestTimeoutPolicy_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::RelativeRequestTimeoutPolicy_ptr
+ACE_INLINE ::Messaging::RelativeRequestTimeoutPolicy_ptr
 Messaging::RelativeRequestTimeoutPolicy_var::in (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::RelativeRequestTimeoutPolicy_ptr &
+ACE_INLINE ::Messaging::RelativeRequestTimeoutPolicy_ptr &
 Messaging::RelativeRequestTimeoutPolicy_var::inout (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::RelativeRequestTimeoutPolicy_ptr &
+ACE_INLINE ::Messaging::RelativeRequestTimeoutPolicy_ptr &
 Messaging::RelativeRequestTimeoutPolicy_var::out (void)
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = Messaging::RelativeRequestTimeoutPolicy::_nil ();
+  this->ptr_ = ::Messaging::RelativeRequestTimeoutPolicy::_nil ();
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::RelativeRequestTimeoutPolicy_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 ();
+  ::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 (Messaging::RelativeRequestTimeoutPolicy_ptr &p)
+Messaging::RelativeRequestTimeoutPolicy_out::RelativeRequestTimeoutPolicy_out (RelativeRequestTimeoutPolicy_ptr &p)
   : ptr_ (p)
 {
-  this->ptr_ = Messaging::RelativeRequestTimeoutPolicy::_nil ();
+  this->ptr_ = ::Messaging::RelativeRequestTimeoutPolicy::_nil ();
 }
 
 ACE_INLINE
-Messaging::RelativeRequestTimeoutPolicy_out::RelativeRequestTimeoutPolicy_out (Messaging::RelativeRequestTimeoutPolicy_var &p) // constructor from _var
+Messaging::RelativeRequestTimeoutPolicy_out::RelativeRequestTimeoutPolicy_out (RelativeRequestTimeoutPolicy_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = Messaging::RelativeRequestTimeoutPolicy::_nil ();
+  this->ptr_ = ::Messaging::RelativeRequestTimeoutPolicy::_nil ();
 }
 
 ACE_INLINE
-Messaging::RelativeRequestTimeoutPolicy_out::RelativeRequestTimeoutPolicy_out (const Messaging::RelativeRequestTimeoutPolicy_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (Messaging::RelativeRequestTimeoutPolicy_out&,p).ptr_)
+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)
+ACE_INLINE ::Messaging::RelativeRequestTimeoutPolicy_out &
+Messaging::RelativeRequestTimeoutPolicy_out::operator= (const ::Messaging::RelativeRequestTimeoutPolicy_out &p)
 {
-  this->ptr_ = ACE_const_cast (Messaging::RelativeRequestTimeoutPolicy_out&,p).ptr_;
+  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)
+Messaging::RelativeRequestTimeoutPolicy_out::operator= (const ::Messaging::RelativeRequestTimeoutPolicy_var &p)
 {
-  this->ptr_ = Messaging::RelativeRequestTimeoutPolicy::_duplicate (p.ptr ());
+  this->ptr_ = ::Messaging::RelativeRequestTimeoutPolicy::_duplicate (p.ptr ());
   return *this;
 }
 
 ACE_INLINE Messaging::RelativeRequestTimeoutPolicy_out &
-Messaging::RelativeRequestTimeoutPolicy_out::operator= (Messaging::RelativeRequestTimeoutPolicy_ptr p)
+Messaging::RelativeRequestTimeoutPolicy_out::operator= (RelativeRequestTimeoutPolicy_ptr p)
 {
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE
-Messaging::RelativeRequestTimeoutPolicy_out::operator Messaging::RelativeRequestTimeoutPolicy_ptr &() // cast
+ACE_INLINE 
+Messaging::RelativeRequestTimeoutPolicy_out::operator ::Messaging::RelativeRequestTimeoutPolicy_ptr &() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::RelativeRequestTimeoutPolicy_ptr &
+ACE_INLINE ::Messaging::RelativeRequestTimeoutPolicy_ptr &
 Messaging::RelativeRequestTimeoutPolicy_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::RelativeRequestTimeoutPolicy_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)
@@ -1842,27 +1812,12 @@ Messaging::RelativeRoundtripTimeoutPolicy::RelativeRoundtripTimeoutPolicy (void)
 {}
 
 ACE_INLINE
-Messaging::RelativeRoundtripTimeoutPolicy::RelativeRoundtripTimeoutPolicy (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
-  : CORBA_Object (objref, _tao_servant, _tao_collocated)
-{}
-
-ACE_INLINE
 Messaging::RelativeRoundtripTimeoutPolicy::~RelativeRoundtripTimeoutPolicy (void) // destructor
 {}
 
-ACE_INLINE Messaging::RelativeRoundtripTimeoutPolicy_ptr
-Messaging::RelativeRoundtripTimeoutPolicy::_duplicate (Messaging::RelativeRoundtripTimeoutPolicy_ptr obj)
-{
-  if (!CORBA::is_nil (obj))
-    obj->_add_ref ();
-  return obj;
-}
 
-ACE_INLINE Messaging::RelativeRoundtripTimeoutPolicy_ptr
-Messaging::RelativeRoundtripTimeoutPolicy::_nil (void)
-{
-  return (Messaging::RelativeRoundtripTimeoutPolicy_ptr)0;
-}
+#if !defined (_MESSAGING_RELATIVEROUNDTRIPTIMEOUTPOLICY___VAR_CI_)
+#define _MESSAGING_RELATIVEROUNDTRIPTIMEOUTPOLICY___VAR_CI_
 
 // *************************************************************
 // Inline operations for class Messaging::RelativeRoundtripTimeoutPolicy_var
@@ -1870,23 +1825,23 @@ Messaging::RelativeRoundtripTimeoutPolicy::_nil (void)
 
 ACE_INLINE
 Messaging::RelativeRoundtripTimeoutPolicy_var::RelativeRoundtripTimeoutPolicy_var (void) // default constructor
-  : ptr_ (Messaging::RelativeRoundtripTimeoutPolicy::_nil ())
+  : ptr_ (RelativeRoundtripTimeoutPolicy::_nil ())
 {}
 
 ACE_INLINE
-Messaging::RelativeRoundtripTimeoutPolicy_var::RelativeRoundtripTimeoutPolicy_var (Messaging::RelativeRoundtripTimeoutPolicy_ptr p)
+Messaging::RelativeRoundtripTimeoutPolicy_var::RelativeRoundtripTimeoutPolicy_var (RelativeRoundtripTimeoutPolicy_ptr p)
   : ptr_ (p)
 {}
 
-ACE_INLINE Messaging::RelativeRoundtripTimeoutPolicy_ptr
+ACE_INLINE ::Messaging::RelativeRoundtripTimeoutPolicy_ptr
 Messaging::RelativeRoundtripTimeoutPolicy_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 ACE_INLINE
-Messaging::RelativeRoundtripTimeoutPolicy_var::RelativeRoundtripTimeoutPolicy_var (const Messaging::RelativeRoundtripTimeoutPolicy_var &p) // copy constructor
-  : ptr_ (Messaging::RelativeRoundtripTimeoutPolicy::_duplicate (p.ptr ()))
+Messaging::RelativeRoundtripTimeoutPolicy_var::RelativeRoundtripTimeoutPolicy_var (const ::Messaging::RelativeRoundtripTimeoutPolicy_var &p) // copy constructor
+  : ptr_ (RelativeRoundtripTimeoutPolicy::_duplicate (p.ptr ()))
 {}
 
 ACE_INLINE
@@ -1896,7 +1851,7 @@ Messaging::RelativeRoundtripTimeoutPolicy_var::~RelativeRoundtripTimeoutPolicy_v
 }
 
 ACE_INLINE Messaging::RelativeRoundtripTimeoutPolicy_var &
-Messaging::RelativeRoundtripTimeoutPolicy_var::operator= (Messaging::RelativeRoundtripTimeoutPolicy_ptr p)
+Messaging::RelativeRoundtripTimeoutPolicy_var::operator= (RelativeRoundtripTimeoutPolicy_ptr p)
 {
   CORBA::release (this->ptr_);
   this->ptr_ = p;
@@ -1904,154 +1859,170 @@ Messaging::RelativeRoundtripTimeoutPolicy_var::operator= (Messaging::RelativeRou
 }
 
 ACE_INLINE Messaging::RelativeRoundtripTimeoutPolicy_var &
-Messaging::RelativeRoundtripTimeoutPolicy_var::operator= (const Messaging::RelativeRoundtripTimeoutPolicy_var &p)
+Messaging::RelativeRoundtripTimeoutPolicy_var::operator= (const ::Messaging::RelativeRoundtripTimeoutPolicy_var &p)
 {
   if (this != &p)
   {
     CORBA::release (this->ptr_);
-    this->ptr_ = Messaging::RelativeRoundtripTimeoutPolicy::_duplicate (p.ptr ());
+    this->ptr_ = ::Messaging::RelativeRoundtripTimeoutPolicy::_duplicate (p.ptr ());
   }
   return *this;
 }
 
-ACE_INLINE
-Messaging::RelativeRoundtripTimeoutPolicy_var::operator const Messaging::RelativeRoundtripTimeoutPolicy_ptr &() const // cast
+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
+ACE_INLINE 
+Messaging::RelativeRoundtripTimeoutPolicy_var::operator ::Messaging::RelativeRoundtripTimeoutPolicy_ptr &() // cast 
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::RelativeRoundtripTimeoutPolicy_ptr
+ACE_INLINE ::Messaging::RelativeRoundtripTimeoutPolicy_ptr
 Messaging::RelativeRoundtripTimeoutPolicy_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::RelativeRoundtripTimeoutPolicy_ptr
+ACE_INLINE ::Messaging::RelativeRoundtripTimeoutPolicy_ptr
 Messaging::RelativeRoundtripTimeoutPolicy_var::in (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::RelativeRoundtripTimeoutPolicy_ptr &
+ACE_INLINE ::Messaging::RelativeRoundtripTimeoutPolicy_ptr &
 Messaging::RelativeRoundtripTimeoutPolicy_var::inout (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::RelativeRoundtripTimeoutPolicy_ptr &
+ACE_INLINE ::Messaging::RelativeRoundtripTimeoutPolicy_ptr &
 Messaging::RelativeRoundtripTimeoutPolicy_var::out (void)
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = Messaging::RelativeRoundtripTimeoutPolicy::_nil ();
+  this->ptr_ = ::Messaging::RelativeRoundtripTimeoutPolicy::_nil ();
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::RelativeRoundtripTimeoutPolicy_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 ();
+  ::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 (Messaging::RelativeRoundtripTimeoutPolicy_ptr &p)
+Messaging::RelativeRoundtripTimeoutPolicy_out::RelativeRoundtripTimeoutPolicy_out (RelativeRoundtripTimeoutPolicy_ptr &p)
   : ptr_ (p)
 {
-  this->ptr_ = Messaging::RelativeRoundtripTimeoutPolicy::_nil ();
+  this->ptr_ = ::Messaging::RelativeRoundtripTimeoutPolicy::_nil ();
 }
 
 ACE_INLINE
-Messaging::RelativeRoundtripTimeoutPolicy_out::RelativeRoundtripTimeoutPolicy_out (Messaging::RelativeRoundtripTimeoutPolicy_var &p) // constructor from _var
+Messaging::RelativeRoundtripTimeoutPolicy_out::RelativeRoundtripTimeoutPolicy_out (RelativeRoundtripTimeoutPolicy_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = Messaging::RelativeRoundtripTimeoutPolicy::_nil ();
+  this->ptr_ = ::Messaging::RelativeRoundtripTimeoutPolicy::_nil ();
 }
 
 ACE_INLINE
-Messaging::RelativeRoundtripTimeoutPolicy_out::RelativeRoundtripTimeoutPolicy_out (const Messaging::RelativeRoundtripTimeoutPolicy_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (Messaging::RelativeRoundtripTimeoutPolicy_out&,p).ptr_)
+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)
+ACE_INLINE ::Messaging::RelativeRoundtripTimeoutPolicy_out &
+Messaging::RelativeRoundtripTimeoutPolicy_out::operator= (const ::Messaging::RelativeRoundtripTimeoutPolicy_out &p)
 {
-  this->ptr_ = ACE_const_cast (Messaging::RelativeRoundtripTimeoutPolicy_out&,p).ptr_;
+  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)
+Messaging::RelativeRoundtripTimeoutPolicy_out::operator= (const ::Messaging::RelativeRoundtripTimeoutPolicy_var &p)
 {
-  this->ptr_ = Messaging::RelativeRoundtripTimeoutPolicy::_duplicate (p.ptr ());
+  this->ptr_ = ::Messaging::RelativeRoundtripTimeoutPolicy::_duplicate (p.ptr ());
   return *this;
 }
 
 ACE_INLINE Messaging::RelativeRoundtripTimeoutPolicy_out &
-Messaging::RelativeRoundtripTimeoutPolicy_out::operator= (Messaging::RelativeRoundtripTimeoutPolicy_ptr p)
+Messaging::RelativeRoundtripTimeoutPolicy_out::operator= (RelativeRoundtripTimeoutPolicy_ptr p)
 {
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE
-Messaging::RelativeRoundtripTimeoutPolicy_out::operator Messaging::RelativeRoundtripTimeoutPolicy_ptr &() // cast
+ACE_INLINE 
+Messaging::RelativeRoundtripTimeoutPolicy_out::operator ::Messaging::RelativeRoundtripTimeoutPolicy_ptr &() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::RelativeRoundtripTimeoutPolicy_ptr &
+ACE_INLINE ::Messaging::RelativeRoundtripTimeoutPolicy_ptr &
 Messaging::RelativeRoundtripTimeoutPolicy_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::RelativeRoundtripTimeoutPolicy_ptr
+ACE_INLINE ::Messaging::RelativeRoundtripTimeoutPolicy_ptr
 Messaging::RelativeRoundtripTimeoutPolicy_out::operator-> (void)
 {
   return this->ptr_;
 }
 
-#endif /* TAO_HAS_RELATIVE_ROUNDTRIP_TIMEOUT_POLICY == 1 */
 
-#if (TAO_HAS_ROUTING_POLICY == 1)
+#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 (Messaging::RoutingTypeRange *p)
+Messaging::RoutingTypeRange_var::RoutingTypeRange_var (RoutingTypeRange *p)
   : ptr_ (p)
 {}
 
 ACE_INLINE
-Messaging::RoutingTypeRange_var::RoutingTypeRange_var (const Messaging::RoutingTypeRange_var &p) // copy constructor
+Messaging::RoutingTypeRange_var::RoutingTypeRange_var (const ::Messaging::RoutingTypeRange_var &p) // copy constructor
 {
   if (p.ptr_)
-    ACE_NEW (this->ptr_,
-             Messaging::RoutingTypeRange(*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
 {
@@ -2059,82 +2030,92 @@ Messaging::RoutingTypeRange_var::~RoutingTypeRange_var (void) // destructor
 }
 
 ACE_INLINE Messaging::RoutingTypeRange_var &
-Messaging::RoutingTypeRange_var::operator= (Messaging::RoutingTypeRange *p)
+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)
+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);
+    ACE_NEW_RETURN (this->ptr_, ::Messaging::RoutingTypeRange (*p.ptr_), *this);
   }
   return *this;
 }
 
-ACE_INLINE const Messaging::RoutingTypeRange *
+// 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 *
+ACE_INLINE ::Messaging::RoutingTypeRange *
 Messaging::RoutingTypeRange_var::operator-> (void)
 {
   return this->ptr_;
 }
 
 ACE_INLINE
-Messaging::RoutingTypeRange_var::operator const Messaging::RoutingTypeRange &() const // cast
+Messaging::RoutingTypeRange_var::operator const ::Messaging::RoutingTypeRange &() const // cast
 {
   return *this->ptr_;
 }
 
 ACE_INLINE
-Messaging::RoutingTypeRange_var::operator Messaging::RoutingTypeRange &() // cast
+Messaging::RoutingTypeRange_var::operator ::Messaging::RoutingTypeRange &() // cast 
 {
   return *this->ptr_;
 }
 
 ACE_INLINE
-Messaging::RoutingTypeRange_var::operator Messaging::RoutingTypeRange &() const// cast
+Messaging::RoutingTypeRange_var::operator ::Messaging::RoutingTypeRange &() const // cast 
 {
   return *this->ptr_;
 }
 
-ACE_INLINE const Messaging::RoutingTypeRange &
+ACE_INLINE const ::Messaging::RoutingTypeRange &
 Messaging::RoutingTypeRange_var::in (void) const
 {
   return *this->ptr_;
 }
 
-ACE_INLINE Messaging::RoutingTypeRange &
+ACE_INLINE ::Messaging::RoutingTypeRange &
 Messaging::RoutingTypeRange_var::inout (void)
 {
   return *this->ptr_;
 }
 
-// mapping for fixed size
-ACE_INLINE Messaging::RoutingTypeRange &
+// mapping for fixed size 
+ACE_INLINE ::Messaging::RoutingTypeRange &
 Messaging::RoutingTypeRange_var::out (void)
 {
   return *this->ptr_;
 }
 
-ACE_INLINE Messaging::RoutingTypeRange
+ACE_INLINE ::Messaging::RoutingTypeRange
 Messaging::RoutingTypeRange_var::_retn (void)
 {
   return *this->ptr_;
 }
 
-ACE_INLINE Messaging::RoutingTypeRange *
+ACE_INLINE ::Messaging::RoutingTypeRange *
 Messaging::RoutingTypeRange_var::ptr (void) const
 {
   return this->ptr_;
@@ -2145,27 +2126,12 @@ Messaging::RoutingPolicy::RoutingPolicy (void) // default constructor
 {}
 
 ACE_INLINE
-Messaging::RoutingPolicy::RoutingPolicy (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
-  : CORBA_Object (objref, _tao_servant, _tao_collocated)
-{}
-
-ACE_INLINE
 Messaging::RoutingPolicy::~RoutingPolicy (void) // destructor
 {}
 
-ACE_INLINE Messaging::RoutingPolicy_ptr
-Messaging::RoutingPolicy::_duplicate (Messaging::RoutingPolicy_ptr obj)
-{
-  if (!CORBA::is_nil (obj))
-    obj->_add_ref ();
-  return obj;
-}
 
-ACE_INLINE Messaging::RoutingPolicy_ptr
-Messaging::RoutingPolicy::_nil (void)
-{
-  return (Messaging::RoutingPolicy_ptr)0;
-}
+#if !defined (_MESSAGING_ROUTINGPOLICY___VAR_CI_)
+#define _MESSAGING_ROUTINGPOLICY___VAR_CI_
 
 // *************************************************************
 // Inline operations for class Messaging::RoutingPolicy_var
@@ -2173,23 +2139,23 @@ Messaging::RoutingPolicy::_nil (void)
 
 ACE_INLINE
 Messaging::RoutingPolicy_var::RoutingPolicy_var (void) // default constructor
-  : ptr_ (Messaging::RoutingPolicy::_nil ())
+  : ptr_ (RoutingPolicy::_nil ())
 {}
 
 ACE_INLINE
-Messaging::RoutingPolicy_var::RoutingPolicy_var (Messaging::RoutingPolicy_ptr p)
+Messaging::RoutingPolicy_var::RoutingPolicy_var (RoutingPolicy_ptr p)
   : ptr_ (p)
 {}
 
-ACE_INLINE Messaging::RoutingPolicy_ptr
+ACE_INLINE ::Messaging::RoutingPolicy_ptr
 Messaging::RoutingPolicy_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 ACE_INLINE
-Messaging::RoutingPolicy_var::RoutingPolicy_var (const Messaging::RoutingPolicy_var &p) // copy constructor
-  : ptr_ (Messaging::RoutingPolicy::_duplicate (p.ptr ()))
+Messaging::RoutingPolicy_var::RoutingPolicy_var (const ::Messaging::RoutingPolicy_var &p) // copy constructor
+  : ptr_ (RoutingPolicy::_duplicate (p.ptr ()))
 {}
 
 ACE_INLINE
@@ -2199,7 +2165,7 @@ Messaging::RoutingPolicy_var::~RoutingPolicy_var (void) // destructor
 }
 
 ACE_INLINE Messaging::RoutingPolicy_var &
-Messaging::RoutingPolicy_var::operator= (Messaging::RoutingPolicy_ptr p)
+Messaging::RoutingPolicy_var::operator= (RoutingPolicy_ptr p)
 {
   CORBA::release (this->ptr_);
   this->ptr_ = p;
@@ -2207,126 +2173,136 @@ Messaging::RoutingPolicy_var::operator= (Messaging::RoutingPolicy_ptr p)
 }
 
 ACE_INLINE Messaging::RoutingPolicy_var &
-Messaging::RoutingPolicy_var::operator= (const Messaging::RoutingPolicy_var &p)
+Messaging::RoutingPolicy_var::operator= (const ::Messaging::RoutingPolicy_var &p)
 {
   if (this != &p)
   {
     CORBA::release (this->ptr_);
-    this->ptr_ = Messaging::RoutingPolicy::_duplicate (p.ptr ());
+    this->ptr_ = ::Messaging::RoutingPolicy::_duplicate (p.ptr ());
   }
   return *this;
 }
 
-ACE_INLINE
-Messaging::RoutingPolicy_var::operator const Messaging::RoutingPolicy_ptr &() const // cast
+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
+ACE_INLINE 
+Messaging::RoutingPolicy_var::operator ::Messaging::RoutingPolicy_ptr &() // cast 
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::RoutingPolicy_ptr
+ACE_INLINE ::Messaging::RoutingPolicy_ptr
 Messaging::RoutingPolicy_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::RoutingPolicy_ptr
+ACE_INLINE ::Messaging::RoutingPolicy_ptr
 Messaging::RoutingPolicy_var::in (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::RoutingPolicy_ptr &
+ACE_INLINE ::Messaging::RoutingPolicy_ptr &
 Messaging::RoutingPolicy_var::inout (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::RoutingPolicy_ptr &
+ACE_INLINE ::Messaging::RoutingPolicy_ptr &
 Messaging::RoutingPolicy_var::out (void)
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = Messaging::RoutingPolicy::_nil ();
+  this->ptr_ = ::Messaging::RoutingPolicy::_nil ();
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::RoutingPolicy_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 ();
+  ::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 (Messaging::RoutingPolicy_ptr &p)
+Messaging::RoutingPolicy_out::RoutingPolicy_out (RoutingPolicy_ptr &p)
   : ptr_ (p)
 {
-  this->ptr_ = Messaging::RoutingPolicy::_nil ();
+  this->ptr_ = ::Messaging::RoutingPolicy::_nil ();
 }
 
 ACE_INLINE
-Messaging::RoutingPolicy_out::RoutingPolicy_out (Messaging::RoutingPolicy_var &p) // constructor from _var
+Messaging::RoutingPolicy_out::RoutingPolicy_out (RoutingPolicy_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = Messaging::RoutingPolicy::_nil ();
+  this->ptr_ = ::Messaging::RoutingPolicy::_nil ();
 }
 
 ACE_INLINE
-Messaging::RoutingPolicy_out::RoutingPolicy_out (const Messaging::RoutingPolicy_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (Messaging::RoutingPolicy_out&,p).ptr_)
+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)
+ACE_INLINE ::Messaging::RoutingPolicy_out &
+Messaging::RoutingPolicy_out::operator= (const ::Messaging::RoutingPolicy_out &p)
 {
-  this->ptr_ = ACE_const_cast (Messaging::RoutingPolicy_out&,p).ptr_;
+  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)
+Messaging::RoutingPolicy_out::operator= (const ::Messaging::RoutingPolicy_var &p)
 {
-  this->ptr_ = Messaging::RoutingPolicy::_duplicate (p.ptr ());
+  this->ptr_ = ::Messaging::RoutingPolicy::_duplicate (p.ptr ());
   return *this;
 }
 
 ACE_INLINE Messaging::RoutingPolicy_out &
-Messaging::RoutingPolicy_out::operator= (Messaging::RoutingPolicy_ptr p)
+Messaging::RoutingPolicy_out::operator= (RoutingPolicy_ptr p)
 {
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE
-Messaging::RoutingPolicy_out::operator Messaging::RoutingPolicy_ptr &() // cast
+ACE_INLINE 
+Messaging::RoutingPolicy_out::operator ::Messaging::RoutingPolicy_ptr &() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::RoutingPolicy_ptr &
+ACE_INLINE ::Messaging::RoutingPolicy_ptr &
 Messaging::RoutingPolicy_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::RoutingPolicy_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)
@@ -2336,27 +2312,12 @@ Messaging::MaxHopsPolicy::MaxHopsPolicy (void) // default constructor
 {}
 
 ACE_INLINE
-Messaging::MaxHopsPolicy::MaxHopsPolicy (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
-  : CORBA_Object (objref, _tao_servant, _tao_collocated)
-{}
-
-ACE_INLINE
 Messaging::MaxHopsPolicy::~MaxHopsPolicy (void) // destructor
 {}
 
-ACE_INLINE Messaging::MaxHopsPolicy_ptr
-Messaging::MaxHopsPolicy::_duplicate (Messaging::MaxHopsPolicy_ptr obj)
-{
-  if (!CORBA::is_nil (obj))
-    obj->_add_ref ();
-  return obj;
-}
 
-ACE_INLINE Messaging::MaxHopsPolicy_ptr
-Messaging::MaxHopsPolicy::_nil (void)
-{
-  return (Messaging::MaxHopsPolicy_ptr)0;
-}
+#if !defined (_MESSAGING_MAXHOPSPOLICY___VAR_CI_)
+#define _MESSAGING_MAXHOPSPOLICY___VAR_CI_
 
 // *************************************************************
 // Inline operations for class Messaging::MaxHopsPolicy_var
@@ -2364,23 +2325,23 @@ Messaging::MaxHopsPolicy::_nil (void)
 
 ACE_INLINE
 Messaging::MaxHopsPolicy_var::MaxHopsPolicy_var (void) // default constructor
-  : ptr_ (Messaging::MaxHopsPolicy::_nil ())
+  : ptr_ (MaxHopsPolicy::_nil ())
 {}
 
 ACE_INLINE
-Messaging::MaxHopsPolicy_var::MaxHopsPolicy_var (Messaging::MaxHopsPolicy_ptr p)
+Messaging::MaxHopsPolicy_var::MaxHopsPolicy_var (MaxHopsPolicy_ptr p)
   : ptr_ (p)
 {}
 
-ACE_INLINE Messaging::MaxHopsPolicy_ptr
+ACE_INLINE ::Messaging::MaxHopsPolicy_ptr
 Messaging::MaxHopsPolicy_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 ACE_INLINE
-Messaging::MaxHopsPolicy_var::MaxHopsPolicy_var (const Messaging::MaxHopsPolicy_var &p) // copy constructor
-  : ptr_ (Messaging::MaxHopsPolicy::_duplicate (p.ptr ()))
+Messaging::MaxHopsPolicy_var::MaxHopsPolicy_var (const ::Messaging::MaxHopsPolicy_var &p) // copy constructor
+  : ptr_ (MaxHopsPolicy::_duplicate (p.ptr ()))
 {}
 
 ACE_INLINE
@@ -2390,7 +2351,7 @@ Messaging::MaxHopsPolicy_var::~MaxHopsPolicy_var (void) // destructor
 }
 
 ACE_INLINE Messaging::MaxHopsPolicy_var &
-Messaging::MaxHopsPolicy_var::operator= (Messaging::MaxHopsPolicy_ptr p)
+Messaging::MaxHopsPolicy_var::operator= (MaxHopsPolicy_ptr p)
 {
   CORBA::release (this->ptr_);
   this->ptr_ = p;
@@ -2398,126 +2359,136 @@ Messaging::MaxHopsPolicy_var::operator= (Messaging::MaxHopsPolicy_ptr p)
 }
 
 ACE_INLINE Messaging::MaxHopsPolicy_var &
-Messaging::MaxHopsPolicy_var::operator= (const Messaging::MaxHopsPolicy_var &p)
+Messaging::MaxHopsPolicy_var::operator= (const ::Messaging::MaxHopsPolicy_var &p)
 {
   if (this != &p)
   {
     CORBA::release (this->ptr_);
-    this->ptr_ = Messaging::MaxHopsPolicy::_duplicate (p.ptr ());
+    this->ptr_ = ::Messaging::MaxHopsPolicy::_duplicate (p.ptr ());
   }
   return *this;
 }
 
-ACE_INLINE
-Messaging::MaxHopsPolicy_var::operator const Messaging::MaxHopsPolicy_ptr &() const // cast
+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
+ACE_INLINE 
+Messaging::MaxHopsPolicy_var::operator ::Messaging::MaxHopsPolicy_ptr &() // cast 
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::MaxHopsPolicy_ptr
+ACE_INLINE ::Messaging::MaxHopsPolicy_ptr
 Messaging::MaxHopsPolicy_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::MaxHopsPolicy_ptr
+ACE_INLINE ::Messaging::MaxHopsPolicy_ptr
 Messaging::MaxHopsPolicy_var::in (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::MaxHopsPolicy_ptr &
+ACE_INLINE ::Messaging::MaxHopsPolicy_ptr &
 Messaging::MaxHopsPolicy_var::inout (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::MaxHopsPolicy_ptr &
+ACE_INLINE ::Messaging::MaxHopsPolicy_ptr &
 Messaging::MaxHopsPolicy_var::out (void)
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = Messaging::MaxHopsPolicy::_nil ();
+  this->ptr_ = ::Messaging::MaxHopsPolicy::_nil ();
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::MaxHopsPolicy_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 ();
+  ::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 (Messaging::MaxHopsPolicy_ptr &p)
+Messaging::MaxHopsPolicy_out::MaxHopsPolicy_out (MaxHopsPolicy_ptr &p)
   : ptr_ (p)
 {
-  this->ptr_ = Messaging::MaxHopsPolicy::_nil ();
+  this->ptr_ = ::Messaging::MaxHopsPolicy::_nil ();
 }
 
 ACE_INLINE
-Messaging::MaxHopsPolicy_out::MaxHopsPolicy_out (Messaging::MaxHopsPolicy_var &p) // constructor from _var
+Messaging::MaxHopsPolicy_out::MaxHopsPolicy_out (MaxHopsPolicy_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = Messaging::MaxHopsPolicy::_nil ();
+  this->ptr_ = ::Messaging::MaxHopsPolicy::_nil ();
 }
 
 ACE_INLINE
-Messaging::MaxHopsPolicy_out::MaxHopsPolicy_out (const Messaging::MaxHopsPolicy_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (Messaging::MaxHopsPolicy_out&,p).ptr_)
+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)
+ACE_INLINE ::Messaging::MaxHopsPolicy_out &
+Messaging::MaxHopsPolicy_out::operator= (const ::Messaging::MaxHopsPolicy_out &p)
 {
-  this->ptr_ = ACE_const_cast (Messaging::MaxHopsPolicy_out&,p).ptr_;
+  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)
+Messaging::MaxHopsPolicy_out::operator= (const ::Messaging::MaxHopsPolicy_var &p)
 {
-  this->ptr_ = Messaging::MaxHopsPolicy::_duplicate (p.ptr ());
+  this->ptr_ = ::Messaging::MaxHopsPolicy::_duplicate (p.ptr ());
   return *this;
 }
 
 ACE_INLINE Messaging::MaxHopsPolicy_out &
-Messaging::MaxHopsPolicy_out::operator= (Messaging::MaxHopsPolicy_ptr p)
+Messaging::MaxHopsPolicy_out::operator= (MaxHopsPolicy_ptr p)
 {
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE
-Messaging::MaxHopsPolicy_out::operator Messaging::MaxHopsPolicy_ptr &() // cast
+ACE_INLINE 
+Messaging::MaxHopsPolicy_out::operator ::Messaging::MaxHopsPolicy_ptr &() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::MaxHopsPolicy_ptr &
+ACE_INLINE ::Messaging::MaxHopsPolicy_ptr &
 Messaging::MaxHopsPolicy_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::MaxHopsPolicy_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)
@@ -2527,27 +2498,12 @@ Messaging::QueueOrderPolicy::QueueOrderPolicy (void) // default constructor
 {}
 
 ACE_INLINE
-Messaging::QueueOrderPolicy::QueueOrderPolicy (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
-  : CORBA_Object (objref, _tao_servant, _tao_collocated)
-{}
-
-ACE_INLINE
 Messaging::QueueOrderPolicy::~QueueOrderPolicy (void) // destructor
 {}
 
-ACE_INLINE Messaging::QueueOrderPolicy_ptr
-Messaging::QueueOrderPolicy::_duplicate (Messaging::QueueOrderPolicy_ptr obj)
-{
-  if (!CORBA::is_nil (obj))
-    obj->_add_ref ();
-  return obj;
-}
 
-ACE_INLINE Messaging::QueueOrderPolicy_ptr
-Messaging::QueueOrderPolicy::_nil (void)
-{
-  return (Messaging::QueueOrderPolicy_ptr)0;
-}
+#if !defined (_MESSAGING_QUEUEORDERPOLICY___VAR_CI_)
+#define _MESSAGING_QUEUEORDERPOLICY___VAR_CI_
 
 // *************************************************************
 // Inline operations for class Messaging::QueueOrderPolicy_var
@@ -2555,23 +2511,23 @@ Messaging::QueueOrderPolicy::_nil (void)
 
 ACE_INLINE
 Messaging::QueueOrderPolicy_var::QueueOrderPolicy_var (void) // default constructor
-  : ptr_ (Messaging::QueueOrderPolicy::_nil ())
+  : ptr_ (QueueOrderPolicy::_nil ())
 {}
 
 ACE_INLINE
-Messaging::QueueOrderPolicy_var::QueueOrderPolicy_var (Messaging::QueueOrderPolicy_ptr p)
+Messaging::QueueOrderPolicy_var::QueueOrderPolicy_var (QueueOrderPolicy_ptr p)
   : ptr_ (p)
 {}
 
-ACE_INLINE Messaging::QueueOrderPolicy_ptr
+ACE_INLINE ::Messaging::QueueOrderPolicy_ptr
 Messaging::QueueOrderPolicy_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 ACE_INLINE
-Messaging::QueueOrderPolicy_var::QueueOrderPolicy_var (const Messaging::QueueOrderPolicy_var &p) // copy constructor
-  : ptr_ (Messaging::QueueOrderPolicy::_duplicate (p.ptr ()))
+Messaging::QueueOrderPolicy_var::QueueOrderPolicy_var (const ::Messaging::QueueOrderPolicy_var &p) // copy constructor
+  : ptr_ (QueueOrderPolicy::_duplicate (p.ptr ()))
 {}
 
 ACE_INLINE
@@ -2581,7 +2537,7 @@ Messaging::QueueOrderPolicy_var::~QueueOrderPolicy_var (void) // destructor
 }
 
 ACE_INLINE Messaging::QueueOrderPolicy_var &
-Messaging::QueueOrderPolicy_var::operator= (Messaging::QueueOrderPolicy_ptr p)
+Messaging::QueueOrderPolicy_var::operator= (QueueOrderPolicy_ptr p)
 {
   CORBA::release (this->ptr_);
   this->ptr_ = p;
@@ -2589,126 +2545,136 @@ Messaging::QueueOrderPolicy_var::operator= (Messaging::QueueOrderPolicy_ptr p)
 }
 
 ACE_INLINE Messaging::QueueOrderPolicy_var &
-Messaging::QueueOrderPolicy_var::operator= (const Messaging::QueueOrderPolicy_var &p)
+Messaging::QueueOrderPolicy_var::operator= (const ::Messaging::QueueOrderPolicy_var &p)
 {
   if (this != &p)
   {
     CORBA::release (this->ptr_);
-    this->ptr_ = Messaging::QueueOrderPolicy::_duplicate (p.ptr ());
+    this->ptr_ = ::Messaging::QueueOrderPolicy::_duplicate (p.ptr ());
   }
   return *this;
 }
 
-ACE_INLINE
-Messaging::QueueOrderPolicy_var::operator const Messaging::QueueOrderPolicy_ptr &() const // cast
+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
+ACE_INLINE 
+Messaging::QueueOrderPolicy_var::operator ::Messaging::QueueOrderPolicy_ptr &() // cast 
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::QueueOrderPolicy_ptr
+ACE_INLINE ::Messaging::QueueOrderPolicy_ptr
 Messaging::QueueOrderPolicy_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::QueueOrderPolicy_ptr
+ACE_INLINE ::Messaging::QueueOrderPolicy_ptr
 Messaging::QueueOrderPolicy_var::in (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::QueueOrderPolicy_ptr &
+ACE_INLINE ::Messaging::QueueOrderPolicy_ptr &
 Messaging::QueueOrderPolicy_var::inout (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::QueueOrderPolicy_ptr &
+ACE_INLINE ::Messaging::QueueOrderPolicy_ptr &
 Messaging::QueueOrderPolicy_var::out (void)
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = Messaging::QueueOrderPolicy::_nil ();
+  this->ptr_ = ::Messaging::QueueOrderPolicy::_nil ();
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::QueueOrderPolicy_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 ();
+  ::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 (Messaging::QueueOrderPolicy_ptr &p)
+Messaging::QueueOrderPolicy_out::QueueOrderPolicy_out (QueueOrderPolicy_ptr &p)
   : ptr_ (p)
 {
-  this->ptr_ = Messaging::QueueOrderPolicy::_nil ();
+  this->ptr_ = ::Messaging::QueueOrderPolicy::_nil ();
 }
 
 ACE_INLINE
-Messaging::QueueOrderPolicy_out::QueueOrderPolicy_out (Messaging::QueueOrderPolicy_var &p) // constructor from _var
+Messaging::QueueOrderPolicy_out::QueueOrderPolicy_out (QueueOrderPolicy_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = Messaging::QueueOrderPolicy::_nil ();
+  this->ptr_ = ::Messaging::QueueOrderPolicy::_nil ();
 }
 
 ACE_INLINE
-Messaging::QueueOrderPolicy_out::QueueOrderPolicy_out (const Messaging::QueueOrderPolicy_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (Messaging::QueueOrderPolicy_out&,p).ptr_)
+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)
+ACE_INLINE ::Messaging::QueueOrderPolicy_out &
+Messaging::QueueOrderPolicy_out::operator= (const ::Messaging::QueueOrderPolicy_out &p)
 {
-  this->ptr_ = ACE_const_cast (Messaging::QueueOrderPolicy_out&,p).ptr_;
+  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)
+Messaging::QueueOrderPolicy_out::operator= (const ::Messaging::QueueOrderPolicy_var &p)
 {
-  this->ptr_ = Messaging::QueueOrderPolicy::_duplicate (p.ptr ());
+  this->ptr_ = ::Messaging::QueueOrderPolicy::_duplicate (p.ptr ());
   return *this;
 }
 
 ACE_INLINE Messaging::QueueOrderPolicy_out &
-Messaging::QueueOrderPolicy_out::operator= (Messaging::QueueOrderPolicy_ptr p)
+Messaging::QueueOrderPolicy_out::operator= (QueueOrderPolicy_ptr p)
 {
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE
-Messaging::QueueOrderPolicy_out::operator Messaging::QueueOrderPolicy_ptr &() // cast
+ACE_INLINE 
+Messaging::QueueOrderPolicy_out::operator ::Messaging::QueueOrderPolicy_ptr &() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::QueueOrderPolicy_ptr &
+ACE_INLINE ::Messaging::QueueOrderPolicy_ptr &
 Messaging::QueueOrderPolicy_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::QueueOrderPolicy_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 */
 
 // *************************************************************
@@ -2721,16 +2687,15 @@ Messaging::PolicyValue_var::PolicyValue_var (void) // default constructor
 {}
 
 ACE_INLINE
-Messaging::PolicyValue_var::PolicyValue_var (Messaging::PolicyValue *p)
+Messaging::PolicyValue_var::PolicyValue_var (PolicyValue *p)
   : ptr_ (p)
 {}
 
 ACE_INLINE
-Messaging::PolicyValue_var::PolicyValue_var (const Messaging::PolicyValue_var &p) // copy constructor
+Messaging::PolicyValue_var::PolicyValue_var (const ::Messaging::PolicyValue_var &p) // copy constructor
 {
   if (p.ptr_)
-    ACE_NEW (this->ptr_,
-             Messaging::PolicyValue(*p.ptr_));
+    ACE_NEW (this->ptr_, ::Messaging::PolicyValue (*p.ptr_));
   else
     this->ptr_ = 0;
 }
@@ -2742,70 +2707,75 @@ Messaging::PolicyValue_var::~PolicyValue_var (void) // destructor
 }
 
 ACE_INLINE Messaging::PolicyValue_var &
-Messaging::PolicyValue_var::operator= (Messaging::PolicyValue *p)
+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)
+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);
+    ACE_NEW_RETURN (this->ptr_, ::Messaging::PolicyValue (*p.ptr_), *this);
   }
   return *this;
 }
 
-ACE_INLINE const Messaging::PolicyValue *
+ACE_INLINE const ::Messaging::PolicyValue *
 Messaging::PolicyValue_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::PolicyValue *
+ACE_INLINE ::Messaging::PolicyValue *
 Messaging::PolicyValue_var::operator-> (void)
 {
   return this->ptr_;
 }
 
 ACE_INLINE
-Messaging::PolicyValue_var::operator const Messaging::PolicyValue &() const // cast
+Messaging::PolicyValue_var::operator const ::Messaging::PolicyValue &() const // cast
 {
   return *this->ptr_;
 }
 
 ACE_INLINE
-Messaging::PolicyValue_var::operator Messaging::PolicyValue &() // cast
+Messaging::PolicyValue_var::operator ::Messaging::PolicyValue &() // cast 
 {
   return *this->ptr_;
 }
 
 ACE_INLINE
-Messaging::PolicyValue_var::operator Messaging::PolicyValue &() const// cast
+Messaging::PolicyValue_var::operator ::Messaging::PolicyValue &() const // cast 
 {
   return *this->ptr_;
 }
 
-ACE_INLINE const Messaging::PolicyValue &
+// 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 &
+ACE_INLINE ::Messaging::PolicyValue &
 Messaging::PolicyValue_var::inout (void)
 {
   return *this->ptr_;
 }
 
-// mapping for variable size
-ACE_INLINE Messaging::PolicyValue *&
+// mapping for variable size 
+ACE_INLINE ::Messaging::PolicyValue *&
 Messaging::PolicyValue_var::out (void)
 {
   delete this->ptr_;
@@ -2813,15 +2783,15 @@ Messaging::PolicyValue_var::out (void)
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::PolicyValue *
+ACE_INLINE ::Messaging::PolicyValue *
 Messaging::PolicyValue_var::_retn (void)
 {
-  Messaging::PolicyValue *tmp = this->ptr_;
+  ::Messaging::PolicyValue *tmp = this->ptr_;
   this->ptr_ = 0;
   return tmp;
 }
 
-ACE_INLINE Messaging::PolicyValue *
+ACE_INLINE ::Messaging::PolicyValue *
 Messaging::PolicyValue_var::ptr (void) const
 {
   return this->ptr_;
@@ -2832,14 +2802,14 @@ Messaging::PolicyValue_var::ptr (void) const
 // *************************************************************
 
 ACE_INLINE
-Messaging::PolicyValue_out::PolicyValue_out (Messaging::PolicyValue *&p)
+Messaging::PolicyValue_out::PolicyValue_out (::Messaging::PolicyValue *&p)
   : ptr_ (p)
 {
   this->ptr_ = 0;
 }
 
 ACE_INLINE
-Messaging::PolicyValue_out::PolicyValue_out (Messaging::PolicyValue_var &p) // constructor from _var
+Messaging::PolicyValue_out::PolicyValue_out (PolicyValue_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   delete this->ptr_;
@@ -2847,177 +2817,197 @@ Messaging::PolicyValue_out::PolicyValue_out (Messaging::PolicyValue_var &p) // c
 }
 
 ACE_INLINE
-Messaging::PolicyValue_out::PolicyValue_out (const Messaging::PolicyValue_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (Messaging::PolicyValue_out&,p).ptr_)
+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)
+Messaging::PolicyValue_out::operator= (const ::Messaging::PolicyValue_out &p)
 {
-  this->ptr_ = ACE_const_cast (Messaging::PolicyValue_out&,p).ptr_;
+  this->ptr_ = ACE_const_cast (PolicyValue_out&, p).ptr_;
   return *this;
 }
 
 ACE_INLINE Messaging::PolicyValue_out &
-Messaging::PolicyValue_out::operator= (Messaging::PolicyValue *p)
+Messaging::PolicyValue_out::operator= (PolicyValue *p)
 {
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE
-Messaging::PolicyValue_out::operator Messaging::PolicyValue *&() // cast
+ACE_INLINE 
+Messaging::PolicyValue_out::operator ::Messaging::PolicyValue *&() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::PolicyValue *&
+ACE_INLINE ::Messaging::PolicyValue *&
 Messaging::PolicyValue_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::PolicyValue *
+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::PolicyValueSeq_var
+// Inline operations for class Messaging::PolicyValue::_tao_seq_Octet_var
 // *************************************************************
 
 ACE_INLINE
-Messaging::PolicyValueSeq_var::PolicyValueSeq_var (void) // default constructor
+Messaging::PolicyValue::_tao_seq_Octet_var::_tao_seq_Octet_var (void) // default constructor
   : ptr_ (0)
 {}
 
 ACE_INLINE
-Messaging::PolicyValueSeq_var::PolicyValueSeq_var (Messaging::PolicyValueSeq *p)
+Messaging::PolicyValue::_tao_seq_Octet_var::_tao_seq_Octet_var (_tao_seq_Octet *p)
   : ptr_ (p)
 {}
 
 ACE_INLINE
-Messaging::PolicyValueSeq_var::PolicyValueSeq_var (const Messaging::PolicyValueSeq_var &p) // copy constructor
+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::PolicyValueSeq (*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::PolicyValueSeq_var::~PolicyValueSeq_var (void) // destructor
+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::PolicyValueSeq_var &
-Messaging::PolicyValueSeq_var::operator= (Messaging::PolicyValueSeq *p)
+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::PolicyValueSeq_var &
-Messaging::PolicyValueSeq_var::operator= (const Messaging::PolicyValueSeq_var &p) // deep copy
+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::PolicyValueSeq (*p.ptr_),
-                    *this);
+    ACE_NEW_RETURN (this->ptr_, ::Messaging::PolicyValue::_tao_seq_Octet (*p.ptr_), *this);
   }
   return *this;
 }
 
-ACE_INLINE const Messaging::PolicyValueSeq *
-Messaging::PolicyValueSeq_var::operator-> (void) const
+// 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::PolicyValueSeq *
-Messaging::PolicyValueSeq_var::operator-> (void)
+ACE_INLINE ::Messaging::PolicyValue::_tao_seq_Octet *
+Messaging::PolicyValue::_tao_seq_Octet_var::operator-> (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE
-Messaging::PolicyValueSeq_var::operator const Messaging::PolicyValueSeq &() const // cast
+ACE_INLINE 
+Messaging::PolicyValue::_tao_seq_Octet_var::operator const ::Messaging::PolicyValue::_tao_seq_Octet &() const // cast
 {
   return *this->ptr_;
 }
 
-ACE_INLINE
-Messaging::PolicyValueSeq_var::operator Messaging::PolicyValueSeq &() // cast
+ACE_INLINE 
+Messaging::PolicyValue::_tao_seq_Octet_var::operator ::Messaging::PolicyValue::_tao_seq_Octet &() // cast 
 {
   return *this->ptr_;
 }
 
-ACE_INLINE
-Messaging::PolicyValueSeq_var::operator Messaging::PolicyValueSeq &() const// cast
+ACE_INLINE 
+Messaging::PolicyValue::_tao_seq_Octet_var::operator ::Messaging::PolicyValue::_tao_seq_Octet &() const // cast 
 {
   return *this->ptr_;
 }
 
-ACE_INLINE Messaging::PolicyValue &
-Messaging::PolicyValueSeq_var::operator[] (CORBA::ULong slot)
+ACE_INLINE CORBA::Octet &
+Messaging::PolicyValue::_tao_seq_Octet_var::operator[] (CORBA::ULong index)
 {
-  return this->ptr_->operator[] (slot);
+  return this->ptr_->operator[] (index);
 }
 
-ACE_INLINE const Messaging::PolicyValueSeq &
-Messaging::PolicyValueSeq_var::in (void) const
+ACE_INLINE const ::Messaging::PolicyValue::_tao_seq_Octet &
+Messaging::PolicyValue::_tao_seq_Octet_var::in (void) const
 {
   return *this->ptr_;
 }
 
-ACE_INLINE Messaging::PolicyValueSeq &
-Messaging::PolicyValueSeq_var::inout (void)
+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::PolicyValueSeq *&
-Messaging::PolicyValueSeq_var::out (void)
+// 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::PolicyValueSeq *
-Messaging::PolicyValueSeq_var::_retn (void)
+ACE_INLINE ::Messaging::PolicyValue::_tao_seq_Octet *
+Messaging::PolicyValue::_tao_seq_Octet_var::_retn (void)
 {
-  Messaging::PolicyValueSeq *tmp = this->ptr_;
+  ::Messaging::PolicyValue::_tao_seq_Octet *tmp = this->ptr_;
   this->ptr_ = 0;
   return tmp;
 }
 
-ACE_INLINE Messaging::PolicyValueSeq *
-Messaging::PolicyValueSeq_var::ptr (void) const
+ACE_INLINE ::Messaging::PolicyValue::_tao_seq_Octet *
+Messaging::PolicyValue::_tao_seq_Octet_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 // *************************************************************
-// Inline operations for class Messaging::PolicyValueSeq_out
+// Inline operations for class Messaging::PolicyValue::_tao_seq_Octet_out
 // *************************************************************
 
 ACE_INLINE
-Messaging::PolicyValueSeq_out::PolicyValueSeq_out (Messaging::PolicyValueSeq *&p)
+Messaging::PolicyValue::_tao_seq_Octet_out::_tao_seq_Octet_out (_tao_seq_Octet *&p)
   : ptr_ (p)
 {
   this->ptr_ = 0;
 }
 
 ACE_INLINE
-Messaging::PolicyValueSeq_out::PolicyValueSeq_out (Messaging::PolicyValueSeq_var &p) // constructor from _var
+Messaging::PolicyValue::_tao_seq_Octet_out::_tao_seq_Octet_out (_tao_seq_Octet_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   delete this->ptr_;
@@ -3025,183 +3015,369 @@ Messaging::PolicyValueSeq_out::PolicyValueSeq_out (Messaging::PolicyValueSeq_var
 }
 
 ACE_INLINE
-Messaging::PolicyValueSeq_out::PolicyValueSeq_out (const Messaging::PolicyValueSeq_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (Messaging::PolicyValueSeq_out&,p).ptr_)
+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::PolicyValueSeq_out &
-Messaging::PolicyValueSeq_out::operator= (const Messaging::PolicyValueSeq_out &p)
+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 (Messaging::PolicyValueSeq_out&,p).ptr_;
+  this->ptr_ = ACE_const_cast (_tao_seq_Octet_out&, p).ptr_;
   return *this;
 }
 
-ACE_INLINE Messaging::PolicyValueSeq_out &
-Messaging::PolicyValueSeq_out::operator= (Messaging::PolicyValueSeq *p)
+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::PolicyValueSeq_out::operator Messaging::PolicyValueSeq *&() // cast
+ACE_INLINE 
+Messaging::PolicyValue::_tao_seq_Octet_out::operator ::Messaging::PolicyValue::_tao_seq_Octet *&() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::PolicyValueSeq *&
-Messaging::PolicyValueSeq_out::ptr (void) // ptr
+ACE_INLINE ::Messaging::PolicyValue::_tao_seq_Octet *&
+Messaging::PolicyValue::_tao_seq_Octet_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::PolicyValueSeq *
-Messaging::PolicyValueSeq_out::operator-> (void)
+ACE_INLINE ::Messaging::PolicyValue::_tao_seq_Octet *
+Messaging::PolicyValue::_tao_seq_Octet_out::operator-> (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::PolicyValue &
-Messaging::PolicyValueSeq_out::operator[] (CORBA::ULong slot)
+ACE_INLINE CORBA::Octet &
+Messaging::PolicyValue::_tao_seq_Octet_out::operator[] (CORBA::ULong index)
 {
-  return this->ptr_->operator[] (slot);
+  return this->ptr_->operator[] (index);
 }
 
 
-#if (TAO_HAS_AMI_CALLBACK == 1)
+#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;
+      }
+      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::ExceptionHolder::_tao_seq_Octet_var
+// Inline operations for class Messaging::PolicyValueSeq_var
 // *************************************************************
 
 ACE_INLINE
-Messaging::ExceptionHolder::_tao_seq_Octet_var::_tao_seq_Octet_var (void) // default constructor
+Messaging::PolicyValueSeq_var::PolicyValueSeq_var (void) // default constructor
   : ptr_ (0)
 {}
 
 ACE_INLINE
-Messaging::ExceptionHolder::_tao_seq_Octet_var::_tao_seq_Octet_var (Messaging::ExceptionHolder::_tao_seq_Octet *p)
+Messaging::PolicyValueSeq_var::PolicyValueSeq_var (PolicyValueSeq *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
+Messaging::PolicyValueSeq_var::PolicyValueSeq_var (const ::Messaging::PolicyValueSeq_var &p) // copy constructor
 {
   if (p.ptr_)
-    ACE_NEW (this->ptr_, Messaging::ExceptionHolder::_tao_seq_Octet (*p.ptr_));
+    ACE_NEW (this->ptr_, ::Messaging::PolicyValueSeq (*p.ptr_));
   else
     this->ptr_ = 0;
 }
 
 ACE_INLINE
-Messaging::ExceptionHolder::_tao_seq_Octet_var::~_tao_seq_Octet_var (void) // destructor
+Messaging::PolicyValueSeq_var::~PolicyValueSeq_var (void) // destructor
 {
   delete this->ptr_;
 }
 
-ACE_INLINE Messaging::ExceptionHolder::_tao_seq_Octet_var &
-Messaging::ExceptionHolder::_tao_seq_Octet_var::operator= (Messaging::ExceptionHolder::_tao_seq_Octet *p)
+ACE_INLINE Messaging::PolicyValueSeq_var &
+Messaging::PolicyValueSeq_var::operator= (PolicyValueSeq *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
+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::ExceptionHolder::_tao_seq_Octet (*p.ptr_), *this);
+    ACE_NEW_RETURN (this->ptr_, ::Messaging::PolicyValueSeq (*p.ptr_), *this);
   }
   return *this;
 }
 
-ACE_INLINE const Messaging::ExceptionHolder::_tao_seq_Octet *
-Messaging::ExceptionHolder::_tao_seq_Octet_var::operator-> (void) const
+ACE_INLINE const ::Messaging::PolicyValueSeq *
+Messaging::PolicyValueSeq_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::ExceptionHolder::_tao_seq_Octet *
-Messaging::ExceptionHolder::_tao_seq_Octet_var::operator-> (void)
+ACE_INLINE ::Messaging::PolicyValueSeq *
+Messaging::PolicyValueSeq_var::operator-> (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE
-Messaging::ExceptionHolder::_tao_seq_Octet_var::operator const Messaging::ExceptionHolder::_tao_seq_Octet &() const // cast
+ACE_INLINE 
+Messaging::PolicyValueSeq_var::operator const ::Messaging::PolicyValueSeq &() const // cast
 {
   return *this->ptr_;
 }
 
-ACE_INLINE
-Messaging::ExceptionHolder::_tao_seq_Octet_var::operator Messaging::ExceptionHolder::_tao_seq_Octet &() // cast
+ACE_INLINE 
+Messaging::PolicyValueSeq_var::operator ::Messaging::PolicyValueSeq &() // cast 
 {
   return *this->ptr_;
 }
 
-ACE_INLINE
-Messaging::ExceptionHolder::_tao_seq_Octet_var::operator Messaging::ExceptionHolder::_tao_seq_Octet &() const// cast
+ACE_INLINE 
+Messaging::PolicyValueSeq_var::operator ::Messaging::PolicyValueSeq &() const // cast 
 {
   return *this->ptr_;
 }
 
-ACE_INLINE CORBA::Octet &
-Messaging::ExceptionHolder::_tao_seq_Octet_var::operator[] (CORBA::ULong index)
+// 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::ExceptionHolder::_tao_seq_Octet &
-Messaging::ExceptionHolder::_tao_seq_Octet_var::in (void) const
+ACE_INLINE const ::Messaging::PolicyValueSeq &
+Messaging::PolicyValueSeq_var::in (void) const
 {
   return *this->ptr_;
 }
 
-ACE_INLINE Messaging::ExceptionHolder::_tao_seq_Octet &
-Messaging::ExceptionHolder::_tao_seq_Octet_var::inout (void)
+ACE_INLINE ::Messaging::PolicyValueSeq &
+Messaging::PolicyValueSeq_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)
+// 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::ExceptionHolder::_tao_seq_Octet *
-Messaging::ExceptionHolder::_tao_seq_Octet_var::_retn (void)
+ACE_INLINE ::Messaging::PolicyValueSeq *
+Messaging::PolicyValueSeq_var::_retn (void)
 {
-  Messaging::ExceptionHolder::_tao_seq_Octet *tmp = this->ptr_;
+  ::Messaging::PolicyValueSeq *tmp = this->ptr_;
   this->ptr_ = 0;
   return tmp;
 }
 
-ACE_INLINE Messaging::ExceptionHolder::_tao_seq_Octet *
-Messaging::ExceptionHolder::_tao_seq_Octet_var::ptr (void) const
+ACE_INLINE ::Messaging::PolicyValueSeq *
+Messaging::PolicyValueSeq_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 // *************************************************************
-// Inline operations for class Messaging::ExceptionHolder::_tao_seq_Octet_out
+// Inline operations for class Messaging::PolicyValueSeq_out
 // *************************************************************
 
 ACE_INLINE
-Messaging::ExceptionHolder::_tao_seq_Octet_out::_tao_seq_Octet_out (Messaging::ExceptionHolder::_tao_seq_Octet *&p)
+Messaging::PolicyValueSeq_out::PolicyValueSeq_out (PolicyValueSeq *&p)
   : ptr_ (p)
 {
   this->ptr_ = 0;
 }
 
 ACE_INLINE
-Messaging::ExceptionHolder::_tao_seq_Octet_out::_tao_seq_Octet_out (Messaging::ExceptionHolder::_tao_seq_Octet_var &p) // constructor from _var
+Messaging::PolicyValueSeq_out::PolicyValueSeq_out (PolicyValueSeq_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   delete this->ptr_;
@@ -3209,64 +3385,69 @@ Messaging::ExceptionHolder::_tao_seq_Octet_out::_tao_seq_Octet_out (Messaging::E
 }
 
 ACE_INLINE
-Messaging::ExceptionHolder::_tao_seq_Octet_out::_tao_seq_Octet_out (const Messaging::ExceptionHolder::_tao_seq_Octet_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (Messaging::ExceptionHolder::_tao_seq_Octet_out&,p).ptr_)
+Messaging::PolicyValueSeq_out::PolicyValueSeq_out (const ::Messaging::PolicyValueSeq_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (PolicyValueSeq_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)
+ACE_INLINE ::Messaging::PolicyValueSeq_out &
+Messaging::PolicyValueSeq_out::operator= (const ::Messaging::PolicyValueSeq_out &p)
 {
-  this->ptr_ = ACE_const_cast (Messaging::ExceptionHolder::_tao_seq_Octet_out&,p).ptr_;
+  this->ptr_ = ACE_const_cast (PolicyValueSeq_out&, p).ptr_;
   return *this;
 }
 
-ACE_INLINE Messaging::ExceptionHolder::_tao_seq_Octet_out &
-Messaging::ExceptionHolder::_tao_seq_Octet_out::operator= (Messaging::ExceptionHolder::_tao_seq_Octet *p)
+ACE_INLINE ::Messaging::PolicyValueSeq_out &
+Messaging::PolicyValueSeq_out::operator= (PolicyValueSeq *p)
 {
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE
-Messaging::ExceptionHolder::_tao_seq_Octet_out::operator Messaging::ExceptionHolder::_tao_seq_Octet *&() // cast
+ACE_INLINE 
+Messaging::PolicyValueSeq_out::operator ::Messaging::PolicyValueSeq *&() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::ExceptionHolder::_tao_seq_Octet *&
-Messaging::ExceptionHolder::_tao_seq_Octet_out::ptr (void) // ptr
+ACE_INLINE ::Messaging::PolicyValueSeq *&
+Messaging::PolicyValueSeq_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::ExceptionHolder::_tao_seq_Octet *
-Messaging::ExceptionHolder::_tao_seq_Octet_out::operator-> (void)
+ACE_INLINE ::Messaging::PolicyValueSeq *
+Messaging::PolicyValueSeq_out::operator-> (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA::Octet &
-Messaging::ExceptionHolder::_tao_seq_Octet_out::operator[] (CORBA::ULong index)
+ACE_INLINE Messaging::PolicyValue &
+Messaging::PolicyValueSeq_out::operator[] (CORBA::ULong index)
 {
   return this->ptr_->operator[] (index);
 }
 
 
+#endif /* end #if !defined */
 
 ACE_INLINE
-Messaging::ExceptionHolder::ExceptionHolder (void) // default constructor
+Messaging::ExceptionHolder::ExceptionHolder () // default constructor
 {}
 
 ACE_INLINE
-Messaging::ExceptionHolder::~ExceptionHolder (void) // destructor
+Messaging::ExceptionHolder::~ExceptionHolder () // destructor
 {}
 
-ACE_INLINE const char*
+ACE_INLINE const char* 
 Messaging::ExceptionHolder::_tao_obv_static_repository_id ()
 {
-  return "IDL:Messaging/ExceptionHolder:1.0";
+  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
 // *************************************************************
@@ -3286,7 +3467,7 @@ Messaging::ExceptionHolder_var::ExceptionHolder_var (const Messaging::ExceptionH
   : ptr_ (ACE_const_cast(Messaging::ExceptionHolder*, p))
 {}
 
-ACE_INLINE Messaging::ExceptionHolder*
+ACE_INLINE Messaging::ExceptionHolder* 
 Messaging::ExceptionHolder_var::ptr (void) const
 {
   return this->ptr_;
@@ -3326,19 +3507,19 @@ Messaging::ExceptionHolder_var::operator= (const Messaging::ExceptionHolder_var
   return *this;
 }
 
-ACE_INLINE
+ACE_INLINE 
 Messaging::ExceptionHolder_var::operator const Messaging::ExceptionHolder* () const // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE
-Messaging::ExceptionHolder_var::operator Messaging::ExceptionHolder* () // cast
+ACE_INLINE 
+Messaging::ExceptionHolder_var::operator Messaging::ExceptionHolder* () // cast 
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::ExceptionHolder*
+ACE_INLINE Messaging::ExceptionHolder* 
 Messaging::ExceptionHolder_var::operator-> (void) const
 {
   return this->ptr_;
@@ -3364,7 +3545,7 @@ Messaging::ExceptionHolder_var::out (void)
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::ExceptionHolder*
+ACE_INLINE Messaging::ExceptionHolder* 
 Messaging::ExceptionHolder_var::_retn (void)
 {
   // yield ownership of managed obj reference
@@ -3374,6 +3555,12 @@ Messaging::ExceptionHolder_var::_retn (void)
 }
 
 
+#endif /* end #if !defined */
+
+
+#if !defined (_MESSAGING_EXCEPTIONHOLDER___OUT_CI_)
+#define _MESSAGING_EXCEPTIONHOLDER___OUT_CI_
+
 // *************************************************************
 // Inline operations for class Messaging::ExceptionHolder_out
 // *************************************************************
@@ -3421,7 +3608,7 @@ Messaging::ExceptionHolder_out::operator= (Messaging::ExceptionHolder* p)
   return *this;
 }
 
-ACE_INLINE
+ACE_INLINE 
 Messaging::ExceptionHolder_out::operator Messaging::ExceptionHolder* &() // cast
 {
   return this->ptr_;
@@ -3433,16 +3620,14 @@ Messaging::ExceptionHolder_out::ptr (void) // ptr
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::ExceptionHolder*
+ACE_INLINE Messaging::ExceptionHolder* 
 Messaging::ExceptionHolder_out::operator-> (void)
 {
   return this->ptr_;
 }
 
 
-
-// ****************************************************************
-
+#endif /* end #if !defined */
 
 ACE_INLINE
 Messaging::ReplyHandler::ReplyHandler (void) // default constructor
@@ -3457,19 +3642,9 @@ ACE_INLINE
 Messaging::ReplyHandler::~ReplyHandler (void) // destructor
 {}
 
-ACE_INLINE Messaging::ReplyHandler_ptr
-Messaging::ReplyHandler::_duplicate (Messaging::ReplyHandler_ptr obj)
-{
-  if (!CORBA::is_nil (obj))
-    obj->_add_ref ();
-  return obj;
-}
 
-ACE_INLINE Messaging::ReplyHandler_ptr
-Messaging::ReplyHandler::_nil (void)
-{
-  return (Messaging::ReplyHandler_ptr)0;
-}
+#if !defined (_MESSAGING_REPLYHANDLER___VAR_CI_)
+#define _MESSAGING_REPLYHANDLER___VAR_CI_
 
 // *************************************************************
 // Inline operations for class Messaging::ReplyHandler_var
@@ -3477,23 +3652,23 @@ Messaging::ReplyHandler::_nil (void)
 
 ACE_INLINE
 Messaging::ReplyHandler_var::ReplyHandler_var (void) // default constructor
-  : ptr_ (Messaging::ReplyHandler::_nil ())
+  : ptr_ (ReplyHandler::_nil ())
 {}
 
 ACE_INLINE
-Messaging::ReplyHandler_var::ReplyHandler_var (Messaging::ReplyHandler_ptr p)
+Messaging::ReplyHandler_var::ReplyHandler_var (ReplyHandler_ptr p)
   : ptr_ (p)
 {}
 
-ACE_INLINE Messaging::ReplyHandler_ptr
+ACE_INLINE ::Messaging::ReplyHandler_ptr
 Messaging::ReplyHandler_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 ACE_INLINE
-Messaging::ReplyHandler_var::ReplyHandler_var (const Messaging::ReplyHandler_var &p) // copy constructor
-  : ptr_ (Messaging::ReplyHandler::_duplicate (p.ptr ()))
+Messaging::ReplyHandler_var::ReplyHandler_var (const ::Messaging::ReplyHandler_var &p) // copy constructor
+  : ptr_ (ReplyHandler::_duplicate (p.ptr ()))
 {}
 
 ACE_INLINE
@@ -3503,7 +3678,7 @@ Messaging::ReplyHandler_var::~ReplyHandler_var (void) // destructor
 }
 
 ACE_INLINE Messaging::ReplyHandler_var &
-Messaging::ReplyHandler_var::operator= (Messaging::ReplyHandler_ptr p)
+Messaging::ReplyHandler_var::operator= (ReplyHandler_ptr p)
 {
   CORBA::release (this->ptr_);
   this->ptr_ = p;
@@ -3511,156 +3686,153 @@ Messaging::ReplyHandler_var::operator= (Messaging::ReplyHandler_ptr p)
 }
 
 ACE_INLINE Messaging::ReplyHandler_var &
-Messaging::ReplyHandler_var::operator= (const Messaging::ReplyHandler_var &p)
+Messaging::ReplyHandler_var::operator= (const ::Messaging::ReplyHandler_var &p)
 {
   if (this != &p)
   {
     CORBA::release (this->ptr_);
-    this->ptr_ = Messaging::ReplyHandler::_duplicate (p.ptr ());
+    this->ptr_ = ::Messaging::ReplyHandler::_duplicate (p.ptr ());
   }
   return *this;
 }
 
-ACE_INLINE
-Messaging::ReplyHandler_var::operator const Messaging::ReplyHandler_ptr &() const // cast
+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
+ACE_INLINE 
+Messaging::ReplyHandler_var::operator ::Messaging::ReplyHandler_ptr &() // cast 
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::ReplyHandler_ptr
+ACE_INLINE ::Messaging::ReplyHandler_ptr
 Messaging::ReplyHandler_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::ReplyHandler_ptr
+ACE_INLINE ::Messaging::ReplyHandler_ptr
 Messaging::ReplyHandler_var::in (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::ReplyHandler_ptr &
+ACE_INLINE ::Messaging::ReplyHandler_ptr &
 Messaging::ReplyHandler_var::inout (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::ReplyHandler_ptr &
+ACE_INLINE ::Messaging::ReplyHandler_ptr &
 Messaging::ReplyHandler_var::out (void)
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = Messaging::ReplyHandler::_nil ();
+  this->ptr_ = ::Messaging::ReplyHandler::_nil ();
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::ReplyHandler_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 ();
+  ::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 (Messaging::ReplyHandler_ptr &p)
+Messaging::ReplyHandler_out::ReplyHandler_out (ReplyHandler_ptr &p)
   : ptr_ (p)
 {
-  this->ptr_ = Messaging::ReplyHandler::_nil ();
+  this->ptr_ = ::Messaging::ReplyHandler::_nil ();
 }
 
 ACE_INLINE
-Messaging::ReplyHandler_out::ReplyHandler_out (Messaging::ReplyHandler_var &p) // constructor from _var
+Messaging::ReplyHandler_out::ReplyHandler_out (ReplyHandler_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = Messaging::ReplyHandler::_nil ();
+  this->ptr_ = ::Messaging::ReplyHandler::_nil ();
 }
 
 ACE_INLINE
-Messaging::ReplyHandler_out::ReplyHandler_out (const Messaging::ReplyHandler_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (Messaging::ReplyHandler_out&,p).ptr_)
+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)
+ACE_INLINE ::Messaging::ReplyHandler_out &
+Messaging::ReplyHandler_out::operator= (const ::Messaging::ReplyHandler_out &p)
 {
-  this->ptr_ = ACE_const_cast (Messaging::ReplyHandler_out&,p).ptr_;
+  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)
+Messaging::ReplyHandler_out::operator= (const ::Messaging::ReplyHandler_var &p)
 {
-  this->ptr_ = Messaging::ReplyHandler::_duplicate (p.ptr ());
+  this->ptr_ = ::Messaging::ReplyHandler::_duplicate (p.ptr ());
   return *this;
 }
 
 ACE_INLINE Messaging::ReplyHandler_out &
-Messaging::ReplyHandler_out::operator= (Messaging::ReplyHandler_ptr p)
+Messaging::ReplyHandler_out::operator= (ReplyHandler_ptr p)
 {
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE
-Messaging::ReplyHandler_out::operator Messaging::ReplyHandler_ptr &() // cast
+ACE_INLINE 
+Messaging::ReplyHandler_out::operator ::Messaging::ReplyHandler_ptr &() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::ReplyHandler_ptr &
+ACE_INLINE ::Messaging::ReplyHandler_ptr &
 Messaging::ReplyHandler_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::ReplyHandler_ptr
+ACE_INLINE ::Messaging::ReplyHandler_ptr
 Messaging::ReplyHandler_out::operator-> (void)
 {
   return this->ptr_;
 }
 
-#endif /* TAO_HAS_AMI_CALLBACK == 1 */
 
-#if (TAO_HAS_AMI_POLLER == 1)
+#endif /* end #if !defined */
 
 ACE_INLINE
-Messaging::Poller::Poller (void) // default constructor
+Messaging::Poller::Poller () // default constructor
 {}
 
 ACE_INLINE
-Messaging::Poller::Poller (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
-  : CORBA_Object (objref, _tao_servant, _tao_collocated)
+Messaging::Poller::~Poller () // destructor
 {}
 
-ACE_INLINE
-Messaging::Poller::~Poller (void) // destructor
-{}
-
-ACE_INLINE Messaging::Poller_ptr
-Messaging::Poller::_duplicate (Messaging::Poller_ptr obj)
+ACE_INLINE const char* 
+Messaging::Poller::_tao_obv_static_repository_id ()
 {
-  if (!CORBA::is_nil (obj))
-    obj->_add_ref ();
-  return obj;
+  return "IDL:omg.org/Messaging/Poller:1.0";
 }
 
-ACE_INLINE Messaging::Poller_ptr
-Messaging::Poller::_nil (void)
-{
-  return (Messaging::Poller_ptr)0;
-}
+
+#if !defined (_MESSAGING_POLLER___VAR_CI_)
+#define _MESSAGING_POLLER___VAR_CI_
 
 // *************************************************************
 // Inline operations for class Messaging::Poller_var
@@ -3668,15 +3840,20 @@ Messaging::Poller::_nil (void)
 
 ACE_INLINE
 Messaging::Poller_var::Poller_var (void) // default constructor
-  : ptr_ (Messaging::Poller::_nil ())
+  : ptr_ (0)
 {}
 
 ACE_INLINE
-Messaging::Poller_var::Poller_var (Messaging::Poller_ptr p)
+Messaging::Poller_var::Poller_var (Messaging::Poller* p)
   : ptr_ (p)
 {}
 
-ACE_INLINE Messaging::Poller_ptr
+ACE_INLINE
+Messaging::Poller_var::Poller_var (const Messaging::Poller* p)
+  : ptr_ (ACE_const_cast(Messaging::Poller*, p))
+{}
+
+ACE_INLINE Messaging::Poller* 
 Messaging::Poller_var::ptr (void) const
 {
   return this->ptr_;
@@ -3684,19 +3861,21 @@ Messaging::Poller_var::ptr (void) const
 
 ACE_INLINE
 Messaging::Poller_var::Poller_var (const Messaging::Poller_var &p) // copy constructor
-  : ptr_ (Messaging::Poller::_duplicate (p.ptr ()))
-{}
+{
+  CORBA::add_ref (p.ptr ());
+  this->ptr_ = p.ptr ();
+}
 
 ACE_INLINE
 Messaging::Poller_var::~Poller_var (void) // destructor
 {
-  CORBA::release (this->ptr_);
+  CORBA::remove_ref (this->ptr_);
 }
 
 ACE_INLINE Messaging::Poller_var &
-Messaging::Poller_var::operator= (Messaging::Poller_ptr p)
+Messaging::Poller_var::operator= (Messaging::Poller* p)
 {
-  CORBA::release (this->ptr_);
+  CORBA::remove_ref (this->ptr_);
   this->ptr_ = p;
   return *this;
 }
@@ -3706,76 +3885,85 @@ Messaging::Poller_var::operator= (const Messaging::Poller_var &p)
 {
   if (this != &p)
   {
-    CORBA::release (this->ptr_);
-    this->ptr_ = Messaging::Poller::_duplicate (p.ptr ());
+    CORBA::remove_ref (this->ptr_);
+    Poller* tmp = p.ptr ();
+    CORBA::add_ref (tmp);
+    this->ptr_ = tmp;
   }
   return *this;
 }
 
-ACE_INLINE
-Messaging::Poller_var::operator const Messaging::Poller_ptr &() const // cast
+ACE_INLINE 
+Messaging::Poller_var::operator const Messaging::Poller* () const // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE
-Messaging::Poller_var::operator Messaging::Poller_ptr &() // cast
+ACE_INLINE 
+Messaging::Poller_var::operator Messaging::Poller* () // cast 
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::Poller_ptr
+ACE_INLINE Messaging::Poller* 
 Messaging::Poller_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::Poller_ptr
+ACE_INLINE Messaging::Poller*
 Messaging::Poller_var::in (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::Poller_ptr &
+ACE_INLINE Messaging::Poller* &
 Messaging::Poller_var::inout (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::Poller_ptr &
+ACE_INLINE Messaging::Poller* &
 Messaging::Poller_var::out (void)
 {
-  CORBA::release (this->ptr_);
-  this->ptr_ = Messaging::Poller::_nil ();
+  CORBA::remove_ref (this->ptr_);
+  this->ptr_ = 0;
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::Poller_ptr
+ACE_INLINE Messaging::Poller* 
 Messaging::Poller_var::_retn (void)
 {
   // yield ownership of managed obj reference
-  Messaging::Poller_ptr val = this->ptr_;
-  this->ptr_ = Messaging::Poller::_nil ();
-  return val;
+  Poller* tmp = this->ptr_;
+  this->ptr_ = 0;
+  return tmp;
 }
 
+
+#endif /* end #if !defined */
+
+
+#if !defined (_MESSAGING_POLLER___OUT_CI_)
+#define _MESSAGING_POLLER___OUT_CI_
+
 // *************************************************************
 // Inline operations for class Messaging::Poller_out
 // *************************************************************
 
 ACE_INLINE
-Messaging::Poller_out::Poller_out (Messaging::Poller_ptr &p)
+Messaging::Poller_out::Poller_out (Messaging::Poller* &p)
   : ptr_ (p)
 {
-  this->ptr_ = Messaging::Poller::_nil ();
+  this->ptr_ = 0;
 }
 
 ACE_INLINE
 Messaging::Poller_out::Poller_out (Messaging::Poller_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
-  CORBA::release (this->ptr_);
-  this->ptr_ = Messaging::Poller::_nil ();
+  CORBA::remove_ref (this->ptr_);
+  this->ptr_ = 0;
 }
 
 ACE_INLINE
@@ -3793,141 +3981,41 @@ Messaging::Poller_out::operator= (const Messaging::Poller_out &p)
 ACE_INLINE Messaging::Poller_out &
 Messaging::Poller_out::operator= (const Messaging::Poller_var &p)
 {
-  this->ptr_ = Messaging::Poller::_duplicate (p.ptr ());
+  Poller* tmp = p.ptr ();
+  CORBA::add_ref (tmp);
+  this->ptr_ = tmp;
   return *this;
 }
 
 ACE_INLINE Messaging::Poller_out &
-Messaging::Poller_out::operator= (Messaging::Poller_ptr p)
+Messaging::Poller_out::operator= (Messaging::Poller* p)
 {
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE
-Messaging::Poller_out::operator Messaging::Poller_ptr &() // cast
+ACE_INLINE 
+Messaging::Poller_out::operator Messaging::Poller* &() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::Poller_ptr &
+ACE_INLINE Messaging::Poller* &
 Messaging::Poller_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE Messaging::Poller_ptr
+ACE_INLINE Messaging::Poller* 
 Messaging::Poller_out::operator-> (void)
 {
   return this->ptr_;
 }
 
-#endif /* TAO_HAS_AMI_POLLER == 1 */
-
-// ****************************************************************
-
-#if (TAO_HAS_REBIND_POLICY == 1)
-
-ACE_INLINE CORBA::Boolean
-operator<< (
-    TAO_OutputCDR &strm,
-    const Messaging::RebindPolicy_ptr _tao_objref
-  )
-{
-  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
-  return (strm << _tao_corba_obj);
-}
-
-ACE_INLINE CORBA::Boolean
-operator>> (
-    TAO_InputCDR &strm,
-    Messaging::RebindPolicy_ptr &_tao_objref
-  )
-{
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::Object_var obj;
-    if ((strm >> obj.inout ()) == 0)
-      return 0;
-    // narrow to the right type
-    _tao_objref =
-      Messaging::RebindPolicy::_narrow (
-          obj.in (),
-          ACE_TRY_ENV
-        );
-    ACE_TRY_CHECK;
-    return 1;
-  }
-  ACE_CATCHANY
-  {
-    // do nothing
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-#endif /* TAO_HAS_REBIND_POLICY == 1 */
-
-#if (TAO_HAS_SYNC_SCOPE_POLICY == 1)
-
-ACE_INLINE CORBA::Boolean
-operator<< (
-    TAO_OutputCDR &,
-    const Messaging::SyncScopePolicy_ptr
-  );
-ACE_INLINE CORBA::Boolean
-operator>> (
-    TAO_InputCDR &,
-    Messaging::SyncScopePolicy_ptr &
-  );
-
-ACE_INLINE CORBA::Boolean
-operator<< (
-    TAO_OutputCDR &strm,
-    const Messaging::SyncScopePolicy_ptr _tao_objref
-  )
-{
-  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
-  return (strm << _tao_corba_obj);
-}
-
-ACE_INLINE CORBA::Boolean
-operator>> (
-    TAO_InputCDR &strm,
-    Messaging::SyncScopePolicy_ptr &_tao_objref
-  )
-{
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::Object_var obj;
-    if ((strm >> obj.inout ()) == 0)
-      return 0;
-    // narrow to the right type
-    _tao_objref =
-      Messaging::SyncScopePolicy::_narrow (
-          obj.in (),
-          ACE_TRY_ENV
-        );
-    ACE_TRY_CHECK;
-    return 1;
-  }
-  ACE_CATCHANY
-  {
-    // do nothing
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-#endif /* TAO_HAS_SYNC_SCOPE_POLICY == 1 */
 
-#if (TAO_HAS_PRIORITY_POLICIES == 1)
+#endif /* end #if !defined */
 
-ACE_INLINE CORBA::Boolean
-operator<< (
-    TAO_OutputCDR &strm,
-    const Messaging::PriorityRange &_tao_aggregate
-  )
+ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const Messaging::PriorityRange &_tao_aggregate)
 {
   if (
     (strm << _tao_aggregate.min) &&
@@ -3936,14 +4024,10 @@ operator<< (
     return 1;
   else
     return 0;
-
+  
 }
 
-ACE_INLINE CORBA::Boolean
-operator>> (
-    TAO_InputCDR &strm,
-    Messaging::PriorityRange &_tao_aggregate
-  )
+ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, Messaging::PriorityRange &_tao_aggregate)
 {
   if (
     (strm >> _tao_aggregate.min) &&
@@ -3952,346 +4036,10 @@ operator>> (
     return 1;
   else
     return 0;
-
+  
 }
 
-ACE_INLINE CORBA::Boolean
-operator<< (
-    TAO_OutputCDR &strm,
-    const Messaging::RequestPriorityPolicy_ptr _tao_objref
-  )
-{
-  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
-  return (strm << _tao_corba_obj);
-}
-
-ACE_INLINE CORBA::Boolean
-operator>> (
-    TAO_InputCDR &strm,
-    Messaging::RequestPriorityPolicy_ptr &_tao_objref
-  )
-{
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::Object_var obj;
-    if ((strm >> obj.inout ()) == 0)
-      return 0;
-    // narrow to the right type
-    _tao_objref =
-      Messaging::RequestPriorityPolicy::_narrow (
-          obj.in (),
-          ACE_TRY_ENV
-        );
-    ACE_TRY_CHECK;
-    return 1;
-  }
-  ACE_CATCHANY
-  {
-    // do nothing
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-ACE_INLINE CORBA::Boolean
-operator<< (
-    TAO_OutputCDR &strm,
-    const Messaging::ReplyPriorityPolicy_ptr _tao_objref
-  )
-{
-  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
-  return (strm << _tao_corba_obj);
-}
-
-ACE_INLINE CORBA::Boolean
-operator>> (
-    TAO_InputCDR &strm,
-    Messaging::ReplyPriorityPolicy_ptr &_tao_objref
-  )
-{
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::Object_var obj;
-    if ((strm >> obj.inout ()) == 0)
-      return 0;
-    // narrow to the right type
-    _tao_objref =
-      Messaging::ReplyPriorityPolicy::_narrow (
-          obj.in (),
-          ACE_TRY_ENV
-        );
-    ACE_TRY_CHECK;
-    return 1;
-  }
-  ACE_CATCHANY
-  {
-    // do nothing
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-#endif /* TAO_HAS_PRIORITY_POLICIES == 1 */
-
-#if (TAO_HAS_REQUEST_START_TIME_POLICY == 1)
-
-ACE_INLINE CORBA::Boolean
-operator<< (
-    TAO_OutputCDR &strm,
-    const Messaging::RequestStartTimePolicy_ptr _tao_objref
-  )
-{
-  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
-  return (strm << _tao_corba_obj);
-}
-
-ACE_INLINE CORBA::Boolean
-operator>> (
-    TAO_InputCDR &strm,
-    Messaging::RequestStartTimePolicy_ptr &_tao_objref
-  )
-{
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::Object_var obj;
-    if ((strm >> obj.inout ()) == 0)
-      return 0;
-    // narrow to the right type
-    _tao_objref =
-      Messaging::RequestStartTimePolicy::_narrow (
-          obj.in (),
-          ACE_TRY_ENV
-        );
-    ACE_TRY_CHECK;
-    return 1;
-  }
-  ACE_CATCHANY
-  {
-    // do nothing
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-#endif /* TAO_HAS_REQUEST_START_TIME_POLICY == 1 */
-
-#if (TAO_HAS_REQUEST_END_TIME_POLICY == 1)
-
-ACE_INLINE CORBA::Boolean
-operator<< (
-    TAO_OutputCDR &strm,
-    const Messaging::RequestEndTimePolicy_ptr _tao_objref
-  )
-{
-  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
-  return (strm << _tao_corba_obj);
-}
-
-ACE_INLINE CORBA::Boolean
-operator>> (
-    TAO_InputCDR &strm,
-    Messaging::RequestEndTimePolicy_ptr &_tao_objref
-  )
-{
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::Object_var obj;
-    if ((strm >> obj.inout ()) == 0)
-      return 0;
-    // narrow to the right type
-    _tao_objref =
-      Messaging::RequestEndTimePolicy::_narrow (
-          obj.in (),
-          ACE_TRY_ENV
-        );
-    ACE_TRY_CHECK;
-    return 1;
-  }
-  ACE_CATCHANY
-  {
-    // do nothing
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-#endif /* TAO_HAS_REQUEST_END_TIME_POLICY == 1 */
-
-#if (TAO_HAS_REPLY_START_TIME_POLICY == 1)
-
-ACE_INLINE CORBA::Boolean
-operator<< (
-    TAO_OutputCDR &strm,
-    const Messaging::ReplyStartTimePolicy_ptr _tao_objref
-  )
-{
-  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
-  return (strm << _tao_corba_obj);
-}
-
-ACE_INLINE CORBA::Boolean
-operator>> (
-    TAO_InputCDR &strm,
-    Messaging::ReplyStartTimePolicy_ptr &_tao_objref
-  )
-{
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::Object_var obj;
-    if ((strm >> obj.inout ()) == 0)
-      return 0;
-    // narrow to the right type
-    _tao_objref =
-      Messaging::ReplyStartTimePolicy::_narrow (
-          obj.in (),
-          ACE_TRY_ENV
-        );
-    ACE_TRY_CHECK;
-    return 1;
-  }
-  ACE_CATCHANY
-  {
-    // do nothing
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-#endif /* TAO_HAS_REPLY_START_TIME_POLICY == 1 */
-
-#if (TAO_HAS_REPLY_END_TIME_POLICY == 1)
-
-ACE_INLINE CORBA::Boolean
-operator<< (
-    TAO_OutputCDR &strm,
-    const Messaging::ReplyEndTimePolicy_ptr _tao_objref
-  )
-{
-  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
-  return (strm << _tao_corba_obj);
-}
-
-ACE_INLINE CORBA::Boolean
-operator>> (
-    TAO_InputCDR &strm,
-    Messaging::ReplyEndTimePolicy_ptr &_tao_objref
-  )
-{
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::Object_var obj;
-    if ((strm >> obj.inout ()) == 0)
-      return 0;
-    // narrow to the right type
-    _tao_objref =
-      Messaging::ReplyEndTimePolicy::_narrow (
-          obj.in (),
-          ACE_TRY_ENV
-        );
-    ACE_TRY_CHECK;
-    return 1;
-  }
-  ACE_CATCHANY
-  {
-    // do nothing
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-#endif /* TAO_HAS_REPLY_END_TIME_POLICY == 1 */
-
-#if (TAO_HAS_RELATIVE_REQUEST_TIMEOUT_POLICY == 1)
-
-ACE_INLINE CORBA::Boolean
-operator<< (
-    TAO_OutputCDR &strm,
-    const Messaging::RelativeRequestTimeoutPolicy_ptr _tao_objref
-  )
-{
-  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
-  return (strm << _tao_corba_obj);
-}
-
-ACE_INLINE CORBA::Boolean
-operator>> (
-    TAO_InputCDR &strm,
-    Messaging::RelativeRequestTimeoutPolicy_ptr &_tao_objref
-  )
-{
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::Object_var obj;
-    if ((strm >> obj.inout ()) == 0)
-      return 0;
-    // narrow to the right type
-    _tao_objref =
-      Messaging::RelativeRequestTimeoutPolicy::_narrow (
-          obj.in (),
-          ACE_TRY_ENV
-        );
-    ACE_TRY_CHECK;
-    return 1;
-  }
-  ACE_CATCHANY
-  {
-    // do nothing
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-#endif /* TAO_HAS_RELATIVE_REQUEST_TIMEOUT_POLICY == 1 */
-
-#if (TAO_HAS_RELATIVE_ROUNDTRIP_TIMEOUT_POLICY == 1)
-
-ACE_INLINE CORBA::Boolean
-operator<< (
-    TAO_OutputCDR &strm,
-    const Messaging::RelativeRoundtripTimeoutPolicy_ptr _tao_objref
-  )
-{
-  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
-  return (strm << _tao_corba_obj);
-}
-
-ACE_INLINE CORBA::Boolean
-operator>> (
-    TAO_InputCDR &strm,
-    Messaging::RelativeRoundtripTimeoutPolicy_ptr &_tao_objref
-  )
-{
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::Object_var obj;
-    if ((strm >> obj.inout ()) == 0)
-      return 0;
-    // narrow to the right type
-    _tao_objref =
-      Messaging::RelativeRoundtripTimeoutPolicy::_narrow (
-          obj.in (),
-          ACE_TRY_ENV
-        );
-    ACE_TRY_CHECK;
-    return 1;
-  }
-  ACE_CATCHANY
-  {
-    // do nothing
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-#endif /* TAO_HAS_RELATIVE_ROUNDTRIP_TIMEOUT_POLICY == 1 */
-
-#if (TAO_HAS_ROUTING_POLICY == 1)
-
-ACE_INLINE CORBA::Boolean
-operator<< (
-    TAO_OutputCDR &strm,
-    const Messaging::RoutingTypeRange &_tao_aggregate
-  )
+ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const Messaging::RoutingTypeRange &_tao_aggregate)
 {
   if (
     (strm << _tao_aggregate.min) &&
@@ -4300,14 +4048,10 @@ operator<< (
     return 1;
   else
     return 0;
-
+  
 }
 
-ACE_INLINE CORBA::Boolean
-operator>> (
-    TAO_InputCDR &strm,
-    Messaging::RoutingTypeRange &_tao_aggregate
-  )
+ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, Messaging::RoutingTypeRange &_tao_aggregate)
 {
   if (
     (strm >> _tao_aggregate.min) &&
@@ -4316,199 +4060,25 @@ operator>> (
     return 1;
   else
     return 0;
-
-}
-
-ACE_INLINE CORBA::Boolean
-operator<< (
-    TAO_OutputCDR &strm,
-    const Messaging::RoutingPolicy_ptr _tao_objref
-  )
-{
-  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
-  return (strm << _tao_corba_obj);
-}
-
-ACE_INLINE CORBA::Boolean
-operator>> (
-    TAO_InputCDR &strm,
-    Messaging::RoutingPolicy_ptr &_tao_objref
-  )
-{
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::Object_var obj;
-    if ((strm >> obj.inout ()) == 0)
-      return 0;
-    // narrow to the right type
-    _tao_objref =
-      Messaging::RoutingPolicy::_narrow (
-          obj.in (),
-          ACE_TRY_ENV
-        );
-    ACE_TRY_CHECK;
-    return 1;
-  }
-  ACE_CATCHANY
-  {
-    // do nothing
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-#endif /* TAO_HAS_ROUTING_POLICY == 1 */
-
-#if (TAO_HAS_MAX_HOPS_POLICY == 1)
-
-ACE_INLINE CORBA::Boolean
-operator<< (
-    TAO_OutputCDR &strm,
-    const Messaging::MaxHopsPolicy_ptr _tao_objref
-  )
-{
-  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
-  return (strm << _tao_corba_obj);
-}
-
-ACE_INLINE CORBA::Boolean
-operator>> (
-    TAO_InputCDR &strm,
-    Messaging::MaxHopsPolicy_ptr &_tao_objref
-  )
-{
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::Object_var obj;
-    if ((strm >> obj.inout ()) == 0)
-      return 0;
-    // narrow to the right type
-    _tao_objref =
-      Messaging::MaxHopsPolicy::_narrow (
-          obj.in (),
-          ACE_TRY_ENV
-        );
-    ACE_TRY_CHECK;
-    return 1;
-  }
-  ACE_CATCHANY
-  {
-    // do nothing
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-#endif /* TAO_HAS_MAX_HOPS_POLICY == 1 */
-
-#if (TAO_HAS_QUEUE_ORDER_POLICY == 1)
-
-ACE_INLINE CORBA::Boolean
-operator<< (
-    TAO_OutputCDR &strm,
-    const Messaging::QueueOrderPolicy_ptr _tao_objref
-  )
-{
-  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
-  return (strm << _tao_corba_obj);
-}
-
-ACE_INLINE CORBA::Boolean
-operator>> (
-    TAO_InputCDR &strm,
-    Messaging::QueueOrderPolicy_ptr &_tao_objref
-  )
-{
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::Object_var obj;
-    if ((strm >> obj.inout ()) == 0)
-      return 0;
-    // narrow to the right type
-    _tao_objref =
-      Messaging::QueueOrderPolicy::_narrow (
-          obj.in (),
-          ACE_TRY_ENV
-        );
-    ACE_TRY_CHECK;
-    return 1;
-  }
-  ACE_CATCHANY
-  {
-    // do nothing
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-#endif /* TAO_HAS_QUEUE_ORDER_POLICY == 1 */
-
-// ****************************************************************
-
-ACE_INLINE CORBA::Boolean operator<< (
-    TAO_OutputCDR &strm,
-    const Messaging::PolicyValue::_tao_seq_Octet &_tao_sequence
-  )
-{
-  if (strm << _tao_sequence.length ())
-  {
-    // encode all elements
-
-#if defined (TAO_NO_COPY_OCTET_SEQUENCES)
-    {
-      TAO_Unbounded_Sequence<CORBA::Octet> *oseq =
-        ACE_dynamic_cast (TAO_Unbounded_Sequence<CORBA::Octet>*, (Messaging::PolicyValue::_tao_seq_Octet *)&_tao_sequence);
-      if (oseq->mb ())
-        return strm.write_octet_array_mb (oseq->mb ());
-      else
-        return strm.write_octet_array (_tao_sequence.get_buffer (), _tao_sequence.length ());
-    }
-
-#else /* TAO_NO_COPY_OCTET_SEQUENCES */
-    return strm.write_octet_array (_tao_sequence.get_buffer (), _tao_sequence.length ());
-
-#endif /* TAO_NO_COPY_OCTET_SEQUENCES */
-  }
-  return 0; // error
+  
 }
 
-ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, Messaging::PolicyValue::_tao_seq_Octet &_tao_sequence)
-{
-  CORBA::ULong _tao_seq_len;
-  if (strm >> _tao_seq_len)
-  {
-    // set the length of the sequence
-    _tao_sequence.length (_tao_seq_len);
-    // retrieve all the elements
 
-#if defined (TAO_NO_COPY_OCTET_SEQUENCES)
-    if (ACE_BIT_DISABLED (strm.start ()->flags (),ACE_Message_Block::DONT_DELETE))
-    {
-      TAO_Unbounded_Sequence<CORBA::Octet> *oseq =
-        ACE_dynamic_cast(TAO_Unbounded_Sequence<CORBA::Octet>*, &_tao_sequence);
-      oseq->replace (_tao_seq_len, strm.start ());
-      oseq->mb ()->wr_ptr (oseq->mb()->rd_ptr () + _tao_seq_len);
-      strm.skip_bytes (_tao_seq_len);
-      return 1;
-    }
-    else
-      return strm.read_octet_array (_tao_sequence.get_buffer (), _tao_seq_len);
-
-#else /* TAO_NO_COPY_OCTET_SEQUENCES */
-    return strm.read_octet_array (_tao_sequence.get_buffer (), _tao_sequence.length ());
+#if !defined _TAO_CDR_OP_Messaging_PolicyValue__tao_seq_Octet_I_
+#define _TAO_CDR_OP_Messaging_PolicyValue__tao_seq_Octet_I_
 
-#endif /* TAO_NO_COPY_OCTET_SEQUENCES */
-  }
-  return 0; // error
-}
+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
-  )
+ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const Messaging::PolicyValue &_tao_aggregate)
 {
   if (
     (strm << _tao_aggregate.ptype) &&
@@ -4517,14 +4087,10 @@ operator<< (
     return 1;
   else
     return 0;
-
+  
 }
 
-ACE_INLINE CORBA::Boolean
-operator>> (
-    TAO_InputCDR &strm,
-    Messaging::PolicyValue &_tao_aggregate
-  )
+ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, Messaging::PolicyValue &_tao_aggregate)
 {
   if (
     (strm >> _tao_aggregate.ptype) &&
@@ -4533,51 +4099,23 @@ operator>> (
     return 1;
   else
     return 0;
-
+  
 }
 
-// ****************************************************************
 
-ACE_INLINE CORBA::Boolean
-operator<< (
-    TAO_OutputCDR &strm,
-    const Messaging::PolicyValueSeq &_tao_sequence
-  )
-{
-  if (strm << _tao_sequence.length ())
-  {
-    // encode all elements
-    CORBA::Boolean _tao_marshal_flag = 1;
-    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
-      _tao_marshal_flag = (strm << _tao_sequence[i]);
-    return _tao_marshal_flag;
-  }
-  return 0; // error
-}
+#if !defined _TAO_CDR_OP_Messaging_PolicyValueSeq_I_
+#define _TAO_CDR_OP_Messaging_PolicyValueSeq_I_
 
-ACE_INLINE CORBA::Boolean
-operator>> (
-    TAO_InputCDR &strm,
-    Messaging::PolicyValueSeq &_tao_sequence
-  )
-{
-  CORBA::ULong _tao_seq_len;
-  if (strm >> _tao_seq_len)
-  {
-    // set the length of the sequence
-    _tao_sequence.length (_tao_seq_len);
-    // retrieve all the elements
-    CORBA::Boolean _tao_marshal_flag = 1;
-    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
-      _tao_marshal_flag = (strm >> _tao_sequence[i]);
-    return _tao_marshal_flag;
-  }
-  return 0; // error
-}
-
-// ****************************************************************
+CORBA::Boolean TAO_Export operator<< (
+    TAO_OutputCDR &,
+    const Messaging::PolicyValueSeq &
+  );
+CORBA::Boolean TAO_Export operator>> (
+    TAO_InputCDR &,
+    Messaging::PolicyValueSeq &
+  );
 
-#if (TAO_HAS_AMI_CALLBACK == 1) || (TAO_HAS_AMI_POLLER == 1)
+#endif /* _TAO_CDR_OP_Messaging_PolicyValueSeq_I_ */
 
 ACE_INLINE CORBA::Boolean
 operator<< (TAO_OutputCDR &strm, const Messaging::ExceptionHolder *_tao_valuetype)
@@ -4599,12 +4137,12 @@ 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)
+    (strm << _pd_marshaled_exception)
   )
     return 1;
   else
     return 0;
-
+  
 }
 
 ACE_INLINE CORBA::Boolean
@@ -4613,80 +4151,14 @@ 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)
+    (strm >> _pd_marshaled_exception)
   )
     return 1;
   else
     return 0;
-
-}
-
-
-
-ACE_INLINE CORBA::Boolean operator<< (
-    TAO_OutputCDR &strm,
-    const Messaging::ExceptionHolder::_tao_seq_Octet &_tao_sequence
-  )
-{
-  if (strm << _tao_sequence.length ())
-  {
-    // encode all elements
-
-#if defined (TAO_NO_COPY_OCTET_SEQUENCES)
-    {
-      TAO_Unbounded_Sequence<CORBA::Octet> *oseq =
-        ACE_dynamic_cast (TAO_Unbounded_Sequence<CORBA::Octet>*, (Messaging::PolicyValue::_tao_seq_Octet *)&_tao_sequence);
-      if (oseq->mb ())
-        return strm.write_octet_array_mb (oseq->mb ());
-      else
-        return strm.write_octet_array (_tao_sequence.get_buffer (), _tao_sequence.length ());
-    }
-
-#else /* TAO_NO_COPY_OCTET_SEQUENCES */
-    return strm.write_octet_array (_tao_sequence.get_buffer (), _tao_sequence.length ());
-
-#endif /* TAO_NO_COPY_OCTET_SEQUENCES */
-  }
-  return 0; // error
-}
-
-ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, Messaging::ExceptionHolder::_tao_seq_Octet &_tao_sequence)
-{
-  CORBA::ULong _tao_seq_len;
-  if (strm >> _tao_seq_len)
-  {
-    // set the length of the sequence
-    _tao_sequence.length (_tao_seq_len);
-    // retrieve all the elements
-
-#if defined (TAO_NO_COPY_OCTET_SEQUENCES)
-    if (ACE_BIT_DISABLED (strm.start ()->flags (),ACE_Message_Block::DONT_DELETE))
-    {
-      TAO_Unbounded_Sequence<CORBA::Octet> *oseq =
-        ACE_dynamic_cast(TAO_Unbounded_Sequence<CORBA::Octet>*, &_tao_sequence);
-      oseq->replace (_tao_seq_len, strm.start ());
-      oseq->mb ()->wr_ptr (oseq->mb()->rd_ptr () + _tao_seq_len);
-      strm.skip_bytes (_tao_seq_len);
-      return 1;
-    }
-    else
-      return strm.read_octet_array (_tao_sequence.get_buffer (), _tao_seq_len);
-
-#else /* TAO_NO_COPY_OCTET_SEQUENCES */
-    return strm.read_octet_array (_tao_sequence.get_buffer (), _tao_sequence.length ());
-
-#endif /* TAO_NO_COPY_OCTET_SEQUENCES */
-  }
-  return 0; // error
+  
 }
 
-
-#endif /* TAO_HAS_AMI_CALLBACK == 1 || TAO_HAS_AMI_POLLER == 1 */
-
-#if (TAO_HAS_AMI_CALLBACK == 1)
-
-// ****************************************************************
-
 ACE_INLINE CORBA::Boolean
 operator<< (
     TAO_OutputCDR &,
@@ -4736,59 +4208,43 @@ operator>> (
   return 0;
 }
 
-#endif /* TAO_HAS_AMI_CALLBACK == 1 */
-
-// ****************************************************************
-
-#if (TAO_HAS_AMI_POLLER == 1)
-
-ACE_INLINE CORBA::Boolean
-operator<< (
-    TAO_OutputCDR &,
-    const Messaging::Poller_ptr
-  );
 ACE_INLINE CORBA::Boolean
-operator>> (
-    TAO_InputCDR &,
-    Messaging::Poller_ptr &
-  );
+operator<< (TAO_OutputCDR &strm, const Messaging::Poller *_tao_valuetype)
+{
+  return CORBA_ValueBase::_tao_marshal (strm,
+    ACE_const_cast (Messaging::Poller*, _tao_valuetype),
+    (ptr_arith_t) &Messaging::Poller::_downcast);
+}
 
 ACE_INLINE CORBA::Boolean
-operator<< (
-    TAO_OutputCDR &strm,
-    const Messaging::Poller_ptr _tao_objref
-  )
+operator>> (TAO_InputCDR &strm, Messaging::Poller *&_tao_valuetype)
 {
-  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
-  return (strm << _tao_corba_obj);
+  return Messaging::Poller::_tao_unmarshal (strm, _tao_valuetype);
 }
 
 ACE_INLINE CORBA::Boolean
-operator>> (
-    TAO_InputCDR &strm,
-    Messaging::Poller_ptr &_tao_objref
+OBV_Messaging::Poller::_tao_marshal_state (TAO_OutputCDR &strm)
+{
+  if (
+    (strm << _pd_target.in ()) &&
+    (strm << _pd_op_name.in ())
   )
+    return 1;
+  else
+    return 0;
+  
+}
+
+ACE_INLINE CORBA::Boolean
+OBV_Messaging::Poller::_tao_unmarshal_state (TAO_InputCDR &strm)
 {
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::Object_var obj;
-    if ((strm >> obj.inout ()) == 0)
-      return 0;
-    // narrow to the right type
-    _tao_objref =
-      Messaging::Poller::_narrow (
-          obj.in (),
-          ACE_TRY_ENV
-        );
-    ACE_TRY_CHECK;
+  if (
+    (strm >> _pd_target.out ()) &&
+    (strm >> _pd_op_name.out ())
+  )
     return 1;
-  }
-  ACE_CATCHANY
-  {
-    // do nothing
-  }
-  ACE_ENDTRY;
-  return 0;
+  else
+    return 0;
+  
 }
 
-#endif /* TAO_HAS_AMI_POLLER == 1 */