PortableServer updates

8 files changed, 3758 insertions, 2162 deletions

diff --git a/TAO/tao/PortableServer/POA.cpp b/TAO/tao/PortableServer/POA.cpp
index efc47afd0b8..37522f59b2c 100644
--- a/TAO/tao/PortableServer/POA.cpp
+++ b/TAO/tao/PortableServer/POA.cpp
@@ -23,6 +23,8 @@
 
 #include "Default_Acceptor_Filter.h"
 
+#include "PortableGroup_Hooks.h"
+
 // auto_ptr class
 #include "ace/Auto_Ptr.h"
 
@@ -3516,6 +3518,91 @@ TAO_POA_Guard::TAO_POA_Guard (TAO_POA &poa
         CORBA::COMPLETED_NO));
 }
 
+#if (TAO_HAS_MIOP == 1)
+
+PortableServer::ObjectId *
+TAO_POA::create_id_for_reference (CORBA::Object_ptr the_ref
+                                  TAO_ENV_ARG_DECL)
+    ACE_THROW_SPEC ((
+      CORBA::SystemException,
+      PortableServer::NotAGroupObject
+    ))
+{
+  TAO_POA_PortableGroup_Hooks *hooks = this->orb_core_.portable_group_poa_hooks ();
+  if (hooks == 0)
+    {
+      ACE_THROW_RETURN (CORBA::NO_IMPLEMENT (), 0);
+    }
+
+  PortableServer::ObjectId *obj_id =
+    hooks->create_id_for_reference (*this, the_ref TAO_ENV_ARG_PARAMETER);
+  ACE_CHECK_RETURN (0);
+
+  return obj_id;
+}
+
+PortableServer::IDs *
+TAO_POA::reference_to_ids (CORBA::Object_ptr the_ref
+                           TAO_ENV_ARG_DECL)
+    ACE_THROW_SPEC ((
+      CORBA::SystemException,
+      PortableServer::NotAGroupObject
+    ))
+{
+  TAO_POA_PortableGroup_Hooks *hooks = this->orb_core_.portable_group_poa_hooks ();
+  if (hooks == 0)
+    {
+      ACE_THROW_RETURN (CORBA::NO_IMPLEMENT (),
+                        0);
+    }
+
+  PortableServer::IDs *id_list =
+    hooks->reference_to_ids (*this, the_ref TAO_ENV_ARG_PARAMETER);
+  ACE_CHECK_RETURN (PortableServer::IDs::_nil ());
+
+  return id_list;
+}
+
+void 
+TAO_POA::associate_reference_with_id (CORBA::Object_ptr ref,
+                                      const PortableServer::ObjectId & oid
+                                      TAO_ENV_ARG_DECL)
+    ACE_THROW_SPEC ((
+      CORBA::SystemException,
+      PortableServer::NotAGroupObject
+    ))
+{
+  TAO_POA_PortableGroup_Hooks *hooks = this->orb_core_.portable_group_poa_hooks ();
+  if (hooks == 0)
+    {
+      ACE_THROW (CORBA::NO_IMPLEMENT ());
+    }
+
+  hooks->associate_reference_with_id (*this, ref, oid TAO_ENV_ARG_PARAMETER);
+  ACE_CHECK;
+}
+
+void 
+TAO_POA::disassociate_reference_with_id (CORBA::Object_ptr ref,
+                                         const PortableServer::ObjectId & oid
+                                         TAO_ENV_ARG_DECL)
+    ACE_THROW_SPEC ((
+      CORBA::SystemException,
+      PortableServer::NotAGroupObject
+    ))
+{
+  TAO_POA_PortableGroup_Hooks *hooks = this->orb_core_.portable_group_poa_hooks ();
+  if (hooks == 0)
+    {
+      ACE_THROW (CORBA::NO_IMPLEMENT ());
+    }
+
+  hooks->disassociate_reference_with_id (*this, ref, oid TAO_ENV_ARG_PARAMETER);
+  ACE_CHECK;
+}
+
+#endif /* TAO_HAS_MIOP == 1 */
+
 #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)
 
 template class ACE_Array_Base<TAO_Active_Object_Map::Map_Entry *>;
diff --git a/TAO/tao/PortableServer/POA.h b/TAO/tao/PortableServer/POA.h
index 7558af8eac7..3c1b46504b9 100644
--- a/TAO/tao/PortableServer/POA.h
+++ b/TAO/tao/PortableServer/POA.h
@@ -316,6 +316,48 @@ public:
   CORBA::OctetSeq *id (TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)
     ACE_THROW_SPEC ((CORBA::SystemException));
 
+#if (TAO_HAS_MIOP == 1)
+  virtual PortableServer::ObjectId * create_id_for_reference (
+      CORBA::Object_ptr the_ref
+      TAO_ENV_ARG_DECL_WITH_DEFAULTS
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException,
+      PortableServer::NotAGroupObject
+    ));
+
+
+  virtual PortableServer::IDs * reference_to_ids (
+      CORBA::Object_ptr the_ref
+      TAO_ENV_ARG_DECL_WITH_DEFAULTS
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException,
+      PortableServer::NotAGroupObject
+    ));
+
+  virtual void associate_reference_with_id (
+      CORBA::Object_ptr ref,
+      const PortableServer::ObjectId & oid
+      TAO_ENV_ARG_DECL_WITH_DEFAULTS
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException,
+      PortableServer::NotAGroupObject
+    ));
+
+  virtual void disassociate_reference_with_id (
+      CORBA::Object_ptr ref,
+      const PortableServer::ObjectId & oid
+      TAO_ENV_ARG_DECL_WITH_DEFAULTS
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException,
+      PortableServer::NotAGroupObject
+    ));
+
+#endif /* TAO_HAS_MIOP == 1 */
+
   /// Accessor for POA policies.
   TAO_POA_Policy_Set &policies (void);
 
diff --git a/TAO/tao/PortableServer/PortableGroup_Hooks.cpp b/TAO/tao/PortableServer/PortableGroup_Hooks.cpp
new file mode 100644
index 00000000000..36834ac4740
--- /dev/null
+++ b/TAO/tao/PortableServer/PortableGroup_Hooks.cpp
@@ -0,0 +1,13 @@
+// -*- C++ -*-
+//
+// $Id$
+
+#include "PortableGroup_Hooks.h"
+
+ACE_RCSID (TAO_PortableServer,
+           PortableGroup_Hooks,
+           "$Id$")
+
+TAO_POA_PortableGroup_Hooks::~TAO_POA_PortableGroup_Hooks (void)
+{
+}
diff --git a/TAO/tao/PortableServer/PortableGroup_Hooks.h b/TAO/tao/PortableServer/PortableGroup_Hooks.h
new file mode 100644
index 00000000000..707a4970fc4
--- /dev/null
+++ b/TAO/tao/PortableServer/PortableGroup_Hooks.h
@@ -0,0 +1,85 @@
+/* -*- C++ -*- */
+
+//=============================================================================
+/**
+ *  @file   PortableGroup_Hooks.h
+ *
+ *  $Id$
+ *
+ *  @author Frank Hunleth <fhunleth@cs.wustl.edu>
+ */
+//=============================================================================
+
+#ifndef TAO_PORTABLEGROUP_HOOKS_H
+#define TAO_PORTABLEGROUP_HOOKS_H
+#include "ace/pre.h"
+
+#include "PortableServerC.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+# pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+#include "POA.h"
+
+
+/**
+ * @class TAO_POA_PortableGroup_Hooks
+ *
+ * @brief TAO_POA_PortableGroup_Hooks
+ *
+ * This class is an abstract base class that contains hooks for the
+ * PortableGroup library.
+ */
+class TAO_PortableServer_Export TAO_POA_PortableGroup_Hooks
+{
+public:
+  /// Destructor.
+  virtual ~TAO_POA_PortableGroup_Hooks (void);
+
+  virtual PortableServer::ObjectId * create_id_for_reference (
+      TAO_POA &the_poa,
+      CORBA::Object_ptr the_ref
+      TAO_ENV_ARG_DECL_WITH_DEFAULTS
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException,
+      PortableServer::NotAGroupObject
+    )) = 0;
+
+  virtual PortableServer::IDs * reference_to_ids (
+      TAO_POA &the_poa,
+      CORBA::Object_ptr the_ref
+      TAO_ENV_ARG_DECL_WITH_DEFAULTS
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException,
+      PortableServer::NotAGroupObject
+    )) = 0;
+
+  virtual void associate_reference_with_id (
+      TAO_POA &the_poa,
+      CORBA::Object_ptr ref,
+      const PortableServer::ObjectId & oid
+      TAO_ENV_ARG_DECL_WITH_DEFAULTS
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException,
+      PortableServer::NotAGroupObject
+    )) = 0;
+
+  virtual void disassociate_reference_with_id (
+      TAO_POA &the_poa,
+      CORBA::Object_ptr ref,
+      const PortableServer::ObjectId & oid
+      TAO_ENV_ARG_DECL_WITH_DEFAULTS
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException,
+      PortableServer::NotAGroupObject
+    )) = 0;
+};
+
+
+#include "ace/post.h"
+#endif /* TAO_PORTABLEGROUP_HOOKS_H */
diff --git a/TAO/tao/PortableServer/PortableServerC.cpp b/TAO/tao/PortableServer/PortableServerC.cpp
index b0e28d85495..09ed6ffcacc 100644
--- a/TAO/tao/PortableServer/PortableServerC.cpp
+++ b/TAO/tao/PortableServer/PortableServerC.cpp
@@ -25,7 +25,7 @@
 #include "tao/ORB_Core.h"
 
 #if defined (__BORLANDC__)
-#pragma option -w-rvl -w-rch -w-ccc -w-aus
+#pragma option -w-rvl -w-rch -w-ccc -w-aus -w-sig
 #endif /* __BORLANDC__ */
 
 #if !defined (__ACE_INLINE__)
@@ -38,93 +38,93 @@
 #if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_PORTABLESERVER_POALIST_CS_)
 #define __TAO_UNBOUNDED_OBJECT_SEQUENCE_PORTABLESERVER_POALIST_CS_
 
-  // The Base_Sequence functions, please see tao/Sequence.h
-  void
-  PortableServer::_TAO_Unbounded_Object_Sequence_PortableServer_POAList::_allocate_buffer (CORBA::ULong length)
-  {
-    PortableServer::POA **tmp = 0;
-    tmp = _TAO_Unbounded_Object_Sequence_PortableServer_POAList::allocbuf (length);
-
-    if (this->buffer_ != 0)
-    {
-      PortableServer::POA **old = ACE_reinterpret_cast (PortableServer::POA**, this->buffer_);
-      for (CORBA::ULong i = 0; i < this->length_; ++i)
-        {
-          if (!this->release_)
-            {
-              tmp[i] = PortableServer::POA::_duplicate (old[i]);
-            }
-          else
-            {
-              tmp[i] = old[i];
-            }
-        }
-
-      if (this->release_)
-        {
-          delete[] old;
-        }
-    }
-    this->buffer_ = tmp;
-  }
-
-  void
-  PortableServer::_TAO_Unbounded_Object_Sequence_PortableServer_POAList::_deallocate_buffer (void)
+// The Base_Sequence functions, please see tao/Sequence.h
+void
+PortableServer::_TAO_Unbounded_Object_Sequence_PortableServer_POAList::_allocate_buffer (CORBA::ULong length)
+{
+  PortableServer::POA **tmp = 0;
+  tmp = _TAO_Unbounded_Object_Sequence_PortableServer_POAList::allocbuf (length);
+  
+  if (this->buffer_ != 0)
   {
-    if (this->buffer_ == 0 || this->release_ == 0)
-      return;
-    PortableServer::POA **tmp = ACE_reinterpret_cast (PortableServer::POA**, this->buffer_);
-
+    PortableServer::POA **old = ACE_reinterpret_cast (PortableServer::POA**, this->buffer_);
     for (CORBA::ULong i = 0; i < this->length_; ++i)
       {
-        CORBA::release (tmp[i]);
-        tmp[i] = PortableServer::POA::_nil ();
+        if (!this->release_)
+          {
+            tmp[i] = PortableServer::POA::_duplicate (old[i]);
+          }
+        else
+          {
+            tmp[i] = old[i];
+          }
+      }
+    
+    if (this->release_)
+      {
+        delete[] old;
       }
-
-    _TAO_Unbounded_Object_Sequence_PortableServer_POAList::freebuf (tmp);
-    this->buffer_ = 0;
   }
+  this->buffer_ = tmp;
+}
 
-  PortableServer::_TAO_Unbounded_Object_Sequence_PortableServer_POAList::~_TAO_Unbounded_Object_Sequence_PortableServer_POAList (void)
-  {
-    this->_deallocate_buffer ();
-  }
+void
+PortableServer::_TAO_Unbounded_Object_Sequence_PortableServer_POAList::_deallocate_buffer (void)
+{
+  if (this->buffer_ == 0 || this->release_ == 0)
+    return;
+  PortableServer::POA **tmp = ACE_reinterpret_cast (PortableServer::POA**, this->buffer_);
+  
+  for (CORBA::ULong i = 0; i < this->length_; ++i)
+    {
+      CORBA::release (tmp[i]);
+      tmp[i] = PortableServer::POA::_nil ();
+    }
+  
+  _TAO_Unbounded_Object_Sequence_PortableServer_POAList::freebuf (tmp);
+  this->buffer_ = 0;
+}
 
-  void
-  PortableServer::_TAO_Unbounded_Object_Sequence_PortableServer_POAList::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol)
-  {
-    PortableServer::POA **tmp = ACE_reinterpret_cast (PortableServer::POA**, this->buffer_);
+PortableServer::_TAO_Unbounded_Object_Sequence_PortableServer_POAList::~_TAO_Unbounded_Object_Sequence_PortableServer_POAList (void)
+{
+  this->_deallocate_buffer ();
+}
 
-    for (CORBA::ULong i = nl; i < ol; ++i)
-      {
-        CORBA::release (tmp[i]);
-        tmp[i] = PortableServer::POA::_nil ();
-      }
-  }
+void
+PortableServer::_TAO_Unbounded_Object_Sequence_PortableServer_POAList::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol)
+{
+  PortableServer::POA **tmp = ACE_reinterpret_cast (PortableServer::POA**, this->buffer_);
+  
+  for (CORBA::ULong i = nl; i < ol; ++i)
+    {
+      CORBA::release (tmp[i]);
+      tmp[i] = PortableServer::POA::_nil ();
+    }
+}
 
-  void
-  PortableServer::_TAO_Unbounded_Object_Sequence_PortableServer_POAList::_downcast (
-      void* target,
-      CORBA_Object *src
-      TAO_ENV_ARG_DECL
-    )
-  {
-    PortableServer::POA **tmp = ACE_static_cast (PortableServer::POA**, target);
-    *tmp = PortableServer::POA::_narrow (src TAO_ENV_ARG_PARAMETER);
-    ACE_CHECK;
-  }
+void 
+PortableServer::_TAO_Unbounded_Object_Sequence_PortableServer_POAList::_downcast (
+    void* target,
+    CORBA_Object *src
+    TAO_ENV_ARG_DECL
+  )
+{
+  PortableServer::POA **tmp = ACE_static_cast (PortableServer::POA**, target);
+  *tmp = PortableServer::POA::_narrow (src TAO_ENV_ARG_PARAMETER);
+  ACE_CHECK;
+}
 
-  CORBA_Object*
-  PortableServer::_TAO_Unbounded_Object_Sequence_PortableServer_POAList::_upcast (void *src) const
-  {
-    PortableServer::POA **tmp = ACE_static_cast (PortableServer::POA**, src);
-    return *tmp;
-  }
+CORBA_Object*
+PortableServer::_TAO_Unbounded_Object_Sequence_PortableServer_POAList::_upcast (void *src) const
+{
+  PortableServer::POA **tmp = ACE_static_cast (PortableServer::POA**, src);
+  return *tmp;
+}
 
 #endif /* end #if !defined */
 
 
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
 
 #if !defined (_PORTABLESERVER_POALIST_CS_)
 #define _PORTABLESERVER_POALIST_CS_
@@ -136,37 +136,37 @@
 PortableServer::POAList::POAList (void)
 {}
 PortableServer::POAList::POAList (CORBA::ULong max) // uses max size
-  :
+  : 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Object_Sequence_PortableServer_POAList
+_TAO_Unbounded_Object_Sequence_PortableServer_POAList
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Object_Sequence<PortableServer::POA,PortableServer::POA_var>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+TAO_Unbounded_Object_Sequence<PortableServer::POA,PortableServer::POA_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
  (max)
 {}
 PortableServer::POAList::POAList (CORBA::ULong max, CORBA::ULong length, PortableServer::POA_ptr *buffer, CORBA::Boolean release)
-  :
+  : 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Object_Sequence_PortableServer_POAList
+_TAO_Unbounded_Object_Sequence_PortableServer_POAList
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Object_Sequence<PortableServer::POA,PortableServer::POA_var>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+TAO_Unbounded_Object_Sequence<PortableServer::POA,PortableServer::POA_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
  (max, length, buffer, release)
 {}
 PortableServer::POAList::POAList (const POAList &seq) // copy ctor
-  :
+  : 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Object_Sequence_PortableServer_POAList
+_TAO_Unbounded_Object_Sequence_PortableServer_POAList
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Object_Sequence<PortableServer::POA,PortableServer::POA_var>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+TAO_Unbounded_Object_Sequence<PortableServer::POA,PortableServer::POA_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
  (seq)
 {}
 PortableServer::POAList::~POAList (void) // dtor
 {}
-void PortableServer::POAList::_tao_any_destructor (void *x)
+void PortableServer::POAList::_tao_any_destructor (void *_tao_void_pointer)
 {
-  POAList *tmp = ACE_static_cast (POAList*,x);
+  POAList *tmp = ACE_static_cast (POAList*, _tao_void_pointer);
   delete tmp;
 }
 
@@ -184,37 +184,37 @@ void PortableServer::POAList::_tao_any_destructor (void *x)
 PortableServer::ObjectId::ObjectId (void)
 {}
 PortableServer::ObjectId::ObjectId (CORBA::ULong max) // uses max size
-  :
+  : 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  TAO_Unbounded_Sequence<CORBA::Octet>
+TAO_Unbounded_Sequence<CORBA::Octet>
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Sequence<CORBA::Octet>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+TAO_Unbounded_Sequence<CORBA::Octet>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
  (max)
 {}
 PortableServer::ObjectId::ObjectId (CORBA::ULong max, CORBA::ULong length, CORBA::Octet *buffer, CORBA::Boolean release)
-  :
+  : 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  TAO_Unbounded_Sequence<CORBA::Octet>
+TAO_Unbounded_Sequence<CORBA::Octet>
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Sequence<CORBA::Octet>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+TAO_Unbounded_Sequence<CORBA::Octet>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
  (max, length, buffer, release)
 {}
 PortableServer::ObjectId::ObjectId (const ObjectId &seq) // copy ctor
-  :
+  : 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  TAO_Unbounded_Sequence<CORBA::Octet>
+TAO_Unbounded_Sequence<CORBA::Octet>
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Sequence<CORBA::Octet>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+TAO_Unbounded_Sequence<CORBA::Octet>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
  (seq)
 {}
 PortableServer::ObjectId::~ObjectId (void) // dtor
 {}
-void PortableServer::ObjectId::_tao_any_destructor (void *x)
+void PortableServer::ObjectId::_tao_any_destructor (void *_tao_void_pointer)
 {
-  ObjectId *tmp = ACE_static_cast (ObjectId*,x);
+  ObjectId *tmp = ACE_static_cast (ObjectId*, _tao_void_pointer);
   delete tmp;
 }
 
@@ -224,18 +224,20 @@ void PortableServer::ObjectId::_tao_any_destructor (void *x)
 static const CORBA::Long _oc_PortableServer_ObjectId[] =
 {
   TAO_ENCAP_BYTE_ORDER, // byte order
-  32,
-  ACE_NTOHL (0x49444c3a),
-  ACE_NTOHL (0x506f7274),
-  ACE_NTOHL (0x61626c65),
-  ACE_NTOHL (0x53657276),
-  ACE_NTOHL (0x65722f4f),
-  ACE_NTOHL (0x626a6563),
-  ACE_NTOHL (0x7449643a),
-  ACE_NTOHL (0x312e3000),  // repository ID = IDL:PortableServer/ObjectId:1.0
+  40,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x506f7274), 
+  ACE_NTOHL (0x61626c65), 
+  ACE_NTOHL (0x53657276), 
+  ACE_NTOHL (0x65722f4f), 
+  ACE_NTOHL (0x626a6563), 
+  ACE_NTOHL (0x7449643a), 
+  ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/PortableServer/ObjectId:1.0
   9,
-  ACE_NTOHL (0x4f626a65),
-  ACE_NTOHL (0x63744964),
+  ACE_NTOHL (0x4f626a65), 
+  ACE_NTOHL (0x63744964), 
   ACE_NTOHL (0x0),  // name = ObjectId
   CORBA::tk_sequence, // typecode kind
   12, // encapsulation length
@@ -256,14 +258,14 @@ static CORBA::TypeCode _tc_TAO_tc_PortableServer_ObjectId (
 
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
 TAO_NAMESPACE_BEGIN (PortableServer)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ObjectId, &_tc_TAO_tc_PortableServer_ObjectId)
+TAO_NAMESPACE_DEFINE (::CORBA::TypeCode_ptr, _tc_ObjectId, &_tc_TAO_tc_PortableServer_ObjectId)
 TAO_NAMESPACE_END
 
 #if (TAO_HAS_MINIMUM_CORBA == 0)
 
 // Default constructor.
 PortableServer::ForwardRequest::ForwardRequest (void)
-  : CORBA_UserException ("IDL:PortableServer/ForwardRequest:1.0")
+  : CORBA_UserException ("IDL:omg.org/PortableServer/ForwardRequest:1.0")
 {
 }
 
@@ -272,9 +274,9 @@ PortableServer::ForwardRequest::~ForwardRequest (void)
 {
 }
 
-void PortableServer::ForwardRequest::_tao_any_destructor (void *x)
+void PortableServer::ForwardRequest::_tao_any_destructor (void *_tao_void_pointer)
 {
-  ForwardRequest *tmp = ACE_static_cast (ForwardRequest*,x);
+  ForwardRequest *tmp = ACE_static_cast (ForwardRequest*, _tao_void_pointer);
   delete tmp;
 }
 
@@ -298,7 +300,7 @@ PortableServer::ForwardRequest::operator= (const ::PortableServer::ForwardReques
 PortableServer::ForwardRequest *
 PortableServer::ForwardRequest::_downcast (CORBA::Exception *exc)
 {
-  if (!ACE_OS::strcmp ("IDL:PortableServer/ForwardRequest:1.0", exc->_id ()))
+  if (!ACE_OS::strcmp ("IDL:omg.org/PortableServer/ForwardRequest:1.0", exc->_id ()))
     {
       return ACE_dynamic_cast (ForwardRequest *, exc);
     }
@@ -322,7 +324,7 @@ void PortableServer::ForwardRequest::_tao_encode (
     {
       return;
     }
-
+  
   ACE_THROW (CORBA::MARSHAL ());
 }
 
@@ -335,7 +337,7 @@ void PortableServer::ForwardRequest::_tao_decode (
     {
       return;
     }
-
+  
   ACE_THROW (CORBA::MARSHAL ());
 }
 
@@ -350,7 +352,7 @@ CORBA::Exception *PortableServer::ForwardRequest::_alloc (void)
 PortableServer::ForwardRequest::ForwardRequest (
     const CORBA::Object_ptr  _tao_forward_reference
   )
-  : CORBA_UserException ("IDL:PortableServer/ForwardRequest:1.0")
+  : CORBA_UserException ("IDL:omg.org/PortableServer/ForwardRequest:1.0")
 {
   this->forward_reference = CORBA::Object::_duplicate (_tao_forward_reference);
 }
@@ -358,43 +360,45 @@ PortableServer::ForwardRequest::ForwardRequest (
 static const CORBA::Long _oc_PortableServer_ForwardRequest[] =
 {
   TAO_ENCAP_BYTE_ORDER, // byte order
-  38,
-  ACE_NTOHL (0x49444c3a),
-  ACE_NTOHL (0x506f7274),
-  ACE_NTOHL (0x61626c65),
-  ACE_NTOHL (0x53657276),
-  ACE_NTOHL (0x65722f46),
-  ACE_NTOHL (0x6f727761),
-  ACE_NTOHL (0x72645265),
-  ACE_NTOHL (0x71756573),
-  ACE_NTOHL (0x743a312e),
-  ACE_NTOHL (0x30000000),  // repository ID = IDL:PortableServer/ForwardRequest:1.0
+  46,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x506f7274), 
+  ACE_NTOHL (0x61626c65), 
+  ACE_NTOHL (0x53657276), 
+  ACE_NTOHL (0x65722f46), 
+  ACE_NTOHL (0x6f727761), 
+  ACE_NTOHL (0x72645265), 
+  ACE_NTOHL (0x71756573), 
+  ACE_NTOHL (0x743a312e), 
+  ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/PortableServer/ForwardRequest:1.0
   15,
-  ACE_NTOHL (0x466f7277),
-  ACE_NTOHL (0x61726452),
-  ACE_NTOHL (0x65717565),
+  ACE_NTOHL (0x466f7277), 
+  ACE_NTOHL (0x61726452), 
+  ACE_NTOHL (0x65717565), 
   ACE_NTOHL (0x73740000),  // name = ForwardRequest
   1, // member count
   18,
-  ACE_NTOHL (0x666f7277),
-  ACE_NTOHL (0x6172645f),
-  ACE_NTOHL (0x72656665),
-  ACE_NTOHL (0x72656e63),
+  ACE_NTOHL (0x666f7277), 
+  ACE_NTOHL (0x6172645f), 
+  ACE_NTOHL (0x72656665), 
+  ACE_NTOHL (0x72656e63), 
   ACE_NTOHL (0x65000000),  // name = forward_reference
   CORBA::tk_objref,
   52, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
     29,
-    ACE_NTOHL (0x49444c3a),
-    ACE_NTOHL (0x6f6d672e),
-    ACE_NTOHL (0x6f72672f),
-    ACE_NTOHL (0x434f5242),
-    ACE_NTOHL (0x412f4f62),
-    ACE_NTOHL (0x6a656374),
-    ACE_NTOHL (0x3a312e30),
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f4f62), 
+    ACE_NTOHL (0x6a656374), 
+    ACE_NTOHL (0x3a312e30), 
     ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Object:1.0
     7,
-    ACE_NTOHL (0x4f626a65),
+    ACE_NTOHL (0x4f626a65), 
     ACE_NTOHL (0x63740000),  // name = Object
 
 };
@@ -409,7 +413,7 @@ static CORBA::TypeCode _tc_TAO_tc_PortableServer_ForwardRequest (
 
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
 TAO_NAMESPACE_BEGIN (PortableServer)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ForwardRequest, &_tc_TAO_tc_PortableServer_ForwardRequest)
+TAO_NAMESPACE_DEFINE (::CORBA::TypeCode_ptr, _tc_ForwardRequest, &_tc_TAO_tc_PortableServer_ForwardRequest)
 TAO_NAMESPACE_END
 
 
@@ -419,6 +423,291 @@ CORBA::TypeCode_ptr PortableServer::ForwardRequest::_type (void) const
   return ::PortableServer::_tc_ForwardRequest;
 }
 
+// Default constructor.
+PortableServer::NotAGroupObject::NotAGroupObject (void)
+  : CORBA_UserException ("IDL:omg.org/PortableServer/NotAGroupObject:1.0")
+{
+}
+
+// Destructor - all members are of self managing types.
+PortableServer::NotAGroupObject::~NotAGroupObject (void)
+{
+}
+
+void PortableServer::NotAGroupObject::_tao_any_destructor (void *_tao_void_pointer)
+{
+  NotAGroupObject *tmp = ACE_static_cast (NotAGroupObject*, _tao_void_pointer);
+  delete tmp;
+}
+
+// Copy constructor.
+PortableServer::NotAGroupObject::NotAGroupObject (const ::PortableServer::NotAGroupObject &_tao_excp)
+  : CORBA_UserException (_tao_excp._id ())
+{
+}
+
+// Assignment operator.
+PortableServer::NotAGroupObject&
+PortableServer::NotAGroupObject::operator= (const ::PortableServer::NotAGroupObject &_tao_excp)
+{
+  this->CORBA_UserException::operator= (_tao_excp);
+  return *this;
+}
+
+// Narrow.
+PortableServer::NotAGroupObject *
+PortableServer::NotAGroupObject::_downcast (CORBA::Exception *exc)
+{
+  if (!ACE_OS::strcmp ("IDL:omg.org/PortableServer/NotAGroupObject:1.0", exc->_id ()))
+    {
+      return ACE_dynamic_cast (NotAGroupObject *, exc);
+    }
+  else
+    {
+      return 0;
+    }
+}
+
+void PortableServer::NotAGroupObject::_raise ()
+{
+  TAO_RAISE (*this);
+}
+
+void PortableServer::NotAGroupObject::_tao_encode (
+    TAO_OutputCDR &cdr
+    TAO_ENV_ARG_DECL
+  ) const
+{
+  if (cdr << *this)
+    {
+      return;
+    }
+  
+  ACE_THROW (CORBA::MARSHAL ());
+}
+
+void PortableServer::NotAGroupObject::_tao_decode (
+    TAO_InputCDR &cdr
+    TAO_ENV_ARG_DECL
+  )
+{
+  if (cdr >> *this)
+    {
+      return;
+    }
+  
+  ACE_THROW (CORBA::MARSHAL ());
+}
+
+// TAO extension - the _alloc method.
+CORBA::Exception *PortableServer::NotAGroupObject::_alloc (void)
+{
+  CORBA::Exception *retval = 0;
+  ACE_NEW_RETURN (retval, ::PortableServer::NotAGroupObject, 0);
+  return retval;
+}
+
+static const CORBA::Long _oc_PortableServer_NotAGroupObject[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  47,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x506f7274), 
+  ACE_NTOHL (0x61626c65), 
+  ACE_NTOHL (0x53657276), 
+  ACE_NTOHL (0x65722f4e), 
+  ACE_NTOHL (0x6f744147), 
+  ACE_NTOHL (0x726f7570), 
+  ACE_NTOHL (0x4f626a65), 
+  ACE_NTOHL (0x63743a31), 
+  ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/PortableServer/NotAGroupObject:1.0
+  16,
+  ACE_NTOHL (0x4e6f7441), 
+  ACE_NTOHL (0x47726f75), 
+  ACE_NTOHL (0x704f626a), 
+  ACE_NTOHL (0x65637400),  // name = NotAGroupObject
+  0, // member count
+};
+
+static CORBA::TypeCode _tc_TAO_tc_PortableServer_NotAGroupObject (
+    CORBA::tk_except,
+    sizeof (_oc_PortableServer_NotAGroupObject),
+    (char *) &_oc_PortableServer_NotAGroupObject,
+    0,
+    sizeof (PortableServer::NotAGroupObject)
+  );
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (PortableServer)
+TAO_NAMESPACE_DEFINE (::CORBA::TypeCode_ptr, _tc_NotAGroupObject, &_tc_TAO_tc_PortableServer_NotAGroupObject)
+TAO_NAMESPACE_END
+
+
+// TAO extension - the virtual _type method.
+CORBA::TypeCode_ptr PortableServer::NotAGroupObject::_type (void) const
+{
+  return ::PortableServer::_tc_NotAGroupObject;
+}
+
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+
+#if !defined (__TAO_UNBOUNDED_SEQUENCE_PORTABLESERVER_IDS_CS_)
+#define __TAO_UNBOUNDED_SEQUENCE_PORTABLESERVER_IDS_CS_
+
+void
+PortableServer::_TAO_Unbounded_Sequence_PortableServer_IDs::_allocate_buffer (CORBA::ULong length)
+{
+  PortableServer::ObjectId* tmp = 0;
+  tmp = _TAO_Unbounded_Sequence_PortableServer_IDs::allocbuf (length);
+  
+  if (this->buffer_ != 0)
+  {
+    PortableServer::ObjectId *old = ACE_reinterpret_cast (PortableServer::ObjectId *,this->buffer_);
+    
+    for (CORBA::ULong i = 0; i < this->length_; ++i)
+      tmp[i] = old[i];
+    
+    if (this->release_)
+      _TAO_Unbounded_Sequence_PortableServer_IDs::freebuf (old);
+    
+  }
+  this->buffer_ = tmp;
+}
+
+void
+PortableServer::_TAO_Unbounded_Sequence_PortableServer_IDs::_deallocate_buffer (void)
+{
+  if (this->buffer_ == 0 || this->release_ == 0)
+    return;
+  
+  PortableServer::ObjectId *tmp = ACE_reinterpret_cast (PortableServer::ObjectId *,this->buffer_);
+  
+  _TAO_Unbounded_Sequence_PortableServer_IDs::freebuf (tmp);
+  this->buffer_ = 0;
+} 
+
+PortableServer::_TAO_Unbounded_Sequence_PortableServer_IDs::~_TAO_Unbounded_Sequence_PortableServer_IDs (void) // Dtor.
+{
+  this->_deallocate_buffer ();
+}
+
+
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_PORTABLESERVER_IDS_CS_)
+#define _PORTABLESERVER_IDS_CS_
+
+// *************************************************************
+// PortableServer::IDs
+// *************************************************************
+
+PortableServer::IDs::IDs (void)
+{}
+PortableServer::IDs::IDs (CORBA::ULong max) // uses max size
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+_TAO_Unbounded_Sequence_PortableServer_IDs
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+TAO_Unbounded_Sequence<PortableServer::ObjectId>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max)
+{}
+PortableServer::IDs::IDs (CORBA::ULong max, CORBA::ULong length, PortableServer::ObjectId *buffer, CORBA::Boolean release)
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+_TAO_Unbounded_Sequence_PortableServer_IDs
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+TAO_Unbounded_Sequence<PortableServer::ObjectId>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max, length, buffer, release)
+{}
+PortableServer::IDs::IDs (const IDs &seq) // copy ctor
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+_TAO_Unbounded_Sequence_PortableServer_IDs
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+TAO_Unbounded_Sequence<PortableServer::ObjectId>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (seq)
+{}
+PortableServer::IDs::~IDs (void) // dtor
+{}
+void PortableServer::IDs::_tao_any_destructor (void *_tao_void_pointer)
+{
+  IDs *tmp = ACE_static_cast (IDs*, _tao_void_pointer);
+  delete tmp;
+}
+
+
+#endif /* end #if !defined */
+
+static const CORBA::Long _oc_PortableServer_IDs[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  35,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x506f7274), 
+  ACE_NTOHL (0x61626c65), 
+  ACE_NTOHL (0x53657276), 
+  ACE_NTOHL (0x65722f49), 
+  ACE_NTOHL (0x44733a31), 
+  ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/PortableServer/IDs:1.0
+  4,
+  ACE_NTOHL (0x49447300),  // name = IDs
+  CORBA::tk_sequence, // typecode kind
+  100, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    CORBA::tk_alias, // typecode kind for typedefs
+    84, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      40,
+      ACE_NTOHL (0x49444c3a), 
+      ACE_NTOHL (0x6f6d672e), 
+      ACE_NTOHL (0x6f72672f), 
+      ACE_NTOHL (0x506f7274), 
+      ACE_NTOHL (0x61626c65), 
+      ACE_NTOHL (0x53657276), 
+      ACE_NTOHL (0x65722f4f), 
+      ACE_NTOHL (0x626a6563), 
+      ACE_NTOHL (0x7449643a), 
+      ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/PortableServer/ObjectId:1.0
+      9,
+      ACE_NTOHL (0x4f626a65), 
+      ACE_NTOHL (0x63744964), 
+      ACE_NTOHL (0x0),  // name = ObjectId
+      CORBA::tk_sequence, // typecode kind
+      12, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        CORBA::tk_octet,
+
+        0U,
+
+
+    0U,
+
+};
+
+static CORBA::TypeCode _tc_TAO_tc_PortableServer_IDs (
+    CORBA::tk_alias,
+    sizeof (_oc_PortableServer_IDs),
+    (char *) &_oc_PortableServer_IDs,
+    0,
+    sizeof (PortableServer::IDs)
+  );
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (PortableServer)
+TAO_NAMESPACE_DEFINE (::CORBA::TypeCode_ptr, _tc_IDs, &_tc_TAO_tc_PortableServer_IDs)
+TAO_NAMESPACE_END
+
 #endif /* TAO_HAS_MINIMUM_CORBA == 0 */
 
 TAO_NAMESPACE_TYPE (const CORBA::ULong)
@@ -455,35 +744,37 @@ TAO_NAMESPACE_END
 static const CORBA::Long _oc_PortableServer_ThreadPolicyValue[] =
 {
   TAO_ENCAP_BYTE_ORDER, // byte order
-  41,
-  ACE_NTOHL (0x49444c3a),
-  ACE_NTOHL (0x506f7274),
-  ACE_NTOHL (0x61626c65),
-  ACE_NTOHL (0x53657276),
-  ACE_NTOHL (0x65722f54),
-  ACE_NTOHL (0x68726561),
-  ACE_NTOHL (0x64506f6c),
-  ACE_NTOHL (0x69637956),
-  ACE_NTOHL (0x616c7565),
-  ACE_NTOHL (0x3a312e30),
-  ACE_NTOHL (0x0),  // repository ID = IDL:PortableServer/ThreadPolicyValue:1.0
+  49,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x506f7274), 
+  ACE_NTOHL (0x61626c65), 
+  ACE_NTOHL (0x53657276), 
+  ACE_NTOHL (0x65722f54), 
+  ACE_NTOHL (0x68726561), 
+  ACE_NTOHL (0x64506f6c), 
+  ACE_NTOHL (0x69637956), 
+  ACE_NTOHL (0x616c7565), 
+  ACE_NTOHL (0x3a312e30), 
+  ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/PortableServer/ThreadPolicyValue:1.0
   18,
-  ACE_NTOHL (0x54687265),
-  ACE_NTOHL (0x6164506f),
-  ACE_NTOHL (0x6c696379),
-  ACE_NTOHL (0x56616c75),
+  ACE_NTOHL (0x54687265), 
+  ACE_NTOHL (0x6164506f), 
+  ACE_NTOHL (0x6c696379), 
+  ACE_NTOHL (0x56616c75), 
   ACE_NTOHL (0x65000000),  // name = ThreadPolicyValue
   2, // member count
   15,
-  ACE_NTOHL (0x4f52425f),
-  ACE_NTOHL (0x4354524c),
-  ACE_NTOHL (0x5f4d4f44),
+  ACE_NTOHL (0x4f52425f), 
+  ACE_NTOHL (0x4354524c), 
+  ACE_NTOHL (0x5f4d4f44), 
   ACE_NTOHL (0x454c0000),  // name = ORB_CTRL_MODEL
   20,
-  ACE_NTOHL (0x53494e47),
-  ACE_NTOHL (0x4c455f54),
-  ACE_NTOHL (0x48524541),
-  ACE_NTOHL (0x445f4d4f),
+  ACE_NTOHL (0x53494e47), 
+  ACE_NTOHL (0x4c455f54), 
+  ACE_NTOHL (0x48524541), 
+  ACE_NTOHL (0x445f4d4f), 
   ACE_NTOHL (0x44454c00),  // name = SINGLE_THREAD_MODEL
 };
 
@@ -497,7 +788,7 @@ static CORBA::TypeCode _tc_TAO_tc_PortableServer_ThreadPolicyValue (
 
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
 TAO_NAMESPACE_BEGIN (PortableServer)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ThreadPolicyValue, &_tc_TAO_tc_PortableServer_ThreadPolicyValue)
+TAO_NAMESPACE_DEFINE (::CORBA::TypeCode_ptr, _tc_ThreadPolicyValue, &_tc_TAO_tc_PortableServer_ThreadPolicyValue)
 TAO_NAMESPACE_END
 
 int PortableServer::ThreadPolicy::_tao_class_id = 0;
@@ -550,7 +841,7 @@ PortableServer::ThreadPolicy_var::operator const ::PortableServer::ThreadPolicy_
   return this->ptr_;
 }
 
-PortableServer::ThreadPolicy_var::operator ::PortableServer::ThreadPolicy_ptr &() // cast
+PortableServer::ThreadPolicy_var::operator ::PortableServer::ThreadPolicy_ptr &() // cast 
 {
   return this->ptr_;
 }
@@ -686,42 +977,40 @@ PortableServer::ThreadPolicy_out::operator-> (void)
 
 
 // default constructor
-PortableServer::ThreadPolicy::ThreadPolicy ()
-{
-  }
-
-// destructor
-PortableServer::ThreadPolicy::~ThreadPolicy (void)
+PortableServer::ThreadPolicy::ThreadPolicy (void)
 {}
-
-PortableServer::ThreadPolicy_ptr PortableServer::ThreadPolicy::_narrow (
-    CORBA::Object_ptr obj
-    TAO_ENV_ARG_DECL
-  )
-{
-  return ThreadPolicy::_unchecked_narrow (obj TAO_ENV_ARG_PARAMETER);
-}
-
-PortableServer::ThreadPolicy_ptr PortableServer::ThreadPolicy::_unchecked_narrow (
-    CORBA::Object_ptr obj
-    TAO_ENV_ARG_DECL_NOT_USED
-  )
-{
-  if (CORBA::is_nil (obj))
-    return ThreadPolicy::_nil ();
-  return
-      ACE_reinterpret_cast
-        (
-          ThreadPolicy_ptr,
-            obj->_tao_QueryInterface
-              (
-                ACE_reinterpret_cast
-                  (
-                    ptr_arith_t,
-                    &ThreadPolicy::_tao_class_id
-                  )
-              )
-        );
+  // destructor
+  PortableServer::ThreadPolicy::~ThreadPolicy (void)
+  {}
+  
+  PortableServer::ThreadPolicy_ptr PortableServer::ThreadPolicy::_narrow (
+      CORBA::Object_ptr obj
+      TAO_ENV_ARG_DECL
+    )
+  {
+    return ThreadPolicy::_unchecked_narrow (obj TAO_ENV_ARG_PARAMETER);
+  }
+  
+  PortableServer::ThreadPolicy_ptr PortableServer::ThreadPolicy::_unchecked_narrow (
+      CORBA::Object_ptr obj
+      TAO_ENV_ARG_DECL_NOT_USED
+    )
+  {
+    if (CORBA::is_nil (obj))
+      return ThreadPolicy::_nil ();
+    return
+        ACE_reinterpret_cast
+          (
+            ThreadPolicy_ptr,
+              obj->_tao_QueryInterface
+                (
+                  ACE_reinterpret_cast
+                    (
+                      ptr_arith_t,
+                      &ThreadPolicy::_tao_class_id
+                    )
+                )
+          );
 }
 
 PortableServer::ThreadPolicy_ptr
@@ -754,7 +1043,7 @@ void *PortableServer::ThreadPolicy::_tao_QueryInterface (ptr_arith_t type)
   else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_tao_class_id))
     retv = ACE_reinterpret_cast (void *,
       ACE_static_cast (CORBA::Object_ptr, this));
-
+    
   if (retv)
     this->_add_ref ();
   return retv;
@@ -762,7 +1051,7 @@ void *PortableServer::ThreadPolicy::_tao_QueryInterface (ptr_arith_t type)
 
 const char* PortableServer::ThreadPolicy::_interface_repository_id (void) const
 {
-  return "IDL:PortableServer/ThreadPolicy:1.0";
+  return "IDL:omg.org/PortableServer/ThreadPolicy:1.0";
 }
 
 #endif /* TAO_HAS_MINIMUM_POA == 0 */
@@ -770,32 +1059,34 @@ const char* PortableServer::ThreadPolicy::_interface_repository_id (void) const
 static const CORBA::Long _oc_PortableServer_LifespanPolicyValue[] =
 {
   TAO_ENCAP_BYTE_ORDER, // byte order
-  43,
-  ACE_NTOHL (0x49444c3a),
-  ACE_NTOHL (0x506f7274),
-  ACE_NTOHL (0x61626c65),
-  ACE_NTOHL (0x53657276),
-  ACE_NTOHL (0x65722f4c),
-  ACE_NTOHL (0x69666573),
-  ACE_NTOHL (0x70616e50),
-  ACE_NTOHL (0x6f6c6963),
-  ACE_NTOHL (0x7956616c),
-  ACE_NTOHL (0x75653a31),
-  ACE_NTOHL (0x2e300000),  // repository ID = IDL:PortableServer/LifespanPolicyValue:1.0
+  51,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x506f7274), 
+  ACE_NTOHL (0x61626c65), 
+  ACE_NTOHL (0x53657276), 
+  ACE_NTOHL (0x65722f4c), 
+  ACE_NTOHL (0x69666573), 
+  ACE_NTOHL (0x70616e50), 
+  ACE_NTOHL (0x6f6c6963), 
+  ACE_NTOHL (0x7956616c), 
+  ACE_NTOHL (0x75653a31), 
+  ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/PortableServer/LifespanPolicyValue:1.0
   20,
-  ACE_NTOHL (0x4c696665),
-  ACE_NTOHL (0x7370616e),
-  ACE_NTOHL (0x506f6c69),
-  ACE_NTOHL (0x63795661),
+  ACE_NTOHL (0x4c696665), 
+  ACE_NTOHL (0x7370616e), 
+  ACE_NTOHL (0x506f6c69), 
+  ACE_NTOHL (0x63795661), 
   ACE_NTOHL (0x6c756500),  // name = LifespanPolicyValue
   2, // member count
   10,
-  ACE_NTOHL (0x5452414e),
-  ACE_NTOHL (0x5349454e),
+  ACE_NTOHL (0x5452414e), 
+  ACE_NTOHL (0x5349454e), 
   ACE_NTOHL (0x54000000),  // name = TRANSIENT
   11,
-  ACE_NTOHL (0x50455253),
-  ACE_NTOHL (0x49535445),
+  ACE_NTOHL (0x50455253), 
+  ACE_NTOHL (0x49535445), 
   ACE_NTOHL (0x4e540000),  // name = PERSISTENT
 };
 
@@ -809,7 +1100,7 @@ static CORBA::TypeCode _tc_TAO_tc_PortableServer_LifespanPolicyValue (
 
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
 TAO_NAMESPACE_BEGIN (PortableServer)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_LifespanPolicyValue, &_tc_TAO_tc_PortableServer_LifespanPolicyValue)
+TAO_NAMESPACE_DEFINE (::CORBA::TypeCode_ptr, _tc_LifespanPolicyValue, &_tc_TAO_tc_PortableServer_LifespanPolicyValue)
 TAO_NAMESPACE_END
 
 int PortableServer::LifespanPolicy::_tao_class_id = 0;
@@ -862,7 +1153,7 @@ PortableServer::LifespanPolicy_var::operator const ::PortableServer::LifespanPol
   return this->ptr_;
 }
 
-PortableServer::LifespanPolicy_var::operator ::PortableServer::LifespanPolicy_ptr &() // cast
+PortableServer::LifespanPolicy_var::operator ::PortableServer::LifespanPolicy_ptr &() // cast 
 {
   return this->ptr_;
 }
@@ -998,42 +1289,40 @@ PortableServer::LifespanPolicy_out::operator-> (void)
 
 
 // default constructor
-PortableServer::LifespanPolicy::LifespanPolicy ()
-{
-  }
-
-// destructor
-PortableServer::LifespanPolicy::~LifespanPolicy (void)
+PortableServer::LifespanPolicy::LifespanPolicy (void)
 {}
-
-PortableServer::LifespanPolicy_ptr PortableServer::LifespanPolicy::_narrow (
-    CORBA::Object_ptr obj
-    TAO_ENV_ARG_DECL
-  )
-{
-  return LifespanPolicy::_unchecked_narrow (obj TAO_ENV_ARG_PARAMETER);
-}
-
-PortableServer::LifespanPolicy_ptr PortableServer::LifespanPolicy::_unchecked_narrow (
-    CORBA::Object_ptr obj
-    TAO_ENV_ARG_DECL_NOT_USED
-  )
-{
-  if (CORBA::is_nil (obj))
-    return LifespanPolicy::_nil ();
-  return
-      ACE_reinterpret_cast
-        (
-          LifespanPolicy_ptr,
-            obj->_tao_QueryInterface
-              (
-                ACE_reinterpret_cast
-                  (
-                    ptr_arith_t,
-                    &LifespanPolicy::_tao_class_id
-                  )
-              )
-        );
+  // destructor
+  PortableServer::LifespanPolicy::~LifespanPolicy (void)
+  {}
+  
+  PortableServer::LifespanPolicy_ptr PortableServer::LifespanPolicy::_narrow (
+      CORBA::Object_ptr obj
+      TAO_ENV_ARG_DECL
+    )
+  {
+    return LifespanPolicy::_unchecked_narrow (obj TAO_ENV_ARG_PARAMETER);
+  }
+  
+  PortableServer::LifespanPolicy_ptr PortableServer::LifespanPolicy::_unchecked_narrow (
+      CORBA::Object_ptr obj
+      TAO_ENV_ARG_DECL_NOT_USED
+    )
+  {
+    if (CORBA::is_nil (obj))
+      return LifespanPolicy::_nil ();
+    return
+        ACE_reinterpret_cast
+          (
+            LifespanPolicy_ptr,
+              obj->_tao_QueryInterface
+                (
+                  ACE_reinterpret_cast
+                    (
+                      ptr_arith_t,
+                      &LifespanPolicy::_tao_class_id
+                    )
+                )
+          );
 }
 
 PortableServer::LifespanPolicy_ptr
@@ -1066,7 +1355,7 @@ void *PortableServer::LifespanPolicy::_tao_QueryInterface (ptr_arith_t type)
   else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_tao_class_id))
     retv = ACE_reinterpret_cast (void *,
       ACE_static_cast (CORBA::Object_ptr, this));
-
+    
   if (retv)
     this->_add_ref ();
   return retv;
@@ -1074,40 +1363,42 @@ void *PortableServer::LifespanPolicy::_tao_QueryInterface (ptr_arith_t type)
 
 const char* PortableServer::LifespanPolicy::_interface_repository_id (void) const
 {
-  return "IDL:PortableServer/LifespanPolicy:1.0";
+  return "IDL:omg.org/PortableServer/LifespanPolicy:1.0";
 }
 
 static const CORBA::Long _oc_PortableServer_IdUniquenessPolicyValue[] =
 {
   TAO_ENCAP_BYTE_ORDER, // byte order
-  47,
-  ACE_NTOHL (0x49444c3a),
-  ACE_NTOHL (0x506f7274),
-  ACE_NTOHL (0x61626c65),
-  ACE_NTOHL (0x53657276),
-  ACE_NTOHL (0x65722f49),
-  ACE_NTOHL (0x64556e69),
-  ACE_NTOHL (0x7175656e),
-  ACE_NTOHL (0x65737350),
-  ACE_NTOHL (0x6f6c6963),
-  ACE_NTOHL (0x7956616c),
-  ACE_NTOHL (0x75653a31),
-  ACE_NTOHL (0x2e300000),  // repository ID = IDL:PortableServer/IdUniquenessPolicyValue:1.0
+  55,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x506f7274), 
+  ACE_NTOHL (0x61626c65), 
+  ACE_NTOHL (0x53657276), 
+  ACE_NTOHL (0x65722f49), 
+  ACE_NTOHL (0x64556e69), 
+  ACE_NTOHL (0x7175656e), 
+  ACE_NTOHL (0x65737350), 
+  ACE_NTOHL (0x6f6c6963), 
+  ACE_NTOHL (0x7956616c), 
+  ACE_NTOHL (0x75653a31), 
+  ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/PortableServer/IdUniquenessPolicyValue:1.0
   24,
-  ACE_NTOHL (0x4964556e),
-  ACE_NTOHL (0x69717565),
-  ACE_NTOHL (0x6e657373),
-  ACE_NTOHL (0x506f6c69),
-  ACE_NTOHL (0x63795661),
+  ACE_NTOHL (0x4964556e), 
+  ACE_NTOHL (0x69717565), 
+  ACE_NTOHL (0x6e657373), 
+  ACE_NTOHL (0x506f6c69), 
+  ACE_NTOHL (0x63795661), 
   ACE_NTOHL (0x6c756500),  // name = IdUniquenessPolicyValue
   2, // member count
   10,
-  ACE_NTOHL (0x554e4951),
-  ACE_NTOHL (0x55455f49),
+  ACE_NTOHL (0x554e4951), 
+  ACE_NTOHL (0x55455f49), 
   ACE_NTOHL (0x44000000),  // name = UNIQUE_ID
   12,
-  ACE_NTOHL (0x4d554c54),
-  ACE_NTOHL (0x49504c45),
+  ACE_NTOHL (0x4d554c54), 
+  ACE_NTOHL (0x49504c45), 
   ACE_NTOHL (0x5f494400),  // name = MULTIPLE_ID
 };
 
@@ -1121,7 +1412,7 @@ static CORBA::TypeCode _tc_TAO_tc_PortableServer_IdUniquenessPolicyValue (
 
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
 TAO_NAMESPACE_BEGIN (PortableServer)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_IdUniquenessPolicyValue, &_tc_TAO_tc_PortableServer_IdUniquenessPolicyValue)
+TAO_NAMESPACE_DEFINE (::CORBA::TypeCode_ptr, _tc_IdUniquenessPolicyValue, &_tc_TAO_tc_PortableServer_IdUniquenessPolicyValue)
 TAO_NAMESPACE_END
 
 int PortableServer::IdUniquenessPolicy::_tao_class_id = 0;
@@ -1174,7 +1465,7 @@ PortableServer::IdUniquenessPolicy_var::operator const ::PortableServer::IdUniqu
   return this->ptr_;
 }
 
-PortableServer::IdUniquenessPolicy_var::operator ::PortableServer::IdUniquenessPolicy_ptr &() // cast
+PortableServer::IdUniquenessPolicy_var::operator ::PortableServer::IdUniquenessPolicy_ptr &() // cast 
 {
   return this->ptr_;
 }
@@ -1310,42 +1601,40 @@ PortableServer::IdUniquenessPolicy_out::operator-> (void)
 
 
 // default constructor
-PortableServer::IdUniquenessPolicy::IdUniquenessPolicy ()
-{
-  }
-
-// destructor
-PortableServer::IdUniquenessPolicy::~IdUniquenessPolicy (void)
+PortableServer::IdUniquenessPolicy::IdUniquenessPolicy (void)
 {}
-
-PortableServer::IdUniquenessPolicy_ptr PortableServer::IdUniquenessPolicy::_narrow (
-    CORBA::Object_ptr obj
-    TAO_ENV_ARG_DECL
-  )
-{
-  return IdUniquenessPolicy::_unchecked_narrow (obj TAO_ENV_ARG_PARAMETER);
-}
-
-PortableServer::IdUniquenessPolicy_ptr PortableServer::IdUniquenessPolicy::_unchecked_narrow (
-    CORBA::Object_ptr obj
-    TAO_ENV_ARG_DECL_NOT_USED
-  )
-{
-  if (CORBA::is_nil (obj))
-    return IdUniquenessPolicy::_nil ();
-  return
-      ACE_reinterpret_cast
-        (
-          IdUniquenessPolicy_ptr,
-            obj->_tao_QueryInterface
-              (
-                ACE_reinterpret_cast
-                  (
-                    ptr_arith_t,
-                    &IdUniquenessPolicy::_tao_class_id
-                  )
-              )
-        );
+  // destructor
+  PortableServer::IdUniquenessPolicy::~IdUniquenessPolicy (void)
+  {}
+  
+  PortableServer::IdUniquenessPolicy_ptr PortableServer::IdUniquenessPolicy::_narrow (
+      CORBA::Object_ptr obj
+      TAO_ENV_ARG_DECL
+    )
+  {
+    return IdUniquenessPolicy::_unchecked_narrow (obj TAO_ENV_ARG_PARAMETER);
+  }
+  
+  PortableServer::IdUniquenessPolicy_ptr PortableServer::IdUniquenessPolicy::_unchecked_narrow (
+      CORBA::Object_ptr obj
+      TAO_ENV_ARG_DECL_NOT_USED
+    )
+  {
+    if (CORBA::is_nil (obj))
+      return IdUniquenessPolicy::_nil ();
+    return
+        ACE_reinterpret_cast
+          (
+            IdUniquenessPolicy_ptr,
+              obj->_tao_QueryInterface
+                (
+                  ACE_reinterpret_cast
+                    (
+                      ptr_arith_t,
+                      &IdUniquenessPolicy::_tao_class_id
+                    )
+                )
+          );
 }
 
 PortableServer::IdUniquenessPolicy_ptr
@@ -1378,7 +1667,7 @@ void *PortableServer::IdUniquenessPolicy::_tao_QueryInterface (ptr_arith_t type)
   else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_tao_class_id))
     retv = ACE_reinterpret_cast (void *,
       ACE_static_cast (CORBA::Object_ptr, this));
-
+    
   if (retv)
     this->_add_ref ();
   return retv;
@@ -1386,39 +1675,41 @@ void *PortableServer::IdUniquenessPolicy::_tao_QueryInterface (ptr_arith_t type)
 
 const char* PortableServer::IdUniquenessPolicy::_interface_repository_id (void) const
 {
-  return "IDL:PortableServer/IdUniquenessPolicy:1.0";
+  return "IDL:omg.org/PortableServer/IdUniquenessPolicy:1.0";
 }
 
 static const CORBA::Long _oc_PortableServer_IdAssignmentPolicyValue[] =
 {
   TAO_ENCAP_BYTE_ORDER, // byte order
-  47,
-  ACE_NTOHL (0x49444c3a),
-  ACE_NTOHL (0x506f7274),
-  ACE_NTOHL (0x61626c65),
-  ACE_NTOHL (0x53657276),
-  ACE_NTOHL (0x65722f49),
-  ACE_NTOHL (0x64417373),
-  ACE_NTOHL (0x69676e6d),
-  ACE_NTOHL (0x656e7450),
-  ACE_NTOHL (0x6f6c6963),
-  ACE_NTOHL (0x7956616c),
-  ACE_NTOHL (0x75653a31),
-  ACE_NTOHL (0x2e300000),  // repository ID = IDL:PortableServer/IdAssignmentPolicyValue:1.0
+  55,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x506f7274), 
+  ACE_NTOHL (0x61626c65), 
+  ACE_NTOHL (0x53657276), 
+  ACE_NTOHL (0x65722f49), 
+  ACE_NTOHL (0x64417373), 
+  ACE_NTOHL (0x69676e6d), 
+  ACE_NTOHL (0x656e7450), 
+  ACE_NTOHL (0x6f6c6963), 
+  ACE_NTOHL (0x7956616c), 
+  ACE_NTOHL (0x75653a31), 
+  ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/PortableServer/IdAssignmentPolicyValue:1.0
   24,
-  ACE_NTOHL (0x49644173),
-  ACE_NTOHL (0x7369676e),
-  ACE_NTOHL (0x6d656e74),
-  ACE_NTOHL (0x506f6c69),
-  ACE_NTOHL (0x63795661),
+  ACE_NTOHL (0x49644173), 
+  ACE_NTOHL (0x7369676e), 
+  ACE_NTOHL (0x6d656e74), 
+  ACE_NTOHL (0x506f6c69), 
+  ACE_NTOHL (0x63795661), 
   ACE_NTOHL (0x6c756500),  // name = IdAssignmentPolicyValue
   2, // member count
   8,
-  ACE_NTOHL (0x55534552),
+  ACE_NTOHL (0x55534552), 
   ACE_NTOHL (0x5f494400),  // name = USER_ID
   10,
-  ACE_NTOHL (0x53595354),
-  ACE_NTOHL (0x454d5f49),
+  ACE_NTOHL (0x53595354), 
+  ACE_NTOHL (0x454d5f49), 
   ACE_NTOHL (0x44000000),  // name = SYSTEM_ID
 };
 
@@ -1432,7 +1723,7 @@ static CORBA::TypeCode _tc_TAO_tc_PortableServer_IdAssignmentPolicyValue (
 
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
 TAO_NAMESPACE_BEGIN (PortableServer)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_IdAssignmentPolicyValue, &_tc_TAO_tc_PortableServer_IdAssignmentPolicyValue)
+TAO_NAMESPACE_DEFINE (::CORBA::TypeCode_ptr, _tc_IdAssignmentPolicyValue, &_tc_TAO_tc_PortableServer_IdAssignmentPolicyValue)
 TAO_NAMESPACE_END
 
 int PortableServer::IdAssignmentPolicy::_tao_class_id = 0;
@@ -1485,7 +1776,7 @@ PortableServer::IdAssignmentPolicy_var::operator const ::PortableServer::IdAssig
   return this->ptr_;
 }
 
-PortableServer::IdAssignmentPolicy_var::operator ::PortableServer::IdAssignmentPolicy_ptr &() // cast
+PortableServer::IdAssignmentPolicy_var::operator ::PortableServer::IdAssignmentPolicy_ptr &() // cast 
 {
   return this->ptr_;
 }
@@ -1621,42 +1912,40 @@ PortableServer::IdAssignmentPolicy_out::operator-> (void)
 
 
 // default constructor
-PortableServer::IdAssignmentPolicy::IdAssignmentPolicy ()
-{
-  }
-
-// destructor
-PortableServer::IdAssignmentPolicy::~IdAssignmentPolicy (void)
+PortableServer::IdAssignmentPolicy::IdAssignmentPolicy (void)
 {}
-
-PortableServer::IdAssignmentPolicy_ptr PortableServer::IdAssignmentPolicy::_narrow (
-    CORBA::Object_ptr obj
-    TAO_ENV_ARG_DECL
-  )
-{
-  return IdAssignmentPolicy::_unchecked_narrow (obj TAO_ENV_ARG_PARAMETER);
-}
-
-PortableServer::IdAssignmentPolicy_ptr PortableServer::IdAssignmentPolicy::_unchecked_narrow (
-    CORBA::Object_ptr obj
-    TAO_ENV_ARG_DECL_NOT_USED
-  )
-{
-  if (CORBA::is_nil (obj))
-    return IdAssignmentPolicy::_nil ();
-  return
-      ACE_reinterpret_cast
-        (
-          IdAssignmentPolicy_ptr,
-            obj->_tao_QueryInterface
-              (
-                ACE_reinterpret_cast
-                  (
-                    ptr_arith_t,
-                    &IdAssignmentPolicy::_tao_class_id
-                  )
-              )
-        );
+  // destructor
+  PortableServer::IdAssignmentPolicy::~IdAssignmentPolicy (void)
+  {}
+  
+  PortableServer::IdAssignmentPolicy_ptr PortableServer::IdAssignmentPolicy::_narrow (
+      CORBA::Object_ptr obj
+      TAO_ENV_ARG_DECL
+    )
+  {
+    return IdAssignmentPolicy::_unchecked_narrow (obj TAO_ENV_ARG_PARAMETER);
+  }
+  
+  PortableServer::IdAssignmentPolicy_ptr PortableServer::IdAssignmentPolicy::_unchecked_narrow (
+      CORBA::Object_ptr obj
+      TAO_ENV_ARG_DECL_NOT_USED
+    )
+  {
+    if (CORBA::is_nil (obj))
+      return IdAssignmentPolicy::_nil ();
+    return
+        ACE_reinterpret_cast
+          (
+            IdAssignmentPolicy_ptr,
+              obj->_tao_QueryInterface
+                (
+                  ACE_reinterpret_cast
+                    (
+                      ptr_arith_t,
+                      &IdAssignmentPolicy::_tao_class_id
+                    )
+                )
+          );
 }
 
 PortableServer::IdAssignmentPolicy_ptr
@@ -1689,7 +1978,7 @@ void *PortableServer::IdAssignmentPolicy::_tao_QueryInterface (ptr_arith_t type)
   else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_tao_class_id))
     retv = ACE_reinterpret_cast (void *,
       ACE_static_cast (CORBA::Object_ptr, this));
-
+    
   if (retv)
     this->_add_ref ();
   return retv;
@@ -1697,7 +1986,7 @@ void *PortableServer::IdAssignmentPolicy::_tao_QueryInterface (ptr_arith_t type)
 
 const char* PortableServer::IdAssignmentPolicy::_interface_repository_id (void) const
 {
-  return "IDL:PortableServer/IdAssignmentPolicy:1.0";
+  return "IDL:omg.org/PortableServer/IdAssignmentPolicy:1.0";
 }
 
 #if (TAO_HAS_MINIMUM_POA == 0)
@@ -1705,43 +1994,45 @@ const char* PortableServer::IdAssignmentPolicy::_interface_repository_id (void)
 static const CORBA::Long _oc_PortableServer_ImplicitActivationPolicyValue[] =
 {
   TAO_ENCAP_BYTE_ORDER, // byte order
-  53,
-  ACE_NTOHL (0x49444c3a),
-  ACE_NTOHL (0x506f7274),
-  ACE_NTOHL (0x61626c65),
-  ACE_NTOHL (0x53657276),
-  ACE_NTOHL (0x65722f49),
-  ACE_NTOHL (0x6d706c69),
-  ACE_NTOHL (0x63697441),
-  ACE_NTOHL (0x63746976),
-  ACE_NTOHL (0x6174696f),
-  ACE_NTOHL (0x6e506f6c),
-  ACE_NTOHL (0x69637956),
-  ACE_NTOHL (0x616c7565),
-  ACE_NTOHL (0x3a312e30),
-  ACE_NTOHL (0x0),  // repository ID = IDL:PortableServer/ImplicitActivationPolicyValue:1.0
+  61,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x506f7274), 
+  ACE_NTOHL (0x61626c65), 
+  ACE_NTOHL (0x53657276), 
+  ACE_NTOHL (0x65722f49), 
+  ACE_NTOHL (0x6d706c69), 
+  ACE_NTOHL (0x63697441), 
+  ACE_NTOHL (0x63746976), 
+  ACE_NTOHL (0x6174696f), 
+  ACE_NTOHL (0x6e506f6c), 
+  ACE_NTOHL (0x69637956), 
+  ACE_NTOHL (0x616c7565), 
+  ACE_NTOHL (0x3a312e30), 
+  ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/PortableServer/ImplicitActivationPolicyValue:1.0
   30,
-  ACE_NTOHL (0x496d706c),
-  ACE_NTOHL (0x69636974),
-  ACE_NTOHL (0x41637469),
-  ACE_NTOHL (0x76617469),
-  ACE_NTOHL (0x6f6e506f),
-  ACE_NTOHL (0x6c696379),
-  ACE_NTOHL (0x56616c75),
+  ACE_NTOHL (0x496d706c), 
+  ACE_NTOHL (0x69636974), 
+  ACE_NTOHL (0x41637469), 
+  ACE_NTOHL (0x76617469), 
+  ACE_NTOHL (0x6f6e506f), 
+  ACE_NTOHL (0x6c696379), 
+  ACE_NTOHL (0x56616c75), 
   ACE_NTOHL (0x65000000),  // name = ImplicitActivationPolicyValue
   2, // member count
   20,
-  ACE_NTOHL (0x494d504c),
-  ACE_NTOHL (0x49434954),
-  ACE_NTOHL (0x5f414354),
-  ACE_NTOHL (0x49564154),
+  ACE_NTOHL (0x494d504c), 
+  ACE_NTOHL (0x49434954), 
+  ACE_NTOHL (0x5f414354), 
+  ACE_NTOHL (0x49564154), 
   ACE_NTOHL (0x494f4e00),  // name = IMPLICIT_ACTIVATION
   23,
-  ACE_NTOHL (0x4e4f5f49),
-  ACE_NTOHL (0x4d504c49),
-  ACE_NTOHL (0x4349545f),
-  ACE_NTOHL (0x41435449),
-  ACE_NTOHL (0x56415449),
+  ACE_NTOHL (0x4e4f5f49), 
+  ACE_NTOHL (0x4d504c49), 
+  ACE_NTOHL (0x4349545f), 
+  ACE_NTOHL (0x41435449), 
+  ACE_NTOHL (0x56415449), 
   ACE_NTOHL (0x4f4e0000),  // name = NO_IMPLICIT_ACTIVATION
 };
 
@@ -1755,7 +2046,7 @@ static CORBA::TypeCode _tc_TAO_tc_PortableServer_ImplicitActivationPolicyValue (
 
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
 TAO_NAMESPACE_BEGIN (PortableServer)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ImplicitActivationPolicyValue, &_tc_TAO_tc_PortableServer_ImplicitActivationPolicyValue)
+TAO_NAMESPACE_DEFINE (::CORBA::TypeCode_ptr, _tc_ImplicitActivationPolicyValue, &_tc_TAO_tc_PortableServer_ImplicitActivationPolicyValue)
 TAO_NAMESPACE_END
 
 int PortableServer::ImplicitActivationPolicy::_tao_class_id = 0;
@@ -1808,7 +2099,7 @@ PortableServer::ImplicitActivationPolicy_var::operator const ::PortableServer::I
   return this->ptr_;
 }
 
-PortableServer::ImplicitActivationPolicy_var::operator ::PortableServer::ImplicitActivationPolicy_ptr &() // cast
+PortableServer::ImplicitActivationPolicy_var::operator ::PortableServer::ImplicitActivationPolicy_ptr &() // cast 
 {
   return this->ptr_;
 }
@@ -1944,42 +2235,40 @@ PortableServer::ImplicitActivationPolicy_out::operator-> (void)
 
 
 // default constructor
-PortableServer::ImplicitActivationPolicy::ImplicitActivationPolicy ()
-{
-  }
-
-// destructor
-PortableServer::ImplicitActivationPolicy::~ImplicitActivationPolicy (void)
+PortableServer::ImplicitActivationPolicy::ImplicitActivationPolicy (void)
 {}
-
-PortableServer::ImplicitActivationPolicy_ptr PortableServer::ImplicitActivationPolicy::_narrow (
-    CORBA::Object_ptr obj
-    TAO_ENV_ARG_DECL
-  )
-{
-  return ImplicitActivationPolicy::_unchecked_narrow (obj TAO_ENV_ARG_PARAMETER);
-}
-
-PortableServer::ImplicitActivationPolicy_ptr PortableServer::ImplicitActivationPolicy::_unchecked_narrow (
-    CORBA::Object_ptr obj
-    TAO_ENV_ARG_DECL_NOT_USED
-  )
-{
-  if (CORBA::is_nil (obj))
-    return ImplicitActivationPolicy::_nil ();
-  return
-      ACE_reinterpret_cast
-        (
-          ImplicitActivationPolicy_ptr,
-            obj->_tao_QueryInterface
-              (
-                ACE_reinterpret_cast
-                  (
-                    ptr_arith_t,
-                    &ImplicitActivationPolicy::_tao_class_id
-                  )
-              )
-        );
+  // destructor
+  PortableServer::ImplicitActivationPolicy::~ImplicitActivationPolicy (void)
+  {}
+  
+  PortableServer::ImplicitActivationPolicy_ptr PortableServer::ImplicitActivationPolicy::_narrow (
+      CORBA::Object_ptr obj
+      TAO_ENV_ARG_DECL
+    )
+  {
+    return ImplicitActivationPolicy::_unchecked_narrow (obj TAO_ENV_ARG_PARAMETER);
+  }
+  
+  PortableServer::ImplicitActivationPolicy_ptr PortableServer::ImplicitActivationPolicy::_unchecked_narrow (
+      CORBA::Object_ptr obj
+      TAO_ENV_ARG_DECL_NOT_USED
+    )
+  {
+    if (CORBA::is_nil (obj))
+      return ImplicitActivationPolicy::_nil ();
+    return
+        ACE_reinterpret_cast
+          (
+            ImplicitActivationPolicy_ptr,
+              obj->_tao_QueryInterface
+                (
+                  ACE_reinterpret_cast
+                    (
+                      ptr_arith_t,
+                      &ImplicitActivationPolicy::_tao_class_id
+                    )
+                )
+          );
 }
 
 PortableServer::ImplicitActivationPolicy_ptr
@@ -2012,7 +2301,7 @@ void *PortableServer::ImplicitActivationPolicy::_tao_QueryInterface (ptr_arith_t
   else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_tao_class_id))
     retv = ACE_reinterpret_cast (void *,
       ACE_static_cast (CORBA::Object_ptr, this));
-
+    
   if (retv)
     this->_add_ref ();
   return retv;
@@ -2020,41 +2309,43 @@ void *PortableServer::ImplicitActivationPolicy::_tao_QueryInterface (ptr_arith_t
 
 const char* PortableServer::ImplicitActivationPolicy::_interface_repository_id (void) const
 {
-  return "IDL:PortableServer/ImplicitActivationPolicy:1.0";
+  return "IDL:omg.org/PortableServer/ImplicitActivationPolicy:1.0";
 }
 
 static const CORBA::Long _oc_PortableServer_ServantRetentionPolicyValue[] =
 {
   TAO_ENCAP_BYTE_ORDER, // byte order
-  51,
-  ACE_NTOHL (0x49444c3a),
-  ACE_NTOHL (0x506f7274),
-  ACE_NTOHL (0x61626c65),
-  ACE_NTOHL (0x53657276),
-  ACE_NTOHL (0x65722f53),
-  ACE_NTOHL (0x65727661),
-  ACE_NTOHL (0x6e745265),
-  ACE_NTOHL (0x74656e74),
-  ACE_NTOHL (0x696f6e50),
-  ACE_NTOHL (0x6f6c6963),
-  ACE_NTOHL (0x7956616c),
-  ACE_NTOHL (0x75653a31),
-  ACE_NTOHL (0x2e300000),  // repository ID = IDL:PortableServer/ServantRetentionPolicyValue:1.0
+  59,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x506f7274), 
+  ACE_NTOHL (0x61626c65), 
+  ACE_NTOHL (0x53657276), 
+  ACE_NTOHL (0x65722f53), 
+  ACE_NTOHL (0x65727661), 
+  ACE_NTOHL (0x6e745265), 
+  ACE_NTOHL (0x74656e74), 
+  ACE_NTOHL (0x696f6e50), 
+  ACE_NTOHL (0x6f6c6963), 
+  ACE_NTOHL (0x7956616c), 
+  ACE_NTOHL (0x75653a31), 
+  ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/PortableServer/ServantRetentionPolicyValue:1.0
   28,
-  ACE_NTOHL (0x53657276),
-  ACE_NTOHL (0x616e7452),
-  ACE_NTOHL (0x6574656e),
-  ACE_NTOHL (0x74696f6e),
-  ACE_NTOHL (0x506f6c69),
-  ACE_NTOHL (0x63795661),
+  ACE_NTOHL (0x53657276), 
+  ACE_NTOHL (0x616e7452), 
+  ACE_NTOHL (0x6574656e), 
+  ACE_NTOHL (0x74696f6e), 
+  ACE_NTOHL (0x506f6c69), 
+  ACE_NTOHL (0x63795661), 
   ACE_NTOHL (0x6c756500),  // name = ServantRetentionPolicyValue
   2, // member count
   7,
-  ACE_NTOHL (0x52455441),
+  ACE_NTOHL (0x52455441), 
   ACE_NTOHL (0x494e0000),  // name = RETAIN
   11,
-  ACE_NTOHL (0x4e4f4e5f),
-  ACE_NTOHL (0x52455441),
+  ACE_NTOHL (0x4e4f4e5f), 
+  ACE_NTOHL (0x52455441), 
   ACE_NTOHL (0x494e0000),  // name = NON_RETAIN
 };
 
@@ -2068,7 +2359,7 @@ static CORBA::TypeCode _tc_TAO_tc_PortableServer_ServantRetentionPolicyValue (
 
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
 TAO_NAMESPACE_BEGIN (PortableServer)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ServantRetentionPolicyValue, &_tc_TAO_tc_PortableServer_ServantRetentionPolicyValue)
+TAO_NAMESPACE_DEFINE (::CORBA::TypeCode_ptr, _tc_ServantRetentionPolicyValue, &_tc_TAO_tc_PortableServer_ServantRetentionPolicyValue)
 TAO_NAMESPACE_END
 
 int PortableServer::ServantRetentionPolicy::_tao_class_id = 0;
@@ -2121,7 +2412,7 @@ PortableServer::ServantRetentionPolicy_var::operator const ::PortableServer::Ser
   return this->ptr_;
 }
 
-PortableServer::ServantRetentionPolicy_var::operator ::PortableServer::ServantRetentionPolicy_ptr &() // cast
+PortableServer::ServantRetentionPolicy_var::operator ::PortableServer::ServantRetentionPolicy_ptr &() // cast 
 {
   return this->ptr_;
 }
@@ -2257,42 +2548,40 @@ PortableServer::ServantRetentionPolicy_out::operator-> (void)
 
 
 // default constructor
-PortableServer::ServantRetentionPolicy::ServantRetentionPolicy ()
-{
-  }
-
-// destructor
-PortableServer::ServantRetentionPolicy::~ServantRetentionPolicy (void)
+PortableServer::ServantRetentionPolicy::ServantRetentionPolicy (void)
 {}
-
-PortableServer::ServantRetentionPolicy_ptr PortableServer::ServantRetentionPolicy::_narrow (
-    CORBA::Object_ptr obj
-    TAO_ENV_ARG_DECL
-  )
-{
-  return ServantRetentionPolicy::_unchecked_narrow (obj TAO_ENV_ARG_PARAMETER);
-}
-
-PortableServer::ServantRetentionPolicy_ptr PortableServer::ServantRetentionPolicy::_unchecked_narrow (
-    CORBA::Object_ptr obj
-    TAO_ENV_ARG_DECL_NOT_USED
-  )
-{
-  if (CORBA::is_nil (obj))
-    return ServantRetentionPolicy::_nil ();
-  return
-      ACE_reinterpret_cast
-        (
-          ServantRetentionPolicy_ptr,
-            obj->_tao_QueryInterface
-              (
-                ACE_reinterpret_cast
-                  (
-                    ptr_arith_t,
-                    &ServantRetentionPolicy::_tao_class_id
-                  )
-              )
-        );
+  // destructor
+  PortableServer::ServantRetentionPolicy::~ServantRetentionPolicy (void)
+  {}
+  
+  PortableServer::ServantRetentionPolicy_ptr PortableServer::ServantRetentionPolicy::_narrow (
+      CORBA::Object_ptr obj
+      TAO_ENV_ARG_DECL
+    )
+  {
+    return ServantRetentionPolicy::_unchecked_narrow (obj TAO_ENV_ARG_PARAMETER);
+  }
+  
+  PortableServer::ServantRetentionPolicy_ptr PortableServer::ServantRetentionPolicy::_unchecked_narrow (
+      CORBA::Object_ptr obj
+      TAO_ENV_ARG_DECL_NOT_USED
+    )
+  {
+    if (CORBA::is_nil (obj))
+      return ServantRetentionPolicy::_nil ();
+    return
+        ACE_reinterpret_cast
+          (
+            ServantRetentionPolicy_ptr,
+              obj->_tao_QueryInterface
+                (
+                  ACE_reinterpret_cast
+                    (
+                      ptr_arith_t,
+                      &ServantRetentionPolicy::_tao_class_id
+                    )
+                )
+          );
 }
 
 PortableServer::ServantRetentionPolicy_ptr
@@ -2325,7 +2614,7 @@ void *PortableServer::ServantRetentionPolicy::_tao_QueryInterface (ptr_arith_t t
   else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_tao_class_id))
     retv = ACE_reinterpret_cast (void *,
       ACE_static_cast (CORBA::Object_ptr, this));
-
+    
   if (retv)
     this->_add_ref ();
   return retv;
@@ -2333,55 +2622,57 @@ void *PortableServer::ServantRetentionPolicy::_tao_QueryInterface (ptr_arith_t t
 
 const char* PortableServer::ServantRetentionPolicy::_interface_repository_id (void) const
 {
-  return "IDL:PortableServer/ServantRetentionPolicy:1.0";
+  return "IDL:omg.org/PortableServer/ServantRetentionPolicy:1.0";
 }
 
 static const CORBA::Long _oc_PortableServer_RequestProcessingPolicyValue[] =
 {
   TAO_ENCAP_BYTE_ORDER, // byte order
-  52,
-  ACE_NTOHL (0x49444c3a),
-  ACE_NTOHL (0x506f7274),
-  ACE_NTOHL (0x61626c65),
-  ACE_NTOHL (0x53657276),
-  ACE_NTOHL (0x65722f52),
-  ACE_NTOHL (0x65717565),
-  ACE_NTOHL (0x73745072),
-  ACE_NTOHL (0x6f636573),
-  ACE_NTOHL (0x73696e67),
-  ACE_NTOHL (0x506f6c69),
-  ACE_NTOHL (0x63795661),
-  ACE_NTOHL (0x6c75653a),
-  ACE_NTOHL (0x312e3000),  // repository ID = IDL:PortableServer/RequestProcessingPolicyValue:1.0
+  60,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x506f7274), 
+  ACE_NTOHL (0x61626c65), 
+  ACE_NTOHL (0x53657276), 
+  ACE_NTOHL (0x65722f52), 
+  ACE_NTOHL (0x65717565), 
+  ACE_NTOHL (0x73745072), 
+  ACE_NTOHL (0x6f636573), 
+  ACE_NTOHL (0x73696e67), 
+  ACE_NTOHL (0x506f6c69), 
+  ACE_NTOHL (0x63795661), 
+  ACE_NTOHL (0x6c75653a), 
+  ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/PortableServer/RequestProcessingPolicyValue:1.0
   29,
-  ACE_NTOHL (0x52657175),
-  ACE_NTOHL (0x65737450),
-  ACE_NTOHL (0x726f6365),
-  ACE_NTOHL (0x7373696e),
-  ACE_NTOHL (0x67506f6c),
-  ACE_NTOHL (0x69637956),
-  ACE_NTOHL (0x616c7565),
+  ACE_NTOHL (0x52657175), 
+  ACE_NTOHL (0x65737450), 
+  ACE_NTOHL (0x726f6365), 
+  ACE_NTOHL (0x7373696e), 
+  ACE_NTOHL (0x67506f6c), 
+  ACE_NTOHL (0x69637956), 
+  ACE_NTOHL (0x616c7565), 
   ACE_NTOHL (0x0),  // name = RequestProcessingPolicyValue
   3, // member count
   27,
-  ACE_NTOHL (0x5553455f),
-  ACE_NTOHL (0x41435449),
-  ACE_NTOHL (0x56455f4f),
-  ACE_NTOHL (0x424a4543),
-  ACE_NTOHL (0x545f4d41),
-  ACE_NTOHL (0x505f4f4e),
+  ACE_NTOHL (0x5553455f), 
+  ACE_NTOHL (0x41435449), 
+  ACE_NTOHL (0x56455f4f), 
+  ACE_NTOHL (0x424a4543), 
+  ACE_NTOHL (0x545f4d41), 
+  ACE_NTOHL (0x505f4f4e), 
   ACE_NTOHL (0x4c590000),  // name = USE_ACTIVE_OBJECT_MAP_ONLY
   20,
-  ACE_NTOHL (0x5553455f),
-  ACE_NTOHL (0x44454641),
-  ACE_NTOHL (0x554c545f),
-  ACE_NTOHL (0x53455256),
+  ACE_NTOHL (0x5553455f), 
+  ACE_NTOHL (0x44454641), 
+  ACE_NTOHL (0x554c545f), 
+  ACE_NTOHL (0x53455256), 
   ACE_NTOHL (0x414e5400),  // name = USE_DEFAULT_SERVANT
   20,
-  ACE_NTOHL (0x5553455f),
-  ACE_NTOHL (0x53455256),
-  ACE_NTOHL (0x414e545f),
-  ACE_NTOHL (0x4d414e41),
+  ACE_NTOHL (0x5553455f), 
+  ACE_NTOHL (0x53455256), 
+  ACE_NTOHL (0x414e545f), 
+  ACE_NTOHL (0x4d414e41), 
   ACE_NTOHL (0x47455200),  // name = USE_SERVANT_MANAGER
 };
 
@@ -2395,7 +2686,7 @@ static CORBA::TypeCode _tc_TAO_tc_PortableServer_RequestProcessingPolicyValue (
 
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
 TAO_NAMESPACE_BEGIN (PortableServer)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_RequestProcessingPolicyValue, &_tc_TAO_tc_PortableServer_RequestProcessingPolicyValue)
+TAO_NAMESPACE_DEFINE (::CORBA::TypeCode_ptr, _tc_RequestProcessingPolicyValue, &_tc_TAO_tc_PortableServer_RequestProcessingPolicyValue)
 TAO_NAMESPACE_END
 
 int PortableServer::RequestProcessingPolicy::_tao_class_id = 0;
@@ -2448,7 +2739,7 @@ PortableServer::RequestProcessingPolicy_var::operator const ::PortableServer::Re
   return this->ptr_;
 }
 
-PortableServer::RequestProcessingPolicy_var::operator ::PortableServer::RequestProcessingPolicy_ptr &() // cast
+PortableServer::RequestProcessingPolicy_var::operator ::PortableServer::RequestProcessingPolicy_ptr &() // cast 
 {
   return this->ptr_;
 }
@@ -2584,42 +2875,40 @@ PortableServer::RequestProcessingPolicy_out::operator-> (void)
 
 
 // default constructor
-PortableServer::RequestProcessingPolicy::RequestProcessingPolicy ()
-{
-  }
-
-// destructor
-PortableServer::RequestProcessingPolicy::~RequestProcessingPolicy (void)
+PortableServer::RequestProcessingPolicy::RequestProcessingPolicy (void)
 {}
-
-PortableServer::RequestProcessingPolicy_ptr PortableServer::RequestProcessingPolicy::_narrow (
-    CORBA::Object_ptr obj
-    TAO_ENV_ARG_DECL
-  )
-{
-  return RequestProcessingPolicy::_unchecked_narrow (obj TAO_ENV_ARG_PARAMETER);
-}
-
-PortableServer::RequestProcessingPolicy_ptr PortableServer::RequestProcessingPolicy::_unchecked_narrow (
-    CORBA::Object_ptr obj
-    TAO_ENV_ARG_DECL_NOT_USED
-  )
-{
-  if (CORBA::is_nil (obj))
-    return RequestProcessingPolicy::_nil ();
-  return
-      ACE_reinterpret_cast
-        (
-          RequestProcessingPolicy_ptr,
-            obj->_tao_QueryInterface
-              (
-                ACE_reinterpret_cast
-                  (
-                    ptr_arith_t,
-                    &RequestProcessingPolicy::_tao_class_id
-                  )
-              )
-        );
+  // destructor
+  PortableServer::RequestProcessingPolicy::~RequestProcessingPolicy (void)
+  {}
+  
+  PortableServer::RequestProcessingPolicy_ptr PortableServer::RequestProcessingPolicy::_narrow (
+      CORBA::Object_ptr obj
+      TAO_ENV_ARG_DECL
+    )
+  {
+    return RequestProcessingPolicy::_unchecked_narrow (obj TAO_ENV_ARG_PARAMETER);
+  }
+  
+  PortableServer::RequestProcessingPolicy_ptr PortableServer::RequestProcessingPolicy::_unchecked_narrow (
+      CORBA::Object_ptr obj
+      TAO_ENV_ARG_DECL_NOT_USED
+    )
+  {
+    if (CORBA::is_nil (obj))
+      return RequestProcessingPolicy::_nil ();
+    return
+        ACE_reinterpret_cast
+          (
+            RequestProcessingPolicy_ptr,
+              obj->_tao_QueryInterface
+                (
+                  ACE_reinterpret_cast
+                    (
+                      ptr_arith_t,
+                      &RequestProcessingPolicy::_tao_class_id
+                    )
+                )
+          );
 }
 
 PortableServer::RequestProcessingPolicy_ptr
@@ -2652,7 +2941,7 @@ void *PortableServer::RequestProcessingPolicy::_tao_QueryInterface (ptr_arith_t
   else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_tao_class_id))
     retv = ACE_reinterpret_cast (void *,
       ACE_static_cast (CORBA::Object_ptr, this));
-
+    
   if (retv)
     this->_add_ref ();
   return retv;
@@ -2660,7 +2949,7 @@ void *PortableServer::RequestProcessingPolicy::_tao_QueryInterface (ptr_arith_t
 
 const char* PortableServer::RequestProcessingPolicy::_interface_repository_id (void) const
 {
-  return "IDL:PortableServer/RequestProcessingPolicy:1.0";
+  return "IDL:omg.org/PortableServer/RequestProcessingPolicy:1.0";
 }
 
 #endif /* TAO_HAS_MINIMUM_POA == 0 */
@@ -2715,7 +3004,7 @@ PortableServer::POAManager_var::operator const ::PortableServer::POAManager_ptr
   return this->ptr_;
 }
 
-PortableServer::POAManager_var::operator ::PortableServer::POAManager_ptr &() // cast
+PortableServer::POAManager_var::operator ::PortableServer::POAManager_ptr &() // cast 
 {
   return this->ptr_;
 }
@@ -2851,42 +3140,40 @@ PortableServer::POAManager_out::operator-> (void)
 
 
 // default constructor
-PortableServer::POAManager::POAManager ()
-{
-  }
-
-// destructor
-PortableServer::POAManager::~POAManager (void)
+PortableServer::POAManager::POAManager (void)
 {}
-
-PortableServer::POAManager_ptr PortableServer::POAManager::_narrow (
-    CORBA::Object_ptr obj
-    TAO_ENV_ARG_DECL
-  )
-{
-  return POAManager::_unchecked_narrow (obj TAO_ENV_ARG_PARAMETER);
-}
-
-PortableServer::POAManager_ptr PortableServer::POAManager::_unchecked_narrow (
-    CORBA::Object_ptr obj
-    TAO_ENV_ARG_DECL_NOT_USED
-  )
-{
-  if (CORBA::is_nil (obj))
-    return POAManager::_nil ();
-  return
-      ACE_reinterpret_cast
-        (
-          POAManager_ptr,
-            obj->_tao_QueryInterface
-              (
-                ACE_reinterpret_cast
-                  (
-                    ptr_arith_t,
-                    &POAManager::_tao_class_id
-                  )
-              )
-        );
+  // destructor
+  PortableServer::POAManager::~POAManager (void)
+  {}
+  
+  PortableServer::POAManager_ptr PortableServer::POAManager::_narrow (
+      CORBA::Object_ptr obj
+      TAO_ENV_ARG_DECL
+    )
+  {
+    return POAManager::_unchecked_narrow (obj TAO_ENV_ARG_PARAMETER);
+  }
+  
+  PortableServer::POAManager_ptr PortableServer::POAManager::_unchecked_narrow (
+      CORBA::Object_ptr obj
+      TAO_ENV_ARG_DECL_NOT_USED
+    )
+  {
+    if (CORBA::is_nil (obj))
+      return POAManager::_nil ();
+    return
+        ACE_reinterpret_cast
+          (
+            POAManager_ptr,
+              obj->_tao_QueryInterface
+                (
+                  ACE_reinterpret_cast
+                    (
+                      ptr_arith_t,
+                      &POAManager::_tao_class_id
+                    )
+                )
+          );
 }
 
 PortableServer::POAManager_ptr
@@ -2907,7 +3194,7 @@ void *PortableServer::POAManager::_tao_QueryInterface (ptr_arith_t type)
   else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_tao_class_id))
     retv = ACE_reinterpret_cast (void *,
       ACE_static_cast (CORBA::Object_ptr, this));
-
+    
   if (retv)
     this->_add_ref ();
   return retv;
@@ -2915,12 +3202,12 @@ void *PortableServer::POAManager::_tao_QueryInterface (ptr_arith_t type)
 
 const char* PortableServer::POAManager::_interface_repository_id (void) const
 {
-  return "IDL:PortableServer/POAManager:1.0";
+  return "IDL:omg.org/PortableServer/POAManager:1.0";
 }
 
 // Default constructor.
 PortableServer::POAManager::AdapterInactive::AdapterInactive (void)
-  : CORBA_UserException ("IDL:PortableServer/POAManager/AdapterInactive:1.0")
+  : CORBA_UserException ("IDL:omg.org/PortableServer/POAManager/AdapterInactive:1.0")
 {
 }
 
@@ -2947,7 +3234,7 @@ PortableServer::POAManager::AdapterInactive::operator= (const ::PortableServer::
 PortableServer::POAManager::AdapterInactive *
 PortableServer::POAManager::AdapterInactive::_downcast (CORBA::Exception *exc)
 {
-  if (!ACE_OS::strcmp ("IDL:PortableServer/POAManager/AdapterInactive:1.0", exc->_id ()))
+  if (!ACE_OS::strcmp ("IDL:omg.org/PortableServer/POAManager/AdapterInactive:1.0", exc->_id ()))
     {
       return ACE_dynamic_cast (AdapterInactive *, exc);
     }
@@ -3038,7 +3325,7 @@ PortableServer::AdapterActivator_var::operator const ::PortableServer::AdapterAc
   return this->ptr_;
 }
 
-PortableServer::AdapterActivator_var::operator ::PortableServer::AdapterActivator_ptr &() // cast
+PortableServer::AdapterActivator_var::operator ::PortableServer::AdapterActivator_ptr &() // cast 
 {
   return this->ptr_;
 }
@@ -3174,42 +3461,40 @@ PortableServer::AdapterActivator_out::operator-> (void)
 
 
 // default constructor
-PortableServer::AdapterActivator::AdapterActivator ()
-{
-  }
-
-// destructor
-PortableServer::AdapterActivator::~AdapterActivator (void)
+PortableServer::AdapterActivator::AdapterActivator (void)
 {}
-
-PortableServer::AdapterActivator_ptr PortableServer::AdapterActivator::_narrow (
-    CORBA::Object_ptr obj
-    TAO_ENV_ARG_DECL
-  )
-{
-  return AdapterActivator::_unchecked_narrow (obj TAO_ENV_ARG_PARAMETER);
-}
-
-PortableServer::AdapterActivator_ptr PortableServer::AdapterActivator::_unchecked_narrow (
-    CORBA::Object_ptr obj
-    TAO_ENV_ARG_DECL_NOT_USED
-  )
-{
-  if (CORBA::is_nil (obj))
-    return AdapterActivator::_nil ();
-  return
-      ACE_reinterpret_cast
-        (
-          AdapterActivator_ptr,
-            obj->_tao_QueryInterface
-              (
-                ACE_reinterpret_cast
-                  (
-                    ptr_arith_t,
-                    &AdapterActivator::_tao_class_id
-                  )
-              )
-        );
+  // destructor
+  PortableServer::AdapterActivator::~AdapterActivator (void)
+  {}
+  
+  PortableServer::AdapterActivator_ptr PortableServer::AdapterActivator::_narrow (
+      CORBA::Object_ptr obj
+      TAO_ENV_ARG_DECL
+    )
+  {
+    return AdapterActivator::_unchecked_narrow (obj TAO_ENV_ARG_PARAMETER);
+  }
+  
+  PortableServer::AdapterActivator_ptr PortableServer::AdapterActivator::_unchecked_narrow (
+      CORBA::Object_ptr obj
+      TAO_ENV_ARG_DECL_NOT_USED
+    )
+  {
+    if (CORBA::is_nil (obj))
+      return AdapterActivator::_nil ();
+    return
+        ACE_reinterpret_cast
+          (
+            AdapterActivator_ptr,
+              obj->_tao_QueryInterface
+                (
+                  ACE_reinterpret_cast
+                    (
+                      ptr_arith_t,
+                      &AdapterActivator::_tao_class_id
+                    )
+                )
+          );
 }
 
 PortableServer::AdapterActivator_ptr
@@ -3230,7 +3515,7 @@ void *PortableServer::AdapterActivator::_tao_QueryInterface (ptr_arith_t type)
   else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_tao_class_id))
     retv = ACE_reinterpret_cast (void *,
       ACE_static_cast (CORBA::Object_ptr, this));
-
+    
   if (retv)
     this->_add_ref ();
   return retv;
@@ -3238,7 +3523,7 @@ void *PortableServer::AdapterActivator::_tao_QueryInterface (ptr_arith_t type)
 
 const char* PortableServer::AdapterActivator::_interface_repository_id (void) const
 {
-  return "IDL:PortableServer/AdapterActivator:1.0";
+  return "IDL:omg.org/PortableServer/AdapterActivator:2.3";
 }
 
 int PortableServer::ServantManager::_tao_class_id = 0;
@@ -3291,7 +3576,7 @@ PortableServer::ServantManager_var::operator const ::PortableServer::ServantMana
   return this->ptr_;
 }
 
-PortableServer::ServantManager_var::operator ::PortableServer::ServantManager_ptr &() // cast
+PortableServer::ServantManager_var::operator ::PortableServer::ServantManager_ptr &() // cast 
 {
   return this->ptr_;
 }
@@ -3427,42 +3712,40 @@ PortableServer::ServantManager_out::operator-> (void)
 
 
 // default constructor
-PortableServer::ServantManager::ServantManager ()
-{
-  }
-
-// destructor
-PortableServer::ServantManager::~ServantManager (void)
+PortableServer::ServantManager::ServantManager (void)
 {}
-
-PortableServer::ServantManager_ptr PortableServer::ServantManager::_narrow (
-    CORBA::Object_ptr obj
-    TAO_ENV_ARG_DECL
-  )
-{
-  return ServantManager::_unchecked_narrow (obj TAO_ENV_ARG_PARAMETER);
-}
-
-PortableServer::ServantManager_ptr PortableServer::ServantManager::_unchecked_narrow (
-    CORBA::Object_ptr obj
-    TAO_ENV_ARG_DECL_NOT_USED
-  )
-{
-  if (CORBA::is_nil (obj))
-    return ServantManager::_nil ();
-  return
-      ACE_reinterpret_cast
-        (
-          ServantManager_ptr,
-            obj->_tao_QueryInterface
-              (
-                ACE_reinterpret_cast
-                  (
-                    ptr_arith_t,
-                    &ServantManager::_tao_class_id
-                  )
-              )
-        );
+  // destructor
+  PortableServer::ServantManager::~ServantManager (void)
+  {}
+  
+  PortableServer::ServantManager_ptr PortableServer::ServantManager::_narrow (
+      CORBA::Object_ptr obj
+      TAO_ENV_ARG_DECL
+    )
+  {
+    return ServantManager::_unchecked_narrow (obj TAO_ENV_ARG_PARAMETER);
+  }
+  
+  PortableServer::ServantManager_ptr PortableServer::ServantManager::_unchecked_narrow (
+      CORBA::Object_ptr obj
+      TAO_ENV_ARG_DECL_NOT_USED
+    )
+  {
+    if (CORBA::is_nil (obj))
+      return ServantManager::_nil ();
+    return
+        ACE_reinterpret_cast
+          (
+            ServantManager_ptr,
+              obj->_tao_QueryInterface
+                (
+                  ACE_reinterpret_cast
+                    (
+                      ptr_arith_t,
+                      &ServantManager::_tao_class_id
+                    )
+                )
+          );
 }
 
 PortableServer::ServantManager_ptr
@@ -3483,7 +3766,7 @@ void *PortableServer::ServantManager::_tao_QueryInterface (ptr_arith_t type)
   else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_tao_class_id))
     retv = ACE_reinterpret_cast (void *,
       ACE_static_cast (CORBA::Object_ptr, this));
-
+    
   if (retv)
     this->_add_ref ();
   return retv;
@@ -3491,7 +3774,7 @@ void *PortableServer::ServantManager::_tao_QueryInterface (ptr_arith_t type)
 
 const char* PortableServer::ServantManager::_interface_repository_id (void) const
 {
-  return "IDL:PortableServer/ServantManager:1.0";
+  return "IDL:omg.org/PortableServer/ServantManager:1.0";
 }
 
 int PortableServer::ServantActivator::_tao_class_id = 0;
@@ -3544,7 +3827,7 @@ PortableServer::ServantActivator_var::operator const ::PortableServer::ServantAc
   return this->ptr_;
 }
 
-PortableServer::ServantActivator_var::operator ::PortableServer::ServantActivator_ptr &() // cast
+PortableServer::ServantActivator_var::operator ::PortableServer::ServantActivator_ptr &() // cast 
 {
   return this->ptr_;
 }
@@ -3680,42 +3963,40 @@ PortableServer::ServantActivator_out::operator-> (void)
 
 
 // default constructor
-PortableServer::ServantActivator::ServantActivator ()
-{
-  }
-
-// destructor
-PortableServer::ServantActivator::~ServantActivator (void)
+PortableServer::ServantActivator::ServantActivator (void)
 {}
-
-PortableServer::ServantActivator_ptr PortableServer::ServantActivator::_narrow (
-    CORBA::Object_ptr obj
-    TAO_ENV_ARG_DECL
-  )
-{
-  return ServantActivator::_unchecked_narrow (obj TAO_ENV_ARG_PARAMETER);
-}
-
-PortableServer::ServantActivator_ptr PortableServer::ServantActivator::_unchecked_narrow (
-    CORBA::Object_ptr obj
-    TAO_ENV_ARG_DECL_NOT_USED
-  )
-{
-  if (CORBA::is_nil (obj))
-    return ServantActivator::_nil ();
-  return
-      ACE_reinterpret_cast
-        (
-          ServantActivator_ptr,
-            obj->_tao_QueryInterface
-              (
-                ACE_reinterpret_cast
-                  (
-                    ptr_arith_t,
-                    &ServantActivator::_tao_class_id
-                  )
-              )
-        );
+  // destructor
+  PortableServer::ServantActivator::~ServantActivator (void)
+  {}
+  
+  PortableServer::ServantActivator_ptr PortableServer::ServantActivator::_narrow (
+      CORBA::Object_ptr obj
+      TAO_ENV_ARG_DECL
+    )
+  {
+    return ServantActivator::_unchecked_narrow (obj TAO_ENV_ARG_PARAMETER);
+  }
+  
+  PortableServer::ServantActivator_ptr PortableServer::ServantActivator::_unchecked_narrow (
+      CORBA::Object_ptr obj
+      TAO_ENV_ARG_DECL_NOT_USED
+    )
+  {
+    if (CORBA::is_nil (obj))
+      return ServantActivator::_nil ();
+    return
+        ACE_reinterpret_cast
+          (
+            ServantActivator_ptr,
+              obj->_tao_QueryInterface
+                (
+                  ACE_reinterpret_cast
+                    (
+                      ptr_arith_t,
+                      &ServantActivator::_tao_class_id
+                    )
+                )
+          );
 }
 
 PortableServer::ServantActivator_ptr
@@ -3748,7 +4029,7 @@ void *PortableServer::ServantActivator::_tao_QueryInterface (ptr_arith_t type)
   else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_tao_class_id))
     retv = ACE_reinterpret_cast (void *,
       ACE_static_cast (CORBA::Object_ptr, this));
-
+    
   if (retv)
     this->_add_ref ();
   return retv;
@@ -3756,7 +4037,7 @@ void *PortableServer::ServantActivator::_tao_QueryInterface (ptr_arith_t type)
 
 const char* PortableServer::ServantActivator::_interface_repository_id (void) const
 {
-  return "IDL:PortableServer/ServantActivator:1.0";
+  return "IDL:omg.org/PortableServer/ServantActivator:2.3";
 }
 
 int PortableServer::ServantLocator::_tao_class_id = 0;
@@ -3809,7 +4090,7 @@ PortableServer::ServantLocator_var::operator const ::PortableServer::ServantLoca
   return this->ptr_;
 }
 
-PortableServer::ServantLocator_var::operator ::PortableServer::ServantLocator_ptr &() // cast
+PortableServer::ServantLocator_var::operator ::PortableServer::ServantLocator_ptr &() // cast 
 {
   return this->ptr_;
 }
@@ -3945,42 +4226,40 @@ PortableServer::ServantLocator_out::operator-> (void)
 
 
 // default constructor
-PortableServer::ServantLocator::ServantLocator ()
-{
-  }
-
-// destructor
-PortableServer::ServantLocator::~ServantLocator (void)
+PortableServer::ServantLocator::ServantLocator (void)
 {}
-
-PortableServer::ServantLocator_ptr PortableServer::ServantLocator::_narrow (
-    CORBA::Object_ptr obj
-    TAO_ENV_ARG_DECL
-  )
-{
-  return ServantLocator::_unchecked_narrow (obj TAO_ENV_ARG_PARAMETER);
-}
-
-PortableServer::ServantLocator_ptr PortableServer::ServantLocator::_unchecked_narrow (
-    CORBA::Object_ptr obj
-    TAO_ENV_ARG_DECL_NOT_USED
-  )
-{
-  if (CORBA::is_nil (obj))
-    return ServantLocator::_nil ();
-  return
-      ACE_reinterpret_cast
-        (
-          ServantLocator_ptr,
-            obj->_tao_QueryInterface
-              (
-                ACE_reinterpret_cast
-                  (
-                    ptr_arith_t,
-                    &ServantLocator::_tao_class_id
-                  )
-              )
-        );
+  // destructor
+  PortableServer::ServantLocator::~ServantLocator (void)
+  {}
+  
+  PortableServer::ServantLocator_ptr PortableServer::ServantLocator::_narrow (
+      CORBA::Object_ptr obj
+      TAO_ENV_ARG_DECL
+    )
+  {
+    return ServantLocator::_unchecked_narrow (obj TAO_ENV_ARG_PARAMETER);
+  }
+  
+  PortableServer::ServantLocator_ptr PortableServer::ServantLocator::_unchecked_narrow (
+      CORBA::Object_ptr obj
+      TAO_ENV_ARG_DECL_NOT_USED
+    )
+  {
+    if (CORBA::is_nil (obj))
+      return ServantLocator::_nil ();
+    return
+        ACE_reinterpret_cast
+          (
+            ServantLocator_ptr,
+              obj->_tao_QueryInterface
+                (
+                  ACE_reinterpret_cast
+                    (
+                      ptr_arith_t,
+                      &ServantLocator::_tao_class_id
+                    )
+                )
+          );
 }
 
 PortableServer::ServantLocator_ptr
@@ -4013,7 +4292,7 @@ void *PortableServer::ServantLocator::_tao_QueryInterface (ptr_arith_t type)
   else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_tao_class_id))
     retv = ACE_reinterpret_cast (void *,
       ACE_static_cast (CORBA::Object_ptr, this));
-
+    
   if (retv)
     this->_add_ref ();
   return retv;
@@ -4021,7 +4300,7 @@ void *PortableServer::ServantLocator::_tao_QueryInterface (ptr_arith_t type)
 
 const char* PortableServer::ServantLocator::_interface_repository_id (void) const
 {
-  return "IDL:PortableServer/ServantLocator:1.0";
+  return "IDL:omg.org/PortableServer/ServantLocator:2.3";
 }
 
 #endif /* TAO_HAS_MINIMUM_POA == 0 */
@@ -4076,7 +4355,7 @@ PortableServer::POA_var::operator const ::PortableServer::POA_ptr &() const // c
   return this->ptr_;
 }
 
-PortableServer::POA_var::operator ::PortableServer::POA_ptr &() // cast
+PortableServer::POA_var::operator ::PortableServer::POA_ptr &() // cast 
 {
   return this->ptr_;
 }
@@ -4212,42 +4491,40 @@ PortableServer::POA_out::operator-> (void)
 
 
 // default constructor
-PortableServer::POA::POA ()
-{
-  }
-
-// destructor
-PortableServer::POA::~POA (void)
+PortableServer::POA::POA (void)
 {}
-
-PortableServer::POA_ptr PortableServer::POA::_narrow (
-    CORBA::Object_ptr obj
-    TAO_ENV_ARG_DECL
-  )
-{
-  return POA::_unchecked_narrow (obj TAO_ENV_ARG_PARAMETER);
-}
-
-PortableServer::POA_ptr PortableServer::POA::_unchecked_narrow (
-    CORBA::Object_ptr obj
-    TAO_ENV_ARG_DECL_NOT_USED
-  )
-{
-  if (CORBA::is_nil (obj))
-    return POA::_nil ();
-  return
-      ACE_reinterpret_cast
-        (
-          POA_ptr,
-            obj->_tao_QueryInterface
-              (
-                ACE_reinterpret_cast
-                  (
-                    ptr_arith_t,
-                    &POA::_tao_class_id
-                  )
-              )
-        );
+  // destructor
+  PortableServer::POA::~POA (void)
+  {}
+  
+  PortableServer::POA_ptr PortableServer::POA::_narrow (
+      CORBA::Object_ptr obj
+      TAO_ENV_ARG_DECL
+    )
+  {
+    return POA::_unchecked_narrow (obj TAO_ENV_ARG_PARAMETER);
+  }
+  
+  PortableServer::POA_ptr PortableServer::POA::_unchecked_narrow (
+      CORBA::Object_ptr obj
+      TAO_ENV_ARG_DECL_NOT_USED
+    )
+  {
+    if (CORBA::is_nil (obj))
+      return POA::_nil ();
+    return
+        ACE_reinterpret_cast
+          (
+            POA_ptr,
+              obj->_tao_QueryInterface
+                (
+                  ACE_reinterpret_cast
+                    (
+                      ptr_arith_t,
+                      &POA::_tao_class_id
+                    )
+                )
+          );
 }
 
 PortableServer::POA_ptr
@@ -4268,7 +4545,7 @@ void *PortableServer::POA::_tao_QueryInterface (ptr_arith_t type)
   else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_tao_class_id))
     retv = ACE_reinterpret_cast (void *,
       ACE_static_cast (CORBA::Object_ptr, this));
-
+    
   if (retv)
     this->_add_ref ();
   return retv;
@@ -4276,12 +4553,12 @@ void *PortableServer::POA::_tao_QueryInterface (ptr_arith_t type)
 
 const char* PortableServer::POA::_interface_repository_id (void) const
 {
-  return "IDL:PortableServer/POA:1.0";
+  return "IDL:omg.org/PortableServer/POA:2.3";
 }
 
 // Default constructor.
 PortableServer::POA::AdapterAlreadyExists::AdapterAlreadyExists (void)
-  : CORBA_UserException ("IDL:PortableServer/POA/AdapterAlreadyExists:1.0")
+  : CORBA_UserException ("IDL:omg.org/PortableServer/POA/AdapterAlreadyExists:1.0")
 {
 }
 
@@ -4308,7 +4585,7 @@ PortableServer::POA::AdapterAlreadyExists::operator= (const ::PortableServer::PO
 PortableServer::POA::AdapterAlreadyExists *
 PortableServer::POA::AdapterAlreadyExists::_downcast (CORBA::Exception *exc)
 {
-  if (!ACE_OS::strcmp ("IDL:PortableServer/POA/AdapterAlreadyExists:1.0", exc->_id ()))
+  if (!ACE_OS::strcmp ("IDL:omg.org/PortableServer/POA/AdapterAlreadyExists:1.0", exc->_id ()))
     {
       return ACE_dynamic_cast (AdapterAlreadyExists *, exc);
     }
@@ -4349,7 +4626,7 @@ CORBA::Exception *PortableServer::POA::AdapterAlreadyExists::_alloc (void)
 
 // Default constructor.
 PortableServer::POA::AdapterNonExistent::AdapterNonExistent (void)
-  : CORBA_UserException ("IDL:PortableServer/POA/AdapterNonExistent:1.0")
+  : CORBA_UserException ("IDL:omg.org/PortableServer/POA/AdapterNonExistent:1.0")
 {
 }
 
@@ -4376,7 +4653,7 @@ PortableServer::POA::AdapterNonExistent::operator= (const ::PortableServer::POA:
 PortableServer::POA::AdapterNonExistent *
 PortableServer::POA::AdapterNonExistent::_downcast (CORBA::Exception *exc)
 {
-  if (!ACE_OS::strcmp ("IDL:PortableServer/POA/AdapterNonExistent:1.0", exc->_id ()))
+  if (!ACE_OS::strcmp ("IDL:omg.org/PortableServer/POA/AdapterNonExistent:1.0", exc->_id ()))
     {
       return ACE_dynamic_cast (AdapterNonExistent *, exc);
     }
@@ -4417,7 +4694,7 @@ CORBA::Exception *PortableServer::POA::AdapterNonExistent::_alloc (void)
 
 // Default constructor.
 PortableServer::POA::InvalidPolicy::InvalidPolicy (void)
-  : CORBA_UserException ("IDL:PortableServer/POA/InvalidPolicy:1.0")
+  : CORBA_UserException ("IDL:omg.org/PortableServer/POA/InvalidPolicy:1.0")
 {
 }
 
@@ -4446,7 +4723,7 @@ PortableServer::POA::InvalidPolicy::operator= (const ::PortableServer::POA::Inva
 PortableServer::POA::InvalidPolicy *
 PortableServer::POA::InvalidPolicy::_downcast (CORBA::Exception *exc)
 {
-  if (!ACE_OS::strcmp ("IDL:PortableServer/POA/InvalidPolicy:1.0", exc->_id ()))
+  if (!ACE_OS::strcmp ("IDL:omg.org/PortableServer/POA/InvalidPolicy:1.0", exc->_id ()))
     {
       return ACE_dynamic_cast (InvalidPolicy *, exc);
     }
@@ -4488,7 +4765,7 @@ CORBA::Exception *PortableServer::POA::InvalidPolicy::_alloc (void)
 PortableServer::POA::InvalidPolicy::InvalidPolicy (
     CORBA::UShort _tao_index
   )
-  : CORBA_UserException ("IDL:PortableServer/POA/InvalidPolicy:1.0")
+  : CORBA_UserException ("IDL:omg.org/PortableServer/POA/InvalidPolicy:1.0")
 {
   this->index = _tao_index;
 }
@@ -4497,7 +4774,7 @@ PortableServer::POA::InvalidPolicy::InvalidPolicy (
 
 // Default constructor.
 PortableServer::POA::NoServant::NoServant (void)
-  : CORBA_UserException ("IDL:PortableServer/POA/NoServant:1.0")
+  : CORBA_UserException ("IDL:omg.org/PortableServer/POA/NoServant:1.0")
 {
 }
 
@@ -4524,7 +4801,7 @@ PortableServer::POA::NoServant::operator= (const ::PortableServer::POA::NoServan
 PortableServer::POA::NoServant *
 PortableServer::POA::NoServant::_downcast (CORBA::Exception *exc)
 {
-  if (!ACE_OS::strcmp ("IDL:PortableServer/POA/NoServant:1.0", exc->_id ()))
+  if (!ACE_OS::strcmp ("IDL:omg.org/PortableServer/POA/NoServant:1.0", exc->_id ()))
     {
       return ACE_dynamic_cast (NoServant *, exc);
     }
@@ -4567,7 +4844,7 @@ CORBA::Exception *PortableServer::POA::NoServant::_alloc (void)
 
 // Default constructor.
 PortableServer::POA::ObjectAlreadyActive::ObjectAlreadyActive (void)
-  : CORBA_UserException ("IDL:PortableServer/POA/ObjectAlreadyActive:1.0")
+  : CORBA_UserException ("IDL:omg.org/PortableServer/POA/ObjectAlreadyActive:1.0")
 {
 }
 
@@ -4594,7 +4871,7 @@ PortableServer::POA::ObjectAlreadyActive::operator= (const ::PortableServer::POA
 PortableServer::POA::ObjectAlreadyActive *
 PortableServer::POA::ObjectAlreadyActive::_downcast (CORBA::Exception *exc)
 {
-  if (!ACE_OS::strcmp ("IDL:PortableServer/POA/ObjectAlreadyActive:1.0", exc->_id ()))
+  if (!ACE_OS::strcmp ("IDL:omg.org/PortableServer/POA/ObjectAlreadyActive:1.0", exc->_id ()))
     {
       return ACE_dynamic_cast (ObjectAlreadyActive *, exc);
     }
@@ -4635,7 +4912,7 @@ CORBA::Exception *PortableServer::POA::ObjectAlreadyActive::_alloc (void)
 
 // Default constructor.
 PortableServer::POA::ObjectNotActive::ObjectNotActive (void)
-  : CORBA_UserException ("IDL:PortableServer/POA/ObjectNotActive:1.0")
+  : CORBA_UserException ("IDL:omg.org/PortableServer/POA/ObjectNotActive:1.0")
 {
 }
 
@@ -4662,7 +4939,7 @@ PortableServer::POA::ObjectNotActive::operator= (const ::PortableServer::POA::Ob
 PortableServer::POA::ObjectNotActive *
 PortableServer::POA::ObjectNotActive::_downcast (CORBA::Exception *exc)
 {
-  if (!ACE_OS::strcmp ("IDL:PortableServer/POA/ObjectNotActive:1.0", exc->_id ()))
+  if (!ACE_OS::strcmp ("IDL:omg.org/PortableServer/POA/ObjectNotActive:1.0", exc->_id ()))
     {
       return ACE_dynamic_cast (ObjectNotActive *, exc);
     }
@@ -4703,7 +4980,7 @@ CORBA::Exception *PortableServer::POA::ObjectNotActive::_alloc (void)
 
 // Default constructor.
 PortableServer::POA::ServantAlreadyActive::ServantAlreadyActive (void)
-  : CORBA_UserException ("IDL:PortableServer/POA/ServantAlreadyActive:1.0")
+  : CORBA_UserException ("IDL:omg.org/PortableServer/POA/ServantAlreadyActive:1.0")
 {
 }
 
@@ -4730,7 +5007,7 @@ PortableServer::POA::ServantAlreadyActive::operator= (const ::PortableServer::PO
 PortableServer::POA::ServantAlreadyActive *
 PortableServer::POA::ServantAlreadyActive::_downcast (CORBA::Exception *exc)
 {
-  if (!ACE_OS::strcmp ("IDL:PortableServer/POA/ServantAlreadyActive:1.0", exc->_id ()))
+  if (!ACE_OS::strcmp ("IDL:omg.org/PortableServer/POA/ServantAlreadyActive:1.0", exc->_id ()))
     {
       return ACE_dynamic_cast (ServantAlreadyActive *, exc);
     }
@@ -4771,7 +5048,7 @@ CORBA::Exception *PortableServer::POA::ServantAlreadyActive::_alloc (void)
 
 // Default constructor.
 PortableServer::POA::ServantNotActive::ServantNotActive (void)
-  : CORBA_UserException ("IDL:PortableServer/POA/ServantNotActive:1.0")
+  : CORBA_UserException ("IDL:omg.org/PortableServer/POA/ServantNotActive:1.0")
 {
 }
 
@@ -4798,7 +5075,7 @@ PortableServer::POA::ServantNotActive::operator= (const ::PortableServer::POA::S
 PortableServer::POA::ServantNotActive *
 PortableServer::POA::ServantNotActive::_downcast (CORBA::Exception *exc)
 {
-  if (!ACE_OS::strcmp ("IDL:PortableServer/POA/ServantNotActive:1.0", exc->_id ()))
+  if (!ACE_OS::strcmp ("IDL:omg.org/PortableServer/POA/ServantNotActive:1.0", exc->_id ()))
     {
       return ACE_dynamic_cast (ServantNotActive *, exc);
     }
@@ -4839,7 +5116,7 @@ CORBA::Exception *PortableServer::POA::ServantNotActive::_alloc (void)
 
 // Default constructor.
 PortableServer::POA::WrongAdapter::WrongAdapter (void)
-  : CORBA_UserException ("IDL:PortableServer/POA/WrongAdapter:1.0")
+  : CORBA_UserException ("IDL:omg.org/PortableServer/POA/WrongAdapter:1.0")
 {
 }
 
@@ -4866,7 +5143,7 @@ PortableServer::POA::WrongAdapter::operator= (const ::PortableServer::POA::Wrong
 PortableServer::POA::WrongAdapter *
 PortableServer::POA::WrongAdapter::_downcast (CORBA::Exception *exc)
 {
-  if (!ACE_OS::strcmp ("IDL:PortableServer/POA/WrongAdapter:1.0", exc->_id ()))
+  if (!ACE_OS::strcmp ("IDL:omg.org/PortableServer/POA/WrongAdapter:1.0", exc->_id ()))
     {
       return ACE_dynamic_cast (WrongAdapter *, exc);
     }
@@ -4907,7 +5184,7 @@ CORBA::Exception *PortableServer::POA::WrongAdapter::_alloc (void)
 
 // Default constructor.
 PortableServer::POA::WrongPolicy::WrongPolicy (void)
-  : CORBA_UserException ("IDL:PortableServer/POA/WrongPolicy:1.0")
+  : CORBA_UserException ("IDL:omg.org/PortableServer/POA/WrongPolicy:1.0")
 {
 }
 
@@ -4934,7 +5211,7 @@ PortableServer::POA::WrongPolicy::operator= (const ::PortableServer::POA::WrongP
 PortableServer::POA::WrongPolicy *
 PortableServer::POA::WrongPolicy::_downcast (CORBA::Exception *exc)
 {
-  if (!ACE_OS::strcmp ("IDL:PortableServer/POA/WrongPolicy:1.0", exc->_id ()))
+  if (!ACE_OS::strcmp ("IDL:omg.org/PortableServer/POA/WrongPolicy:1.0", exc->_id ()))
     {
       return ACE_dynamic_cast (WrongPolicy *, exc);
     }
@@ -5023,7 +5300,7 @@ PortableServer::Current_var::operator const ::PortableServer::Current_ptr &() co
   return this->ptr_;
 }
 
-PortableServer::Current_var::operator ::PortableServer::Current_ptr &() // cast
+PortableServer::Current_var::operator ::PortableServer::Current_ptr &() // cast 
 {
   return this->ptr_;
 }
@@ -5159,42 +5436,40 @@ PortableServer::Current_out::operator-> (void)
 
 
 // default constructor
-PortableServer::Current::Current ()
-{
-  }
-
-// destructor
-PortableServer::Current::~Current (void)
+PortableServer::Current::Current (void)
 {}
-
-PortableServer::Current_ptr PortableServer::Current::_narrow (
-    CORBA::Object_ptr obj
-    TAO_ENV_ARG_DECL
-  )
-{
-  return Current::_unchecked_narrow (obj TAO_ENV_ARG_PARAMETER);
-}
-
-PortableServer::Current_ptr PortableServer::Current::_unchecked_narrow (
-    CORBA::Object_ptr obj
-    TAO_ENV_ARG_DECL_NOT_USED
-  )
-{
-  if (CORBA::is_nil (obj))
-    return Current::_nil ();
-  return
-      ACE_reinterpret_cast
-        (
-          Current_ptr,
-            obj->_tao_QueryInterface
-              (
-                ACE_reinterpret_cast
-                  (
-                    ptr_arith_t,
-                    &Current::_tao_class_id
-                  )
-              )
-        );
+  // destructor
+  PortableServer::Current::~Current (void)
+  {}
+  
+  PortableServer::Current_ptr PortableServer::Current::_narrow (
+      CORBA::Object_ptr obj
+      TAO_ENV_ARG_DECL
+    )
+  {
+    return Current::_unchecked_narrow (obj TAO_ENV_ARG_PARAMETER);
+  }
+  
+  PortableServer::Current_ptr PortableServer::Current::_unchecked_narrow (
+      CORBA::Object_ptr obj
+      TAO_ENV_ARG_DECL_NOT_USED
+    )
+  {
+    if (CORBA::is_nil (obj))
+      return Current::_nil ();
+    return
+        ACE_reinterpret_cast
+          (
+            Current_ptr,
+              obj->_tao_QueryInterface
+                (
+                  ACE_reinterpret_cast
+                    (
+                      ptr_arith_t,
+                      &Current::_tao_class_id
+                    )
+                )
+          );
 }
 
 PortableServer::Current_ptr
@@ -5227,7 +5502,7 @@ void *PortableServer::Current::_tao_QueryInterface (ptr_arith_t type)
   else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_tao_class_id))
     retv = ACE_reinterpret_cast (void *,
       ACE_static_cast (CORBA::Object_ptr, this));
-
+    
   if (retv)
     this->_add_ref ();
   return retv;
@@ -5235,12 +5510,12 @@ void *PortableServer::Current::_tao_QueryInterface (ptr_arith_t type)
 
 const char* PortableServer::Current::_interface_repository_id (void) const
 {
-  return "IDL:PortableServer/Current:1.0";
+  return "IDL:omg.org/PortableServer/Current:2.3";
 }
 
 // Default constructor.
 PortableServer::Current::NoContext::NoContext (void)
-  : CORBA_UserException ("IDL:PortableServer/Current/NoContext:1.0")
+  : CORBA_UserException ("IDL:omg.org/PortableServer/Current/NoContext:1.0")
 {
 }
 
@@ -5267,7 +5542,7 @@ PortableServer::Current::NoContext::operator= (const ::PortableServer::Current::
 PortableServer::Current::NoContext *
 PortableServer::Current::NoContext::_downcast (CORBA::Exception *exc)
 {
-  if (!ACE_OS::strcmp ("IDL:PortableServer/Current/NoContext:1.0", exc->_id ()))
+  if (!ACE_OS::strcmp ("IDL:omg.org/PortableServer/Current/NoContext:1.0", exc->_id ()))
     {
       return ACE_dynamic_cast (NoContext *, exc);
     }
@@ -5374,13 +5649,13 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::Ob
   ACE_TRY_NEW_ENV
   {
     CORBA::TypeCode_var type = _tao_any.type ();
-
+    
     CORBA::Boolean result = type->equivalent (PortableServer::_tc_ObjectId TAO_ENV_ARG_PARAMETER);
     ACE_TRY_CHECK;
-
+    
     if (!result)
       return 0; // not equivalent
-
+    
     if (_tao_any.any_owns_data ())
     {
       _tao_elem = ACE_static_cast(
@@ -5462,13 +5737,13 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::Fo
   ACE_TRY_NEW_ENV
   {
     CORBA::TypeCode_var type = _tao_any.type ();
-
+    
     CORBA::Boolean result = type->equivalent (PortableServer::_tc_ForwardRequest TAO_ENV_ARG_PARAMETER);
     ACE_TRY_CHECK;
-
+    
     if (!result)
       return 0; // not equivalent
-
+    
     if (_tao_any.any_owns_data ())
     {
       _tao_elem = (PortableServer::ForwardRequest *)_tao_any.value ();
@@ -5487,7 +5762,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::Fo
         return 0;
       if (ACE_OS::strcmp (
           interface_repository_id.in (),
-          "IDL:PortableServer/ForwardRequest:1.0"))
+          "IDL:omg.org/PortableServer/ForwardRequest:1.0"))
         return 0;
       if (stream >> *tmp)
       {
@@ -5513,6 +5788,187 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::Fo
   return 0;
 }
 
+void operator<<= (CORBA::Any &_tao_any, const PortableServer::NotAGroupObject &_tao_elem) // copying
+{
+  TAO_OutputCDR stream;
+  stream << _tao_elem;
+  _tao_any._tao_replace (
+      PortableServer::_tc_NotAGroupObject,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin ()
+    );
+}
+
+void operator<<= (CORBA::Any &_tao_any, PortableServer::NotAGroupObject *_tao_elem) // non copying
+{
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      PortableServer::_tc_NotAGroupObject,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      PortableServer::NotAGroupObject::_tao_any_destructor
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::NotAGroupObject *&_tao_elem)
+{
+  return _tao_any >>= ACE_const_cast(
+      const PortableServer::NotAGroupObject*&,
+      _tao_elem
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::NotAGroupObject *&_tao_elem)
+{
+  _tao_elem = 0;
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (PortableServer::_tc_NotAGroupObject TAO_ENV_ARG_PARAMETER);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    if (_tao_any.any_owns_data ())
+    {
+      _tao_elem = (PortableServer::NotAGroupObject *)_tao_any.value ();
+      return 1;
+    }
+    else
+    {
+      PortableServer::NotAGroupObject *tmp;
+      ACE_NEW_RETURN (tmp, PortableServer::NotAGroupObject, 0);
+      TAO_InputCDR stream (
+          _tao_any._tao_get_cdr (),
+          _tao_any._tao_byte_order ()
+        );
+      CORBA::String_var interface_repository_id;
+      if (!(stream >> interface_repository_id.out ()))
+        return 0;
+      if (ACE_OS::strcmp (
+          interface_repository_id.in (),
+          "IDL:omg.org/PortableServer/NotAGroupObject:1.0"))
+        return 0;
+      if (stream >> *tmp)
+      {
+        ((CORBA::Any *)&_tao_any)->_tao_replace (
+            PortableServer::_tc_NotAGroupObject,
+            1,
+            tmp,
+            PortableServer::NotAGroupObject::_tao_any_destructor
+          );
+        _tao_elem = tmp;
+        return 1;
+      }
+      else
+      {
+        delete tmp;
+      }
+    }
+  }
+  ACE_CATCHANY
+  {
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+void operator<<= (
+    CORBA::Any &_tao_any,
+    const PortableServer::IDs &_tao_elem
+  ) // copying
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        PortableServer::_tc_IDs,
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin ()
+      );
+  }
+}
+
+void operator<<= (CORBA::Any &_tao_any, PortableServer::IDs *_tao_elem) // non copying
+{
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      PortableServer::_tc_IDs,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      PortableServer::IDs::_tao_any_destructor
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::IDs *&_tao_elem)
+{
+  return _tao_any >>= ACE_const_cast(
+      const PortableServer::IDs*&,
+      _tao_elem
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::IDs *&_tao_elem)
+{
+  _tao_elem = 0;
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (PortableServer::_tc_IDs TAO_ENV_ARG_PARAMETER);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    if (_tao_any.any_owns_data ())
+    {
+      _tao_elem = ACE_static_cast(
+          const PortableServer::IDs*,
+          _tao_any.value ()
+        );
+      return 1;
+    }
+    else
+    {
+      PortableServer::IDs *tmp;
+      ACE_NEW_RETURN (tmp, PortableServer::IDs, 0);
+      TAO_InputCDR stream (
+          _tao_any._tao_get_cdr (),
+          _tao_any._tao_byte_order ()
+        );
+      if (stream >> *tmp)
+      {
+        ((CORBA::Any *)&_tao_any)->_tao_replace (
+            PortableServer::_tc_IDs,
+            1,
+            ACE_static_cast (void *, tmp),
+            PortableServer::IDs::_tao_any_destructor
+          );
+        _tao_elem = tmp;
+        return 1;
+      }
+      else
+      {
+        delete tmp;
+      }
+    }
+  }
+  ACE_CATCHANY
+  {
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
 #endif /* TAO_HAS_MINIMUM_CORBA == 0 */
 
 #if (TAO_HAS_MINIMUM_POA == 0)
@@ -5533,13 +5989,13 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::ThreadPo
   ACE_TRY_NEW_ENV
   {
     CORBA::TypeCode_var type = _tao_any.type ();
-
+    
     CORBA::Boolean result = type->equivalent (PortableServer::_tc_ThreadPolicyValue TAO_ENV_ARG_PARAMETER);
     ACE_TRY_CHECK;
-
+    
     if (!result)
       return 0; // not equivalent
-
+    
     TAO_InputCDR stream (
         _tao_any._tao_get_cdr (),
         _tao_any._tao_byte_order ()
@@ -5582,13 +6038,13 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::Lifespan
   ACE_TRY_NEW_ENV
   {
     CORBA::TypeCode_var type = _tao_any.type ();
-
+    
     CORBA::Boolean result = type->equivalent (PortableServer::_tc_LifespanPolicyValue TAO_ENV_ARG_PARAMETER);
     ACE_TRY_CHECK;
-
+    
     if (!result)
       return 0; // not equivalent
-
+    
     TAO_InputCDR stream (
         _tao_any._tao_get_cdr (),
         _tao_any._tao_byte_order ()
@@ -5629,13 +6085,13 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::IdUnique
   ACE_TRY_NEW_ENV
   {
     CORBA::TypeCode_var type = _tao_any.type ();
-
+    
     CORBA::Boolean result = type->equivalent (PortableServer::_tc_IdUniquenessPolicyValue TAO_ENV_ARG_PARAMETER);
     ACE_TRY_CHECK;
-
+    
     if (!result)
       return 0; // not equivalent
-
+    
     TAO_InputCDR stream (
         _tao_any._tao_get_cdr (),
         _tao_any._tao_byte_order ()
@@ -5676,13 +6132,13 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::IdAssign
   ACE_TRY_NEW_ENV
   {
     CORBA::TypeCode_var type = _tao_any.type ();
-
+    
     CORBA::Boolean result = type->equivalent (PortableServer::_tc_IdAssignmentPolicyValue TAO_ENV_ARG_PARAMETER);
     ACE_TRY_CHECK;
-
+    
     if (!result)
       return 0; // not equivalent
-
+    
     TAO_InputCDR stream (
         _tao_any._tao_get_cdr (),
         _tao_any._tao_byte_order ()
@@ -5725,13 +6181,13 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::Implicit
   ACE_TRY_NEW_ENV
   {
     CORBA::TypeCode_var type = _tao_any.type ();
-
+    
     CORBA::Boolean result = type->equivalent (PortableServer::_tc_ImplicitActivationPolicyValue TAO_ENV_ARG_PARAMETER);
     ACE_TRY_CHECK;
-
+    
     if (!result)
       return 0; // not equivalent
-
+    
     TAO_InputCDR stream (
         _tao_any._tao_get_cdr (),
         _tao_any._tao_byte_order ()
@@ -5772,13 +6228,13 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::ServantR
   ACE_TRY_NEW_ENV
   {
     CORBA::TypeCode_var type = _tao_any.type ();
-
+    
     CORBA::Boolean result = type->equivalent (PortableServer::_tc_ServantRetentionPolicyValue TAO_ENV_ARG_PARAMETER);
     ACE_TRY_CHECK;
-
+    
     if (!result)
       return 0; // not equivalent
-
+    
     TAO_InputCDR stream (
         _tao_any._tao_get_cdr (),
         _tao_any._tao_byte_order ()
@@ -5819,13 +6275,13 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::RequestP
   ACE_TRY_NEW_ENV
   {
     CORBA::TypeCode_var type = _tao_any.type ();
-
+    
     CORBA::Boolean result = type->equivalent (PortableServer::_tc_RequestProcessingPolicyValue TAO_ENV_ARG_PARAMETER);
     ACE_TRY_CHECK;
-
+    
     if (!result)
       return 0; // not equivalent
-
+    
     TAO_InputCDR stream (
         _tao_any._tao_get_cdr (),
         _tao_any._tao_byte_order ()
@@ -5913,20 +6369,20 @@ CORBA::Boolean operator<< (
   if (strm << _tao_sequence.length ())
   {
     // encode all elements
-
+    
 #if (TAO_NO_COPY_OCTET_SEQUENCES == 1)
     {
-      TAO_Unbounded_Sequence<CORBA::Octet> *oseq =
+      TAO_Unbounded_Sequence<CORBA::Octet> *oseq = 
         ACE_static_cast (TAO_Unbounded_Sequence<CORBA::Octet>*, (PortableServer::ObjectId *)&_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 == 0 */
     return strm.write_octet_array (_tao_sequence.get_buffer (), _tao_sequence.length ());
-
+  
 #endif /* TAO_NO_COPY_OCTET_SEQUENCES == 0 */
   }
   return 0; // error
@@ -5943,10 +6399,10 @@ CORBA::Boolean operator>> (
     // set the length of the sequence
     _tao_sequence.length (_tao_seq_len);
     // If length is 0 we return true.
-    if (0 >= _tao_seq_len)
+    if (0 >= _tao_seq_len) 
       return 1;
     // retrieve all the elements
-
+    
 #if (TAO_NO_COPY_OCTET_SEQUENCES == 1)
     if (ACE_BIT_DISABLED (strm.start ()->flags (),
     ACE_Message_Block::DONT_DELETE))
@@ -5956,7 +6412,7 @@ CORBA::Boolean operator>> (
       strm.orb_core ()->resource_factory ()->
       input_cdr_allocator_type_locked () == 1)
       {
-        TAO_Unbounded_Sequence<CORBA::Octet> *oseq =
+        TAO_Unbounded_Sequence<CORBA::Octet> *oseq = 
           ACE_static_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);
@@ -5967,8 +6423,56 @@ CORBA::Boolean operator>> (
     return strm.read_octet_array (_tao_sequence.get_buffer (), _tao_seq_len);
 #else /* TAO_NO_COPY_OCTET_SEQUENCES == 0 */
     return strm.read_octet_array (_tao_sequence.get_buffer (), _tao_sequence.length ());
-
+  
 #endif /* TAO_NO_COPY_OCTET_SEQUENCES == 0 */
   }
   return 0; // error
 }
+
+CORBA::Boolean operator<< (
+    TAO_OutputCDR &strm,
+    const PortableServer::IDs &_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
+}
+
+CORBA::Boolean operator>> (
+    TAO_InputCDR &strm,
+    PortableServer::IDs &_tao_sequence
+  )
+{
+  CORBA::ULong _tao_seq_len;
+  if (strm >> _tao_seq_len)
+  {
+    // set the length of the sequence
+    _tao_sequence.length (_tao_seq_len);
+    // If length is 0 we return true.
+    if (0 >= _tao_seq_len) 
+      return 1;
+    // Add a check to the length of the sequence
+    // to make sure it does not exceed the length
+    // of the stream. (See bug 58.)
+    if (_tao_seq_len > strm.length())
+      return 0;
+    // 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
+}
+
diff --git a/TAO/tao/PortableServer/PortableServerC.h b/TAO/tao/PortableServer/PortableServerC.h
index 844e2beded5..616c2ba2e5a 100644
--- a/TAO/tao/PortableServer/PortableServerC.h
+++ b/TAO/tao/PortableServer/PortableServerC.h
@@ -19,8 +19,8 @@
 // Information about TAO is available at:
 //     http://www.cs.wustl.edu/~schmidt/TAO.html
 
-#ifndef _TAO_IDL_ORIG_PORTABLESERVERC_H_
-#define _TAO_IDL_ORIG_PORTABLESERVERC_H_
+#ifndef _TAO_IDL_PORTABLESERVERC_H_
+#define _TAO_IDL_PORTABLESERVERC_H_
 
 #include "ace/pre.h"
 #include "portableserver_export.h"
@@ -76,47 +76,50 @@ TAO_NAMESPACE  PortableServer
   typedef TAO_DynamicImplementation DynamicImplementation;
 
   class POA;
-
+  
 #if !defined (_PORTABLESERVER_POA___PTR_CH_)
 #define _PORTABLESERVER_POA___PTR_CH_
-
+  
   typedef POA *POA_ptr;
-
+  
 #endif /* end #if !defined */
-
-
+  
+  
 #if !defined (_PORTABLESERVER_POA___VAR_CH_)
 #define _PORTABLESERVER_POA___VAR_CH_
-
+  
   class TAO_PortableServer_Export POA_var : public TAO_Base_var
   {
   public:
     POA_var (void); // default constructor
-    POA_var (POA_ptr p) : ptr_ (p) {}
+    POA_var (POA_ptr p) : ptr_ (p) {} 
     POA_var (const POA_var &); // copy constructor
     ~POA_var (void); // destructor
-
+    
     POA_var &operator= (POA_ptr);
     POA_var &operator= (const POA_var &);
     POA_ptr operator-> (void) const;
-
+    
     operator const POA_ptr &() const;
     operator POA_ptr &();
-    // in, inout, out, _retn
+    // in, inout, out, _retn 
     POA_ptr in (void) const;
     POA_ptr &inout (void);
     POA_ptr &out (void);
     POA_ptr _retn (void);
     POA_ptr ptr (void) const;
-
+    
     // Hooks used by template sequence and object manager classes
     // for non-defined forward declared interfaces.
     static POA_ptr tao_duplicate (POA_ptr);
     static void tao_release (POA_ptr);
     static POA_ptr tao_nil (void);
-    static POA_ptr tao_narrow (CORBA::Object * TAO_ENV_ARG_DECL_NOT_USED);
+    static POA_ptr tao_narrow (
+        CORBA::Object *
+        TAO_ENV_ARG_DECL_NOT_USED
+      );
     static CORBA::Object * tao_upcast (void *);
-
+  
   private:
     POA_ptr ptr_;
     // Unimplemented - prevents widening assignment.
@@ -126,11 +129,11 @@ TAO_NAMESPACE  PortableServer
 
 
 #endif /* end #if !defined */
-
-
+  
+  
 #if !defined (_PORTABLESERVER_POA___OUT_CH_)
 #define _PORTABLESERVER_POA___OUT_CH_
-
+  
   class TAO_PortableServer_Export POA_out
   {
   public:
@@ -143,141 +146,156 @@ TAO_NAMESPACE  PortableServer
     operator POA_ptr &();
     POA_ptr &ptr (void);
     POA_ptr operator-> (void);
-
+  
   private:
     POA_ptr &ptr_;
   };
-
-
+  
+  
 #endif /* end #if !defined */
-
-
+  
+  
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-
+  
 #if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_PORTABLESERVER_POALIST_CH_)
 #define __TAO_UNBOUNDED_OBJECT_SEQUENCE_PORTABLESERVER_POALIST_CH_
-
-    class _TAO_Unbounded_Object_Sequence_PortableServer_POAList : public TAO_Unbounded_Base_Sequence
-    {
-    public:
-      // = Initialization and termination methods.
-
-      _TAO_Unbounded_Object_Sequence_PortableServer_POAList (void);
-      _TAO_Unbounded_Object_Sequence_PortableServer_POAList (CORBA::ULong maximum);
-      _TAO_Unbounded_Object_Sequence_PortableServer_POAList (CORBA::ULong maximum,
+  
+  class TAO_EXPORT_MACRO _TAO_Unbounded_Object_Sequence_PortableServer_POAList
+    : public TAO_Unbounded_Base_Sequence
+  {
+  public:
+    // = Initialization and termination methods.
+    _TAO_Unbounded_Object_Sequence_PortableServer_POAList (void);
+    _TAO_Unbounded_Object_Sequence_PortableServer_POAList (CORBA::ULong maximum);
+    _TAO_Unbounded_Object_Sequence_PortableServer_POAList (
+        CORBA::ULong maximum,
         CORBA::ULong length,
         POA* *value,
-        CORBA::Boolean release = 0);
-      _TAO_Unbounded_Object_Sequence_PortableServer_POAList(const _TAO_Unbounded_Object_Sequence_PortableServer_POAList &rhs);
-      virtual ~_TAO_Unbounded_Object_Sequence_PortableServer_POAList (void);
-      _TAO_Unbounded_Object_Sequence_PortableServer_POAList &operator= (const _TAO_Unbounded_Object_Sequence_PortableServer_POAList &rhs);
-      TAO_Object_Manager<PortableServer::POA,PortableServer::POA_var> operator[] (CORBA::ULong index) const;
-      static POA **allocbuf (CORBA::ULong nelems);
-      static void freebuf (POA **buffer);
-      // The Base_Sequence functions, please see tao/Sequence.h
-      virtual void _allocate_buffer (CORBA::ULong length);
-      virtual void _deallocate_buffer (void);
-      POA* *get_buffer (CORBA::Boolean orphan = 0);
-      const POA* *get_buffer (void) const;
-      virtual void _shrink_buffer (CORBA::ULong nl, CORBA::ULong ol);
-      virtual void _downcast (
-          void* target,
-          CORBA_Object *src
-          TAO_ENV_ARG_DECL_WITH_DEFAULTS);
-
-      virtual CORBA_Object* _upcast (void *src) const;
-
-    };
-
+        CORBA::Boolean release = 0
+      );
+    _TAO_Unbounded_Object_Sequence_PortableServer_POAList (
+        const _TAO_Unbounded_Object_Sequence_PortableServer_POAList &rhs
+      );
+    _TAO_Unbounded_Object_Sequence_PortableServer_POAList &operator= (
+        const _TAO_Unbounded_Object_Sequence_PortableServer_POAList &rhs
+      );
+    virtual ~_TAO_Unbounded_Object_Sequence_PortableServer_POAList (void);
+    
+    // = Accessors.
+    TAO_Object_Manager<PortableServer::POA,PortableServer::POA_var> operator[] (CORBA::ULong index) const;
+    
+    // = Static operations.
+    static POA **allocbuf (CORBA::ULong nelems);
+    static void freebuf (POA **buffer);
+    
+    // Implement the TAO_Base_Sequence methods (see Sequence.h)
+    virtual void _allocate_buffer (CORBA::ULong length);
+    virtual void _deallocate_buffer (void);
+    POA* *get_buffer (CORBA::Boolean orphan = 0);
+    const POA* *get_buffer (void) const;
+    virtual void _shrink_buffer (
+        CORBA::ULong nl,
+        CORBA::ULong ol
+      );
+    
+    virtual void _downcast (
+        void* target,
+        CORBA_Object *src
+        TAO_ENV_ARG_DECL_WITH_DEFAULTS
+      );
+    virtual CORBA_Object* _upcast (void *src) const;
+  };
+  
 #endif /* end #if !defined */
-
-
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
-
+  
+  
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+  
 #if !defined (_PORTABLESERVER_POALIST_CH_)
 #define _PORTABLESERVER_POALIST_CH_
-
+  
   class POAList;
   class POAList_var;
-
+  
   // *************************************************************
   // POAList
   // *************************************************************
-
-  class TAO_PortableServer_Export POAList : public
+  
+  class TAO_PortableServer_Export POAList : public 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-    _TAO_Unbounded_Object_Sequence_PortableServer_POAList
+  _TAO_Unbounded_Object_Sequence_PortableServer_POAList
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
-    TAO_Unbounded_Object_Sequence<POA,POA_var>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<POA,POA_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
   {
   public:
     POAList (void); // default ctor
     POAList (CORBA::ULong max); // uses max size
     POAList (
-      CORBA::ULong max,
-      CORBA::ULong length,
-      POA_ptr *buffer,
-      CORBA::Boolean release = 0
-    );
+        CORBA::ULong max, 
+        CORBA::ULong length, 
+        POA_ptr *buffer, 
+        CORBA::Boolean release = 0
+      );
     POAList (const POAList &); // copy ctor
     ~POAList (void);
     static void _tao_any_destructor (void*);
-
+    
 #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
     typedef POAList_var _var_type;
 #endif /* ! __GNUC__ || g++ >= 2.8 */
-
+    
+    
   };
-
+  
 #endif /* end #if !defined */
-
-
+  
+  
 #if !defined (_PORTABLESERVER_POALIST___VAR_CH_)
 #define _PORTABLESERVER_POALIST___VAR_CH_
-
+  
   // *************************************************************
   // class PortableServer::POAList_var
   // *************************************************************
-
+  
   class TAO_PortableServer_Export POAList_var
   {
   public:
-    POAList_var (void); // default constructor
+    POAList_var (void);
     POAList_var (POAList *);
-    POAList_var (const POAList_var &); // copy constructor
-    ~POAList_var (void); // destructor
-
+    POAList_var (const POAList_var &);
+    ~POAList_var (void);
+    
     POAList_var &operator= (POAList *);
     POAList_var &operator= (const POAList_var &);
     POAList *operator-> (void);
     const POAList *operator-> (void) const;
-
+    
     operator const POAList &() const;
     operator POAList &();
     operator POAList &() const;
     operator POAList *&(); // variable-size base types only
-
+    
     TAO_Object_Manager<POA, POA_var> operator[] (CORBA::ULong index);
-
-    // in, inout, out, _retn
+    
+    // in, inout, out, _retn 
     const POAList &in (void) const;
     POAList &inout (void);
     POAList *&out (void);
     POAList *_retn (void);
     POAList *ptr (void) const;
-
+  
   private:
     POAList *ptr_;
   };
-
-
+  
+  
 #endif /* end #if !defined */
-
-
+  
+  
 #if !defined (_PORTABLESERVER_POALIST___OUT_CH_)
 #define _PORTABLESERVER_POALIST___OUT_CH_
-
+  
   class TAO_PortableServer_Export POAList_out
   {
   public:
@@ -290,52 +308,52 @@ TAO_NAMESPACE  PortableServer
     POAList *&ptr (void);
     POAList *operator-> (void);
     TAO_Object_Manager<POA, POA_var> operator[] (CORBA::ULong index);
-
+  
   private:
     POAList *&ptr_;
-    // assignment from T_var not allowed
+    // Assignment from T_var not allowed.
     void operator= (const POAList_var &);
   };
-
-
+  
+  
 #endif /* end #if !defined */
-
-
+  
+  
 #if !defined (_PORTABLESERVER_OBJECTID_CH_)
 #define _PORTABLESERVER_OBJECTID_CH_
-
+  
   class ObjectId;
   class ObjectId_var;
-
+  
   // *************************************************************
   // ObjectId
   // *************************************************************
-
-  class TAO_PortableServer_Export ObjectId : public
+  
+  class TAO_PortableServer_Export ObjectId : public 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-    TAO_Unbounded_Sequence<CORBA::Octet>
+  TAO_Unbounded_Sequence<CORBA::Octet>
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
-    TAO_Unbounded_Sequence<CORBA::Octet>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<CORBA::Octet>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
   {
   public:
     ObjectId (void); // default ctor
     ObjectId (CORBA::ULong max); // uses max size
     ObjectId (
-      CORBA::ULong max,
-      CORBA::ULong length,
-      CORBA::Octet *buffer,
-      CORBA::Boolean release = 0
-    );
+        CORBA::ULong max, 
+        CORBA::ULong length, 
+        CORBA::Octet *buffer, 
+        CORBA::Boolean release = 0
+      );
     ObjectId (const ObjectId &); // copy ctor
     ~ObjectId (void);
     static void _tao_any_destructor (void*);
-
+    
 #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
     typedef ObjectId_var _var_type;
 #endif /* ! __GNUC__ || g++ >= 2.8 */
-
-
+    
+    
 #if (TAO_NO_COPY_OCTET_SEQUENCES == 1)
     ObjectId (
         CORBA::ULong length,
@@ -343,59 +361,61 @@ TAO_NAMESPACE  PortableServer
       )
       : TAO_Unbounded_Sequence<CORBA::Octet> (length, mb) {}
 #endif /* TAO_NO_COPY_OCTET_SEQUENCE == 1 */
-
+    
   };
-
+  
 #endif /* end #if !defined */
-
-
+  
+  
 #if !defined (_PORTABLESERVER_OBJECTID___VAR_CH_)
 #define _PORTABLESERVER_OBJECTID___VAR_CH_
-
+  
   // *************************************************************
   // class PortableServer::ObjectId_var
   // *************************************************************
-
+  
   class TAO_PortableServer_Export ObjectId_var
   {
   public:
-    ObjectId_var (void); // default constructor
+    ObjectId_var (void);
     ObjectId_var (ObjectId *);
-    ObjectId_var (const ObjectId_var &); // copy constructor
-    ObjectId_var (const ObjectId &); // fixed-size base types only
-    ~ObjectId_var (void); // destructor
-
+    ObjectId_var (const ObjectId_var &);
+    // Fixed-size base types only.
+    ObjectId_var (const ObjectId &);
+    ~ObjectId_var (void);
+    
     ObjectId_var &operator= (ObjectId *);
     ObjectId_var &operator= (const ObjectId_var &);
-    ObjectId_var &operator= (const ObjectId &); // fixed-size base types only
+    // Fixed-size base types only.
+    ObjectId_var &operator= (const ObjectId &);
     ObjectId *operator-> (void);
     const ObjectId *operator-> (void) const;
-
+    
     operator const ObjectId &() const;
     operator ObjectId &();
     operator ObjectId &() const;
-
+    
     CORBA::Octet & operator[] (CORBA::ULong index);
     const CORBA::Octet & operator[] (CORBA::ULong index) const;
-
-    // in, inout, out, _retn
+    
+    // in, inout, out, _retn 
     const ObjectId &in (void) const;
     ObjectId &inout (void);
     ObjectId *&out (void);
     ObjectId *_retn (void);
     ObjectId *ptr (void) const;
-
+  
   private:
     ObjectId *ptr_;
   };
-
-
+  
+  
 #endif /* end #if !defined */
-
-
+  
+  
 #if !defined (_PORTABLESERVER_OBJECTID___OUT_CH_)
 #define _PORTABLESERVER_OBJECTID___OUT_CH_
-
+  
   class TAO_PortableServer_Export ObjectId_out
   {
   public:
@@ -408,139 +428,350 @@ TAO_NAMESPACE  PortableServer
     ObjectId *&ptr (void);
     ObjectId *operator-> (void);
     CORBA::Octet & operator[] (CORBA::ULong index);
-
+  
   private:
     ObjectId *&ptr_;
-    // assignment from T_var not allowed
+    // Assignment from T_var not allowed.
     void operator= (const ObjectId_var &);
   };
-
-
+  
+  
 #endif /* end #if !defined */
-
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ObjectId;
-
-
+  
+  TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_ObjectId;
+  
 #if (TAO_HAS_MINIMUM_CORBA == 0)
-
+  
 #if !defined (_PORTABLESERVER_FORWARDREQUEST_CH_)
 #define _PORTABLESERVER_FORWARDREQUEST_CH_
-
+  
   class TAO_PortableServer_Export ForwardRequest : public CORBA::UserException
   {
   public:
     CORBA::Object_var forward_reference;
-
+    
     ForwardRequest (void);
     // Default constructor.
-
+    
     ForwardRequest (const ForwardRequest &);
     // Copy constructor.
-
+    
     ~ForwardRequest (void);
     // Destructor.
-
+    
     static void _tao_any_destructor (void*);
-
+    
     ForwardRequest &operator= (const ForwardRequest &);
-
+    
     virtual void _raise (void);
 
     virtual void _tao_encode (
         TAO_OutputCDR &
         TAO_ENV_ARG_DECL_NOT_USED
       ) const;
-
+    
     virtual void _tao_decode (
         TAO_InputCDR &
         TAO_ENV_ARG_DECL_NOT_USED
       );
-
+    
     static ForwardRequest *_downcast (CORBA::Exception *);
 
     ForwardRequest (
         const CORBA::Object_ptr  _tao_forward_reference
       );
-
+    
     // = TAO extension.
     static CORBA::Exception *_alloc (void);
     virtual CORBA::TypeCode_ptr _type (void) const;
   }; // Exception PortableServer::ForwardRequest.
 
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ForwardRequest;
+TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_ForwardRequest;
+  
+  
+#endif /* end #if !defined */
+  
+  
+#if !defined (_PORTABLESERVER_NOTAGROUPOBJECT_CH_)
+#define _PORTABLESERVER_NOTAGROUPOBJECT_CH_
+  
+  class TAO_PortableServer_Export NotAGroupObject : public CORBA::UserException
+  {
+  public:
+    
+    NotAGroupObject (void);
+    // Default constructor.
+    
+    NotAGroupObject (const NotAGroupObject &);
+    // Copy constructor.
+    
+    ~NotAGroupObject (void);
+    // Destructor.
+    
+    static void _tao_any_destructor (void*);
+    
+    NotAGroupObject &operator= (const NotAGroupObject &);
+    
+    virtual void _raise (void);
 
+    virtual void _tao_encode (
+        TAO_OutputCDR &
+        TAO_ENV_ARG_DECL_NOT_USED
+      ) const;
+    
+    virtual void _tao_decode (
+        TAO_InputCDR &
+        TAO_ENV_ARG_DECL_NOT_USED
+      );
+    
+    static NotAGroupObject *_downcast (CORBA::Exception *);
 
-#endif /* end #if !defined */
 
+    // = TAO extension.
+    static CORBA::Exception *_alloc (void);
+    virtual CORBA::TypeCode_ptr _type (void) const;
+  }; // Exception PortableServer::NotAGroupObject.
+
+TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_NotAGroupObject;
+  
+  
+#endif /* end #if !defined */
+  
+  
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_SEQUENCE_PORTABLESERVER_IDS_CH_)
+#define __TAO_UNBOUNDED_SEQUENCE_PORTABLESERVER_IDS_CH_
+  
+  class TAO_EXPORT_MACRO _TAO_Unbounded_Sequence_PortableServer_IDs
+    : public TAO_Unbounded_Base_Sequence
+  {
+  public:
+    // = Initialization and termination methods.
+    _TAO_Unbounded_Sequence_PortableServer_IDs (void);
+    _TAO_Unbounded_Sequence_PortableServer_IDs (CORBA::ULong maximum); 
+    _TAO_Unbounded_Sequence_PortableServer_IDs (
+        CORBA::ULong maximum,
+        CORBA::ULong length,
+        ObjectId *data,
+        CORBA::Boolean release = 0
+      );
+    _TAO_Unbounded_Sequence_PortableServer_IDs (
+        const _TAO_Unbounded_Sequence_PortableServer_IDs &rhs
+      );
+    _TAO_Unbounded_Sequence_PortableServer_IDs &operator= (
+        const _TAO_Unbounded_Sequence_PortableServer_IDs &rhs
+      );
+    virtual ~_TAO_Unbounded_Sequence_PortableServer_IDs (void);
+    
+    // = Accessors.
+    ObjectId &operator[] (CORBA::ULong i);
+    const ObjectId &operator[] (CORBA::ULong i) const;
+    
+    // = Static operations.
+    static ObjectId *allocbuf (CORBA::ULong size);
+    static void freebuf (ObjectId *buffer);
+    
+    // Implement the TAO_Base_Sequence methods (see Sequence.h)
+    virtual void _allocate_buffer (CORBA::ULong length);
+    virtual void _deallocate_buffer (void);
+    ObjectId *get_buffer (CORBA::Boolean orphan = 0);
+    const ObjectId *get_buffer (void) const;
+    void replace (
+        CORBA::ULong max,
+        CORBA::ULong length,
+        ObjectId *data,
+        CORBA::Boolean release
+      );
+  };
+  
+#endif /* end #if !defined */
+  
+  
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+  
+#if !defined (_PORTABLESERVER_IDS_CH_)
+#define _PORTABLESERVER_IDS_CH_
+  
+  class IDs;
+  class IDs_var;
+  
+  // *************************************************************
+  // IDs
+  // *************************************************************
+  
+  class TAO_PortableServer_Export IDs : public 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Sequence_PortableServer_IDs
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<ObjectId>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+  {
+  public:
+    IDs (void); // default ctor
+    IDs (CORBA::ULong max); // uses max size
+    IDs (
+        CORBA::ULong max, 
+        CORBA::ULong length, 
+        ObjectId *buffer, 
+        CORBA::Boolean release = 0
+      );
+    IDs (const IDs &); // copy ctor
+    ~IDs (void);
+    static void _tao_any_destructor (void*);
+    
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+    typedef IDs_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+    
+    
+  };
+  
+#endif /* end #if !defined */
+  
+  
+#if !defined (_PORTABLESERVER_IDS___VAR_CH_)
+#define _PORTABLESERVER_IDS___VAR_CH_
+  
+  // *************************************************************
+  // class PortableServer::IDs_var
+  // *************************************************************
+  
+  class TAO_PortableServer_Export IDs_var
+  {
+  public:
+    IDs_var (void);
+    IDs_var (IDs *);
+    IDs_var (const IDs_var &);
+    ~IDs_var (void);
+    
+    IDs_var &operator= (IDs *);
+    IDs_var &operator= (const IDs_var &);
+    IDs *operator-> (void);
+    const IDs *operator-> (void) const;
+    
+    operator const IDs &() const;
+    operator IDs &();
+    operator IDs &() const;
+    operator IDs *&(); // variable-size base types only
+    
+    ObjectId & operator[] (CORBA::ULong index);
+    const ObjectId & operator[] (CORBA::ULong index) const;
+    
+    // in, inout, out, _retn 
+    const IDs &in (void) const;
+    IDs &inout (void);
+    IDs *&out (void);
+    IDs *_retn (void);
+    IDs *ptr (void) const;
+  
+  private:
+    IDs *ptr_;
+  };
+  
+  
+#endif /* end #if !defined */
+  
+  
+#if !defined (_PORTABLESERVER_IDS___OUT_CH_)
+#define _PORTABLESERVER_IDS___OUT_CH_
+  
+  class TAO_PortableServer_Export IDs_out
+  {
+  public:
+    IDs_out (IDs *&);
+    IDs_out (IDs_var &);
+    IDs_out (const IDs_out &);
+    IDs_out &operator= (const IDs_out &);
+    IDs_out &operator= (IDs *);
+    operator IDs *&();
+    IDs *&ptr (void);
+    IDs *operator-> (void);
+    ObjectId & operator[] (CORBA::ULong index);
+  
+  private:
+    IDs *&ptr_;
+    // Assignment from T_var not allowed.
+    void operator= (const IDs_var &);
+  };
+  
+  
+#endif /* end #if !defined */
+  
 #endif /* TAO_HAS_MINIMUM_CORBA == 0 */
 
+  TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_IDs;
+  
   TAO_NAMESPACE_STORAGE_CLASS const CORBA::ULong THREAD_POLICY_ID;
-
+  
   TAO_NAMESPACE_STORAGE_CLASS const CORBA::ULong LIFESPAN_POLICY_ID;
-
+  
   TAO_NAMESPACE_STORAGE_CLASS const CORBA::ULong ID_UNIQUENESS_POLICY_ID;
-
+  
   TAO_NAMESPACE_STORAGE_CLASS const CORBA::ULong ID_ASSIGNMENT_POLICY_ID;
-
+  
   TAO_NAMESPACE_STORAGE_CLASS const CORBA::ULong IMPLICIT_ACTIVATION_POLICY_ID;
-
+  
   TAO_NAMESPACE_STORAGE_CLASS const CORBA::ULong SERVANT_RETENTION_POLICY_ID;
-
+  
   TAO_NAMESPACE_STORAGE_CLASS const CORBA::ULong REQUEST_PROCESSING_POLICY_ID;
-
+  
   enum ThreadPolicyValue
   {
-        ORB_CTRL_MODEL,
-        SINGLE_THREAD_MODEL
+    ORB_CTRL_MODEL,
+    SINGLE_THREAD_MODEL
   };
-
+  
 #if (TAO_HAS_MINIMUM_POA == 0)
 
   typedef ThreadPolicyValue &ThreadPolicyValue_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ThreadPolicyValue;
-
-
+  TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_ThreadPolicyValue;
+  
+  
 #if !defined (_PORTABLESERVER_THREADPOLICY___PTR_CH_)
 #define _PORTABLESERVER_THREADPOLICY___PTR_CH_
-
+  
   class ThreadPolicy;
   typedef ThreadPolicy *ThreadPolicy_ptr;
-
+  
 #endif /* end #if !defined */
-
-
+  
+  
 #if !defined (_PORTABLESERVER_THREADPOLICY___VAR_CH_)
 #define _PORTABLESERVER_THREADPOLICY___VAR_CH_
-
+  
   class TAO_PortableServer_Export ThreadPolicy_var : public TAO_Base_var
   {
   public:
     ThreadPolicy_var (void); // default constructor
-    ThreadPolicy_var (ThreadPolicy_ptr p) : ptr_ (p) {}
+    ThreadPolicy_var (ThreadPolicy_ptr p) : ptr_ (p) {} 
     ThreadPolicy_var (const ThreadPolicy_var &); // copy constructor
     ~ThreadPolicy_var (void); // destructor
-
+    
     ThreadPolicy_var &operator= (ThreadPolicy_ptr);
     ThreadPolicy_var &operator= (const ThreadPolicy_var &);
     ThreadPolicy_ptr operator-> (void) const;
-
+    
     operator const ThreadPolicy_ptr &() const;
     operator ThreadPolicy_ptr &();
-    // in, inout, out, _retn
+    // in, inout, out, _retn 
     ThreadPolicy_ptr in (void) const;
     ThreadPolicy_ptr &inout (void);
     ThreadPolicy_ptr &out (void);
     ThreadPolicy_ptr _retn (void);
     ThreadPolicy_ptr ptr (void) const;
-
+    
     // Hooks used by template sequence and object manager classes
     // for non-defined forward declared interfaces.
     static ThreadPolicy_ptr tao_duplicate (ThreadPolicy_ptr);
     static void tao_release (ThreadPolicy_ptr);
     static ThreadPolicy_ptr tao_nil (void);
-    static ThreadPolicy_ptr tao_narrow (CORBA::Object * TAO_ENV_ARG_DECL_NOT_USED);
+    static ThreadPolicy_ptr tao_narrow (
+        CORBA::Object *
+        TAO_ENV_ARG_DECL_NOT_USED
+      );
     static CORBA::Object * tao_upcast (void *);
-
+  
   private:
     ThreadPolicy_ptr ptr_;
     // Unimplemented - prevents widening assignment.
@@ -550,11 +781,11 @@ TAO_NAMESPACE  PortableServer
 
 
 #endif /* end #if !defined */
-
-
+  
+  
 #if !defined (_PORTABLESERVER_THREADPOLICY___OUT_CH_)
 #define _PORTABLESERVER_THREADPOLICY___OUT_CH_
-
+  
   class TAO_PortableServer_Export ThreadPolicy_out
   {
   public:
@@ -567,19 +798,20 @@ TAO_NAMESPACE  PortableServer
     operator ThreadPolicy_ptr &();
     ThreadPolicy_ptr &ptr (void);
     ThreadPolicy_ptr operator-> (void);
-
+  
   private:
     ThreadPolicy_ptr &ptr_;
   };
-
-
+  
+  
 #endif /* end #if !defined */
-
-
+  
+  
 #if !defined (_PORTABLESERVER_THREADPOLICY_CH_)
 #define _PORTABLESERVER_THREADPOLICY_CH_
-
-class TAO_PortableServer_Export ThreadPolicy: public virtual CORBA::Policy
+  
+  class TAO_PortableServer_Export ThreadPolicy
+    : public virtual CORBA::Policy
   {
   public:
   #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
@@ -587,98 +819,106 @@ class TAO_PortableServer_Export ThreadPolicy: public virtual CORBA::Policy
     typedef ThreadPolicy_var _var_type;
   #endif /* ! __GNUC__ || g++ >= 2.8 */
 
-  static int _tao_class_id;
-
-    // the static operations
+    static int _tao_class_id;
+    
+    // The static operations.
     static ThreadPolicy_ptr _duplicate (ThreadPolicy_ptr obj);
+    
     static ThreadPolicy_ptr _narrow (
         CORBA::Object_ptr obj
-        TAO_ENV_ARG_DECL_WITH_DEFAULTS);
-
+        TAO_ENV_ARG_DECL_WITH_DEFAULTS
+      );
+    
     static ThreadPolicy_ptr _unchecked_narrow (
         CORBA::Object_ptr obj
-        TAO_ENV_ARG_DECL_WITH_DEFAULTS);
-
+        TAO_ENV_ARG_DECL_WITH_DEFAULTS
+      );
+    
     static ThreadPolicy_ptr _nil (void)
       {
         return (ThreadPolicy_ptr)0;
       }
-
-    virtual PortableServer::ThreadPolicyValue value (
-        TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)
-
+    
+    virtual ::PortableServer::ThreadPolicyValue value (
+        TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
+      )
       ACE_THROW_SPEC ((
         CORBA::SystemException
       )) = 0;
-
+    
     virtual void *_tao_QueryInterface (ptr_arith_t type);
-
+    
     virtual const char* _interface_repository_id (void) const;
 
   protected:
-    ThreadPolicy ();
-
+    ThreadPolicy (void);
+    
     virtual ~ThreadPolicy (void);
+  
   private:
     ThreadPolicy (const ThreadPolicy &);
     void operator= (const ThreadPolicy &);
   };
-
-
+  
+  
 #endif /* end #if !defined */
 
 #endif /* TAO_HAS_MINIMUM_POA == 0 */
-
+  
   enum LifespanPolicyValue
   {
-        TRANSIENT,
-        PERSISTENT
+    TRANSIENT,
+    PERSISTENT
   };
+  
   typedef LifespanPolicyValue &LifespanPolicyValue_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_LifespanPolicyValue;
-
-
+  TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_LifespanPolicyValue;
+  
+  
 #if !defined (_PORTABLESERVER_LIFESPANPOLICY___PTR_CH_)
 #define _PORTABLESERVER_LIFESPANPOLICY___PTR_CH_
-
+  
   class LifespanPolicy;
   typedef LifespanPolicy *LifespanPolicy_ptr;
-
+  
 #endif /* end #if !defined */
-
-
+  
+  
 #if !defined (_PORTABLESERVER_LIFESPANPOLICY___VAR_CH_)
 #define _PORTABLESERVER_LIFESPANPOLICY___VAR_CH_
-
+  
   class TAO_PortableServer_Export LifespanPolicy_var : public TAO_Base_var
   {
   public:
     LifespanPolicy_var (void); // default constructor
-    LifespanPolicy_var (LifespanPolicy_ptr p) : ptr_ (p) {}
+    LifespanPolicy_var (LifespanPolicy_ptr p) : ptr_ (p) {} 
     LifespanPolicy_var (const LifespanPolicy_var &); // copy constructor
     ~LifespanPolicy_var (void); // destructor
-
+    
     LifespanPolicy_var &operator= (LifespanPolicy_ptr);
     LifespanPolicy_var &operator= (const LifespanPolicy_var &);
     LifespanPolicy_ptr operator-> (void) const;
-
+    
     operator const LifespanPolicy_ptr &() const;
     operator LifespanPolicy_ptr &();
-    // in, inout, out, _retn
+    // in, inout, out, _retn 
     LifespanPolicy_ptr in (void) const;
     LifespanPolicy_ptr &inout (void);
     LifespanPolicy_ptr &out (void);
     LifespanPolicy_ptr _retn (void);
     LifespanPolicy_ptr ptr (void) const;
-
+    
     // Hooks used by template sequence and object manager classes
     // for non-defined forward declared interfaces.
     static LifespanPolicy_ptr tao_duplicate (LifespanPolicy_ptr);
     static void tao_release (LifespanPolicy_ptr);
     static LifespanPolicy_ptr tao_nil (void);
-    static LifespanPolicy_ptr tao_narrow (CORBA::Object * TAO_ENV_ARG_DECL_NOT_USED);
+    static LifespanPolicy_ptr tao_narrow (
+        CORBA::Object *
+        TAO_ENV_ARG_DECL_NOT_USED
+      );
     static CORBA::Object * tao_upcast (void *);
-
+  
   private:
     LifespanPolicy_ptr ptr_;
     // Unimplemented - prevents widening assignment.
@@ -688,11 +928,11 @@ class TAO_PortableServer_Export ThreadPolicy: public virtual CORBA::Policy
 
 
 #endif /* end #if !defined */
-
-
+  
+  
 #if !defined (_PORTABLESERVER_LIFESPANPOLICY___OUT_CH_)
 #define _PORTABLESERVER_LIFESPANPOLICY___OUT_CH_
-
+  
   class TAO_PortableServer_Export LifespanPolicy_out
   {
   public:
@@ -705,19 +945,20 @@ class TAO_PortableServer_Export ThreadPolicy: public virtual CORBA::Policy
     operator LifespanPolicy_ptr &();
     LifespanPolicy_ptr &ptr (void);
     LifespanPolicy_ptr operator-> (void);
-
+  
   private:
     LifespanPolicy_ptr &ptr_;
   };
-
-
+  
+  
 #endif /* end #if !defined */
-
-
+  
+  
 #if !defined (_PORTABLESERVER_LIFESPANPOLICY_CH_)
 #define _PORTABLESERVER_LIFESPANPOLICY_CH_
-
-class TAO_PortableServer_Export LifespanPolicy: public virtual CORBA::Policy
+  
+  class TAO_PortableServer_Export LifespanPolicy
+    : public virtual CORBA::Policy
   {
   public:
   #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
@@ -725,96 +966,104 @@ class TAO_PortableServer_Export LifespanPolicy: public virtual CORBA::Policy
     typedef LifespanPolicy_var _var_type;
   #endif /* ! __GNUC__ || g++ >= 2.8 */
 
-  static int _tao_class_id;
-
-    // the static operations
+    static int _tao_class_id;
+    
+    // The static operations.
     static LifespanPolicy_ptr _duplicate (LifespanPolicy_ptr obj);
+    
     static LifespanPolicy_ptr _narrow (
         CORBA::Object_ptr obj
-        TAO_ENV_ARG_DECL_WITH_DEFAULTS);
-
+        TAO_ENV_ARG_DECL_WITH_DEFAULTS
+      );
+    
     static LifespanPolicy_ptr _unchecked_narrow (
         CORBA::Object_ptr obj
-        TAO_ENV_ARG_DECL_WITH_DEFAULTS);
-
+        TAO_ENV_ARG_DECL_WITH_DEFAULTS
+      );
+    
     static LifespanPolicy_ptr _nil (void)
       {
         return (LifespanPolicy_ptr)0;
       }
-
-    virtual PortableServer::LifespanPolicyValue value (
-        TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)
-
+    
+    virtual ::PortableServer::LifespanPolicyValue value (
+        TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
+      )
       ACE_THROW_SPEC ((
         CORBA::SystemException
       )) = 0;
-
+    
     virtual void *_tao_QueryInterface (ptr_arith_t type);
-
+    
     virtual const char* _interface_repository_id (void) const;
 
   protected:
-    LifespanPolicy ();
-
+    LifespanPolicy (void);
+    
     virtual ~LifespanPolicy (void);
+  
   private:
     LifespanPolicy (const LifespanPolicy &);
     void operator= (const LifespanPolicy &);
   };
-
-
+  
+  
 #endif /* end #if !defined */
-
+  
   enum IdUniquenessPolicyValue
   {
-        UNIQUE_ID,
-        MULTIPLE_ID
+    UNIQUE_ID,
+    MULTIPLE_ID
   };
+  
   typedef IdUniquenessPolicyValue &IdUniquenessPolicyValue_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_IdUniquenessPolicyValue;
-
-
+  TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_IdUniquenessPolicyValue;
+  
+  
 #if !defined (_PORTABLESERVER_IDUNIQUENESSPOLICY___PTR_CH_)
 #define _PORTABLESERVER_IDUNIQUENESSPOLICY___PTR_CH_
-
+  
   class IdUniquenessPolicy;
   typedef IdUniquenessPolicy *IdUniquenessPolicy_ptr;
-
+  
 #endif /* end #if !defined */
-
-
+  
+  
 #if !defined (_PORTABLESERVER_IDUNIQUENESSPOLICY___VAR_CH_)
 #define _PORTABLESERVER_IDUNIQUENESSPOLICY___VAR_CH_
-
+  
   class TAO_PortableServer_Export IdUniquenessPolicy_var : public TAO_Base_var
   {
   public:
     IdUniquenessPolicy_var (void); // default constructor
-    IdUniquenessPolicy_var (IdUniquenessPolicy_ptr p) : ptr_ (p) {}
+    IdUniquenessPolicy_var (IdUniquenessPolicy_ptr p) : ptr_ (p) {} 
     IdUniquenessPolicy_var (const IdUniquenessPolicy_var &); // copy constructor
     ~IdUniquenessPolicy_var (void); // destructor
-
+    
     IdUniquenessPolicy_var &operator= (IdUniquenessPolicy_ptr);
     IdUniquenessPolicy_var &operator= (const IdUniquenessPolicy_var &);
     IdUniquenessPolicy_ptr operator-> (void) const;
-
+    
     operator const IdUniquenessPolicy_ptr &() const;
     operator IdUniquenessPolicy_ptr &();
-    // in, inout, out, _retn
+    // in, inout, out, _retn 
     IdUniquenessPolicy_ptr in (void) const;
     IdUniquenessPolicy_ptr &inout (void);
     IdUniquenessPolicy_ptr &out (void);
     IdUniquenessPolicy_ptr _retn (void);
     IdUniquenessPolicy_ptr ptr (void) const;
-
+    
     // Hooks used by template sequence and object manager classes
     // for non-defined forward declared interfaces.
     static IdUniquenessPolicy_ptr tao_duplicate (IdUniquenessPolicy_ptr);
     static void tao_release (IdUniquenessPolicy_ptr);
     static IdUniquenessPolicy_ptr tao_nil (void);
-    static IdUniquenessPolicy_ptr tao_narrow (CORBA::Object * TAO_ENV_ARG_DECL_NOT_USED);
+    static IdUniquenessPolicy_ptr tao_narrow (
+        CORBA::Object *
+        TAO_ENV_ARG_DECL_NOT_USED
+      );
     static CORBA::Object * tao_upcast (void *);
-
+  
   private:
     IdUniquenessPolicy_ptr ptr_;
     // Unimplemented - prevents widening assignment.
@@ -824,11 +1073,11 @@ class TAO_PortableServer_Export LifespanPolicy: public virtual CORBA::Policy
 
 
 #endif /* end #if !defined */
-
-
+  
+  
 #if !defined (_PORTABLESERVER_IDUNIQUENESSPOLICY___OUT_CH_)
 #define _PORTABLESERVER_IDUNIQUENESSPOLICY___OUT_CH_
-
+  
   class TAO_PortableServer_Export IdUniquenessPolicy_out
   {
   public:
@@ -841,19 +1090,20 @@ class TAO_PortableServer_Export LifespanPolicy: public virtual CORBA::Policy
     operator IdUniquenessPolicy_ptr &();
     IdUniquenessPolicy_ptr &ptr (void);
     IdUniquenessPolicy_ptr operator-> (void);
-
+  
   private:
     IdUniquenessPolicy_ptr &ptr_;
   };
-
-
+  
+  
 #endif /* end #if !defined */
-
-
+  
+  
 #if !defined (_PORTABLESERVER_IDUNIQUENESSPOLICY_CH_)
 #define _PORTABLESERVER_IDUNIQUENESSPOLICY_CH_
-
-class TAO_PortableServer_Export IdUniquenessPolicy: public virtual CORBA::Policy
+  
+  class TAO_PortableServer_Export IdUniquenessPolicy
+    : public virtual CORBA::Policy
   {
   public:
   #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
@@ -861,96 +1111,104 @@ class TAO_PortableServer_Export IdUniquenessPolicy: public virtual CORBA::Policy
     typedef IdUniquenessPolicy_var _var_type;
   #endif /* ! __GNUC__ || g++ >= 2.8 */
 
-  static int _tao_class_id;
-
-    // the static operations
+    static int _tao_class_id;
+    
+    // The static operations.
     static IdUniquenessPolicy_ptr _duplicate (IdUniquenessPolicy_ptr obj);
+    
     static IdUniquenessPolicy_ptr _narrow (
         CORBA::Object_ptr obj
-        TAO_ENV_ARG_DECL_WITH_DEFAULTS);
-
+        TAO_ENV_ARG_DECL_WITH_DEFAULTS
+      );
+    
     static IdUniquenessPolicy_ptr _unchecked_narrow (
         CORBA::Object_ptr obj
-        TAO_ENV_ARG_DECL_WITH_DEFAULTS);
-
+        TAO_ENV_ARG_DECL_WITH_DEFAULTS
+      );
+    
     static IdUniquenessPolicy_ptr _nil (void)
       {
         return (IdUniquenessPolicy_ptr)0;
       }
-
-    virtual PortableServer::IdUniquenessPolicyValue value (
-        TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)
-
+    
+    virtual ::PortableServer::IdUniquenessPolicyValue value (
+        TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
+      )
       ACE_THROW_SPEC ((
         CORBA::SystemException
       )) = 0;
-
+    
     virtual void *_tao_QueryInterface (ptr_arith_t type);
-
+    
     virtual const char* _interface_repository_id (void) const;
 
   protected:
-    IdUniquenessPolicy ();
-
+    IdUniquenessPolicy (void);
+    
     virtual ~IdUniquenessPolicy (void);
+  
   private:
     IdUniquenessPolicy (const IdUniquenessPolicy &);
     void operator= (const IdUniquenessPolicy &);
   };
-
-
+  
+  
 #endif /* end #if !defined */
-
+  
   enum IdAssignmentPolicyValue
   {
-        USER_ID,
-        SYSTEM_ID
+    USER_ID,
+    SYSTEM_ID
   };
+  
   typedef IdAssignmentPolicyValue &IdAssignmentPolicyValue_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_IdAssignmentPolicyValue;
-
-
+  TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_IdAssignmentPolicyValue;
+  
+  
 #if !defined (_PORTABLESERVER_IDASSIGNMENTPOLICY___PTR_CH_)
 #define _PORTABLESERVER_IDASSIGNMENTPOLICY___PTR_CH_
-
+  
   class IdAssignmentPolicy;
   typedef IdAssignmentPolicy *IdAssignmentPolicy_ptr;
-
+  
 #endif /* end #if !defined */
-
-
+  
+  
 #if !defined (_PORTABLESERVER_IDASSIGNMENTPOLICY___VAR_CH_)
 #define _PORTABLESERVER_IDASSIGNMENTPOLICY___VAR_CH_
-
+  
   class TAO_PortableServer_Export IdAssignmentPolicy_var : public TAO_Base_var
   {
   public:
     IdAssignmentPolicy_var (void); // default constructor
-    IdAssignmentPolicy_var (IdAssignmentPolicy_ptr p) : ptr_ (p) {}
+    IdAssignmentPolicy_var (IdAssignmentPolicy_ptr p) : ptr_ (p) {} 
     IdAssignmentPolicy_var (const IdAssignmentPolicy_var &); // copy constructor
     ~IdAssignmentPolicy_var (void); // destructor
-
+    
     IdAssignmentPolicy_var &operator= (IdAssignmentPolicy_ptr);
     IdAssignmentPolicy_var &operator= (const IdAssignmentPolicy_var &);
     IdAssignmentPolicy_ptr operator-> (void) const;
-
+    
     operator const IdAssignmentPolicy_ptr &() const;
     operator IdAssignmentPolicy_ptr &();
-    // in, inout, out, _retn
+    // in, inout, out, _retn 
     IdAssignmentPolicy_ptr in (void) const;
     IdAssignmentPolicy_ptr &inout (void);
     IdAssignmentPolicy_ptr &out (void);
     IdAssignmentPolicy_ptr _retn (void);
     IdAssignmentPolicy_ptr ptr (void) const;
-
+    
     // Hooks used by template sequence and object manager classes
     // for non-defined forward declared interfaces.
     static IdAssignmentPolicy_ptr tao_duplicate (IdAssignmentPolicy_ptr);
     static void tao_release (IdAssignmentPolicy_ptr);
     static IdAssignmentPolicy_ptr tao_nil (void);
-    static IdAssignmentPolicy_ptr tao_narrow (CORBA::Object * TAO_ENV_ARG_DECL_NOT_USED);
+    static IdAssignmentPolicy_ptr tao_narrow (
+        CORBA::Object *
+        TAO_ENV_ARG_DECL_NOT_USED
+      );
     static CORBA::Object * tao_upcast (void *);
-
+  
   private:
     IdAssignmentPolicy_ptr ptr_;
     // Unimplemented - prevents widening assignment.
@@ -960,11 +1218,11 @@ class TAO_PortableServer_Export IdUniquenessPolicy: public virtual CORBA::Policy
 
 
 #endif /* end #if !defined */
-
-
+  
+  
 #if !defined (_PORTABLESERVER_IDASSIGNMENTPOLICY___OUT_CH_)
 #define _PORTABLESERVER_IDASSIGNMENTPOLICY___OUT_CH_
-
+  
   class TAO_PortableServer_Export IdAssignmentPolicy_out
   {
   public:
@@ -977,19 +1235,20 @@ class TAO_PortableServer_Export IdUniquenessPolicy: public virtual CORBA::Policy
     operator IdAssignmentPolicy_ptr &();
     IdAssignmentPolicy_ptr &ptr (void);
     IdAssignmentPolicy_ptr operator-> (void);
-
+  
   private:
     IdAssignmentPolicy_ptr &ptr_;
   };
-
-
+  
+  
 #endif /* end #if !defined */
-
-
+  
+  
 #if !defined (_PORTABLESERVER_IDASSIGNMENTPOLICY_CH_)
 #define _PORTABLESERVER_IDASSIGNMENTPOLICY_CH_
-
-class TAO_PortableServer_Export IdAssignmentPolicy: public virtual CORBA::Policy
+  
+  class TAO_PortableServer_Export IdAssignmentPolicy
+    : public virtual CORBA::Policy
   {
   public:
   #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
@@ -997,99 +1256,106 @@ class TAO_PortableServer_Export IdAssignmentPolicy: public virtual CORBA::Policy
     typedef IdAssignmentPolicy_var _var_type;
   #endif /* ! __GNUC__ || g++ >= 2.8 */
 
-  static int _tao_class_id;
-
-    // the static operations
+    static int _tao_class_id;
+    
+    // The static operations.
     static IdAssignmentPolicy_ptr _duplicate (IdAssignmentPolicy_ptr obj);
+    
     static IdAssignmentPolicy_ptr _narrow (
         CORBA::Object_ptr obj
-        TAO_ENV_ARG_DECL_WITH_DEFAULTS);
-
+        TAO_ENV_ARG_DECL_WITH_DEFAULTS
+      );
+    
     static IdAssignmentPolicy_ptr _unchecked_narrow (
         CORBA::Object_ptr obj
-        TAO_ENV_ARG_DECL_WITH_DEFAULTS);
-
+        TAO_ENV_ARG_DECL_WITH_DEFAULTS
+      );
+    
     static IdAssignmentPolicy_ptr _nil (void)
       {
         return (IdAssignmentPolicy_ptr)0;
       }
-
-    virtual PortableServer::IdAssignmentPolicyValue value (
-        TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)
-
+    
+    virtual ::PortableServer::IdAssignmentPolicyValue value (
+        TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
+      )
       ACE_THROW_SPEC ((
         CORBA::SystemException
       )) = 0;
-
+    
     virtual void *_tao_QueryInterface (ptr_arith_t type);
-
+    
     virtual const char* _interface_repository_id (void) const;
 
   protected:
-    IdAssignmentPolicy ();
-
+    IdAssignmentPolicy (void);
+    
     virtual ~IdAssignmentPolicy (void);
+  
   private:
     IdAssignmentPolicy (const IdAssignmentPolicy &);
     void operator= (const IdAssignmentPolicy &);
   };
-
-
+  
+  
 #endif /* end #if !defined */
-
+  
   enum ImplicitActivationPolicyValue
   {
-        IMPLICIT_ACTIVATION,
-        NO_IMPLICIT_ACTIVATION
+    IMPLICIT_ACTIVATION,
+    NO_IMPLICIT_ACTIVATION
   };
-
+  
 #if (TAO_HAS_MINIMUM_POA == 0)
 
   typedef ImplicitActivationPolicyValue &ImplicitActivationPolicyValue_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ImplicitActivationPolicyValue;
-
-
+  TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_ImplicitActivationPolicyValue;
+  
+  
 #if !defined (_PORTABLESERVER_IMPLICITACTIVATIONPOLICY___PTR_CH_)
 #define _PORTABLESERVER_IMPLICITACTIVATIONPOLICY___PTR_CH_
-
+  
   class ImplicitActivationPolicy;
   typedef ImplicitActivationPolicy *ImplicitActivationPolicy_ptr;
-
+  
 #endif /* end #if !defined */
-
-
+  
+  
 #if !defined (_PORTABLESERVER_IMPLICITACTIVATIONPOLICY___VAR_CH_)
 #define _PORTABLESERVER_IMPLICITACTIVATIONPOLICY___VAR_CH_
-
+  
   class TAO_PortableServer_Export ImplicitActivationPolicy_var : public TAO_Base_var
   {
   public:
     ImplicitActivationPolicy_var (void); // default constructor
-    ImplicitActivationPolicy_var (ImplicitActivationPolicy_ptr p) : ptr_ (p) {}
+    ImplicitActivationPolicy_var (ImplicitActivationPolicy_ptr p) : ptr_ (p) {} 
     ImplicitActivationPolicy_var (const ImplicitActivationPolicy_var &); // copy constructor
     ~ImplicitActivationPolicy_var (void); // destructor
-
+    
     ImplicitActivationPolicy_var &operator= (ImplicitActivationPolicy_ptr);
     ImplicitActivationPolicy_var &operator= (const ImplicitActivationPolicy_var &);
     ImplicitActivationPolicy_ptr operator-> (void) const;
-
+    
     operator const ImplicitActivationPolicy_ptr &() const;
     operator ImplicitActivationPolicy_ptr &();
-    // in, inout, out, _retn
+    // in, inout, out, _retn 
     ImplicitActivationPolicy_ptr in (void) const;
     ImplicitActivationPolicy_ptr &inout (void);
     ImplicitActivationPolicy_ptr &out (void);
     ImplicitActivationPolicy_ptr _retn (void);
     ImplicitActivationPolicy_ptr ptr (void) const;
-
+    
     // Hooks used by template sequence and object manager classes
     // for non-defined forward declared interfaces.
     static ImplicitActivationPolicy_ptr tao_duplicate (ImplicitActivationPolicy_ptr);
     static void tao_release (ImplicitActivationPolicy_ptr);
     static ImplicitActivationPolicy_ptr tao_nil (void);
-    static ImplicitActivationPolicy_ptr tao_narrow (CORBA::Object * TAO_ENV_ARG_DECL_NOT_USED);
+    static ImplicitActivationPolicy_ptr tao_narrow (
+        CORBA::Object *
+        TAO_ENV_ARG_DECL_NOT_USED
+      );
     static CORBA::Object * tao_upcast (void *);
-
+  
   private:
     ImplicitActivationPolicy_ptr ptr_;
     // Unimplemented - prevents widening assignment.
@@ -1099,11 +1365,11 @@ class TAO_PortableServer_Export IdAssignmentPolicy: public virtual CORBA::Policy
 
 
 #endif /* end #if !defined */
-
-
+  
+  
 #if !defined (_PORTABLESERVER_IMPLICITACTIVATIONPOLICY___OUT_CH_)
 #define _PORTABLESERVER_IMPLICITACTIVATIONPOLICY___OUT_CH_
-
+  
   class TAO_PortableServer_Export ImplicitActivationPolicy_out
   {
   public:
@@ -1116,19 +1382,20 @@ class TAO_PortableServer_Export IdAssignmentPolicy: public virtual CORBA::Policy
     operator ImplicitActivationPolicy_ptr &();
     ImplicitActivationPolicy_ptr &ptr (void);
     ImplicitActivationPolicy_ptr operator-> (void);
-
+  
   private:
     ImplicitActivationPolicy_ptr &ptr_;
   };
-
-
+  
+  
 #endif /* end #if !defined */
-
-
+  
+  
 #if !defined (_PORTABLESERVER_IMPLICITACTIVATIONPOLICY_CH_)
 #define _PORTABLESERVER_IMPLICITACTIVATIONPOLICY_CH_
-
-class TAO_PortableServer_Export ImplicitActivationPolicy: public virtual CORBA::Policy
+  
+  class TAO_PortableServer_Export ImplicitActivationPolicy
+    : public virtual CORBA::Policy
   {
   public:
   #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
@@ -1136,101 +1403,108 @@ class TAO_PortableServer_Export ImplicitActivationPolicy: public virtual CORBA::
     typedef ImplicitActivationPolicy_var _var_type;
   #endif /* ! __GNUC__ || g++ >= 2.8 */
 
-  static int _tao_class_id;
-
-    // the static operations
+    static int _tao_class_id;
+    
+    // The static operations.
     static ImplicitActivationPolicy_ptr _duplicate (ImplicitActivationPolicy_ptr obj);
+    
     static ImplicitActivationPolicy_ptr _narrow (
         CORBA::Object_ptr obj
-        TAO_ENV_ARG_DECL_WITH_DEFAULTS);
-
+        TAO_ENV_ARG_DECL_WITH_DEFAULTS
+      );
+    
     static ImplicitActivationPolicy_ptr _unchecked_narrow (
         CORBA::Object_ptr obj
-        TAO_ENV_ARG_DECL_WITH_DEFAULTS);
-
+        TAO_ENV_ARG_DECL_WITH_DEFAULTS
+      );
+    
     static ImplicitActivationPolicy_ptr _nil (void)
       {
         return (ImplicitActivationPolicy_ptr)0;
       }
-
-    virtual PortableServer::ImplicitActivationPolicyValue value (
-        TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)
-
+    
+    virtual ::PortableServer::ImplicitActivationPolicyValue value (
+        TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
+      )
       ACE_THROW_SPEC ((
         CORBA::SystemException
       )) = 0;
-
+    
     virtual void *_tao_QueryInterface (ptr_arith_t type);
-
+    
     virtual const char* _interface_repository_id (void) const;
 
   protected:
-    ImplicitActivationPolicy ();
-
+    ImplicitActivationPolicy (void);
+    
     virtual ~ImplicitActivationPolicy (void);
+  
   private:
     ImplicitActivationPolicy (const ImplicitActivationPolicy &);
     void operator= (const ImplicitActivationPolicy &);
   };
-
-
+  
+  
 #endif /* end #if !defined */
-
+  
 #endif /* TAO_HAS_MINIMUM_POA == 0 */
 
   enum ServantRetentionPolicyValue
   {
-        RETAIN,
-        NON_RETAIN
+    RETAIN,
+    NON_RETAIN
   };
-
+  
 #if (TAO_HAS_MINIMUM_POA == 0)
 
   typedef ServantRetentionPolicyValue &ServantRetentionPolicyValue_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ServantRetentionPolicyValue;
-
-
+  TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_ServantRetentionPolicyValue;
+  
+  
 #if !defined (_PORTABLESERVER_SERVANTRETENTIONPOLICY___PTR_CH_)
 #define _PORTABLESERVER_SERVANTRETENTIONPOLICY___PTR_CH_
-
+  
   class ServantRetentionPolicy;
   typedef ServantRetentionPolicy *ServantRetentionPolicy_ptr;
-
+  
 #endif /* end #if !defined */
-
-
+  
+  
 #if !defined (_PORTABLESERVER_SERVANTRETENTIONPOLICY___VAR_CH_)
 #define _PORTABLESERVER_SERVANTRETENTIONPOLICY___VAR_CH_
-
+  
   class TAO_PortableServer_Export ServantRetentionPolicy_var : public TAO_Base_var
   {
   public:
     ServantRetentionPolicy_var (void); // default constructor
-    ServantRetentionPolicy_var (ServantRetentionPolicy_ptr p) : ptr_ (p) {}
+    ServantRetentionPolicy_var (ServantRetentionPolicy_ptr p) : ptr_ (p) {} 
     ServantRetentionPolicy_var (const ServantRetentionPolicy_var &); // copy constructor
     ~ServantRetentionPolicy_var (void); // destructor
-
+    
     ServantRetentionPolicy_var &operator= (ServantRetentionPolicy_ptr);
     ServantRetentionPolicy_var &operator= (const ServantRetentionPolicy_var &);
     ServantRetentionPolicy_ptr operator-> (void) const;
-
+    
     operator const ServantRetentionPolicy_ptr &() const;
     operator ServantRetentionPolicy_ptr &();
-    // in, inout, out, _retn
+    // in, inout, out, _retn 
     ServantRetentionPolicy_ptr in (void) const;
     ServantRetentionPolicy_ptr &inout (void);
     ServantRetentionPolicy_ptr &out (void);
     ServantRetentionPolicy_ptr _retn (void);
     ServantRetentionPolicy_ptr ptr (void) const;
-
+    
     // Hooks used by template sequence and object manager classes
     // for non-defined forward declared interfaces.
     static ServantRetentionPolicy_ptr tao_duplicate (ServantRetentionPolicy_ptr);
     static void tao_release (ServantRetentionPolicy_ptr);
     static ServantRetentionPolicy_ptr tao_nil (void);
-    static ServantRetentionPolicy_ptr tao_narrow (CORBA::Object * TAO_ENV_ARG_DECL_NOT_USED);
+    static ServantRetentionPolicy_ptr tao_narrow (
+        CORBA::Object *
+        TAO_ENV_ARG_DECL_NOT_USED
+      );
     static CORBA::Object * tao_upcast (void *);
-
+  
   private:
     ServantRetentionPolicy_ptr ptr_;
     // Unimplemented - prevents widening assignment.
@@ -1240,11 +1514,11 @@ class TAO_PortableServer_Export ImplicitActivationPolicy: public virtual CORBA::
 
 
 #endif /* end #if !defined */
-
-
+  
+  
 #if !defined (_PORTABLESERVER_SERVANTRETENTIONPOLICY___OUT_CH_)
 #define _PORTABLESERVER_SERVANTRETENTIONPOLICY___OUT_CH_
-
+  
   class TAO_PortableServer_Export ServantRetentionPolicy_out
   {
   public:
@@ -1257,19 +1531,20 @@ class TAO_PortableServer_Export ImplicitActivationPolicy: public virtual CORBA::
     operator ServantRetentionPolicy_ptr &();
     ServantRetentionPolicy_ptr &ptr (void);
     ServantRetentionPolicy_ptr operator-> (void);
-
+  
   private:
     ServantRetentionPolicy_ptr &ptr_;
   };
-
-
+  
+  
 #endif /* end #if !defined */
-
-
+  
+  
 #if !defined (_PORTABLESERVER_SERVANTRETENTIONPOLICY_CH_)
 #define _PORTABLESERVER_SERVANTRETENTIONPOLICY_CH_
-
-class TAO_PortableServer_Export ServantRetentionPolicy: public virtual CORBA::Policy
+  
+  class TAO_PortableServer_Export ServantRetentionPolicy
+    : public virtual CORBA::Policy
   {
   public:
   #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
@@ -1277,102 +1552,109 @@ class TAO_PortableServer_Export ServantRetentionPolicy: public virtual CORBA::Po
     typedef ServantRetentionPolicy_var _var_type;
   #endif /* ! __GNUC__ || g++ >= 2.8 */
 
-  static int _tao_class_id;
-
-    // the static operations
+    static int _tao_class_id;
+    
+    // The static operations.
     static ServantRetentionPolicy_ptr _duplicate (ServantRetentionPolicy_ptr obj);
+    
     static ServantRetentionPolicy_ptr _narrow (
         CORBA::Object_ptr obj
-        TAO_ENV_ARG_DECL_WITH_DEFAULTS);
-
+        TAO_ENV_ARG_DECL_WITH_DEFAULTS
+      );
+    
     static ServantRetentionPolicy_ptr _unchecked_narrow (
         CORBA::Object_ptr obj
-        TAO_ENV_ARG_DECL_WITH_DEFAULTS);
-
+        TAO_ENV_ARG_DECL_WITH_DEFAULTS
+      );
+    
     static ServantRetentionPolicy_ptr _nil (void)
       {
         return (ServantRetentionPolicy_ptr)0;
       }
-
-    virtual PortableServer::ServantRetentionPolicyValue value (
-        TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)
-
+    
+    virtual ::PortableServer::ServantRetentionPolicyValue value (
+        TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
+      )
       ACE_THROW_SPEC ((
         CORBA::SystemException
       )) = 0;
-
+    
     virtual void *_tao_QueryInterface (ptr_arith_t type);
-
+    
     virtual const char* _interface_repository_id (void) const;
 
   protected:
-    ServantRetentionPolicy ();
-
+    ServantRetentionPolicy (void);
+    
     virtual ~ServantRetentionPolicy (void);
+  
   private:
     ServantRetentionPolicy (const ServantRetentionPolicy &);
     void operator= (const ServantRetentionPolicy &);
   };
-
-
+  
+  
 #endif /* end #if !defined */
-
+  
 #endif /* TAO_HAS_MINIMUM_POA == 0 */
 
   enum RequestProcessingPolicyValue
   {
-        USE_ACTIVE_OBJECT_MAP_ONLY,
-        USE_DEFAULT_SERVANT,
-        USE_SERVANT_MANAGER
+    USE_ACTIVE_OBJECT_MAP_ONLY,
+    USE_DEFAULT_SERVANT,
+    USE_SERVANT_MANAGER
   };
-
+  
 #if (TAO_HAS_MINIMUM_POA == 0)
 
   typedef RequestProcessingPolicyValue &RequestProcessingPolicyValue_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_RequestProcessingPolicyValue;
-
-
+  TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_RequestProcessingPolicyValue;
+  
+  
 #if !defined (_PORTABLESERVER_REQUESTPROCESSINGPOLICY___PTR_CH_)
 #define _PORTABLESERVER_REQUESTPROCESSINGPOLICY___PTR_CH_
-
+  
   class RequestProcessingPolicy;
   typedef RequestProcessingPolicy *RequestProcessingPolicy_ptr;
-
+  
 #endif /* end #if !defined */
-
-
+  
+  
 #if !defined (_PORTABLESERVER_REQUESTPROCESSINGPOLICY___VAR_CH_)
 #define _PORTABLESERVER_REQUESTPROCESSINGPOLICY___VAR_CH_
-
+  
   class TAO_PortableServer_Export RequestProcessingPolicy_var : public TAO_Base_var
   {
   public:
     RequestProcessingPolicy_var (void); // default constructor
-    RequestProcessingPolicy_var (RequestProcessingPolicy_ptr p) : ptr_ (p) {}
+    RequestProcessingPolicy_var (RequestProcessingPolicy_ptr p) : ptr_ (p) {} 
     RequestProcessingPolicy_var (const RequestProcessingPolicy_var &); // copy constructor
     ~RequestProcessingPolicy_var (void); // destructor
-
+    
     RequestProcessingPolicy_var &operator= (RequestProcessingPolicy_ptr);
     RequestProcessingPolicy_var &operator= (const RequestProcessingPolicy_var &);
     RequestProcessingPolicy_ptr operator-> (void) const;
-
+    
     operator const RequestProcessingPolicy_ptr &() const;
     operator RequestProcessingPolicy_ptr &();
-    // in, inout, out, _retn
+    // in, inout, out, _retn 
     RequestProcessingPolicy_ptr in (void) const;
     RequestProcessingPolicy_ptr &inout (void);
     RequestProcessingPolicy_ptr &out (void);
     RequestProcessingPolicy_ptr _retn (void);
     RequestProcessingPolicy_ptr ptr (void) const;
-
+    
     // Hooks used by template sequence and object manager classes
     // for non-defined forward declared interfaces.
     static RequestProcessingPolicy_ptr tao_duplicate (RequestProcessingPolicy_ptr);
     static void tao_release (RequestProcessingPolicy_ptr);
     static RequestProcessingPolicy_ptr tao_nil (void);
-    static RequestProcessingPolicy_ptr tao_narrow (CORBA::Object * TAO_ENV_ARG_DECL_NOT_USED);
+    static RequestProcessingPolicy_ptr tao_narrow (
+        CORBA::Object *
+        TAO_ENV_ARG_DECL_NOT_USED
+      );
     static CORBA::Object * tao_upcast (void *);
-
+  
   private:
     RequestProcessingPolicy_ptr ptr_;
     // Unimplemented - prevents widening assignment.
@@ -1382,11 +1664,11 @@ class TAO_PortableServer_Export ServantRetentionPolicy: public virtual CORBA::Po
 
 
 #endif /* end #if !defined */
-
-
+  
+  
 #if !defined (_PORTABLESERVER_REQUESTPROCESSINGPOLICY___OUT_CH_)
 #define _PORTABLESERVER_REQUESTPROCESSINGPOLICY___OUT_CH_
-
+  
   class TAO_PortableServer_Export RequestProcessingPolicy_out
   {
   public:
@@ -1399,19 +1681,20 @@ class TAO_PortableServer_Export ServantRetentionPolicy: public virtual CORBA::Po
     operator RequestProcessingPolicy_ptr &();
     RequestProcessingPolicy_ptr &ptr (void);
     RequestProcessingPolicy_ptr operator-> (void);
-
+  
   private:
     RequestProcessingPolicy_ptr &ptr_;
   };
-
-
+  
+  
 #endif /* end #if !defined */
-
-
+  
+  
 #if !defined (_PORTABLESERVER_REQUESTPROCESSINGPOLICY_CH_)
 #define _PORTABLESERVER_REQUESTPROCESSINGPOLICY_CH_
-
-class TAO_PortableServer_Export RequestProcessingPolicy: public virtual CORBA::Policy
+  
+  class TAO_PortableServer_Export RequestProcessingPolicy
+    : public virtual CORBA::Policy
   {
   public:
   #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
@@ -1419,90 +1702,96 @@ class TAO_PortableServer_Export RequestProcessingPolicy: public virtual CORBA::P
     typedef RequestProcessingPolicy_var _var_type;
   #endif /* ! __GNUC__ || g++ >= 2.8 */
 
-  static int _tao_class_id;
-
-    // the static operations
+    static int _tao_class_id;
+    
+    // The static operations.
     static RequestProcessingPolicy_ptr _duplicate (RequestProcessingPolicy_ptr obj);
+    
     static RequestProcessingPolicy_ptr _narrow (
         CORBA::Object_ptr obj
-        TAO_ENV_ARG_DECL_WITH_DEFAULTS);
-
+        TAO_ENV_ARG_DECL_WITH_DEFAULTS
+      );
+    
     static RequestProcessingPolicy_ptr _unchecked_narrow (
         CORBA::Object_ptr obj
-        TAO_ENV_ARG_DECL_WITH_DEFAULTS);
-
+        TAO_ENV_ARG_DECL_WITH_DEFAULTS
+      );
+    
     static RequestProcessingPolicy_ptr _nil (void)
       {
         return (RequestProcessingPolicy_ptr)0;
       }
-
-    virtual PortableServer::RequestProcessingPolicyValue value (
-        TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)
-
+    
+    virtual ::PortableServer::RequestProcessingPolicyValue value (
+        TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
+      )
       ACE_THROW_SPEC ((
         CORBA::SystemException
       )) = 0;
-
+    
     virtual void *_tao_QueryInterface (ptr_arith_t type);
-
+    
     virtual const char* _interface_repository_id (void) const;
 
   protected:
-    RequestProcessingPolicy ();
-
+    RequestProcessingPolicy (void);
+    
     virtual ~RequestProcessingPolicy (void);
+  
   private:
     RequestProcessingPolicy (const RequestProcessingPolicy &);
     void operator= (const RequestProcessingPolicy &);
   };
-
-
+  
+  
 #endif /* end #if !defined */
-
-
+  
 #endif /* TAO_HAS_MINIMUM_POA == 0 */
-
+  
 #if !defined (_PORTABLESERVER_POAMANAGER___PTR_CH_)
 #define _PORTABLESERVER_POAMANAGER___PTR_CH_
-
+  
   class POAManager;
   typedef POAManager *POAManager_ptr;
-
+  
 #endif /* end #if !defined */
-
-
+  
+  
 #if !defined (_PORTABLESERVER_POAMANAGER___VAR_CH_)
 #define _PORTABLESERVER_POAMANAGER___VAR_CH_
-
+  
   class TAO_PortableServer_Export POAManager_var : public TAO_Base_var
   {
   public:
     POAManager_var (void); // default constructor
-    POAManager_var (POAManager_ptr p) : ptr_ (p) {}
+    POAManager_var (POAManager_ptr p) : ptr_ (p) {} 
     POAManager_var (const POAManager_var &); // copy constructor
     ~POAManager_var (void); // destructor
-
+    
     POAManager_var &operator= (POAManager_ptr);
     POAManager_var &operator= (const POAManager_var &);
     POAManager_ptr operator-> (void) const;
-
+    
     operator const POAManager_ptr &() const;
     operator POAManager_ptr &();
-    // in, inout, out, _retn
+    // in, inout, out, _retn 
     POAManager_ptr in (void) const;
     POAManager_ptr &inout (void);
     POAManager_ptr &out (void);
     POAManager_ptr _retn (void);
     POAManager_ptr ptr (void) const;
-
+    
     // Hooks used by template sequence and object manager classes
     // for non-defined forward declared interfaces.
     static POAManager_ptr tao_duplicate (POAManager_ptr);
     static void tao_release (POAManager_ptr);
     static POAManager_ptr tao_nil (void);
-    static POAManager_ptr tao_narrow (CORBA::Object * TAO_ENV_ARG_DECL_NOT_USED);
+    static POAManager_ptr tao_narrow (
+        CORBA::Object *
+        TAO_ENV_ARG_DECL_NOT_USED
+      );
     static CORBA::Object * tao_upcast (void *);
-
+  
   private:
     POAManager_ptr ptr_;
     // Unimplemented - prevents widening assignment.
@@ -1512,11 +1801,11 @@ class TAO_PortableServer_Export RequestProcessingPolicy: public virtual CORBA::P
 
 
 #endif /* end #if !defined */
-
-
+  
+  
 #if !defined (_PORTABLESERVER_POAMANAGER___OUT_CH_)
 #define _PORTABLESERVER_POAMANAGER___OUT_CH_
-
+  
   class TAO_PortableServer_Export POAManager_out
   {
   public:
@@ -1529,19 +1818,20 @@ class TAO_PortableServer_Export RequestProcessingPolicy: public virtual CORBA::P
     operator POAManager_ptr &();
     POAManager_ptr &ptr (void);
     POAManager_ptr operator-> (void);
-
+  
   private:
     POAManager_ptr &ptr_;
   };
-
-
+  
+  
 #endif /* end #if !defined */
-
-
+  
+  
 #if !defined (_PORTABLESERVER_POAMANAGER_CH_)
 #define _PORTABLESERVER_POAMANAGER_CH_
-
-class TAO_PortableServer_Export POAManager : public virtual CORBA_Object
+  
+  class TAO_PortableServer_Export POAManager
+    : public virtual CORBA_Object
   {
   public:
   #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
@@ -1549,54 +1839,57 @@ class TAO_PortableServer_Export POAManager : public virtual CORBA_Object
     typedef POAManager_var _var_type;
   #endif /* ! __GNUC__ || g++ >= 2.8 */
 
-  static int _tao_class_id;
-
-    // the static operations
+    static int _tao_class_id;
+    
+    // The static operations.
     static POAManager_ptr _duplicate (POAManager_ptr obj);
+    
     static POAManager_ptr _narrow (
         CORBA::Object_ptr obj
-        TAO_ENV_ARG_DECL_WITH_DEFAULTS);
-
+        TAO_ENV_ARG_DECL_WITH_DEFAULTS
+      );
+    
     static POAManager_ptr _unchecked_narrow (
         CORBA::Object_ptr obj
-        TAO_ENV_ARG_DECL_WITH_DEFAULTS);
-
+        TAO_ENV_ARG_DECL_WITH_DEFAULTS
+      );
+    
     static POAManager_ptr _nil (void)
       {
         return (POAManager_ptr)0;
       }
-
-
+    
+    
 #if !defined (_PORTABLESERVER_POAMANAGER_ADAPTERINACTIVE_CH_)
 #define _PORTABLESERVER_POAMANAGER_ADAPTERINACTIVE_CH_
-
+    
     class TAO_PortableServer_Export AdapterInactive : public CORBA::UserException
     {
     public:
-
+      
       AdapterInactive (void);
       // Default constructor.
-
+      
       AdapterInactive (const AdapterInactive &);
       // Copy constructor.
-
+      
       ~AdapterInactive (void);
       // Destructor.
-
+      
       AdapterInactive &operator= (const AdapterInactive &);
-
+      
       virtual void _raise (void);
 
       virtual void _tao_encode (
           TAO_OutputCDR &
           TAO_ENV_ARG_DECL_NOT_USED
         ) const;
-
+      
       virtual void _tao_decode (
           TAO_InputCDR &
           TAO_ENV_ARG_DECL_NOT_USED
         );
-
+      
       static AdapterInactive *_downcast (CORBA::Exception *);
 
 
@@ -1606,122 +1899,123 @@ class TAO_PortableServer_Export POAManager : public virtual CORBA_Object
 
 
 #endif /* end #if !defined */
-
+    
     enum State
     {
-            HOLDING,
-            ACTIVE,
-            DISCARDING,
-            INACTIVE
+      HOLDING,
+      ACTIVE,
+      DISCARDING,
+      INACTIVE
     };
+    
     typedef State &State_out;
     virtual void activate (
-        TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)
-
+        TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
+      )
       ACE_THROW_SPEC ((
         CORBA::SystemException,
         PortableServer::POAManager::AdapterInactive
       )) = 0;
 
 #if (TAO_HAS_MINIMUM_POA == 0)
-
+    
     virtual void hold_requests (
-        CORBA::Boolean wait_for_completion
-        TAO_ENV_ARG_DECL_WITH_DEFAULTS)
-
+        CORBA::Boolean wait_for_completion TAO_ENV_ARG_DECL_WITH_DEFAULTS
+      )
       ACE_THROW_SPEC ((
         CORBA::SystemException,
         PortableServer::POAManager::AdapterInactive
       )) = 0;
-
+    
     virtual void discard_requests (
-        CORBA::Boolean wait_for_completion
-        TAO_ENV_ARG_DECL_WITH_DEFAULTS)
-
+        CORBA::Boolean wait_for_completion TAO_ENV_ARG_DECL_WITH_DEFAULTS
+      )
       ACE_THROW_SPEC ((
         CORBA::SystemException,
         PortableServer::POAManager::AdapterInactive
       )) = 0;
-
+    
     virtual void deactivate (
         CORBA::Boolean etherealize_objects,
-        CORBA::Boolean wait_for_completion
-        TAO_ENV_ARG_DECL_WITH_DEFAULTS)
-
+        CORBA::Boolean wait_for_completion TAO_ENV_ARG_DECL_WITH_DEFAULTS
+      )
       ACE_THROW_SPEC ((
         CORBA::SystemException,
         PortableServer::POAManager::AdapterInactive
       )) = 0;
-
+    
 #endif /* TAO_HAS_MINIMUM_POA == 0 */
 
-    virtual PortableServer::POAManager::State get_state (
-        TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)
-
+    virtual ::PortableServer::POAManager::State get_state (
+        TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
+      )
       ACE_THROW_SPEC ((
         CORBA::SystemException
       )) = 0;
-
+    
     virtual void *_tao_QueryInterface (ptr_arith_t type);
-
+    
     virtual const char* _interface_repository_id (void) const;
 
   protected:
-    POAManager ();
-
+    POAManager (void);
+    
     virtual ~POAManager (void);
+  
   private:
     POAManager (const POAManager &);
     void operator= (const POAManager &);
   };
-
-
+  
+  
 #endif /* end #if !defined */
-
-
+  
 #if (TAO_HAS_MINIMUM_POA == 0)
-
+  
 #if !defined (_PORTABLESERVER_ADAPTERACTIVATOR___PTR_CH_)
 #define _PORTABLESERVER_ADAPTERACTIVATOR___PTR_CH_
-
+  
   class AdapterActivator;
   typedef AdapterActivator *AdapterActivator_ptr;
-
+  
 #endif /* end #if !defined */
-
-
+  
+  
 #if !defined (_PORTABLESERVER_ADAPTERACTIVATOR___VAR_CH_)
 #define _PORTABLESERVER_ADAPTERACTIVATOR___VAR_CH_
-
+  
   class TAO_PortableServer_Export AdapterActivator_var : public TAO_Base_var
   {
   public:
     AdapterActivator_var (void); // default constructor
-    AdapterActivator_var (AdapterActivator_ptr p) : ptr_ (p) {}
+    AdapterActivator_var (AdapterActivator_ptr p) : ptr_ (p) {} 
     AdapterActivator_var (const AdapterActivator_var &); // copy constructor
     ~AdapterActivator_var (void); // destructor
-
+    
     AdapterActivator_var &operator= (AdapterActivator_ptr);
     AdapterActivator_var &operator= (const AdapterActivator_var &);
     AdapterActivator_ptr operator-> (void) const;
-
+    
     operator const AdapterActivator_ptr &() const;
     operator AdapterActivator_ptr &();
-    // in, inout, out, _retn
+    // in, inout, out, _retn 
     AdapterActivator_ptr in (void) const;
     AdapterActivator_ptr &inout (void);
     AdapterActivator_ptr &out (void);
     AdapterActivator_ptr _retn (void);
     AdapterActivator_ptr ptr (void) const;
-
+    
     // Hooks used by template sequence and object manager classes
     // for non-defined forward declared interfaces.
     static AdapterActivator_ptr tao_duplicate (AdapterActivator_ptr);
     static void tao_release (AdapterActivator_ptr);
     static AdapterActivator_ptr tao_nil (void);
-    static AdapterActivator_ptr tao_narrow (CORBA::Object * TAO_ENV_ARG_DECL_NOT_USED);
+    static AdapterActivator_ptr tao_narrow (
+        CORBA::Object *
+        TAO_ENV_ARG_DECL_NOT_USED
+      );
     static CORBA::Object * tao_upcast (void *);
-
+  
   private:
     AdapterActivator_ptr ptr_;
     // Unimplemented - prevents widening assignment.
@@ -1731,11 +2025,11 @@ class TAO_PortableServer_Export POAManager : public virtual CORBA_Object
 
 
 #endif /* end #if !defined */
-
-
+  
+  
 #if !defined (_PORTABLESERVER_ADAPTERACTIVATOR___OUT_CH_)
 #define _PORTABLESERVER_ADAPTERACTIVATOR___OUT_CH_
-
+  
   class TAO_PortableServer_Export AdapterActivator_out
   {
   public:
@@ -1748,19 +2042,20 @@ class TAO_PortableServer_Export POAManager : public virtual CORBA_Object
     operator AdapterActivator_ptr &();
     AdapterActivator_ptr &ptr (void);
     AdapterActivator_ptr operator-> (void);
-
+  
   private:
     AdapterActivator_ptr &ptr_;
   };
-
-
+  
+  
 #endif /* end #if !defined */
-
-
+  
+  
 #if !defined (_PORTABLESERVER_ADAPTERACTIVATOR_CH_)
 #define _PORTABLESERVER_ADAPTERACTIVATOR_CH_
-
-class TAO_PortableServer_Export AdapterActivator : public virtual CORBA_Object
+  
+  class TAO_PortableServer_Export AdapterActivator
+    : public virtual CORBA_Object
   {
   public:
   #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
@@ -1768,90 +2063,96 @@ class TAO_PortableServer_Export AdapterActivator : public virtual CORBA_Object
     typedef AdapterActivator_var _var_type;
   #endif /* ! __GNUC__ || g++ >= 2.8 */
 
-  static int _tao_class_id;
-
-    // the static operations
+    static int _tao_class_id;
+    
+    // The static operations.
     static AdapterActivator_ptr _duplicate (AdapterActivator_ptr obj);
+    
     static AdapterActivator_ptr _narrow (
         CORBA::Object_ptr obj
-        TAO_ENV_ARG_DECL_WITH_DEFAULTS);
-
+        TAO_ENV_ARG_DECL_WITH_DEFAULTS
+      );
+    
     static AdapterActivator_ptr _unchecked_narrow (
         CORBA::Object_ptr obj
-        TAO_ENV_ARG_DECL_WITH_DEFAULTS);
-
+        TAO_ENV_ARG_DECL_WITH_DEFAULTS
+      );
+    
     static AdapterActivator_ptr _nil (void)
       {
         return (AdapterActivator_ptr)0;
       }
-
+    
     virtual CORBA::Boolean unknown_adapter (
         PortableServer::POA_ptr parent,
-        const char * name
-        TAO_ENV_ARG_DECL_WITH_DEFAULTS)
-
+        const char * name TAO_ENV_ARG_DECL_WITH_DEFAULTS
+      )
       ACE_THROW_SPEC ((
         CORBA::SystemException
       )) = 0;
-
+    
     virtual void *_tao_QueryInterface (ptr_arith_t type);
-
+    
     virtual const char* _interface_repository_id (void) const;
 
   protected:
-    AdapterActivator ();
-
+    AdapterActivator (void);
+    
     virtual ~AdapterActivator (void);
+  
   private:
     AdapterActivator (const AdapterActivator &);
     void operator= (const AdapterActivator &);
   };
-
-
+  
+  
 #endif /* end #if !defined */
-
-
+  
+  
 #if !defined (_PORTABLESERVER_SERVANTMANAGER___PTR_CH_)
 #define _PORTABLESERVER_SERVANTMANAGER___PTR_CH_
-
+  
   class ServantManager;
   typedef ServantManager *ServantManager_ptr;
-
+  
 #endif /* end #if !defined */
-
-
+  
+  
 #if !defined (_PORTABLESERVER_SERVANTMANAGER___VAR_CH_)
 #define _PORTABLESERVER_SERVANTMANAGER___VAR_CH_
-
+  
   class TAO_PortableServer_Export ServantManager_var : public TAO_Base_var
   {
   public:
     ServantManager_var (void); // default constructor
-    ServantManager_var (ServantManager_ptr p) : ptr_ (p) {}
+    ServantManager_var (ServantManager_ptr p) : ptr_ (p) {} 
     ServantManager_var (const ServantManager_var &); // copy constructor
     ~ServantManager_var (void); // destructor
-
+    
     ServantManager_var &operator= (ServantManager_ptr);
     ServantManager_var &operator= (const ServantManager_var &);
     ServantManager_ptr operator-> (void) const;
-
+    
     operator const ServantManager_ptr &() const;
     operator ServantManager_ptr &();
-    // in, inout, out, _retn
+    // in, inout, out, _retn 
     ServantManager_ptr in (void) const;
     ServantManager_ptr &inout (void);
     ServantManager_ptr &out (void);
     ServantManager_ptr _retn (void);
     ServantManager_ptr ptr (void) const;
-
+    
     // Hooks used by template sequence and object manager classes
     // for non-defined forward declared interfaces.
     static ServantManager_ptr tao_duplicate (ServantManager_ptr);
     static void tao_release (ServantManager_ptr);
     static ServantManager_ptr tao_nil (void);
-    static ServantManager_ptr tao_narrow (CORBA::Object * TAO_ENV_ARG_DECL_NOT_USED);
+    static ServantManager_ptr tao_narrow (
+        CORBA::Object *
+        TAO_ENV_ARG_DECL_NOT_USED
+      );
     static CORBA::Object * tao_upcast (void *);
-
+  
   private:
     ServantManager_ptr ptr_;
     // Unimplemented - prevents widening assignment.
@@ -1861,11 +2162,11 @@ class TAO_PortableServer_Export AdapterActivator : public virtual CORBA_Object
 
 
 #endif /* end #if !defined */
-
-
+  
+  
 #if !defined (_PORTABLESERVER_SERVANTMANAGER___OUT_CH_)
 #define _PORTABLESERVER_SERVANTMANAGER___OUT_CH_
-
+  
   class TAO_PortableServer_Export ServantManager_out
   {
   public:
@@ -1878,19 +2179,20 @@ class TAO_PortableServer_Export AdapterActivator : public virtual CORBA_Object
     operator ServantManager_ptr &();
     ServantManager_ptr &ptr (void);
     ServantManager_ptr operator-> (void);
-
+  
   private:
     ServantManager_ptr &ptr_;
   };
-
-
+  
+  
 #endif /* end #if !defined */
-
-
+  
+  
 #if !defined (_PORTABLESERVER_SERVANTMANAGER_CH_)
 #define _PORTABLESERVER_SERVANTMANAGER_CH_
-
-class TAO_PortableServer_Export ServantManager : public virtual CORBA_Object
+  
+  class TAO_PortableServer_Export ServantManager
+    : public virtual CORBA_Object
   {
   public:
   #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
@@ -1898,81 +2200,88 @@ class TAO_PortableServer_Export ServantManager : public virtual CORBA_Object
     typedef ServantManager_var _var_type;
   #endif /* ! __GNUC__ || g++ >= 2.8 */
 
-  static int _tao_class_id;
-
-    // the static operations
+    static int _tao_class_id;
+    
+    // The static operations.
     static ServantManager_ptr _duplicate (ServantManager_ptr obj);
+    
     static ServantManager_ptr _narrow (
         CORBA::Object_ptr obj
-        TAO_ENV_ARG_DECL_WITH_DEFAULTS);
-
+        TAO_ENV_ARG_DECL_WITH_DEFAULTS
+      );
+    
     static ServantManager_ptr _unchecked_narrow (
         CORBA::Object_ptr obj
-        TAO_ENV_ARG_DECL_WITH_DEFAULTS);
-
+        TAO_ENV_ARG_DECL_WITH_DEFAULTS
+      );
+    
     static ServantManager_ptr _nil (void)
       {
         return (ServantManager_ptr)0;
       }
-
+    
     virtual void *_tao_QueryInterface (ptr_arith_t type);
-
+    
     virtual const char* _interface_repository_id (void) const;
 
   protected:
-    ServantManager ();
-
+    ServantManager (void);
+    
     virtual ~ServantManager (void);
+  
   private:
     ServantManager (const ServantManager &);
     void operator= (const ServantManager &);
   };
-
-
+  
+  
 #endif /* end #if !defined */
-
-
+  
+  
 #if !defined (_PORTABLESERVER_SERVANTACTIVATOR___PTR_CH_)
 #define _PORTABLESERVER_SERVANTACTIVATOR___PTR_CH_
-
+  
   class ServantActivator;
   typedef ServantActivator *ServantActivator_ptr;
-
+  
 #endif /* end #if !defined */
-
-
+  
+  
 #if !defined (_PORTABLESERVER_SERVANTACTIVATOR___VAR_CH_)
 #define _PORTABLESERVER_SERVANTACTIVATOR___VAR_CH_
-
+  
   class TAO_PortableServer_Export ServantActivator_var : public TAO_Base_var
   {
   public:
     ServantActivator_var (void); // default constructor
-    ServantActivator_var (ServantActivator_ptr p) : ptr_ (p) {}
+    ServantActivator_var (ServantActivator_ptr p) : ptr_ (p) {} 
     ServantActivator_var (const ServantActivator_var &); // copy constructor
     ~ServantActivator_var (void); // destructor
-
+    
     ServantActivator_var &operator= (ServantActivator_ptr);
     ServantActivator_var &operator= (const ServantActivator_var &);
     ServantActivator_ptr operator-> (void) const;
-
+    
     operator const ServantActivator_ptr &() const;
     operator ServantActivator_ptr &();
-    // in, inout, out, _retn
+    // in, inout, out, _retn 
     ServantActivator_ptr in (void) const;
     ServantActivator_ptr &inout (void);
     ServantActivator_ptr &out (void);
     ServantActivator_ptr _retn (void);
     ServantActivator_ptr ptr (void) const;
-
+    
     // Hooks used by template sequence and object manager classes
     // for non-defined forward declared interfaces.
     static ServantActivator_ptr tao_duplicate (ServantActivator_ptr);
     static void tao_release (ServantActivator_ptr);
     static ServantActivator_ptr tao_nil (void);
-    static ServantActivator_ptr tao_narrow (CORBA::Object * TAO_ENV_ARG_DECL_NOT_USED);
+    static ServantActivator_ptr tao_narrow (
+        CORBA::Object *
+        TAO_ENV_ARG_DECL_NOT_USED
+      );
     static CORBA::Object * tao_upcast (void *);
-
+  
   private:
     ServantActivator_ptr ptr_;
     // Unimplemented - prevents widening assignment.
@@ -1982,11 +2291,11 @@ class TAO_PortableServer_Export ServantManager : public virtual CORBA_Object
 
 
 #endif /* end #if !defined */
-
-
+  
+  
 #if !defined (_PORTABLESERVER_SERVANTACTIVATOR___OUT_CH_)
 #define _PORTABLESERVER_SERVANTACTIVATOR___OUT_CH_
-
+  
   class TAO_PortableServer_Export ServantActivator_out
   {
   public:
@@ -1999,19 +2308,20 @@ class TAO_PortableServer_Export ServantManager : public virtual CORBA_Object
     operator ServantActivator_ptr &();
     ServantActivator_ptr &ptr (void);
     ServantActivator_ptr operator-> (void);
-
+  
   private:
     ServantActivator_ptr &ptr_;
   };
-
-
+  
+  
 #endif /* end #if !defined */
-
-
+  
+  
 #if !defined (_PORTABLESERVER_SERVANTACTIVATOR_CH_)
 #define _PORTABLESERVER_SERVANTACTIVATOR_CH_
-
-class TAO_PortableServer_Export ServantActivator: public virtual ServantManager
+  
+  class TAO_PortableServer_Export ServantActivator
+    : public virtual PortableServer::ServantManager
   {
   public:
   #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
@@ -2019,109 +2329,114 @@ class TAO_PortableServer_Export ServantActivator: public virtual ServantManager
     typedef ServantActivator_var _var_type;
   #endif /* ! __GNUC__ || g++ >= 2.8 */
 
-  static int _tao_class_id;
-
-    // the static operations
+    static int _tao_class_id;
+    
+    // The static operations.
     static ServantActivator_ptr _duplicate (ServantActivator_ptr obj);
+    
     static ServantActivator_ptr _narrow (
         CORBA::Object_ptr obj
-        TAO_ENV_ARG_DECL_WITH_DEFAULTS);
-
+        TAO_ENV_ARG_DECL_WITH_DEFAULTS
+      );
+    
     static ServantActivator_ptr _unchecked_narrow (
         CORBA::Object_ptr obj
-        TAO_ENV_ARG_DECL_WITH_DEFAULTS);
-
+        TAO_ENV_ARG_DECL_WITH_DEFAULTS
+      );
+    
     static ServantActivator_ptr _nil (void)
       {
         return (ServantActivator_ptr)0;
       }
-
-    virtual PortableServer::Servant incarnate (
+    
+    virtual ::PortableServer::Servant incarnate (
         const PortableServer::ObjectId & oid,
-        PortableServer::POA_ptr adapter
-      TAO_ENV_ARG_DECL_WITH_DEFAULTS
+        PortableServer::POA_ptr adapter TAO_ENV_ARG_DECL_WITH_DEFAULTS
       )
 #if (TAO_HAS_MINIMUM_CORBA == 0)
-    ACE_THROW_SPEC ((
-      CORBA::SystemException,
-      PortableServer::ForwardRequest
-    )) = 0;
+      ACE_THROW_SPEC ((
+        CORBA::SystemException,
+        PortableServer::ForwardRequest
+      )) = 0;
 #else
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
+      ACE_THROW_SPEC ((
+        CORBA::SystemException
+      )) = 0;
 #endif /* TAO_HAS_MINIMUM_CORBA == 0 */
-
+    
     virtual void etherealize (
         const PortableServer::ObjectId & oid,
         PortableServer::POA_ptr adapter,
         PortableServer::Servant serv,
         CORBA::Boolean cleanup_in_progress,
-        CORBA::Boolean remaining_activations
-        TAO_ENV_ARG_DECL_WITH_DEFAULTS
+        CORBA::Boolean remaining_activations TAO_ENV_ARG_DECL_WITH_DEFAULTS
       )
       ACE_THROW_SPEC ((
         CORBA::SystemException
       )) = 0;
-
+    
     virtual void *_tao_QueryInterface (ptr_arith_t type);
-
+    
     virtual const char* _interface_repository_id (void) const;
 
   protected:
-    ServantActivator ();
-
+    ServantActivator (void);
+    
     virtual ~ServantActivator (void);
+  
   private:
     ServantActivator (const ServantActivator &);
     void operator= (const ServantActivator &);
   };
-
-
+  
+  
 #endif /* end #if !defined */
-
-
+  
+  
 #if !defined (_PORTABLESERVER_SERVANTLOCATOR___PTR_CH_)
 #define _PORTABLESERVER_SERVANTLOCATOR___PTR_CH_
-
+  
   class ServantLocator;
   typedef ServantLocator *ServantLocator_ptr;
-
+  
 #endif /* end #if !defined */
-
-
+  
+  
 #if !defined (_PORTABLESERVER_SERVANTLOCATOR___VAR_CH_)
 #define _PORTABLESERVER_SERVANTLOCATOR___VAR_CH_
-
+  
   class TAO_PortableServer_Export ServantLocator_var : public TAO_Base_var
   {
   public:
     ServantLocator_var (void); // default constructor
-    ServantLocator_var (ServantLocator_ptr p) : ptr_ (p) {}
+    ServantLocator_var (ServantLocator_ptr p) : ptr_ (p) {} 
     ServantLocator_var (const ServantLocator_var &); // copy constructor
     ~ServantLocator_var (void); // destructor
-
+    
     ServantLocator_var &operator= (ServantLocator_ptr);
     ServantLocator_var &operator= (const ServantLocator_var &);
     ServantLocator_ptr operator-> (void) const;
-
+    
     operator const ServantLocator_ptr &() const;
     operator ServantLocator_ptr &();
-    // in, inout, out, _retn
+    // in, inout, out, _retn 
     ServantLocator_ptr in (void) const;
     ServantLocator_ptr &inout (void);
     ServantLocator_ptr &out (void);
     ServantLocator_ptr _retn (void);
     ServantLocator_ptr ptr (void) const;
-
+    
     // Hooks used by template sequence and object manager classes
     // for non-defined forward declared interfaces.
     static ServantLocator_ptr tao_duplicate (ServantLocator_ptr);
     static void tao_release (ServantLocator_ptr);
     static ServantLocator_ptr tao_nil (void);
-    static ServantLocator_ptr tao_narrow (CORBA::Object * TAO_ENV_ARG_DECL_NOT_USED);
+    static ServantLocator_ptr tao_narrow (
+        CORBA::Object *
+        TAO_ENV_ARG_DECL_NOT_USED
+      );
     static CORBA::Object * tao_upcast (void *);
-
+  
   private:
     ServantLocator_ptr ptr_;
     // Unimplemented - prevents widening assignment.
@@ -2131,11 +2446,11 @@ class TAO_PortableServer_Export ServantActivator: public virtual ServantManager
 
 
 #endif /* end #if !defined */
-
-
+  
+  
 #if !defined (_PORTABLESERVER_SERVANTLOCATOR___OUT_CH_)
 #define _PORTABLESERVER_SERVANTLOCATOR___OUT_CH_
-
+  
   class TAO_PortableServer_Export ServantLocator_out
   {
   public:
@@ -2148,19 +2463,20 @@ class TAO_PortableServer_Export ServantActivator: public virtual ServantManager
     operator ServantLocator_ptr &();
     ServantLocator_ptr &ptr (void);
     ServantLocator_ptr operator-> (void);
-
+  
   private:
     ServantLocator_ptr &ptr_;
   };
-
-
+  
+  
 #endif /* end #if !defined */
-
-
+  
+  
 #if !defined (_PORTABLESERVER_SERVANTLOCATOR_CH_)
 #define _PORTABLESERVER_SERVANTLOCATOR_CH_
-
-class TAO_PortableServer_Export ServantLocator: public virtual ServantManager
+  
+  class TAO_PortableServer_Export ServantLocator
+    : public virtual PortableServer::ServantManager
   {
   public:
 
@@ -2171,29 +2487,31 @@ class TAO_PortableServer_Export ServantLocator: public virtual ServantManager
     typedef ServantLocator_var _var_type;
   #endif /* ! __GNUC__ || g++ >= 2.8 */
 
-  static int _tao_class_id;
-
-    // the static operations
+    static int _tao_class_id;
+    
+    // The static operations.
     static ServantLocator_ptr _duplicate (ServantLocator_ptr obj);
+    
     static ServantLocator_ptr _narrow (
         CORBA::Object_ptr obj
-        TAO_ENV_ARG_DECL_WITH_DEFAULTS);
-
+        TAO_ENV_ARG_DECL_WITH_DEFAULTS
+      );
+    
     static ServantLocator_ptr _unchecked_narrow (
         CORBA::Object_ptr obj
-        TAO_ENV_ARG_DECL_WITH_DEFAULTS);
-
+        TAO_ENV_ARG_DECL_WITH_DEFAULTS
+      );
+    
     static ServantLocator_ptr _nil (void)
       {
         return (ServantLocator_ptr)0;
       }
-
-    virtual PortableServer::Servant preinvoke (
+    
+    virtual ::PortableServer::Servant preinvoke (
         const PortableServer::ObjectId & oid,
         PortableServer::POA_ptr adapter,
         const char * operation,
-        PortableServer::ServantLocator::Cookie & the_cookie
-        TAO_ENV_ARG_DECL_WITH_DEFAULTS
+        PortableServer::ServantLocator::Cookie & the_cookie TAO_ENV_ARG_DECL_WITH_DEFAULTS
       )
 #if (TAO_HAS_MINIMUM_CORBA == 0)
       ACE_THROW_SPEC ((
@@ -2204,44 +2522,122 @@ class TAO_PortableServer_Export ServantLocator: public virtual ServantManager
       ACE_THROW_SPEC ((
         CORBA::SystemException
       )) = 0;
-#endif /* TAO_HAS_MINIMUM_CORBA == 0 */
+#endif /* TAO_HAS_MINIMUM_CORBA == 0 */    
 
     virtual void postinvoke (
         const PortableServer::ObjectId & oid,
         PortableServer::POA_ptr adapter,
         const char * operation,
         PortableServer::ServantLocator::Cookie the_cookie,
-        PortableServer::Servant the_servant
-        TAO_ENV_ARG_DECL_WITH_DEFAULTS
+        PortableServer::Servant the_servant TAO_ENV_ARG_DECL_WITH_DEFAULTS
       )
       ACE_THROW_SPEC ((
         CORBA::SystemException
       )) = 0;
-
+    
     virtual void *_tao_QueryInterface (ptr_arith_t type);
-
+    
     virtual const char* _interface_repository_id (void) const;
 
   protected:
-    ServantLocator ();
-
+    ServantLocator (void);
+    
     virtual ~ServantLocator (void);
+  
   private:
     ServantLocator (const ServantLocator &);
     void operator= (const ServantLocator &);
   };
-
-
+  
+  
+#endif /* end #if !defined */
+  
+  
+#if !defined (_PORTABLESERVER_POA___PTR_CH_)
+#define _PORTABLESERVER_POA___PTR_CH_
+  
+  class POA;
+  typedef POA *POA_ptr;
+  
 #endif /* end #if !defined */
+  
+  
+#if !defined (_PORTABLESERVER_POA___VAR_CH_)
+#define _PORTABLESERVER_POA___VAR_CH_
+  
+  class TAO_PortableServer_Export POA_var : public TAO_Base_var
+  {
+  public:
+    POA_var (void); // default constructor
+    POA_var (POA_ptr p) : ptr_ (p) {} 
+    POA_var (const POA_var &); // copy constructor
+    ~POA_var (void); // destructor
+    
+    POA_var &operator= (POA_ptr);
+    POA_var &operator= (const POA_var &);
+    POA_ptr operator-> (void) const;
+    
+    operator const POA_ptr &() const;
+    operator POA_ptr &();
+    // in, inout, out, _retn 
+    POA_ptr in (void) const;
+    POA_ptr &inout (void);
+    POA_ptr &out (void);
+    POA_ptr _retn (void);
+    POA_ptr ptr (void) const;
+    
+    // Hooks used by template sequence and object manager classes
+    // for non-defined forward declared interfaces.
+    static POA_ptr tao_duplicate (POA_ptr);
+    static void tao_release (POA_ptr);
+    static POA_ptr tao_nil (void);
+    static POA_ptr tao_narrow (
+        CORBA::Object *
+        TAO_ENV_ARG_DECL_NOT_USED
+      );
+    static CORBA::Object * tao_upcast (void *);
+  
+  private:
+    POA_ptr ptr_;
+    // Unimplemented - prevents widening assignment.
+    POA_var (const TAO_Base_var &rhs);
+    POA_var &operator= (const TAO_Base_var &rhs);
+  };
 
 
+#endif /* end #if !defined */
+  
+  
+#if !defined (_PORTABLESERVER_POA___OUT_CH_)
+#define _PORTABLESERVER_POA___OUT_CH_
+  
+  class TAO_PortableServer_Export POA_out
+  {
+  public:
+    POA_out (POA_ptr &);
+    POA_out (POA_var &);
+    POA_out (const POA_out &);
+    POA_out &operator= (const POA_out &);
+    POA_out &operator= (const POA_var &);
+    POA_out &operator= (POA_ptr);
+    operator POA_ptr &();
+    POA_ptr &ptr (void);
+    POA_ptr operator-> (void);
+  
+  private:
+    POA_ptr &ptr_;
+  };
+  
+  
+#endif /* end #if !defined */
+  
 #endif /* TAO_HAS_MINIMUM_POA == 0 */
-
+  
 #if !defined (_PORTABLESERVER_POA_CH_)
 #define _PORTABLESERVER_POA_CH_
-
-
-class TAO_PortableServer_Export POA : public virtual CORBA_Object
+  
+  class TAO_PortableServer_Export POA
+    : public virtual CORBA_Object
   {
   public:
   #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
@@ -2249,56 +2645,61 @@ class TAO_PortableServer_Export POA : public virtual CORBA_Object
     typedef POA_var _var_type;
   #endif /* ! __GNUC__ || g++ >= 2.8 */
 
-  static int _tao_class_id;
-
-    // the static operations
+    static int _tao_class_id;
+    
+    // The static operations.
     static POA_ptr _duplicate (POA_ptr obj);
+    
     static POA_ptr _narrow (
         CORBA::Object_ptr obj
-        TAO_ENV_ARG_DECL_WITH_DEFAULTS);
-
+        TAO_ENV_ARG_DECL_WITH_DEFAULTS
+      );
+    
     static POA_ptr _unchecked_narrow (
         CORBA::Object_ptr obj
-        TAO_ENV_ARG_DECL_WITH_DEFAULTS);
-
+        TAO_ENV_ARG_DECL_WITH_DEFAULTS
+      );
+    
     static POA_ptr _nil (void)
       {
         return (POA_ptr)0;
       }
-
-    virtual TAO_POA* _tao_poa_downcast(void) {return 0;}
-
+    
+    virtual TAO_POA* _tao_poa_downcast(void) 
+      { 
+        return 0; 
+      }
+    
 #if !defined (_PORTABLESERVER_POA_ADAPTERALREADYEXISTS_CH_)
 #define _PORTABLESERVER_POA_ADAPTERALREADYEXISTS_CH_
-
+    
     class TAO_PortableServer_Export AdapterAlreadyExists : public CORBA::UserException
     {
     public:
-
+      
       AdapterAlreadyExists (void);
       // Default constructor.
-
+      
       AdapterAlreadyExists (const AdapterAlreadyExists &);
       // Copy constructor.
-
+      
       ~AdapterAlreadyExists (void);
       // Destructor.
-
+      
       AdapterAlreadyExists &operator= (const AdapterAlreadyExists &);
-
+      
       virtual void _raise (void);
 
       virtual void _tao_encode (
           TAO_OutputCDR &
           TAO_ENV_ARG_DECL_NOT_USED
         ) const;
-
+      
       virtual void _tao_decode (
           TAO_InputCDR &
           TAO_ENV_ARG_DECL_NOT_USED
         );
-
-
+      
       static AdapterAlreadyExists *_downcast (CORBA::Exception *);
 
 
@@ -2308,38 +2709,38 @@ class TAO_PortableServer_Export POA : public virtual CORBA_Object
 
 
 #endif /* end #if !defined */
-
-
+    
+    
 #if !defined (_PORTABLESERVER_POA_ADAPTERNONEXISTENT_CH_)
 #define _PORTABLESERVER_POA_ADAPTERNONEXISTENT_CH_
-
+    
     class TAO_PortableServer_Export AdapterNonExistent : public CORBA::UserException
     {
     public:
-
+      
       AdapterNonExistent (void);
       // Default constructor.
-
+      
       AdapterNonExistent (const AdapterNonExistent &);
       // Copy constructor.
-
+      
       ~AdapterNonExistent (void);
       // Destructor.
-
+      
       AdapterNonExistent &operator= (const AdapterNonExistent &);
-
+      
       virtual void _raise (void);
 
       virtual void _tao_encode (
           TAO_OutputCDR &
           TAO_ENV_ARG_DECL_NOT_USED
         ) const;
-
+      
       virtual void _tao_decode (
           TAO_InputCDR &
           TAO_ENV_ARG_DECL_NOT_USED
         );
-
+      
       static AdapterNonExistent *_downcast (CORBA::Exception *);
 
 
@@ -2349,85 +2750,84 @@ class TAO_PortableServer_Export POA : public virtual CORBA_Object
 
 
 #endif /* end #if !defined */
-
-
+    
+    
 #if !defined (_PORTABLESERVER_POA_INVALIDPOLICY_CH_)
 #define _PORTABLESERVER_POA_INVALIDPOLICY_CH_
-
+    
     class TAO_PortableServer_Export InvalidPolicy : public CORBA::UserException
     {
     public:
       CORBA::UShort index;
-
+      
       InvalidPolicy (void);
       // Default constructor.
-
+      
       InvalidPolicy (const InvalidPolicy &);
       // Copy constructor.
-
+      
       ~InvalidPolicy (void);
       // Destructor.
-
+      
       InvalidPolicy &operator= (const InvalidPolicy &);
-
+      
       virtual void _raise (void);
 
       virtual void _tao_encode (
           TAO_OutputCDR &
           TAO_ENV_ARG_DECL_NOT_USED
         ) const;
-
+      
       virtual void _tao_decode (
           TAO_InputCDR &
           TAO_ENV_ARG_DECL_NOT_USED
         );
-
+      
       static InvalidPolicy *_downcast (CORBA::Exception *);
 
       InvalidPolicy (
           CORBA::UShort _tao_index
         );
-
+      
       // = TAO extension.
       static CORBA::Exception *_alloc (void);
     }; // Exception PortableServer::POA::InvalidPolicy.
 
 
 #endif /* end #if !defined */
-
-
+    
 #if (TAO_HAS_MINIMUM_POA == 0)
-
+    
 #if !defined (_PORTABLESERVER_POA_NOSERVANT_CH_)
 #define _PORTABLESERVER_POA_NOSERVANT_CH_
-
+    
     class TAO_PortableServer_Export NoServant : public CORBA::UserException
     {
     public:
-
+      
       NoServant (void);
       // Default constructor.
-
+      
       NoServant (const NoServant &);
       // Copy constructor.
-
+      
       ~NoServant (void);
       // Destructor.
-
+      
       NoServant &operator= (const NoServant &);
-
+      
       virtual void _raise (void);
 
       virtual void _tao_encode (
           TAO_OutputCDR &
           TAO_ENV_ARG_DECL_NOT_USED
         ) const;
-
+      
       virtual void _tao_decode (
           TAO_InputCDR &
           TAO_ENV_ARG_DECL_NOT_USED
         );
-
+      
       static NoServant *_downcast (CORBA::Exception *);
 
 
@@ -2437,40 +2837,39 @@ class TAO_PortableServer_Export POA : public virtual CORBA_Object
 
 
 #endif /* end #if !defined */
-
-
+    
 #endif /* TAO_HAS_MINIMUM_POA == 0 */
-
+    
 #if !defined (_PORTABLESERVER_POA_OBJECTALREADYACTIVE_CH_)
 #define _PORTABLESERVER_POA_OBJECTALREADYACTIVE_CH_
-
+    
     class TAO_PortableServer_Export ObjectAlreadyActive : public CORBA::UserException
     {
     public:
-
+      
       ObjectAlreadyActive (void);
       // Default constructor.
-
+      
       ObjectAlreadyActive (const ObjectAlreadyActive &);
       // Copy constructor.
-
+      
       ~ObjectAlreadyActive (void);
       // Destructor.
-
+      
       ObjectAlreadyActive &operator= (const ObjectAlreadyActive &);
-
+      
       virtual void _raise (void);
 
       virtual void _tao_encode (
           TAO_OutputCDR &
           TAO_ENV_ARG_DECL_NOT_USED
         ) const;
-
+      
       virtual void _tao_decode (
           TAO_InputCDR &
           TAO_ENV_ARG_DECL_NOT_USED
         );
-
+      
       static ObjectAlreadyActive *_downcast (CORBA::Exception *);
 
 
@@ -2480,38 +2879,38 @@ class TAO_PortableServer_Export POA : public virtual CORBA_Object
 
 
 #endif /* end #if !defined */
-
-
+    
+    
 #if !defined (_PORTABLESERVER_POA_OBJECTNOTACTIVE_CH_)
 #define _PORTABLESERVER_POA_OBJECTNOTACTIVE_CH_
-
+    
     class TAO_PortableServer_Export ObjectNotActive : public CORBA::UserException
     {
     public:
-
+      
       ObjectNotActive (void);
       // Default constructor.
-
+      
       ObjectNotActive (const ObjectNotActive &);
       // Copy constructor.
-
+      
       ~ObjectNotActive (void);
       // Destructor.
-
+      
       ObjectNotActive &operator= (const ObjectNotActive &);
-
+      
       virtual void _raise (void);
 
       virtual void _tao_encode (
           TAO_OutputCDR &
           TAO_ENV_ARG_DECL_NOT_USED
         ) const;
-
+      
       virtual void _tao_decode (
           TAO_InputCDR &
           TAO_ENV_ARG_DECL_NOT_USED
         );
-
+      
       static ObjectNotActive *_downcast (CORBA::Exception *);
 
 
@@ -2521,38 +2920,38 @@ class TAO_PortableServer_Export POA : public virtual CORBA_Object
 
 
 #endif /* end #if !defined */
-
-
+    
+    
 #if !defined (_PORTABLESERVER_POA_SERVANTALREADYACTIVE_CH_)
 #define _PORTABLESERVER_POA_SERVANTALREADYACTIVE_CH_
-
+    
     class TAO_PortableServer_Export ServantAlreadyActive : public CORBA::UserException
     {
     public:
-
+      
       ServantAlreadyActive (void);
       // Default constructor.
-
+      
       ServantAlreadyActive (const ServantAlreadyActive &);
       // Copy constructor.
-
+      
       ~ServantAlreadyActive (void);
       // Destructor.
-
+      
       ServantAlreadyActive &operator= (const ServantAlreadyActive &);
-
+      
       virtual void _raise (void);
 
       virtual void _tao_encode (
           TAO_OutputCDR &
           TAO_ENV_ARG_DECL_NOT_USED
         ) const;
-
+      
       virtual void _tao_decode (
           TAO_InputCDR &
           TAO_ENV_ARG_DECL_NOT_USED
         );
-
+      
       static ServantAlreadyActive *_downcast (CORBA::Exception *);
 
 
@@ -2562,38 +2961,38 @@ class TAO_PortableServer_Export POA : public virtual CORBA_Object
 
 
 #endif /* end #if !defined */
-
-
+    
+    
 #if !defined (_PORTABLESERVER_POA_SERVANTNOTACTIVE_CH_)
 #define _PORTABLESERVER_POA_SERVANTNOTACTIVE_CH_
-
+    
     class TAO_PortableServer_Export ServantNotActive : public CORBA::UserException
     {
     public:
-
+      
       ServantNotActive (void);
       // Default constructor.
-
+      
       ServantNotActive (const ServantNotActive &);
       // Copy constructor.
-
+      
       ~ServantNotActive (void);
       // Destructor.
-
+      
       ServantNotActive &operator= (const ServantNotActive &);
-
+      
       virtual void _raise (void);
 
       virtual void _tao_encode (
           TAO_OutputCDR &
           TAO_ENV_ARG_DECL_NOT_USED
         ) const;
-
+      
       virtual void _tao_decode (
           TAO_InputCDR &
           TAO_ENV_ARG_DECL_NOT_USED
         );
-
+      
       static ServantNotActive *_downcast (CORBA::Exception *);
 
 
@@ -2603,38 +3002,38 @@ class TAO_PortableServer_Export POA : public virtual CORBA_Object
 
 
 #endif /* end #if !defined */
-
-
+    
+    
 #if !defined (_PORTABLESERVER_POA_WRONGADAPTER_CH_)
 #define _PORTABLESERVER_POA_WRONGADAPTER_CH_
-
+    
     class TAO_PortableServer_Export WrongAdapter : public CORBA::UserException
     {
     public:
-
+      
       WrongAdapter (void);
       // Default constructor.
-
+      
       WrongAdapter (const WrongAdapter &);
       // Copy constructor.
-
+      
       ~WrongAdapter (void);
       // Destructor.
-
+      
       WrongAdapter &operator= (const WrongAdapter &);
-
+      
       virtual void _raise (void);
 
       virtual void _tao_encode (
           TAO_OutputCDR &
           TAO_ENV_ARG_DECL_NOT_USED
         ) const;
-
+      
       virtual void _tao_decode (
           TAO_InputCDR &
           TAO_ENV_ARG_DECL_NOT_USED
         );
-
+      
       static WrongAdapter *_downcast (CORBA::Exception *);
 
 
@@ -2644,38 +3043,38 @@ class TAO_PortableServer_Export POA : public virtual CORBA_Object
 
 
 #endif /* end #if !defined */
-
-
+    
+    
 #if !defined (_PORTABLESERVER_POA_WRONGPOLICY_CH_)
 #define _PORTABLESERVER_POA_WRONGPOLICY_CH_
-
+    
     class TAO_PortableServer_Export WrongPolicy : public CORBA::UserException
     {
     public:
-
+      
       WrongPolicy (void);
       // Default constructor.
-
+      
       WrongPolicy (const WrongPolicy &);
       // Copy constructor.
-
+      
       ~WrongPolicy (void);
       // Destructor.
-
+      
       WrongPolicy &operator= (const WrongPolicy &);
-
+      
       virtual void _raise (void);
 
       virtual void _tao_encode (
           TAO_OutputCDR &
           TAO_ENV_ARG_DECL_NOT_USED
         ) const;
-
+      
       virtual void _tao_decode (
           TAO_InputCDR &
           TAO_ENV_ARG_DECL_NOT_USED
         );
-
+      
       static WrongPolicy *_downcast (CORBA::Exception *);
 
 
@@ -2685,361 +3084,375 @@ class TAO_PortableServer_Export POA : public virtual CORBA_Object
 
 
 #endif /* end #if !defined */
-
-    virtual PortableServer::POA_ptr create_POA (
+    
+    virtual ::PortableServer::POA_ptr create_POA (
         const char * adapter_name,
         PortableServer::POAManager_ptr a_POAManager,
-        const CORBA::PolicyList & policies
-        TAO_ENV_ARG_DECL_WITH_DEFAULTS)
-
+        const CORBA::PolicyList & policies TAO_ENV_ARG_DECL_WITH_DEFAULTS
+      )
       ACE_THROW_SPEC ((
         CORBA::SystemException,
         PortableServer::POA::AdapterAlreadyExists,
         PortableServer::POA::InvalidPolicy
       )) = 0;
-
-    virtual PortableServer::POA_ptr find_POA (
+    
+    virtual ::PortableServer::POA_ptr find_POA (
         const char * adapter_name,
-        CORBA::Boolean activate_it
-        TAO_ENV_ARG_DECL_WITH_DEFAULTS)
-
+        CORBA::Boolean activate_it TAO_ENV_ARG_DECL_WITH_DEFAULTS
+      )
       ACE_THROW_SPEC ((
         CORBA::SystemException,
         PortableServer::POA::AdapterNonExistent
       )) = 0;
-
+    
     virtual void destroy (
         CORBA::Boolean etherealize_objects,
-        CORBA::Boolean wait_for_completion
-        TAO_ENV_ARG_DECL_WITH_DEFAULTS)
-
+        CORBA::Boolean wait_for_completion TAO_ENV_ARG_DECL_WITH_DEFAULTS
+      )
       ACE_THROW_SPEC ((
         CORBA::SystemException
       )) = 0;
 
 #if (TAO_HAS_MINIMUM_POA == 0)
-
-    virtual PortableServer::ThreadPolicy_ptr create_thread_policy (
-        PortableServer::ThreadPolicyValue value
-        TAO_ENV_ARG_DECL_WITH_DEFAULTS)
-
+    
+    virtual ::PortableServer::ThreadPolicy_ptr create_thread_policy (
+        PortableServer::ThreadPolicyValue value TAO_ENV_ARG_DECL_WITH_DEFAULTS
+      )
       ACE_THROW_SPEC ((
         CORBA::SystemException
       )) = 0;
-
+    
 #endif /* TAO_HAS_MINIMUM_POA == 0 */
 
-    virtual PortableServer::LifespanPolicy_ptr create_lifespan_policy (
-        PortableServer::LifespanPolicyValue value
-        TAO_ENV_ARG_DECL_WITH_DEFAULTS)
-
+    virtual ::PortableServer::LifespanPolicy_ptr create_lifespan_policy (
+        PortableServer::LifespanPolicyValue value TAO_ENV_ARG_DECL_WITH_DEFAULTS
+      )
       ACE_THROW_SPEC ((
         CORBA::SystemException
       )) = 0;
-
-    virtual PortableServer::IdUniquenessPolicy_ptr create_id_uniqueness_policy (
-        PortableServer::IdUniquenessPolicyValue value
-        TAO_ENV_ARG_DECL_WITH_DEFAULTS)
-
+    
+    virtual ::PortableServer::IdUniquenessPolicy_ptr create_id_uniqueness_policy (
+        PortableServer::IdUniquenessPolicyValue value TAO_ENV_ARG_DECL_WITH_DEFAULTS
+      )
       ACE_THROW_SPEC ((
         CORBA::SystemException
       )) = 0;
-
-    virtual PortableServer::IdAssignmentPolicy_ptr create_id_assignment_policy (
-        PortableServer::IdAssignmentPolicyValue value
-        TAO_ENV_ARG_DECL_WITH_DEFAULTS)
-
+    
+    virtual ::PortableServer::IdAssignmentPolicy_ptr create_id_assignment_policy (
+        PortableServer::IdAssignmentPolicyValue value TAO_ENV_ARG_DECL_WITH_DEFAULTS
+      )
       ACE_THROW_SPEC ((
         CORBA::SystemException
       )) = 0;
-
+    
 #if (TAO_HAS_MINIMUM_POA == 0)
 
-    virtual PortableServer::ImplicitActivationPolicy_ptr create_implicit_activation_policy (
-        PortableServer::ImplicitActivationPolicyValue value
-        TAO_ENV_ARG_DECL_WITH_DEFAULTS)
-
+    virtual ::PortableServer::ImplicitActivationPolicy_ptr create_implicit_activation_policy (
+        PortableServer::ImplicitActivationPolicyValue value TAO_ENV_ARG_DECL_WITH_DEFAULTS
+      )
       ACE_THROW_SPEC ((
         CORBA::SystemException
       )) = 0;
-
-    virtual PortableServer::ServantRetentionPolicy_ptr create_servant_retention_policy (
-        PortableServer::ServantRetentionPolicyValue value
-        TAO_ENV_ARG_DECL_WITH_DEFAULTS)
-
+    
+    virtual ::PortableServer::ServantRetentionPolicy_ptr create_servant_retention_policy (
+        PortableServer::ServantRetentionPolicyValue value TAO_ENV_ARG_DECL_WITH_DEFAULTS
+      )
       ACE_THROW_SPEC ((
         CORBA::SystemException
       )) = 0;
-
-    virtual PortableServer::RequestProcessingPolicy_ptr create_request_processing_policy (
-        PortableServer::RequestProcessingPolicyValue value
-        TAO_ENV_ARG_DECL_WITH_DEFAULTS)
-
+    
+    virtual ::PortableServer::RequestProcessingPolicy_ptr create_request_processing_policy (
+        PortableServer::RequestProcessingPolicyValue value TAO_ENV_ARG_DECL_WITH_DEFAULTS
+      )
       ACE_THROW_SPEC ((
         CORBA::SystemException
       )) = 0;
-
+    
 #endif /* TAO_HAS_MINIMUM_POA == 0 */
 
     virtual char * the_name (
-        TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)
-
+        TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
+      )
       ACE_THROW_SPEC ((
         CORBA::SystemException
       )) = 0;
-
-    virtual PortableServer::POA_ptr the_parent (
-        TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)
-
+    
+    virtual ::PortableServer::POA_ptr the_parent (
+        TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
+      )
       ACE_THROW_SPEC ((
         CORBA::SystemException
       )) = 0;
-
-    virtual PortableServer::POAList * the_children (
-        TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)
-
+    
+    virtual ::PortableServer::POAList * the_children (
+        TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
+      )
       ACE_THROW_SPEC ((
         CORBA::SystemException
       )) = 0;
-
-    virtual PortableServer::POAManager_ptr the_POAManager (
-        TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)
-
+    
+    virtual ::PortableServer::POAManager_ptr the_POAManager (
+        TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
+      )
       ACE_THROW_SPEC ((
         CORBA::SystemException
       )) = 0;
-
+    
 #if (TAO_HAS_MINIMUM_POA == 0)
 
-    virtual PortableServer::AdapterActivator_ptr the_activator (
-        TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)
-
+    virtual ::PortableServer::AdapterActivator_ptr the_activator (
+        TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
+      )
       ACE_THROW_SPEC ((
         CORBA::SystemException
       )) = 0;
-
+    
     virtual void the_activator (
-        PortableServer::AdapterActivator_ptr the_activator
-        TAO_ENV_ARG_DECL_WITH_DEFAULTS)
-
+        PortableServer::AdapterActivator_ptr the_activator TAO_ENV_ARG_DECL_WITH_DEFAULTS
+      )
       ACE_THROW_SPEC ((
         CORBA::SystemException
       )) = 0;
-
-    virtual PortableServer::ServantManager_ptr get_servant_manager (
-        TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)
-
+    
+    virtual ::PortableServer::ServantManager_ptr get_servant_manager (
+        TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
+      )
       ACE_THROW_SPEC ((
         CORBA::SystemException,
         PortableServer::POA::WrongPolicy
       )) = 0;
-
+    
     virtual void set_servant_manager (
-        PortableServer::ServantManager_ptr imgr
-        TAO_ENV_ARG_DECL_WITH_DEFAULTS)
-
+        PortableServer::ServantManager_ptr imgr TAO_ENV_ARG_DECL_WITH_DEFAULTS
+      )
       ACE_THROW_SPEC ((
         CORBA::SystemException,
         PortableServer::POA::WrongPolicy
       )) = 0;
-
-    virtual PortableServer::Servant get_servant (
-        TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)
-
+    
+    virtual ::PortableServer::Servant get_servant (
+        TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
+      )
       ACE_THROW_SPEC ((
         CORBA::SystemException,
         PortableServer::POA::NoServant,
         PortableServer::POA::WrongPolicy
       )) = 0;
-
+    
     virtual void set_servant (
-        PortableServer::Servant p_servant
-        TAO_ENV_ARG_DECL_WITH_DEFAULTS)
-
+        PortableServer::Servant p_servant TAO_ENV_ARG_DECL_WITH_DEFAULTS
+      )
       ACE_THROW_SPEC ((
         CORBA::SystemException,
         PortableServer::POA::WrongPolicy
       )) = 0;
-
+    
 #endif /* TAO_HAS_MINIMUM_POA == 0 */
 
-    virtual PortableServer::ObjectId * activate_object (
-        PortableServer::Servant p_servant
-        TAO_ENV_ARG_DECL_WITH_DEFAULTS)
-
+    virtual ::PortableServer::ObjectId * activate_object (
+        PortableServer::Servant p_servant TAO_ENV_ARG_DECL_WITH_DEFAULTS
+      )
       ACE_THROW_SPEC ((
         CORBA::SystemException,
         PortableServer::POA::ServantAlreadyActive,
         PortableServer::POA::WrongPolicy
       )) = 0;
-
+    
     virtual void activate_object_with_id (
         const PortableServer::ObjectId & id,
-        PortableServer::Servant p_servant
-        TAO_ENV_ARG_DECL_WITH_DEFAULTS)
-
+        PortableServer::Servant p_servant TAO_ENV_ARG_DECL_WITH_DEFAULTS
+      )
       ACE_THROW_SPEC ((
         CORBA::SystemException,
         PortableServer::POA::ServantAlreadyActive,
         PortableServer::POA::ObjectAlreadyActive,
         PortableServer::POA::WrongPolicy
       )) = 0;
-
+    
     virtual void deactivate_object (
-        const PortableServer::ObjectId & oid
-        TAO_ENV_ARG_DECL_WITH_DEFAULTS)
-
+        const PortableServer::ObjectId & oid TAO_ENV_ARG_DECL_WITH_DEFAULTS
+      )
       ACE_THROW_SPEC ((
         CORBA::SystemException,
         PortableServer::POA::ObjectNotActive,
         PortableServer::POA::WrongPolicy
       )) = 0;
-
+    
     virtual CORBA::Object_ptr create_reference (
-        const char * intf
-        TAO_ENV_ARG_DECL_WITH_DEFAULTS)
-
+        const char * intf TAO_ENV_ARG_DECL_WITH_DEFAULTS
+      )
       ACE_THROW_SPEC ((
         CORBA::SystemException,
         PortableServer::POA::WrongPolicy
       )) = 0;
-
+    
     virtual CORBA::Object_ptr create_reference_with_id (
         const PortableServer::ObjectId & oid,
-        const char * intf
-        TAO_ENV_ARG_DECL_WITH_DEFAULTS)
-
+        const char * intf TAO_ENV_ARG_DECL_WITH_DEFAULTS
+      )
       ACE_THROW_SPEC ((
         CORBA::SystemException,
         PortableServer::POA::WrongPolicy
       )) = 0;
-
-    virtual PortableServer::ObjectId * servant_to_id (
-        PortableServer::Servant p_servant
-        TAO_ENV_ARG_DECL_WITH_DEFAULTS)
-
+    
+    virtual ::PortableServer::ObjectId * servant_to_id (
+        PortableServer::Servant p_servant TAO_ENV_ARG_DECL_WITH_DEFAULTS
+      )
       ACE_THROW_SPEC ((
         CORBA::SystemException,
         PortableServer::POA::ServantNotActive,
         PortableServer::POA::WrongPolicy
       )) = 0;
-
+    
     virtual CORBA::Object_ptr servant_to_reference (
-        PortableServer::Servant p_servant
-        TAO_ENV_ARG_DECL_WITH_DEFAULTS)
-
+        PortableServer::Servant p_servant TAO_ENV_ARG_DECL_WITH_DEFAULTS
+      )
       ACE_THROW_SPEC ((
         CORBA::SystemException,
         PortableServer::POA::ServantNotActive,
         PortableServer::POA::WrongPolicy
       )) = 0;
-
-    virtual PortableServer::Servant reference_to_servant (
-        CORBA::Object_ptr reference
-        TAO_ENV_ARG_DECL_WITH_DEFAULTS)
-
+    
+    virtual ::PortableServer::Servant reference_to_servant (
+        CORBA::Object_ptr reference TAO_ENV_ARG_DECL_WITH_DEFAULTS
+      )
       ACE_THROW_SPEC ((
         CORBA::SystemException,
         PortableServer::POA::ObjectNotActive,
         PortableServer::POA::WrongAdapter,
         PortableServer::POA::WrongPolicy
       )) = 0;
-
-    virtual PortableServer::ObjectId * reference_to_id (
-        CORBA::Object_ptr reference
-        TAO_ENV_ARG_DECL_WITH_DEFAULTS)
-
+    
+    virtual ::PortableServer::ObjectId * reference_to_id (
+        CORBA::Object_ptr reference TAO_ENV_ARG_DECL_WITH_DEFAULTS
+      )
       ACE_THROW_SPEC ((
         CORBA::SystemException,
         PortableServer::POA::WrongAdapter,
         PortableServer::POA::WrongPolicy
       )) = 0;
-
-    virtual PortableServer::Servant id_to_servant (
-        const PortableServer::ObjectId & oid
-        TAO_ENV_ARG_DECL_WITH_DEFAULTS)
-
+    
+    virtual ::PortableServer::Servant id_to_servant (
+        const PortableServer::ObjectId & oid TAO_ENV_ARG_DECL_WITH_DEFAULTS
+      )
       ACE_THROW_SPEC ((
         CORBA::SystemException,
         PortableServer::POA::ObjectNotActive,
         PortableServer::POA::WrongPolicy
       )) = 0;
-
+    
     virtual CORBA::Object_ptr id_to_reference (
-        const PortableServer::ObjectId & oid
-        TAO_ENV_ARG_DECL_WITH_DEFAULTS)
-
+        const PortableServer::ObjectId & oid TAO_ENV_ARG_DECL_WITH_DEFAULTS
+      )
       ACE_THROW_SPEC ((
         CORBA::SystemException,
         PortableServer::POA::ObjectNotActive,
         PortableServer::POA::WrongPolicy
       )) = 0;
-
-    virtual CORBA::OctetSeq * id (
-        TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)
-
+    
+    virtual ::CORBA::OctetSeq * id (
+        TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
+      )
       ACE_THROW_SPEC ((
         CORBA::SystemException
       )) = 0;
-
+    
+    virtual ::PortableServer::ObjectId * create_id_for_reference (
+        CORBA::Object_ptr the_ref TAO_ENV_ARG_DECL_WITH_DEFAULTS
+      )
+      ACE_THROW_SPEC ((
+        CORBA::SystemException,
+        PortableServer::NotAGroupObject
+      )) = 0;
+    
+    virtual ::PortableServer::IDs * reference_to_ids (
+        CORBA::Object_ptr the_ref TAO_ENV_ARG_DECL_WITH_DEFAULTS
+      )
+      ACE_THROW_SPEC ((
+        CORBA::SystemException,
+        PortableServer::NotAGroupObject
+      )) = 0;
+    
+    virtual void associate_reference_with_id (
+        CORBA::Object_ptr ref,
+        const PortableServer::ObjectId & oid TAO_ENV_ARG_DECL_WITH_DEFAULTS
+      )
+      ACE_THROW_SPEC ((
+        CORBA::SystemException,
+        PortableServer::NotAGroupObject
+      )) = 0;
+    
+    virtual void disassociate_reference_with_id (
+        CORBA::Object_ptr ref,
+        const PortableServer::ObjectId & oid TAO_ENV_ARG_DECL_WITH_DEFAULTS
+      )
+      ACE_THROW_SPEC ((
+        CORBA::SystemException,
+        PortableServer::NotAGroupObject
+      )) = 0;
+    
     virtual void *_tao_QueryInterface (ptr_arith_t type);
-
+    
     virtual const char* _interface_repository_id (void) const;
 
   protected:
-    POA ();
-
+    POA (void);
+    
     virtual ~POA (void);
+  
   private:
     POA (const POA &);
     void operator= (const POA &);
   };
-
-
+  
+  
 #endif /* end #if !defined */
-
-
+  
+  
 #if !defined (_PORTABLESERVER_CURRENT___PTR_CH_)
 #define _PORTABLESERVER_CURRENT___PTR_CH_
-
+  
   class Current;
   typedef Current *Current_ptr;
-
+  
 #endif /* end #if !defined */
-
-
+  
+  
 #if !defined (_PORTABLESERVER_CURRENT___VAR_CH_)
 #define _PORTABLESERVER_CURRENT___VAR_CH_
-
+  
   class TAO_PortableServer_Export Current_var : public TAO_Base_var
   {
   public:
     Current_var (void); // default constructor
-    Current_var (Current_ptr p) : ptr_ (p) {}
+    Current_var (Current_ptr p) : ptr_ (p) {} 
     Current_var (const Current_var &); // copy constructor
     ~Current_var (void); // destructor
-
+    
     Current_var &operator= (Current_ptr);
     Current_var &operator= (const Current_var &);
     Current_ptr operator-> (void) const;
-
+    
     operator const Current_ptr &() const;
     operator Current_ptr &();
-    // in, inout, out, _retn
+    // in, inout, out, _retn 
     Current_ptr in (void) const;
     Current_ptr &inout (void);
     Current_ptr &out (void);
     Current_ptr _retn (void);
     Current_ptr ptr (void) const;
-
+    
     // Hooks used by template sequence and object manager classes
     // for non-defined forward declared interfaces.
     static Current_ptr tao_duplicate (Current_ptr);
     static void tao_release (Current_ptr);
     static Current_ptr tao_nil (void);
-    static Current_ptr tao_narrow (CORBA::Object * TAO_ENV_ARG_DECL_NOT_USED);
+    static Current_ptr tao_narrow (
+        CORBA::Object *
+        TAO_ENV_ARG_DECL_NOT_USED
+      );
     static CORBA::Object * tao_upcast (void *);
-
+  
   private:
     Current_ptr ptr_;
     // Unimplemented - prevents widening assignment.
@@ -3049,11 +3462,11 @@ class TAO_PortableServer_Export POA : public virtual CORBA_Object
 
 
 #endif /* end #if !defined */
-
-
+  
+  
 #if !defined (_PORTABLESERVER_CURRENT___OUT_CH_)
 #define _PORTABLESERVER_CURRENT___OUT_CH_
-
+  
   class TAO_PortableServer_Export Current_out
   {
   public:
@@ -3066,19 +3479,20 @@ class TAO_PortableServer_Export POA : public virtual CORBA_Object
     operator Current_ptr &();
     Current_ptr &ptr (void);
     Current_ptr operator-> (void);
-
+  
   private:
     Current_ptr &ptr_;
   };
-
-
+  
+  
 #endif /* end #if !defined */
-
-
+  
+  
 #if !defined (_PORTABLESERVER_CURRENT_CH_)
 #define _PORTABLESERVER_CURRENT_CH_
-
-class TAO_PortableServer_Export Current: public virtual CORBA::Current
+  
+  class TAO_PortableServer_Export Current
+    : public virtual CORBA::Current
   {
   public:
   #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
@@ -3086,54 +3500,57 @@ class TAO_PortableServer_Export Current: public virtual CORBA::Current
     typedef Current_var _var_type;
   #endif /* ! __GNUC__ || g++ >= 2.8 */
 
-  static int _tao_class_id;
-
-    // the static operations
+    static int _tao_class_id;
+    
+    // The static operations.
     static Current_ptr _duplicate (Current_ptr obj);
+    
     static Current_ptr _narrow (
         CORBA::Object_ptr obj
-        TAO_ENV_ARG_DECL_WITH_DEFAULTS);
-
+        TAO_ENV_ARG_DECL_WITH_DEFAULTS
+      );
+    
     static Current_ptr _unchecked_narrow (
         CORBA::Object_ptr obj
-        TAO_ENV_ARG_DECL_WITH_DEFAULTS);
-
+        TAO_ENV_ARG_DECL_WITH_DEFAULTS
+      );
+    
     static Current_ptr _nil (void)
       {
         return (Current_ptr)0;
       }
-
-
+    
+    
 #if !defined (_PORTABLESERVER_CURRENT_NOCONTEXT_CH_)
 #define _PORTABLESERVER_CURRENT_NOCONTEXT_CH_
-
+    
     class TAO_PortableServer_Export NoContext : public CORBA::UserException
     {
     public:
-
+      
       NoContext (void);
       // Default constructor.
-
+      
       NoContext (const NoContext &);
       // Copy constructor.
-
+      
       ~NoContext (void);
       // Destructor.
-
+      
       NoContext &operator= (const NoContext &);
-
+      
       virtual void _raise (void);
 
       virtual void _tao_encode (
           TAO_OutputCDR &
           TAO_ENV_ARG_DECL_NOT_USED
         ) const;
-
+      
       virtual void _tao_decode (
           TAO_InputCDR &
           TAO_ENV_ARG_DECL_NOT_USED
         );
-
+      
       static NoContext *_downcast (CORBA::Exception *);
 
 
@@ -3143,45 +3560,45 @@ class TAO_PortableServer_Export Current: public virtual CORBA::Current
 
 
 #endif /* end #if !defined */
-
-    virtual PortableServer::POA_ptr get_POA (
-        TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)
-
+    
+    virtual ::PortableServer::POA_ptr get_POA (
+        TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
+      )
       ACE_THROW_SPEC ((
         CORBA::SystemException,
         PortableServer::Current::NoContext
       )) = 0;
-
-    virtual PortableServer::ObjectId * get_object_id (
-        TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)
-
+    
+    virtual ::PortableServer::ObjectId * get_object_id (
+        TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
+      )
       ACE_THROW_SPEC ((
         CORBA::SystemException,
         PortableServer::Current::NoContext
       )) = 0;
-
+    
     virtual void *_tao_QueryInterface (ptr_arith_t type);
-
+    
     virtual const char* _interface_repository_id (void) const;
 
   protected:
-    Current ();
-
+    Current (void);
+    
     virtual ~Current (void);
+  
   private:
     Current (const Current &);
     void operator= (const Current &);
   };
-
-
+  
+  
 #endif /* end #if !defined */
-
-
+  
   TAO_NAMESPACE_STORAGE_CLASS char *ObjectId_to_string (const PortableServer::ObjectId &id);
   TAO_NAMESPACE_STORAGE_CLASS CORBA::WChar *ObjectId_to_wstring (const PortableServer::ObjectId &id);
   TAO_NAMESPACE_STORAGE_CLASS PortableServer::ObjectId *string_to_ObjectId (const char *id);
   TAO_NAMESPACE_STORAGE_CLASS PortableServer::ObjectId *wstring_to_ObjectId (const CORBA::WChar *id);
-
+  
 }
 TAO_NAMESPACE_CLOSE // module PortableServer
 
@@ -3199,6 +3616,15 @@ TAO_PortableServer_Export CORBA::Boolean operator>>= (const CORBA::Any &, const
 
 #endif /* TAO_HAS_MINIMUM_CORBA == 0 */
 
+TAO_PortableServer_Export void operator<<= (CORBA::Any &, const PortableServer::NotAGroupObject &); // copying version
+TAO_PortableServer_Export void operator<<= (CORBA::Any &, PortableServer::NotAGroupObject*); // noncopying version
+TAO_PortableServer_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableServer::NotAGroupObject *&); // deprecated
+TAO_PortableServer_Export CORBA::Boolean operator>>= (const CORBA::Any &, const PortableServer::NotAGroupObject *&);
+TAO_PortableServer_Export void operator<<= (CORBA::Any &, const PortableServer::IDs &); // copying version
+TAO_PortableServer_Export void operator<<= (CORBA::Any &, PortableServer::IDs*); // noncopying version
+TAO_PortableServer_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableServer::IDs *&); // deprecated
+TAO_PortableServer_Export CORBA::Boolean operator>>= (const CORBA::Any &, const PortableServer::IDs *&);
+
 #if (TAO_HAS_MINIMUM_POA == 0)
 
 TAO_PortableServer_Export void operator<<= (CORBA::Any &, PortableServer::ThreadPolicyValue);
@@ -3248,27 +3674,45 @@ TAO_PortableServer_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableSer
 
 #endif /* TAO_HAS_MINIMUM_CORBA == 0 */
 
+TAO_PortableServer_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::NotAGroupObject &);
+TAO_PortableServer_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::NotAGroupObject &);
+
+
+#if !defined _TAO_CDR_OP_PortableServer_IDs_H_
+#define _TAO_CDR_OP_PortableServer_IDs_H_
+
+TAO_PortableServer_Export CORBA::Boolean operator<< (
+    TAO_OutputCDR &,
+    const PortableServer::IDs &
+  );
+TAO_PortableServer_Export CORBA::Boolean operator>> (
+    TAO_InputCDR &,
+    PortableServer::IDs &
+  );
+
+#endif /* _TAO_CDR_OP_PortableServer_IDs_H_ */
+
 #if (TAO_HAS_MINIMUM_POA == 0)
 
-TAO_PortableServer_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::ThreadPolicyValue &); //
+TAO_PortableServer_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::ThreadPolicyValue &); // 
 TAO_PortableServer_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::ThreadPolicyValue &);
 
 #endif /* TAO_HAS_MINIMUM_POA == 0 */
 
-TAO_PortableServer_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::LifespanPolicyValue &); //
+TAO_PortableServer_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::LifespanPolicyValue &); // 
 TAO_PortableServer_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::LifespanPolicyValue &);
-TAO_PortableServer_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::IdUniquenessPolicyValue &); //
+TAO_PortableServer_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::IdUniquenessPolicyValue &); // 
 TAO_PortableServer_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::IdUniquenessPolicyValue &);
-TAO_PortableServer_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::IdAssignmentPolicyValue &); //
+TAO_PortableServer_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::IdAssignmentPolicyValue &); // 
 TAO_PortableServer_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::IdAssignmentPolicyValue &);
 
 #if (TAO_HAS_MINIMUM_POA == 0)
 
-TAO_PortableServer_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::ImplicitActivationPolicyValue &); //
+TAO_PortableServer_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::ImplicitActivationPolicyValue &); // 
 TAO_PortableServer_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::ImplicitActivationPolicyValue &);
-TAO_PortableServer_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::ServantRetentionPolicyValue &); //
+TAO_PortableServer_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::ServantRetentionPolicyValue &); // 
 TAO_PortableServer_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::ServantRetentionPolicyValue &);
-TAO_PortableServer_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::RequestProcessingPolicyValue &); //
+TAO_PortableServer_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::RequestProcessingPolicyValue &); // 
 TAO_PortableServer_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::RequestProcessingPolicyValue &);
 
 #endif /* TAO_HAS_MINIMUM_POA == 0 */
diff --git a/TAO/tao/PortableServer/PortableServerC.i b/TAO/tao/PortableServer/PortableServerC.i
index 6cc1d32a906..085f16840fa 100644
--- a/TAO/tao/PortableServer/PortableServerC.i
+++ b/TAO/tao/PortableServer/PortableServerC.i
@@ -25,162 +25,162 @@
 #if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_PORTABLESERVER_POALIST_CI_)
 #define __TAO_UNBOUNDED_OBJECT_SEQUENCE_PORTABLESERVER_POALIST_CI_
 
-  ACE_INLINE PortableServer::POA **
-  PortableServer::_TAO_Unbounded_Object_Sequence_PortableServer_POAList::allocbuf (CORBA::ULong nelems)
-  {
-    PortableServer::POA **buf = 0;
-
-    ACE_NEW_RETURN (buf, PortableServer::POA*[nelems], 0);
+ACE_INLINE PortableServer::POA **
+PortableServer::_TAO_Unbounded_Object_Sequence_PortableServer_POAList::allocbuf (CORBA::ULong nelems)
+{
+  PortableServer::POA **buf = 0;
+  
+  ACE_NEW_RETURN (buf, PortableServer::POA*[nelems], 0);
+  
+  for (CORBA::ULong i = 0; i < nelems; i++)
+    {
+      buf[i] = PortableServer::POA::_nil ();
+    }
+  
+  return buf;
+}
 
-    for (CORBA::ULong i = 0; i < nelems; i++)
-      {
-        buf[i] = PortableServer::POA::_nil ();
-      }
+ACE_INLINE void 
+PortableServer::_TAO_Unbounded_Object_Sequence_PortableServer_POAList::freebuf (PortableServer::POA **buffer)
+{
+  if (buffer == 0)
+    return;
+  delete[] buffer;
+}
 
-    return buf;
-  }
+ACE_INLINE
+PortableServer::_TAO_Unbounded_Object_Sequence_PortableServer_POAList::_TAO_Unbounded_Object_Sequence_PortableServer_POAList (void)
+{
+}
 
-  ACE_INLINE void
-  PortableServer::_TAO_Unbounded_Object_Sequence_PortableServer_POAList::freebuf (PortableServer::POA **buffer)
-  {
-    if (buffer == 0)
-      return;
-    delete[] buffer;
-  }
+ACE_INLINE
+PortableServer::_TAO_Unbounded_Object_Sequence_PortableServer_POAList::_TAO_Unbounded_Object_Sequence_PortableServer_POAList (CORBA::ULong maximum)
+  : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Object_Sequence_PortableServer_POAList::allocbuf (maximum))
+{
+}
 
-  ACE_INLINE
-  PortableServer::_TAO_Unbounded_Object_Sequence_PortableServer_POAList::_TAO_Unbounded_Object_Sequence_PortableServer_POAList (void)
-  {
-  }
+ACE_INLINE
+PortableServer::_TAO_Unbounded_Object_Sequence_PortableServer_POAList::_TAO_Unbounded_Object_Sequence_PortableServer_POAList (CORBA::ULong maximum,
+  CORBA::ULong length,
+  PortableServer::POA* *value,
+  CORBA::Boolean release)
+: TAO_Unbounded_Base_Sequence (maximum, length, value, release)
+{
+}
 
-  ACE_INLINE
-  PortableServer::_TAO_Unbounded_Object_Sequence_PortableServer_POAList::_TAO_Unbounded_Object_Sequence_PortableServer_POAList (CORBA::ULong maximum)
-    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Object_Sequence_PortableServer_POAList::allocbuf (maximum))
+ACE_INLINE
+PortableServer::_TAO_Unbounded_Object_Sequence_PortableServer_POAList::_TAO_Unbounded_Object_Sequence_PortableServer_POAList(const _TAO_Unbounded_Object_Sequence_PortableServer_POAList &rhs)
+  : TAO_Unbounded_Base_Sequence (rhs)
+{
+  if (rhs.buffer_ != 0)
   {
+    PortableServer::POA **tmp1 = _TAO_Unbounded_Object_Sequence_PortableServer_POAList::allocbuf (this->maximum_);
+    PortableServer::POA ** const tmp2 = ACE_reinterpret_cast (PortableServer::POA ** ACE_CAST_CONST, rhs.buffer_);
+    
+    for (CORBA::ULong i = 0; i < rhs.length_; ++i)
+      {
+        tmp1[i] = PortableServer::POA::_duplicate (tmp2[i]);
+      }
+    
+    this->buffer_ = tmp1;
   }
-
-  ACE_INLINE
-  PortableServer::_TAO_Unbounded_Object_Sequence_PortableServer_POAList::_TAO_Unbounded_Object_Sequence_PortableServer_POAList (CORBA::ULong maximum,
-    CORBA::ULong length,
-    PortableServer::POA* *value,
-    CORBA::Boolean release)
-  : TAO_Unbounded_Base_Sequence (maximum, length, value, release)
+  else
   {
+    this->buffer_ = 0;
   }
+}
 
-  ACE_INLINE
-  PortableServer::_TAO_Unbounded_Object_Sequence_PortableServer_POAList::_TAO_Unbounded_Object_Sequence_PortableServer_POAList(const _TAO_Unbounded_Object_Sequence_PortableServer_POAList &rhs)
-    : TAO_Unbounded_Base_Sequence (rhs)
+ACE_INLINE PortableServer::_TAO_Unbounded_Object_Sequence_PortableServer_POAList &
+PortableServer::_TAO_Unbounded_Object_Sequence_PortableServer_POAList::operator= (const _TAO_Unbounded_Object_Sequence_PortableServer_POAList &rhs)
+{
+  if (this == &rhs)
+    return *this;
+  
+  if (this->release_)
   {
-    if (rhs.buffer_ != 0)
+    PortableServer::POA **tmp = ACE_reinterpret_cast (PortableServer::POA **, this->buffer_);
+    
+    for (CORBA::ULong i = 0; i < this->length_; ++i)
     {
-      PortableServer::POA **tmp1 = _TAO_Unbounded_Object_Sequence_PortableServer_POAList::allocbuf (this->maximum_);
-      PortableServer::POA ** const tmp2 = ACE_reinterpret_cast (PortableServer::POA ** ACE_CAST_CONST, rhs.buffer_);
-
-      for (CORBA::ULong i = 0; i < rhs.length_; ++i)
-        {
-          tmp1[i] = PortableServer::POA::_duplicate (tmp2[i]);
-        }
-
-      this->buffer_ = tmp1;
+      CORBA::release (tmp[i]);
+      tmp[i] = PortableServer::POA::_nil ();
     }
-    else
+    if (this->maximum_ < rhs.maximum_)
     {
-      this->buffer_ = 0;
+      _TAO_Unbounded_Object_Sequence_PortableServer_POAList::freebuf (tmp);
+      this->buffer_ = _TAO_Unbounded_Object_Sequence_PortableServer_POAList::allocbuf (rhs.maximum_);
     }
   }
-
-  ACE_INLINE PortableServer::_TAO_Unbounded_Object_Sequence_PortableServer_POAList &
-  PortableServer::_TAO_Unbounded_Object_Sequence_PortableServer_POAList::operator= (const _TAO_Unbounded_Object_Sequence_PortableServer_POAList &rhs)
-  {
-    if (this == &rhs)
-      return *this;
-
-    if (this->release_)
+  else
+    this->buffer_ = _TAO_Unbounded_Object_Sequence_PortableServer_POAList::allocbuf (rhs.maximum_);
+  
+  TAO_Unbounded_Base_Sequence::operator= (rhs);
+  
+  PortableServer::POA **tmp1 = ACE_reinterpret_cast (PortableServer::POA **, this->buffer_);
+  PortableServer::POA ** const tmp2 = ACE_reinterpret_cast (PortableServer::POA ** ACE_CAST_CONST, rhs.buffer_);
+  
+  for (CORBA::ULong i = 0; i < rhs.length_; ++i)
     {
-      PortableServer::POA **tmp = ACE_reinterpret_cast (PortableServer::POA **, this->buffer_);
-
-      for (CORBA::ULong i = 0; i < this->length_; ++i)
-      {
-        CORBA::release (tmp[i]);
-        tmp[i] = PortableServer::POA::_nil ();
-      }
-      if (this->maximum_ < rhs.maximum_)
-      {
-        _TAO_Unbounded_Object_Sequence_PortableServer_POAList::freebuf (tmp);
-        this->buffer_ = _TAO_Unbounded_Object_Sequence_PortableServer_POAList::allocbuf (rhs.maximum_);
-      }
+      tmp1[i] = PortableServer::POA::_duplicate (tmp2[i]);
     }
-    else
-      this->buffer_ = _TAO_Unbounded_Object_Sequence_PortableServer_POAList::allocbuf (rhs.maximum_);
-
-    TAO_Unbounded_Base_Sequence::operator= (rhs);
-
-    PortableServer::POA **tmp1 = ACE_reinterpret_cast (PortableServer::POA **, this->buffer_);
-    PortableServer::POA ** const tmp2 = ACE_reinterpret_cast (PortableServer::POA ** ACE_CAST_CONST, rhs.buffer_);
-
-    for (CORBA::ULong i = 0; i < rhs.length_; ++i)
-      {
-        tmp1[i] = PortableServer::POA::_duplicate (tmp2[i]);
-      }
-
-    return *this;
-  }
+  
+  return *this;
+}
 
-  ACE_INLINE TAO_Object_Manager<PortableServer::POA,PortableServer::POA_var>
-  PortableServer::_TAO_Unbounded_Object_Sequence_PortableServer_POAList::operator[] (CORBA::ULong index) const
-  // read-write accessor
-  {
-    ACE_ASSERT (index < this->maximum_);
-    PortableServer::POA ** const tmp = ACE_reinterpret_cast (PortableServer::POA ** ACE_CAST_CONST, this->buffer_);
-    return TAO_Object_Manager<PortableServer::POA,PortableServer::POA_var> (tmp + index, this->release_);
-  }
+ACE_INLINE TAO_Object_Manager<PortableServer::POA,PortableServer::POA_var>
+PortableServer::_TAO_Unbounded_Object_Sequence_PortableServer_POAList::operator[] (CORBA::ULong index) const
+// read-write accessor
+{
+  ACE_ASSERT (index < this->maximum_);
+  PortableServer::POA ** const tmp = ACE_reinterpret_cast (PortableServer::POA ** ACE_CAST_CONST, this->buffer_);
+  return TAO_Object_Manager<PortableServer::POA,PortableServer::POA_var> (tmp + index, this->release_);
+}
 
-  ACE_INLINE PortableServer::POA* *
-  PortableServer::_TAO_Unbounded_Object_Sequence_PortableServer_POAList::get_buffer (CORBA::Boolean orphan)
+ACE_INLINE PortableServer::POA* *
+PortableServer::_TAO_Unbounded_Object_Sequence_PortableServer_POAList::get_buffer (CORBA::Boolean orphan)
+{
+  PortableServer::POA **result = 0;
+  if (orphan == 0)
   {
-    PortableServer::POA **result = 0;
-    if (orphan == 0)
+    // We retain ownership.
+    if (this->buffer_ == 0)
     {
-      // We retain ownership.
-      if (this->buffer_ == 0)
-      {
-        result = _TAO_Unbounded_Object_Sequence_PortableServer_POAList::allocbuf (this->maximum_);
-        this->buffer_ = result;
-        this->release_ = 1;
-      }
-      else
-      {
-        result = ACE_reinterpret_cast (PortableServer::POA**, this->buffer_);
-      }
+      result = _TAO_Unbounded_Object_Sequence_PortableServer_POAList::allocbuf (this->maximum_);
+      this->buffer_ = result;
+      this->release_ = 1;
     }
-    else // if (orphan == 1)
+    else
     {
-      if (this->release_ != 0)
-      {
-        // We set the state back to default and relinquish
-        // ownership.
-        result = ACE_reinterpret_cast(PortableServer::POA**,this->buffer_);
-        this->maximum_ = 0;
-        this->length_ = 0;
-        this->buffer_ = 0;
-        this->release_ = 0;
-      }
+      result = ACE_reinterpret_cast (PortableServer::POA**, this->buffer_);
     }
-    return result;
   }
-
-  ACE_INLINE const PortableServer::POA* *
-  PortableServer::_TAO_Unbounded_Object_Sequence_PortableServer_POAList::get_buffer (void) const
+  else // if (orphan == 1)
   {
-    return ACE_reinterpret_cast(const PortableServer::POA ** ACE_CAST_CONST, this->buffer_);
+    if (this->release_ != 0)
+    {
+      // We set the state back to default and relinquish
+      // ownership.
+      result = ACE_reinterpret_cast(PortableServer::POA**,this->buffer_);
+      this->maximum_ = 0;
+      this->length_ = 0;
+      this->buffer_ = 0;
+      this->release_ = 0;
+    }
   }
+  return result;
+}
+
+ACE_INLINE const PortableServer::POA* *
+PortableServer::_TAO_Unbounded_Object_Sequence_PortableServer_POAList::get_buffer (void) const
+{
+  return ACE_reinterpret_cast(const PortableServer::POA ** ACE_CAST_CONST, this->buffer_);
+}
 
 
 #endif /* end #if !defined */
 
 
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
 
 #if !defined (_PORTABLESERVER_POALIST_CI_)
 #define _PORTABLESERVER_POALIST_CI_
@@ -236,7 +236,7 @@ PortableServer::POAList_var::operator= (const ::PortableServer::POAList_var &p)
         {
           POAList *deep_copy =
             new POAList (*p.ptr_);
-
+          
           if (deep_copy != 0)
             {
               POAList *tmp = deep_copy;
@@ -246,7 +246,7 @@ PortableServer::POAList_var::operator= (const ::PortableServer::POAList_var &p)
             }
         }
     }
-
+  
   return *this;
 }
 
@@ -262,27 +262,27 @@ PortableServer::POAList_var::operator-> (void)
   return this->ptr_;
 }
 
-ACE_INLINE
+ACE_INLINE 
 PortableServer::POAList_var::operator const ::PortableServer::POAList &() const // cast
 {
   return *this->ptr_;
 }
 
-ACE_INLINE
-PortableServer::POAList_var::operator ::PortableServer::POAList &() // cast
+ACE_INLINE 
+PortableServer::POAList_var::operator ::PortableServer::POAList &() // cast 
 {
   return *this->ptr_;
 }
 
-ACE_INLINE
-PortableServer::POAList_var::operator ::PortableServer::POAList &() const // cast
+ACE_INLINE 
+PortableServer::POAList_var::operator ::PortableServer::POAList &() const // cast 
 {
   return *this->ptr_;
 }
 
 // variable-size types only
 ACE_INLINE
-PortableServer::POAList_var::operator ::PortableServer::POAList *&() // cast
+PortableServer::POAList_var::operator ::PortableServer::POAList *&() // cast 
 {
   return this->ptr_;
 }
@@ -305,7 +305,7 @@ PortableServer::POAList_var::inout (void)
   return *this->ptr_;
 }
 
-// mapping for variable size
+// mapping for variable size 
 ACE_INLINE ::PortableServer::POAList *&
 PortableServer::POAList_var::out (void)
 {
@@ -366,7 +366,7 @@ PortableServer::POAList_out::operator= (POAList *p)
   return *this;
 }
 
-ACE_INLINE
+ACE_INLINE 
 PortableServer::POAList_out::operator ::PortableServer::POAList *&() // cast
 {
   return this->ptr_;
@@ -455,7 +455,7 @@ PortableServer::ObjectId_var::operator= (const ::PortableServer::ObjectId_var &p
         {
           ObjectId *deep_copy =
             new ObjectId (*p.ptr_);
-
+          
           if (deep_copy != 0)
             {
               ObjectId *tmp = deep_copy;
@@ -465,7 +465,7 @@ PortableServer::ObjectId_var::operator= (const ::PortableServer::ObjectId_var &p
             }
         }
     }
-
+  
   return *this;
 }
 
@@ -493,20 +493,20 @@ PortableServer::ObjectId_var::operator-> (void)
   return this->ptr_;
 }
 
-ACE_INLINE
+ACE_INLINE 
 PortableServer::ObjectId_var::operator const ::PortableServer::ObjectId &() const // cast
 {
   return *this->ptr_;
 }
 
-ACE_INLINE
-PortableServer::ObjectId_var::operator ::PortableServer::ObjectId &() // cast
+ACE_INLINE 
+PortableServer::ObjectId_var::operator ::PortableServer::ObjectId &() // cast 
 {
   return *this->ptr_;
 }
 
-ACE_INLINE
-PortableServer::ObjectId_var::operator ::PortableServer::ObjectId &() const // cast
+ACE_INLINE 
+PortableServer::ObjectId_var::operator ::PortableServer::ObjectId &() const // cast 
 {
   return *this->ptr_;
 }
@@ -535,7 +535,7 @@ PortableServer::ObjectId_var::inout (void)
   return *this->ptr_;
 }
 
-// mapping for variable size
+// mapping for variable size 
 ACE_INLINE ::PortableServer::ObjectId *&
 PortableServer::ObjectId_var::out (void)
 {
@@ -596,7 +596,7 @@ PortableServer::ObjectId_out::operator= (ObjectId *p)
   return *this;
 }
 
-ACE_INLINE
+ACE_INLINE 
 PortableServer::ObjectId_out::operator ::PortableServer::ObjectId *&() // cast
 {
   return this->ptr_;
@@ -627,6 +627,404 @@ PortableServer::ObjectId_out::operator[] (CORBA::ULong index)
 // Inline operations for exception PortableServer::ForwardRequest
 // *************************************************************
 
+// *************************************************************
+// Inline operations for exception PortableServer::NotAGroupObject
+// *************************************************************
+
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+
+#if !defined (__TAO_UNBOUNDED_SEQUENCE_PORTABLESERVER_IDS_CI_)
+#define __TAO_UNBOUNDED_SEQUENCE_PORTABLESERVER_IDS_CI_
+
+// = Static operations.
+ACE_INLINE PortableServer::ObjectId *
+PortableServer::_TAO_Unbounded_Sequence_PortableServer_IDs::allocbuf (CORBA::ULong size)
+// Allocate storage for the sequence.
+{
+  PortableServer::ObjectId *retval = 0;
+  ACE_NEW_RETURN (retval, PortableServer::ObjectId[size], 0);
+  return retval;
+}
+
+ACE_INLINE void PortableServer::_TAO_Unbounded_Sequence_PortableServer_IDs::freebuf (PortableServer::ObjectId *buffer)
+// Free the sequence.
+{
+  delete [] buffer;
+}
+
+ACE_INLINE
+PortableServer::_TAO_Unbounded_Sequence_PortableServer_IDs::_TAO_Unbounded_Sequence_PortableServer_IDs (void) // Default constructor.
+{
+}
+
+ACE_INLINE
+PortableServer::_TAO_Unbounded_Sequence_PortableServer_IDs::_TAO_Unbounded_Sequence_PortableServer_IDs (CORBA::ULong maximum) // Constructor using a maximum length value.
+  : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Sequence_PortableServer_IDs::allocbuf (maximum))
+{
+}
+
+ACE_INLINE
+PortableServer::_TAO_Unbounded_Sequence_PortableServer_IDs::_TAO_Unbounded_Sequence_PortableServer_IDs (CORBA::ULong maximum,
+  CORBA::ULong length,
+  PortableServer::ObjectId *data,
+  CORBA::Boolean release)
+: TAO_Unbounded_Base_Sequence (maximum, length, data, release)
+{
+}
+
+ACE_INLINE
+PortableServer::_TAO_Unbounded_Sequence_PortableServer_IDs::_TAO_Unbounded_Sequence_PortableServer_IDs (const _TAO_Unbounded_Sequence_PortableServer_IDs &rhs)
+// Copy constructor.
+  : TAO_Unbounded_Base_Sequence (rhs)
+{
+  if (rhs.buffer_ != 0)
+  {
+    PortableServer::ObjectId *tmp1 = _TAO_Unbounded_Sequence_PortableServer_IDs::allocbuf (this->maximum_);
+    PortableServer::ObjectId * const tmp2 = ACE_reinterpret_cast (PortableServer::ObjectId * 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 PortableServer::_TAO_Unbounded_Sequence_PortableServer_IDs &
+PortableServer::_TAO_Unbounded_Sequence_PortableServer_IDs::operator= (const _TAO_Unbounded_Sequence_PortableServer_IDs &rhs)
+// Assignment operator.
+{
+  if (this == &rhs)
+    return *this;
+  
+  if (this->release_)
+  {
+    if (this->maximum_ < rhs.maximum_)
+    {
+      // free the old buffer
+      PortableServer::ObjectId *tmp = ACE_reinterpret_cast (PortableServer::ObjectId *, this->buffer_);
+      _TAO_Unbounded_Sequence_PortableServer_IDs::freebuf (tmp);
+      this->buffer_ = _TAO_Unbounded_Sequence_PortableServer_IDs::allocbuf (rhs.maximum_);
+    }
+  }
+  else
+    this->buffer_ = _TAO_Unbounded_Sequence_PortableServer_IDs::allocbuf (rhs.maximum_);
+  
+  TAO_Unbounded_Base_Sequence::operator= (rhs);
+  
+  PortableServer::ObjectId *tmp1 = ACE_reinterpret_cast (PortableServer::ObjectId *, this->buffer_);
+  PortableServer::ObjectId * const tmp2 = ACE_reinterpret_cast (PortableServer::ObjectId * ACE_CAST_CONST, rhs.buffer_);
+  
+  for (CORBA::ULong i = 0; i < this->length_; ++i)
+    tmp1[i] = tmp2[i];
+  
+  return *this;
+}
+
+// = Accessors.
+ACE_INLINE PortableServer::ObjectId &
+PortableServer::_TAO_Unbounded_Sequence_PortableServer_IDs::operator[] (CORBA::ULong i)
+// operator []
+{
+  ACE_ASSERT (i < this->maximum_);
+  PortableServer::ObjectId* tmp = ACE_reinterpret_cast(PortableServer::ObjectId*,this->buffer_);
+  return tmp[i];
+}
+
+ACE_INLINE const PortableServer::ObjectId &
+PortableServer::_TAO_Unbounded_Sequence_PortableServer_IDs::operator[] (CORBA::ULong i) const
+// operator []
+{
+  ACE_ASSERT (i < this->maximum_);
+  PortableServer::ObjectId * const tmp = ACE_reinterpret_cast (PortableServer::ObjectId* ACE_CAST_CONST, this->buffer_);
+  return tmp[i];
+}
+
+// Implement the TAO_Base_Sequence methods (see Sequence.h)
+
+ACE_INLINE PortableServer::ObjectId *
+PortableServer::_TAO_Unbounded_Sequence_PortableServer_IDs::get_buffer (CORBA::Boolean orphan)
+{
+  PortableServer::ObjectId *result = 0;
+  if (orphan == 0)
+  {
+    // We retain ownership.
+    if (this->buffer_ == 0)
+    {
+      result = _TAO_Unbounded_Sequence_PortableServer_IDs::allocbuf (this->length_);
+      this->buffer_ = result;
+      this->release_ = 1;
+    }
+    else
+    {
+      result = ACE_reinterpret_cast (PortableServer::ObjectId*, this->buffer_);
+    }
+  }
+  else // if (orphan == 1)
+  {
+    if (this->release_ != 0)
+    {
+      // We set the state back to default and relinquish
+      // ownership.
+      result = ACE_reinterpret_cast(PortableServer::ObjectId*,this->buffer_);
+      this->maximum_ = 0;
+      this->length_ = 0;
+      this->buffer_ = 0;
+      this->release_ = 0;
+    }
+  }
+  return result;
+}
+
+ACE_INLINE const PortableServer::ObjectId *
+PortableServer::_TAO_Unbounded_Sequence_PortableServer_IDs::get_buffer (void) const
+{
+  return ACE_reinterpret_cast(const PortableServer::ObjectId * ACE_CAST_CONST, this->buffer_);
+}
+
+ACE_INLINE void
+PortableServer::_TAO_Unbounded_Sequence_PortableServer_IDs::replace (CORBA::ULong max,
+CORBA::ULong length,
+PortableServer::ObjectId *data,
+CORBA::Boolean release)
+{
+  this->maximum_ = max;
+  this->length_ = length;
+  if (this->buffer_ && this->release_ == 1)
+  {
+    PortableServer::ObjectId *tmp = ACE_reinterpret_cast(PortableServer::ObjectId*,this->buffer_);
+    _TAO_Unbounded_Sequence_PortableServer_IDs::freebuf (tmp);
+  }
+  this->buffer_ = data;
+  this->release_ = release;
+}
+
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_PORTABLESERVER_IDS_CI_)
+#define _PORTABLESERVER_IDS_CI_
+
+// *************************************************************
+// Inline operations for class PortableServer::IDs_var
+// *************************************************************
+
+ACE_INLINE
+PortableServer::IDs_var::IDs_var (void) // default constructor
+  : ptr_ (0)
+{}
+
+ACE_INLINE
+PortableServer::IDs_var::IDs_var (IDs *p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE
+PortableServer::IDs_var::IDs_var (const ::PortableServer::IDs_var &p) // copy constructor
+{
+  if (p.ptr_)
+    ACE_NEW (this->ptr_, ::PortableServer::IDs (*p.ptr_));
+  else
+    this->ptr_ = 0;
+}
+
+ACE_INLINE
+PortableServer::IDs_var::~IDs_var (void) // destructor
+{
+  delete this->ptr_;
+}
+
+ACE_INLINE PortableServer::IDs_var &
+PortableServer::IDs_var::operator= (IDs *p)
+{
+  delete this->ptr_;
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE ::PortableServer::IDs_var &
+PortableServer::IDs_var::operator= (const ::PortableServer::IDs_var &p)
+{
+  if (this != &p)
+    {
+      if (p.ptr_ == 0)
+        {
+          delete this->ptr_;
+          this->ptr_ = 0;
+        }
+      else
+        {
+          IDs *deep_copy =
+            new IDs (*p.ptr_);
+          
+          if (deep_copy != 0)
+            {
+              IDs *tmp = deep_copy;
+              deep_copy = this->ptr_;
+              this->ptr_ = tmp;
+              delete deep_copy;
+            }
+        }
+    }
+  
+  return *this;
+}
+
+ACE_INLINE const ::PortableServer::IDs *
+PortableServer::IDs_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::PortableServer::IDs *
+PortableServer::IDs_var::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+PortableServer::IDs_var::operator const ::PortableServer::IDs &() const // cast
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE 
+PortableServer::IDs_var::operator ::PortableServer::IDs &() // cast 
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE 
+PortableServer::IDs_var::operator ::PortableServer::IDs &() const // cast 
+{
+  return *this->ptr_;
+}
+
+// variable-size types only
+ACE_INLINE
+PortableServer::IDs_var::operator ::PortableServer::IDs *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE PortableServer::ObjectId &
+PortableServer::IDs_var::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+ACE_INLINE const PortableServer::ObjectId &
+PortableServer::IDs_var::operator[] (CORBA::ULong index) const
+{
+  return ACE_const_cast (const PortableServer::ObjectId &, this->ptr_->operator[] (index));
+}
+
+ACE_INLINE const ::PortableServer::IDs &
+PortableServer::IDs_var::in (void) const
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE ::PortableServer::IDs &
+PortableServer::IDs_var::inout (void)
+{
+  return *this->ptr_;
+}
+
+// mapping for variable size 
+ACE_INLINE ::PortableServer::IDs *&
+PortableServer::IDs_var::out (void)
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+  return this->ptr_;
+}
+
+ACE_INLINE ::PortableServer::IDs *
+PortableServer::IDs_var::_retn (void)
+{
+  ::PortableServer::IDs *tmp = this->ptr_;
+  this->ptr_ = 0;
+  return tmp;
+}
+
+ACE_INLINE ::PortableServer::IDs *
+PortableServer::IDs_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+// *************************************************************
+// Inline operations for class PortableServer::IDs_out
+// *************************************************************
+
+ACE_INLINE
+PortableServer::IDs_out::IDs_out (IDs *&p)
+  : ptr_ (p)
+{
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+PortableServer::IDs_out::IDs_out (IDs_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+PortableServer::IDs_out::IDs_out (const ::PortableServer::IDs_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (IDs_out&, p).ptr_)
+{}
+
+ACE_INLINE ::PortableServer::IDs_out &
+PortableServer::IDs_out::operator= (const ::PortableServer::IDs_out &p)
+{
+  this->ptr_ = ACE_const_cast (IDs_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE ::PortableServer::IDs_out &
+PortableServer::IDs_out::operator= (IDs *p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+PortableServer::IDs_out::operator ::PortableServer::IDs *&() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::PortableServer::IDs *&
+PortableServer::IDs_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::PortableServer::IDs *
+PortableServer::IDs_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE PortableServer::ObjectId &
+PortableServer::IDs_out::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+
+#endif /* end #if !defined */
+
 
 #if (TAO_HAS_MINIMUM_POA == 0)
 
@@ -659,8 +1057,7 @@ tao_PortableServer_ThreadPolicy_nil (
 
 ACE_INLINE PortableServer::ThreadPolicy_ptr
 tao_PortableServer_ThreadPolicy_narrow (
-    CORBA::Object *p
-    TAO_ENV_ARG_DECL
+    CORBA::Object *p TAO_ENV_ARG_DECL
   )
 {
   return PortableServer::ThreadPolicy::_narrow (p TAO_ENV_ARG_PARAMETER);
@@ -711,8 +1108,7 @@ tao_PortableServer_LifespanPolicy_nil (
 
 ACE_INLINE PortableServer::LifespanPolicy_ptr
 tao_PortableServer_LifespanPolicy_narrow (
-    CORBA::Object *p
-    TAO_ENV_ARG_DECL
+    CORBA::Object *p TAO_ENV_ARG_DECL
   )
 {
   return PortableServer::LifespanPolicy::_narrow (p TAO_ENV_ARG_PARAMETER);
@@ -761,8 +1157,7 @@ tao_PortableServer_IdUniquenessPolicy_nil (
 
 ACE_INLINE PortableServer::IdUniquenessPolicy_ptr
 tao_PortableServer_IdUniquenessPolicy_narrow (
-    CORBA::Object *p
-    TAO_ENV_ARG_DECL
+    CORBA::Object *p TAO_ENV_ARG_PARAMETER
   )
 {
   return PortableServer::IdUniquenessPolicy::_narrow (p TAO_ENV_ARG_PARAMETER);
@@ -811,8 +1206,7 @@ tao_PortableServer_IdAssignmentPolicy_nil (
 
 ACE_INLINE PortableServer::IdAssignmentPolicy_ptr
 tao_PortableServer_IdAssignmentPolicy_narrow (
-    CORBA::Object *p
-    TAO_ENV_ARG_DECL
+    CORBA::Object *p TAO_ENV_ARG_DECL
   )
 {
   return PortableServer::IdAssignmentPolicy::_narrow (p TAO_ENV_ARG_PARAMETER);
@@ -863,8 +1257,7 @@ tao_PortableServer_ImplicitActivationPolicy_nil (
 
 ACE_INLINE PortableServer::ImplicitActivationPolicy_ptr
 tao_PortableServer_ImplicitActivationPolicy_narrow (
-    CORBA::Object *p
-    TAO_ENV_ARG_DECL
+    CORBA::Object *p TAO_ENV_ARG_DECL
   )
 {
   return PortableServer::ImplicitActivationPolicy::_narrow (p TAO_ENV_ARG_PARAMETER);
@@ -913,8 +1306,7 @@ tao_PortableServer_ServantRetentionPolicy_nil (
 
 ACE_INLINE PortableServer::ServantRetentionPolicy_ptr
 tao_PortableServer_ServantRetentionPolicy_narrow (
-    CORBA::Object *p
-    TAO_ENV_ARG_DECL
+    CORBA::Object *p TAO_ENV_ARG_DECL
   )
 {
   return PortableServer::ServantRetentionPolicy::_narrow (p TAO_ENV_ARG_PARAMETER);
@@ -963,8 +1355,7 @@ tao_PortableServer_RequestProcessingPolicy_nil (
 
 ACE_INLINE PortableServer::RequestProcessingPolicy_ptr
 tao_PortableServer_RequestProcessingPolicy_narrow (
-    CORBA::Object *p
-    TAO_ENV_ARG_DECL
+    CORBA::Object *p TAO_ENV_ARG_DECL
   )
 {
   return PortableServer::RequestProcessingPolicy::_narrow (p TAO_ENV_ARG_PARAMETER);
@@ -1019,8 +1410,7 @@ tao_PortableServer_POAManager_nil (
 
 ACE_INLINE PortableServer::POAManager_ptr
 tao_PortableServer_POAManager_narrow (
-    CORBA::Object *p
-    TAO_ENV_ARG_DECL
+    CORBA::Object *p TAO_ENV_ARG_DECL
   )
 {
   return PortableServer::POAManager::_narrow (p TAO_ENV_ARG_PARAMETER);
@@ -1071,8 +1461,7 @@ tao_PortableServer_AdapterActivator_nil (
 
 ACE_INLINE PortableServer::AdapterActivator_ptr
 tao_PortableServer_AdapterActivator_narrow (
-    CORBA::Object *p
-    TAO_ENV_ARG_DECL
+    CORBA::Object *p TAO_ENV_ARG_DECL
   )
 {
   return PortableServer::AdapterActivator::_narrow (p TAO_ENV_ARG_PARAMETER);
@@ -1121,8 +1510,7 @@ tao_PortableServer_ServantManager_nil (
 
 ACE_INLINE PortableServer::ServantManager_ptr
 tao_PortableServer_ServantManager_narrow (
-    CORBA::Object *p
-    TAO_ENV_ARG_DECL
+    CORBA::Object *p TAO_ENV_ARG_DECL
   )
 {
   return PortableServer::ServantManager::_narrow (p TAO_ENV_ARG_PARAMETER);
@@ -1171,8 +1559,7 @@ tao_PortableServer_ServantActivator_nil (
 
 ACE_INLINE PortableServer::ServantActivator_ptr
 tao_PortableServer_ServantActivator_narrow (
-    CORBA::Object *p
-    TAO_ENV_ARG_DECL
+    CORBA::Object *p TAO_ENV_ARG_DECL
   )
 {
   return PortableServer::ServantActivator::_narrow (p TAO_ENV_ARG_PARAMETER);
@@ -1221,8 +1608,7 @@ tao_PortableServer_ServantLocator_nil (
 
 ACE_INLINE PortableServer::ServantLocator_ptr
 tao_PortableServer_ServantLocator_narrow (
-    CORBA::Object *p
-    TAO_ENV_ARG_DECL
+    CORBA::Object *p TAO_ENV_ARG_DECL
   )
 {
   return PortableServer::ServantLocator::_narrow (p TAO_ENV_ARG_PARAMETER);
@@ -1313,8 +1699,7 @@ tao_PortableServer_POA_nil (
 
 ACE_INLINE PortableServer::POA_ptr
 tao_PortableServer_POA_narrow (
-    CORBA::Object *p
-    TAO_ENV_ARG_DECL
+    CORBA::Object *p TAO_ENV_ARG_DECL
   )
 {
   return PortableServer::POA::_narrow (p TAO_ENV_ARG_PARAMETER);
@@ -1367,8 +1752,7 @@ tao_PortableServer_Current_nil (
 
 ACE_INLINE PortableServer::Current_ptr
 tao_PortableServer_Current_narrow (
-    CORBA::Object *p
-    TAO_ENV_ARG_DECL
+    CORBA::Object *p TAO_ENV_ARG_DECL
   )
 {
   return PortableServer::Current::_narrow (p TAO_ENV_ARG_PARAMETER);
@@ -1432,6 +1816,35 @@ ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm,PortableServer::Forward
     return 0;
 }
 
+ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const PortableServer::NotAGroupObject &_tao_aggregate)
+{
+  // first marshal the repository ID
+  if (strm << _tao_aggregate._id ())
+    return 1;
+  else
+    return 0;
+}
+
+ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &,PortableServer::NotAGroupObject&)
+{
+  return 1;
+}
+
+
+#if !defined _TAO_CDR_OP_PortableServer_IDs_I_
+#define _TAO_CDR_OP_PortableServer_IDs_I_
+
+CORBA::Boolean TAO_PortableServer_Export operator<< (
+    TAO_OutputCDR &,
+    const PortableServer::IDs &
+  );
+CORBA::Boolean TAO_PortableServer_Export operator>> (
+    TAO_InputCDR &,
+    PortableServer::IDs &
+  );
+
+#endif /* _TAO_CDR_OP_PortableServer_IDs_I_ */
+
 #endif /* TAO_HAS_MINIMUM_CORBA == 0 */
 
 #if (TAO_HAS_MINIMUM_POA == 0)
@@ -1446,12 +1859,12 @@ ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, PortableServer::Thread
 {
   CORBA::ULong _tao_temp = 0;
   CORBA::Boolean _tao_result = strm >> _tao_temp;
-
+  
   if (_tao_result == 1)
     {
       _tao_enumval = ACE_static_cast (PortableServer::ThreadPolicyValue, _tao_temp);
     }
-
+  
   return _tao_result;
 }
 
@@ -1467,12 +1880,12 @@ ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, PortableServer::Lifesp
 {
   CORBA::ULong _tao_temp = 0;
   CORBA::Boolean _tao_result = strm >> _tao_temp;
-
+  
   if (_tao_result == 1)
     {
       _tao_enumval = ACE_static_cast (PortableServer::LifespanPolicyValue, _tao_temp);
     }
-
+  
   return _tao_result;
 }
 
@@ -1486,12 +1899,12 @@ ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, PortableServer::IdUniq
 {
   CORBA::ULong _tao_temp = 0;
   CORBA::Boolean _tao_result = strm >> _tao_temp;
-
+  
   if (_tao_result == 1)
     {
       _tao_enumval = ACE_static_cast (PortableServer::IdUniquenessPolicyValue, _tao_temp);
     }
-
+  
   return _tao_result;
 }
 
@@ -1505,12 +1918,12 @@ ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, PortableServer::IdAssi
 {
   CORBA::ULong _tao_temp = 0;
   CORBA::Boolean _tao_result = strm >> _tao_temp;
-
+  
   if (_tao_result == 1)
     {
       _tao_enumval = ACE_static_cast (PortableServer::IdAssignmentPolicyValue, _tao_temp);
     }
-
+  
   return _tao_result;
 }
 
@@ -1526,12 +1939,12 @@ ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, PortableServer::Implic
 {
   CORBA::ULong _tao_temp = 0;
   CORBA::Boolean _tao_result = strm >> _tao_temp;
-
+  
   if (_tao_result == 1)
     {
       _tao_enumval = ACE_static_cast (PortableServer::ImplicitActivationPolicyValue, _tao_temp);
     }
-
+  
   return _tao_result;
 }
 
@@ -1545,12 +1958,12 @@ ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, PortableServer::Servan
 {
   CORBA::ULong _tao_temp = 0;
   CORBA::Boolean _tao_result = strm >> _tao_temp;
-
+  
   if (_tao_result == 1)
     {
       _tao_enumval = ACE_static_cast (PortableServer::ServantRetentionPolicyValue, _tao_temp);
     }
-
+  
   return _tao_result;
 }
 
@@ -1564,12 +1977,12 @@ ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, PortableServer::Reques
 {
   CORBA::ULong _tao_temp = 0;
   CORBA::Boolean _tao_result = strm >> _tao_temp;
-
+  
   if (_tao_result == 1)
     {
       _tao_enumval = ACE_static_cast (PortableServer::RequestProcessingPolicyValue, _tao_temp);
     }
-
+  
   return _tao_result;
 }
 
diff --git a/TAO/tao/PortableServer/TAO_PortableServer.dsp b/TAO/tao/PortableServer/TAO_PortableServer.dsp
index 6661fa8a227..8e9c008343e 100644
--- a/TAO/tao/PortableServer/TAO_PortableServer.dsp
+++ b/TAO/tao/PortableServer/TAO_PortableServer.dsp
@@ -240,6 +240,10 @@ SOURCE=.\PolicyS.cpp
 # End Source File

 # Begin Source File

 

+SOURCE=.\PortableGroup_Hooks.cpp

+# End Source File

+# Begin Source File

+

 SOURCE=.\PortableServer.cpp

 # End Source File

 # Begin Source File

@@ -372,6 +376,10 @@ SOURCE=.\PolicyS.h
 # End Source File

 # Begin Source File

 

+SOURCE=.\PortableGroup_Hooks.h

+# End Source File

+# Begin Source File

+

 SOURCE=.\PortableServer.h

 # End Source File

 # Begin Source File