ChangeLogTag: Tue Mar 18 21:42:03 2003 Jeff Parsons <j.parsons@vanderbilt.edu>

18 files changed, 1330 insertions, 478 deletions

diff --git a/TAO/ChangeLog b/TAO/ChangeLog
index 1c070470b2c..5047eeba47c 100644
--- a/TAO/ChangeLog
+++ b/TAO/ChangeLog
@@ -1,3 +1,30 @@
+Tue Mar 18 21:42:03 2003  Jeff Parsons <j.parsons@vanderbilt.edu>
+
+        * tao/DomainC.cpp:
+        * tao/DomainC.h:
+        * tao/DomainC.i:
+        * tao/PolicyC.cpp:
+        * tao/PolicyC.h:
+        * tao/Policy_ForwardC.cpp:
+        * tao/Policy_ForwardC.h:
+        * tao/Policy_ForwardC.i:
+        * tao/Sequence_T.cpp:
+        * tao/Sequence_T.h:
+        * tao/Sequence_T.i:
+        * tao/corba.h:
+
+	  Interim hacks to avoid build errors. All the
+	  hand-crafted files will eventually be regenerated.
+
+        * tao/Objref_VarOut_T.cpp:
+        * tao/Objref_VarOut_T.h:
+        * tao/Seq_VarOut_T.cpp:
+        * tao/Seq_VarOut_T.h:
+        * tao/Seq_VarOut_T.inl:
+
+	  New files, a start on templatizing all the
+	  _var and _out classes.
+
 Mon Mar 17 09:51:36 2003  Jeff Parsons <j.parsons@vanderbilt.edu>
 
         * TAO_IDL/ast/ast_module.cpp (fe_add_module):
diff --git a/TAO/tao/DomainC.cpp b/TAO/tao/DomainC.cpp
index ee25cc17c1e..287f5f2caa4 100644
--- a/TAO/tao/DomainC.cpp
+++ b/TAO/tao/DomainC.cpp
@@ -51,7 +51,7 @@
 int CORBA::DomainManager::_tao_class_id = 0;
 
 CORBA::DomainManager_ptr
-tao_CORBA_DomainManager_duplicate (
+CORBA::tao_DomainManager_life::tao_duplicate (
     CORBA::DomainManager_ptr p
   )
 {
@@ -59,7 +59,7 @@ tao_CORBA_DomainManager_duplicate (
 }
 
 void
-tao_CORBA_DomainManager_release (
+CORBA::tao_DomainManager_life::tao_release (
     CORBA::DomainManager_ptr p
   )
 {
@@ -67,7 +67,7 @@ tao_CORBA_DomainManager_release (
 }
 
 CORBA::DomainManager_ptr
-tao_CORBA_DomainManager_nil (
+CORBA::tao_DomainManager_life::tao_nil (
     void
   )
 {
@@ -75,7 +75,7 @@ tao_CORBA_DomainManager_nil (
 }
 
 CORBA::DomainManager_ptr
-tao_CORBA_DomainManager_narrow (
+CORBA::tao_DomainManager_cast::tao_narrow (
     CORBA::Object *p
     ACE_ENV_ARG_DECL
   )
@@ -84,7 +84,7 @@ tao_CORBA_DomainManager_narrow (
 }
 
 CORBA::Object *
-tao_CORBA_DomainManager_upcast (
+CORBA::tao_DomainManager_cast::tao_upcast (
     void *src
   )
 {
@@ -93,17 +93,7 @@ tao_CORBA_DomainManager_upcast (
   return *tmp;
 }
 
-CORBA::Boolean
-tao_CORBA_DomainManager_marshal (
-    CORBA::DomainManager_ptr p,
-    TAO_OutputCDR &strm
-  )
-{
-  return p->marshal (strm);
-}
-
-// TAO_IDL - Generated from
-// W:\ACE_wrappers\TAO\TAO_IDL\be\be_interface.cpp:721
+#if 0
 
 // *************************************************************
 // CORBA::DomainManager_var
@@ -290,8 +280,7 @@ CORBA::DomainManager_out::operator-> (void)
   return this->ptr_;
 }
 
-// TAO_IDL - Generated from
-// W:\ACE_wrappers\TAO\TAO_IDL\be\be_visitor_interface/interceptors_cs.cpp:56
+#endif /* 0 */
 
 #if (TAO_HAS_INTERCEPTORS == 1)
 
@@ -1952,11 +1941,7 @@ CORBA::_TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList::_upcast (void *sr
 
 #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
 
-#if !defined (_CORBA_DOMAINMANAGERLIST_CS_)
-#define _CORBA_DOMAINMANAGERLIST_CS_
-
-// TAO_IDL - Generated from
-// W:\ACE_wrappers\TAO\TAO_IDL\be\be_visitor_sequence/sequence_cs.cpp:250
+#if 0
 
 // *************************************************************
 // CORBA::DomainManagerList
@@ -2015,7 +2000,7 @@ void CORBA::DomainManagerList::_tao_any_destructor (void *_tao_void_pointer)
   delete tmp;
 }
 
-#endif /* end #if !defined */
+#endif /* 0 */
 
 // TAO_IDL - Generated from
 // W:\ACE_wrappers\TAO\TAO_IDL\be\be_visitor_typecode/typecode_defn.cpp:284
diff --git a/TAO/tao/DomainC.h b/TAO/tao/DomainC.h
index 5d1139f9fde..91cc784362b 100644
--- a/TAO/tao/DomainC.h
+++ b/TAO/tao/DomainC.h
@@ -73,7 +73,27 @@ TAO_NAMESPACE  CORBA
   typedef DomainManager *DomainManager_ptr;
 
 #endif /* end #if !defined */
+  
+    struct tao_DomainManager_life;
+    typedef TAO_Objref_Var_T<DomainManager, tao_DomainManager_life> DomainManager_var;
+    typedef TAO_Objref_Out_T<DomainManager, tao_DomainManager_life> DomainManager_out;
+
+    struct tao_DomainManager_life
+    {
+      static DomainManager_ptr tao_duplicate (DomainManager_ptr);
+      static void tao_release (DomainManager_ptr);
+      static DomainManager_ptr tao_nil (void);
+    };
+
+    struct tao_DomainManager_cast
+    {
+      static DomainManager_ptr tao_narrow (CORBA::Object_ptr
+                                 ACE_ENV_ARG_DECL);
+      static CORBA::Object_ptr tao_upcast (void *);
+    };
 
+#if 0
+  
 #if !defined (_CORBA_DOMAINMANAGER___VAR_CH_)
 #define _CORBA_DOMAINMANAGER___VAR_CH_
   
@@ -145,6 +165,8 @@ TAO_NAMESPACE  CORBA
   };
 
 #endif /* end #if !defined */
+
+#endif /* 0 */
   
   // TAO_IDL - Generated from
   // W:\ACE_wrappers\TAO\TAO_IDL\be\be_visitor_interface/interface_ch.cpp:110
@@ -702,9 +724,8 @@ TAO_NAMESPACE  CORBA
   
   TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_ConstructionPolicy;
   
-  // TAO_IDL - Generated from
-  // W:\ACE_wrappers\TAO\TAO_IDL\be\be_visitor_sequence/gen_unbounded_obj_sequence_ch.cpp:62
-
+#if 0
+  
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
 
 #if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_DOMAINMANAGERLIST_CH_)
@@ -780,8 +801,7 @@ TAO_NAMESPACE  CORBA
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
   _TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Object_Sequence<DomainManager,DomainManager_var>
-
+  TAO_Unbounded_Object_Sequence<DomainManager,DomainManager_var,tao_DomainManager_life,tao_DomainManager_cast>
 #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
   {
   public:
@@ -802,7 +822,15 @@ TAO_NAMESPACE  CORBA
   };
 
 #endif /* end #if !defined */
+  
+#endif /* 0 */
 
+  typedef TAO_Unbounded_Object_Sequence<DomainManager,
+                                        DomainManager_var,
+                                        tao_DomainManager_life,
+                                        tao_DomainManager_cast>
+    DomainManagerList;
+  
 #if !defined (_CORBA_DOMAINMANAGERLIST___VAR_CH_)
 #define _CORBA_DOMAINMANAGERLIST___VAR_CH_
   
@@ -833,7 +861,7 @@ TAO_NAMESPACE  CORBA
     // Variable-size base types only.
     operator DomainManagerList *&();
     
-    TAO_Object_Manager<DomainManager, DomainManager_var> operator[] (CORBA::ULong index);
+    TAO_Object_Manager<DomainManager,DomainManager_var,tao_DomainManager_life> operator[] (CORBA::ULong index);
     
     // in, inout, out, _retn 
     const DomainManagerList &in (void) const;
@@ -865,7 +893,7 @@ TAO_NAMESPACE  CORBA
     operator DomainManagerList *&();
     DomainManagerList *&ptr (void);
     DomainManagerList *operator-> (void);
-    TAO_Object_Manager<DomainManager, DomainManager_var> operator[] (CORBA::ULong index);
+    TAO_Object_Manager<DomainManager,DomainManager_var,tao_DomainManager_life> operator[] (CORBA::ULong index);
   
   private:
     DomainManagerList *&ptr_;
diff --git a/TAO/tao/DomainC.i b/TAO/tao/DomainC.i
index 2ceb3142a7d..c4f59a86733 100644
--- a/TAO/tao/DomainC.i
+++ b/TAO/tao/DomainC.i
@@ -386,8 +386,7 @@ CORBA::DomainManagerList_var::operator ::CORBA::DomainManagerList *&() // cast
   return this->ptr_;
 }
 
-ACE_INLINE
-TAO_Object_Manager<CORBA::DomainManager, CORBA::DomainManager_var>
+ACE_INLINE TAO_Object_Manager<CORBA::DomainManager, CORBA::DomainManager_var, CORBA::tao_DomainManager_life>
 CORBA::DomainManagerList_var::operator[] (CORBA::ULong index)
 {
   return this->ptr_->operator[] (index);
@@ -495,8 +494,7 @@ CORBA::DomainManagerList_out::operator-> (void)
   return this->ptr_;
 }
 
-ACE_INLINE
-TAO_Object_Manager<CORBA::DomainManager, CORBA::DomainManager_var>
+ACE_INLINE TAO_Object_Manager<CORBA::DomainManager, CORBA::DomainManager_var, CORBA::tao_DomainManager_life>
 CORBA::DomainManagerList_out::operator[] (CORBA::ULong index)
 {
   return this->ptr_->operator[] (index);
diff --git a/TAO/tao/Objref_VarOut_T.cpp b/TAO/tao/Objref_VarOut_T.cpp
new file mode 100644
index 00000000000..ca626fe45ec
--- /dev/null
+++ b/TAO/tao/Objref_VarOut_T.cpp
@@ -0,0 +1,204 @@
+// $Id$
+
+#ifndef TAO_OBJREF_T_C
+#define TAO_OBJREF_T_C
+
+#include "tao/Objref_VarOut_T.h"
+#include "tao/Environment.h"
+
+ACE_RCSID (tao, 
+           Objref_T, 
+           "$Id$")
+
+template <typename T, typename T_life>
+TAO_Objref_Var_T<T, T_life>::TAO_Objref_Var_T (void)
+  : ptr_ (T_life::tao_nil ())
+{
+}
+
+template <typename T, typename T_life>
+TAO_Objref_Var_T<T, T_life>::TAO_Objref_Var_T (const TAO_Objref_Var_T<T, T_life> & p)
+  : TAO_Base_var (),
+    ptr_ (T_life::tao_duplicate (p.ptr ()))
+{
+}
+
+template <typename T, typename T_life>
+TAO_Objref_Var_T<T, T_life>::~TAO_Objref_Var_T (void)
+{
+  T_life::tao_release (this->ptr_);
+}
+
+template <typename T, typename T_life>
+TAO_Objref_Var_T<T, T_life> &
+TAO_Objref_Var_T<T, T_life>::operator= (T * p)
+{
+  T_life::tao_release (this->ptr_);
+  this->ptr_ = p;
+  return *this;
+}
+
+template <typename T, typename T_life>
+TAO_Objref_Var_T<T, T_life> &
+TAO_Objref_Var_T<T, T_life>::operator= (
+    const TAO_Objref_Var_T<T, T_life> & p
+  )
+{
+  if (this != &p)
+    {
+      T_life::tao_release (this->ptr_);
+      this->ptr_ = T_life::tao_duplicate (p.ptr ());
+    }
+
+  return *this;
+}
+
+template <typename T, typename T_life>
+T *
+TAO_Objref_Var_T<T, T_life>::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+template <typename T, typename T_life>
+TAO_Objref_Var_T<T, T_life>::operator const T *& () const
+{
+  return this->ptr_;
+}
+
+template <typename T, typename T_life>
+TAO_Objref_Var_T<T, T_life>::operator T *& ()
+{
+  return this->ptr_;
+}
+
+template <typename T, typename T_life>
+T *
+TAO_Objref_Var_T<T, T_life>::in (void) const
+{
+  return this->ptr_;
+}
+
+template <typename T, typename T_life>
+T *&
+TAO_Objref_Var_T<T, T_life>::inout (void)
+{
+  return this->ptr_;
+}
+
+template <typename T, typename T_life>
+T *&
+TAO_Objref_Var_T<T, T_life>::out (void)
+{
+  T_life::tao_release (this->ptr_);
+  this->ptr_ = T_life::tao_nil ();
+  return this->ptr_;
+}
+
+template <typename T, typename T_life>
+T *
+TAO_Objref_Var_T<T, T_life>::_retn (void)
+{
+  T * val = this->ptr_;
+  this->ptr_ = T_life::tao_nil ();
+  return val;
+}
+
+template <typename T, typename T_life>
+T *
+TAO_Objref_Var_T<T, T_life>::ptr (void) const
+{
+  return this->ptr_;
+}
+
+template <typename T, typename T_life>
+void
+TAO_Objref_Var_T<T, T_life>::free (void)
+{
+  T_life::tao_release (this->ptr_);
+}
+
+template <typename T, typename T_life>
+void
+TAO_Objref_Var_T<T, T_life>::reset (T * p)
+{
+  T_life::tao_release (this->ptr_);
+  this->ptr_ = p;
+}
+
+// ******************************************************
+
+template <typename T, typename T_life>
+TAO_Objref_Out_T<T, T_life>::TAO_Objref_Out_T (T *& p)
+  : ptr_ (p)
+{
+  this->ptr_ = T_life::tao_nil ();
+}
+
+template <typename T, typename T_life>
+TAO_Objref_Out_T<T, T_life>::TAO_Objref_Out_T (
+    TAO_Objref_Var_T<T, T_life> & p
+  )
+  : ptr_ (p.out ())
+{
+  T_life::tao_release (this->ptr_);
+  this->ptr_ = T_life::tao_nil ();
+}
+
+template <typename T, typename T_life>
+TAO_Objref_Out_T<T, T_life>::TAO_Objref_Out_T (
+    const TAO_Objref_Out_T<T, T_life> & p
+  )
+  : ptr_ (ACE_const_cast (THIS_OUT_TYPE &, p.ptr_))
+{
+}
+
+template <typename T, typename T_life>
+TAO_Objref_Out_T<T, T_life> &
+TAO_Objref_Out_T<T, T_life>::operator= (
+    const TAO_Objref_Out_T<T, T_life> & p
+  )
+{
+  this->ptr_ = ACE_const_cast (THIS_OUT_TYPE &, p).ptr_;
+  return *this;
+}
+
+template <typename T, typename T_life>
+TAO_Objref_Out_T<T, T_life> &
+TAO_Objref_Out_T<T, T_life>::operator= (
+    const TAO_Objref_Var_T<T, T_life> & p
+  )
+{
+  this->ptr_ = T_life::tao_duplicate (p.ptr ());
+  return *this;
+}
+
+template <typename T, typename T_life>
+TAO_Objref_Out_T<T, T_life> &
+TAO_Objref_Out_T<T, T_life>::operator= (T * p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+template <typename T, typename T_life>
+TAO_Objref_Out_T<T, T_life>::operator T *& ()
+{
+  return this->ptr_;
+}
+
+template <typename T, typename T_life>
+T *&
+TAO_Objref_Out_T<T, T_life>::ptr (void)
+{
+  return this->ptr_;
+}
+
+template <typename T, typename T_life>
+T *
+TAO_Objref_Out_T<T, T_life>::operator-> (void)
+{
+  return this->ptr_;
+}
+
+#endif /* TAO_OBJREF_T_C */
diff --git a/TAO/tao/Objref_VarOut_T.h b/TAO/tao/Objref_VarOut_T.h
new file mode 100644
index 00000000000..89e6ca26549
--- /dev/null
+++ b/TAO/tao/Objref_VarOut_T.h
@@ -0,0 +1,111 @@
+// -*- C++ -*-
+
+//=============================================================================
+/**
+ *  @file    Objref_Varout_T.h
+ *
+ *  $Id$
+ *
+ *  @author Jeff Parsons
+ */
+//=============================================================================
+
+
+#ifndef TAO_OBJREF_VAROUT_T_H
+#define TAO_OBJREF_VAROUT_T_H
+
+#include "ace/pre.h"
+
+#include "tao/varbase.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+# pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+#include "ace/CORBA_macros.h"
+
+/**
+ * @class TAO_Objref_Var_T
+ *
+ * @brief Parametrized implementation of _var class for object references.
+ *
+ */
+
+template <typename T, typename T_life>
+class TAO_Objref_Var_T : private TAO_Base_var
+{
+public:
+  TAO_Objref_Var_T (void);
+  TAO_Objref_Var_T (T * p) : ptr_ (p) {}
+  TAO_Objref_Var_T (const TAO_Objref_Var_T<T, T_life> &);
+  ~TAO_Objref_Var_T (void);
+
+  TAO_Objref_Var_T<T, T_life> & operator= (T *);
+  TAO_Objref_Var_T<T, T_life> & operator= (
+      const TAO_Objref_Var_T<T, T_life> &
+    );
+  T * operator-> (void) const;
+
+  // Cast operators.
+  operator const T *& () const;
+  operator T *& ();
+
+  T * in (void) const;
+  T *& inout (void);
+  T *& out (void);
+  T * _retn (void);
+
+  // TAO extension. 
+  T * ptr (void) const;
+
+protected:
+  T * ptr_;
+  void free (void);
+  void reset (T *);
+
+private:
+  // Unimplemented - prevents widening assignment.
+  TAO_Objref_Var_T (const TAO_Base_var &);
+  void operator= (const TAO_Base_var &);
+};
+
+/**
+ * @class TAO_Objref_Out_T
+ *
+ * @brief Parametrized implementation of _out class for object references.
+ *
+ */
+template <typename T, typename T_life>
+class TAO_Objref_Out_T
+{
+public:
+  TAO_Objref_Out_T (T *&);
+  TAO_Objref_Out_T (TAO_Objref_Var_T<T, T_life> &);
+  TAO_Objref_Out_T (const TAO_Objref_Out_T<T, T_life> &);
+
+  TAO_Objref_Out_T &operator= (const TAO_Objref_Out_T<T, T_life> &);
+  TAO_Objref_Out_T &operator= (const TAO_Objref_Var_T<T, T_life> &);
+  TAO_Objref_Out_T &operator= (T *);
+
+  // Cast operator.
+  operator T *& ();
+
+  T *& ptr (void);
+  T * operator-> (void);
+
+private:
+  typedef TAO_Objref_Out_T<T, T_life> THIS_OUT_TYPE;
+  T *& ptr_;
+};
+
+#if defined (ACE_TEMPLATES_REQUIRE_SOURCE)
+#include "tao/Objref_Varout_T.cpp"
+#endif /* ACE_TEMPLATES_REQUIRE_SOURCE */
+
+#if defined (ACE_TEMPLATES_REQUIRE_PRAGMA)
+#pragma implementation ("Objref_Varout_T.cpp")
+#endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */
+
+#include "ace/post.h"
+
+#endif /* TAO_OBJREF_VAROUT_T_H */
diff --git a/TAO/tao/PolicyC.cpp b/TAO/tao/PolicyC.cpp
index 511ca4e2ddf..562868adf60 100644
--- a/TAO/tao/PolicyC.cpp
+++ b/TAO/tao/PolicyC.cpp
@@ -577,7 +577,7 @@ TAO_NAMESPACE_END
 int CORBA::Policy::_tao_class_id = 0;
 
 CORBA::Policy_ptr
-tao_CORBA_Policy_duplicate (
+CORBA::tao_Policy_life::tao_duplicate (
     CORBA::Policy_ptr p
   )
 {
@@ -585,7 +585,7 @@ tao_CORBA_Policy_duplicate (
 }
 
 void
-tao_CORBA_Policy_release (
+CORBA::tao_Policy_life::tao_release (
     CORBA::Policy_ptr p
   )
 {
@@ -593,7 +593,7 @@ tao_CORBA_Policy_release (
 }
 
 CORBA::Policy_ptr
-tao_CORBA_Policy_nil (
+CORBA::tao_Policy_life::tao_nil (
     void
   )
 {
@@ -601,7 +601,7 @@ tao_CORBA_Policy_nil (
 }
 
 CORBA::Policy_ptr
-tao_CORBA_Policy_narrow (
+CORBA::tao_Policy_cast::tao_narrow (
     CORBA::Object *p
     ACE_ENV_ARG_DECL
   )
@@ -610,7 +610,7 @@ tao_CORBA_Policy_narrow (
 }
 
 CORBA::Object *
-tao_CORBA_Policy_upcast (
+CORBA::tao_Policy_cast::tao_upcast (
     void *src
   )
 {
@@ -619,17 +619,7 @@ tao_CORBA_Policy_upcast (
   return *tmp;
 }
 
-CORBA::Boolean
-tao_CORBA_Policy_marshal (
-    CORBA::Policy_ptr p,
-    TAO_OutputCDR &strm
-  )
-{
-  return p->marshal (strm);
-}
-
-// TAO_IDL - Generated from
-// W:\ACE_wrappers\TAO\TAO_IDL\be\be_interface.cpp:721
+#if 0
 
 // *************************************************************
 // CORBA::Policy_var
@@ -816,8 +806,7 @@ CORBA::Policy_out::operator-> (void)
   return this->ptr_;
 }
 
-// TAO_IDL - Generated from
-// W:\ACE_wrappers\TAO\TAO_IDL\be\be_visitor_interface/interceptors_cs.cpp:56
+#endif /* 0 */
 
 #if (TAO_HAS_INTERCEPTORS == 1)
 
diff --git a/TAO/tao/PolicyC.h b/TAO/tao/PolicyC.h
index fc295057577..9a7e0ff4475 100644
--- a/TAO/tao/PolicyC.h
+++ b/TAO/tao/PolicyC.h
@@ -326,9 +326,29 @@ TAO_NAMESPACE  CORBA
   
   class Policy;
   typedef Policy *Policy_ptr;
+  
+  struct tao_Policy_life;
+  typedef TAO_Objref_Var_T<Policy, tao_Policy_life> Policy_var;
+  typedef TAO_Objref_Out_T<Policy, tao_Policy_life> Policy_out;
 
-#endif /* end #if !defined */
+  struct tao_Policy_life
+  {
+    static Policy_ptr tao_duplicate (Policy_ptr);
+    static void tao_release (Policy_ptr);
+    static Policy_ptr tao_nil (void);
+  };
 
+  struct tao_Policy_cast
+  {
+    static Policy_ptr tao_narrow (CORBA::Object_ptr
+                                  ACE_ENV_ARG_DECL);
+    static CORBA::Object_ptr tao_upcast (void *);
+  };
+
+#endif /* end #if !defined */
+  
+#if 0
+ 
 #if !defined (_CORBA_POLICY___VAR_CH_)
 #define _CORBA_POLICY___VAR_CH_
   
@@ -401,6 +421,10 @@ TAO_NAMESPACE  CORBA
 
 #endif /* end #if !defined */
   
+#endif /* 0 */
+
+  // *************************************************************
+  // CORBA::Policy
   // TAO_IDL - Generated from
   // W:\ACE_wrappers\TAO\TAO_IDL\be\be_visitor_interface/interface_ch.cpp:110
 
@@ -705,9 +729,12 @@ TAO_NAMESPACE  CORBA
   
   TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_Policy;
   
-  // TAO_IDL - Generated from
-  // W:\ACE_wrappers\TAO\TAO_IDL\be\be_visitor_interface/interface_ch.cpp:52
-
+  typedef TAO_Unbounded_Object_Sequence<Policy,
+                                        Policy_var,
+                                        tao_Policy_life,
+                                        tao_Policy_cast>
+    PolicyList;
+  
 #if !defined (_CORBA_POLICYMANAGER___PTR_CH_)
 #define _CORBA_POLICYMANAGER___PTR_CH_
   
diff --git a/TAO/tao/Policy_ForwardC.cpp b/TAO/tao/Policy_ForwardC.cpp
index f3d5e403458..1b680735563 100644
--- a/TAO/tao/Policy_ForwardC.cpp
+++ b/TAO/tao/Policy_ForwardC.cpp
@@ -182,11 +182,7 @@ CORBA::_TAO_Unbounded_Object_Sequence_CORBA_PolicyList::_upcast (void *src) cons
 
 #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
 
-#if !defined (_CORBA_POLICYLIST_CS_)
-#define _CORBA_POLICYLIST_CS_
-
-// TAO_IDL - Generated from
-// W:\ACE_wrappers\TAO\TAO_IDL\be\be_visitor_sequence/sequence_cs.cpp:250
+#if 0
 
 // *************************************************************
 // CORBA::PolicyList
@@ -245,7 +241,7 @@ void CORBA::PolicyList::_tao_any_destructor (void *_tao_void_pointer)
   delete tmp;
 }
 
-#endif /* end #if !defined */
+#endif /* 0 */
 
 // TAO_IDL - Generated from
 // W:\ACE_wrappers\TAO\TAO_IDL\be\be_visitor_typecode/typecode_defn.cpp:284
@@ -714,7 +710,7 @@ CORBA::Boolean operator<< (
       for (CORBA::ULong i = 0; i < _tao_seq_len && _tao_marshal_flag; ++i)
         {
           _tao_marshal_flag =
-            tao_CORBA_Policy_marshal (_tao_sequence[i].in (), strm);
+            (strm << _tao_sequence[i].in ());
         }
       
       return _tao_marshal_flag;
diff --git a/TAO/tao/Policy_ForwardC.h b/TAO/tao/Policy_ForwardC.h
index 2713a0ea7b0..5b9aa1153a8 100644
--- a/TAO/tao/Policy_ForwardC.h
+++ b/TAO/tao/Policy_ForwardC.h
@@ -27,6 +27,8 @@
 
 #include "ace/pre.h"
 #include "tao/corbafwd.h"
+#include "tao/Objref_Varout_T.h"
+#include "tao/Seq_VarOut_T.h"
 
 #if !defined (ACE_LACKS_PRAGMA_ONCE)
 # pragma once
@@ -86,182 +88,33 @@ TAO_NAMESPACE  CORBA
 #define _CORBA_POLICY___PTR_CH_
   
   typedef Policy *Policy_ptr;
-
-#endif /* end #if !defined */
-
-#if !defined (_CORBA_POLICY___VAR_CH_)
-#define _CORBA_POLICY___VAR_CH_
-  
-  // TAO_IDL - Generated from
-  // W:\ACE_wrappers\TAO\TAO_IDL\be\be_interface.cpp:571
-  
-  class TAO_Export Policy_var : public TAO_Base_var
-  {
-  public:
-    Policy_var (void); // default constructor
-    Policy_var (Policy_ptr p) : ptr_ (p) {} 
-    Policy_var (const Policy_var &); // copy constructor
-    ~Policy_var (void); // destructor
-    
-    Policy_var &operator= (Policy_ptr);
-    Policy_var &operator= (const Policy_var &);
-    Policy_ptr operator-> (void) const;
-    
-    operator const Policy_ptr &() const;
-    operator Policy_ptr &();
-    // in, inout, out, _retn 
-    Policy_ptr in (void) const;
-    Policy_ptr &inout (void);
-    Policy_ptr &out (void);
-    Policy_ptr _retn (void);
-    Policy_ptr ptr (void) const;
-    
-    // Hooks used by template sequence and object manager classes
-    // for non-defined forward declared interfaces.
-    static Policy_ptr tao_duplicate (Policy_ptr);
-    static void tao_release (Policy_ptr);
-    static Policy_ptr tao_nil (void);
-    static Policy_ptr tao_narrow (
-        CORBA::Object *
-        ACE_ENV_ARG_DECL_NOT_USED
-      );
-    static CORBA::Object * tao_upcast (void *);
-  
-  private:
-    Policy_ptr ptr_;
-    // Unimplemented - prevents widening assignment.
-    Policy_var (const TAO_Base_var &rhs);
-    Policy_var &operator= (const TAO_Base_var &rhs);
-  };
-
-#endif /* end #if !defined */
-
-#if !defined (_CORBA_POLICY___OUT_CH_)
-#define _CORBA_POLICY___OUT_CH_
-  
-  // TAO_IDL - Generated from
-  // W:\ACE_wrappers\TAO\TAO_IDL\be\be_interface.cpp:946
-  
-  class TAO_Export Policy_out
-  {
-  public:
-    Policy_out (Policy_ptr &);
-    Policy_out (Policy_var &);
-    Policy_out (const Policy_out &);
-    Policy_out &operator= (const Policy_out &);
-    Policy_out &operator= (const Policy_var &);
-    Policy_out &operator= (Policy_ptr);
-    operator Policy_ptr &();
-    Policy_ptr &ptr (void);
-    Policy_ptr operator-> (void);
-  
-  private:
-    Policy_ptr &ptr_;
-  };
-
-#endif /* end #if !defined */
   
-  // TAO_IDL - Generated from
-  // W:\ACE_wrappers\TAO\TAO_IDL\be\be_visitor_sequence/gen_unbounded_obj_sequence_ch.cpp:62
+    struct tao_Policy_life;
+    typedef TAO_Objref_Var_T<Policy, tao_Policy_life> Policy_var;
+    typedef TAO_Objref_Out_T<Policy, tao_Policy_life> Policy_out;
 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+    struct tao_Policy_life
+    {
+      static Policy_ptr tao_duplicate (Policy_ptr);
+      static void tao_release (Policy_ptr);
+      static Policy_ptr tao_nil (void);
+    };
 
-#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_POLICYLIST_CH_)
-#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_POLICYLIST_CH_
-  
-  class TAO_Export _TAO_Unbounded_Object_Sequence_CORBA_PolicyList
-    : public TAO_Unbounded_Base_Sequence
-  {
-  public:
-    _TAO_Unbounded_Object_Sequence_CORBA_PolicyList (void);
-    _TAO_Unbounded_Object_Sequence_CORBA_PolicyList (CORBA::ULong maximum);
-    _TAO_Unbounded_Object_Sequence_CORBA_PolicyList (
-        CORBA::ULong maximum,
-        CORBA::ULong length,
-        Policy* *value,
-        CORBA::Boolean release = 0
-      );
-    _TAO_Unbounded_Object_Sequence_CORBA_PolicyList (
-        const _TAO_Unbounded_Object_Sequence_CORBA_PolicyList &rhs
-      );
-    _TAO_Unbounded_Object_Sequence_CORBA_PolicyList &operator= (
-        const _TAO_Unbounded_Object_Sequence_CORBA_PolicyList &rhs
-      );
-    virtual ~_TAO_Unbounded_Object_Sequence_CORBA_PolicyList (void);
-    
-    // = Accessors.
-    TAO_Object_Manager<CORBA::Policy,CORBA::Policy_var> operator[] (CORBA::ULong index) const;
-    
-    // = Static operations.
-    static Policy **allocbuf (CORBA::ULong nelems);
-    static void freebuf (Policy **buffer);
-    
-    // Implement the TAO_Base_Sequence methods (see Sequence.h)
-    virtual void _allocate_buffer (CORBA::ULong length);
-    virtual void _deallocate_buffer (void);
-    Policy* *get_buffer (CORBA::Boolean orphan = 0);
-    const Policy* *get_buffer (void) const;
-    virtual void _shrink_buffer (
-        CORBA::ULong nl,
-        CORBA::ULong ol
-      );
-    
-    virtual void _downcast (
-        void* target,
-        CORBA::Object *src
-        ACE_ENV_ARG_DECL_WITH_DEFAULTS
-      );
-    virtual CORBA::Object* _upcast (void *src) const;
-  };
+    struct tao_Policy_cast
+    {
+      static Policy_ptr tao_narrow (CORBA::Object_ptr
+                                 ACE_ENV_ARG_DECL);
+      static CORBA::Object_ptr tao_upcast (void *);
+    };
 
 #endif /* end #if !defined */
 
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
-
-#if !defined (_CORBA_POLICYLIST_CH_)
-#define _CORBA_POLICYLIST_CH_
-  
-  // TAO_IDL - Generated from
-  // W:\ACE_wrappers\TAO\TAO_IDL\be\be_visitor_sequence/sequence_ch.cpp:371
-  
-  class PolicyList;
-  class PolicyList_var;
-  
-  // *************************************************************
-  // CORBA::PolicyList
-  // *************************************************************
-  
-  class TAO_Export PolicyList : public 
+  typedef TAO_Unbounded_Object_Sequence<Policy,
+                                        Policy_var,
+                                        tao_Policy_life,
+                                        tao_Policy_cast>
+    PolicyList;
   
-  // TAO_IDL - Generated from 
-  // W:\ACE_wrappers\TAO\TAO_IDL\be\be_visitor_sequence/sequence_ch.cpp:51
-
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Object_Sequence_CORBA_PolicyList
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Object_Sequence<Policy,Policy_var>
-
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
-  {
-  public:
-    PolicyList (void);
-    PolicyList (CORBA::ULong max);
-    PolicyList (
-        CORBA::ULong max, 
-        CORBA::ULong length, 
-        Policy_ptr *buffer, 
-        CORBA::Boolean release = 0
-      );
-    PolicyList (const PolicyList &);
-    ~PolicyList (void);
-    
-    static void _tao_any_destructor (void*);
-    
-    typedef PolicyList_var _var_type;
-  };
-
-#endif /* end #if !defined */
-
 #if !defined (_CORBA_POLICYLIST___VAR_CH_)
 #define _CORBA_POLICYLIST___VAR_CH_
   
@@ -292,7 +145,7 @@ TAO_NAMESPACE  CORBA
     // Variable-size base types only.
     operator PolicyList *&();
     
-    TAO_Object_Manager<Policy, Policy_var> operator[] (CORBA::ULong index);
+    TAO_Object_Manager<Policy,Policy_var,tao_Policy_life> operator[] (CORBA::ULong index);
     
     // in, inout, out, _retn 
     const PolicyList &in (void) const;
@@ -324,7 +177,7 @@ TAO_NAMESPACE  CORBA
     operator PolicyList *&();
     PolicyList *&ptr (void);
     PolicyList *operator-> (void);
-    TAO_Object_Manager<Policy, Policy_var> operator[] (CORBA::ULong index);
+    TAO_Object_Manager<Policy,Policy_var,tao_Policy_life> operator[] (CORBA::ULong index);
   
   private:
     PolicyList *&ptr_;
@@ -540,55 +393,8 @@ TAO_NAMESPACE  CORBA
 }
 TAO_NAMESPACE_CLOSE // module CORBA
 
-// TAO_IDL - Generated from
-// W:\ACE_wrappers\TAO\TAO_IDL\be\be_visitor_root/root.cpp:103
-
-// External declarations for undefined interface
-
-// CORBA::Policy
-TAO_Export
-CORBA::Policy_ptr
-tao_CORBA_Policy_duplicate (
-    CORBA::Policy_ptr
-  );
-
-TAO_Export
-void
-tao_CORBA_Policy_release (
-    CORBA::Policy_ptr
-  );
-
-TAO_Export
-CORBA::Policy_ptr
-tao_CORBA_Policy_nil (
-    void
-  );
-
-TAO_Export
-CORBA::Policy_ptr
-tao_CORBA_Policy_narrow (
-    CORBA::Object *
-    ACE_ENV_ARG_DECL_NOT_USED
-  );
-
-TAO_Export
-CORBA::Object *
-tao_CORBA_Policy_upcast (
-    void *
-  );
-
-TAO_Export
-CORBA::Boolean
-tao_CORBA_Policy_marshal (
-    CORBA::Policy_ptr,
-    TAO_OutputCDR &
-  );
-
-// TAO_IDL - Generated from
-// W:\ACE_wrappers\TAO\TAO_IDL\be\be_visitor_interface_fwd/any_op_ch.cpp:65
-
-TAO_Export void operator<<= (CORBA::Any &, CORBA::Policy_ptr); // copying
-TAO_Export void operator<<= (CORBA::Any &, CORBA::Policy_ptr *); // non-copying
+// Any operators for interface CORBA::Policy
+TAO_Export void operator<<= (CORBA::Any &, CORBA::Policy_ptr);
 TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::Policy *&);
 
 // TAO_IDL - Generated from
diff --git a/TAO/tao/Policy_ForwardC.i b/TAO/tao/Policy_ForwardC.i
index 6da5cf38028..58e14095703 100644
--- a/TAO/tao/Policy_ForwardC.i
+++ b/TAO/tao/Policy_ForwardC.i
@@ -334,8 +334,7 @@ CORBA::PolicyList_var::operator ::CORBA::PolicyList *&() // cast
   return this->ptr_;
 }
 
-ACE_INLINE
-TAO_Object_Manager<CORBA::Policy, CORBA::Policy_var>
+ACE_INLINE TAO_Object_Manager<CORBA::Policy, CORBA::Policy_var, CORBA::tao_Policy_life>
 CORBA::PolicyList_var::operator[] (CORBA::ULong index)
 {
   return this->ptr_->operator[] (index);
@@ -443,8 +442,7 @@ CORBA::PolicyList_out::operator-> (void)
   return this->ptr_;
 }
 
-ACE_INLINE
-TAO_Object_Manager<CORBA::Policy, CORBA::Policy_var>
+ACE_INLINE TAO_Object_Manager<CORBA::Policy, CORBA::Policy_var, CORBA::tao_Policy_life>
 CORBA::PolicyList_out::operator[] (CORBA::ULong index)
 {
   return this->ptr_->operator[] (index);
diff --git a/TAO/tao/Seq_VarOut_T.cpp b/TAO/tao/Seq_VarOut_T.cpp
new file mode 100644
index 00000000000..e94be3f774e
--- /dev/null
+++ b/TAO/tao/Seq_VarOut_T.cpp
@@ -0,0 +1,85 @@
+// $Id$
+
+#ifndef TAO_SEQ_VAROUT_T_C
+#define TAO_SEQ_VAROUT_T_C
+
+#include "tao/Seq_VarOut_T.h"
+
+#if !defined (__ACE_INLINE__)
+#include "tao/Seq_VarOut_T.inl"
+#endif /* __ACE_INLINE__ */
+
+ACE_RCSID (tao, 
+           Seq_VarOut_T, 
+           "$Id$")
+
+template<typename T, typename T_elem>
+TAO_Seq_Var_Base_T<T,T_elem>::TAO_Seq_Var_Base_T (
+    const TAO_Seq_Var_Base_T<T,T_elem> & p
+  )
+{
+  if (p.ptr_)
+    {
+      ACE_NEW (this->ptr_, 
+               T (*p.ptr_));
+    }
+  else
+    {
+      this->ptr_ = 0;
+    }
+}
+
+template<typename T, typename T_elem>
+TAO_Seq_Var_Base_T<T,T_elem> &
+TAO_Seq_Var_Base_T<T,T_elem>::operator= (
+    const TAO_Seq_Var_Base_T<T,T_elem> & p
+  )
+{
+  if (this != &p)
+    {
+      if (p.ptr_ == 0)
+        {
+          delete this->ptr_;
+          this->ptr_ = 0;
+        }
+      else
+        {
+          T * deep_copy = 0;
+          ACE_NEW_RETURN (
+              deep_copy,
+              T (*p.ptr_),
+              *this
+            );
+          
+          if (deep_copy != 0)
+            {
+              T * tmp = deep_copy;
+              deep_copy = this->ptr_;
+              this->ptr_ = tmp;
+              delete deep_copy;
+            }
+        }
+    }
+  
+  return *this;
+}
+
+// ****************************************************************************
+
+// Fixed-size types only.
+template<typename T, typename T_elem>
+TAO_FixedSeq_Var_T<T,T_elem> &
+TAO_FixedSeq_Var_T<T,T_elem>::operator= (const T & p)
+{
+  if (this->ptr_ != &p)
+    {
+      delete this->ptr_;
+      ACE_NEW_RETURN (this->ptr_, 
+                      T (p), 
+                      *this);
+    }
+  
+  return *this;
+}
+
+#endif /* TAO_SEQ_VAROUT_T_C */
diff --git a/TAO/tao/Seq_VarOut_T.h b/TAO/tao/Seq_VarOut_T.h
new file mode 100644
index 00000000000..773ccd697b6
--- /dev/null
+++ b/TAO/tao/Seq_VarOut_T.h
@@ -0,0 +1,150 @@
+// -*- C++ -*-
+
+//=============================================================================
+/**
+ *  @file    Seq_VarOut_T.h
+ *
+ *  $Id$
+ *
+ *  @author Jeff Parsons
+ */
+//=============================================================================
+
+
+#ifndef TAO_SEQ_VAROUT_T_H
+#define TAO_SEQ_VAROUT_T_H
+
+#include "ace/pre.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+# pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+/**
+ * @class TAO_FixedSeq_Var_T
+ *
+ * @brief Parametrized implementation of _var base class for sequences
+ *
+ */
+template <typename T, typename T_elem>
+class TAO_Seq_Var_Base_T
+{
+public:
+  TAO_Seq_Var_Base_T (void);
+  TAO_Seq_Var_Base_T (T *);
+  TAO_Seq_Var_Base_T (const TAO_Seq_Var_Base_T<T,T_elem> &);
+  
+  ~TAO_Seq_Var_Base_T (void);
+  
+  TAO_Seq_Var_Base_T &operator= (T *);
+  TAO_Seq_Var_Base_T &operator= (const TAO_Seq_Var_Base_T<T,T_elem> &);
+  
+  T *operator-> (void);
+  const T *operator-> (void) const;
+  
+  operator const T &() const;
+  operator T &();
+  operator T &() const;
+
+  T_elem & operator[] (CORBA::ULong index);
+  const T_elem & operator[] (CORBA::ULong index) const;
+  
+  // in, inout, out, _retn 
+  const T & in (void) const;
+  T & inout (void);
+  T *& out (void);
+  T * _retn (void);
+
+  // TAO extension.
+  T * ptr (void) const;
+
+protected:
+  T * ptr_;
+};
+
+/**
+ * @class TAO_FixedSeq_Var_T
+ *
+ * @brief Parametrized implementation of _var class for sequences
+ * whose element is of fixed size..
+ *
+ */
+template <typename T, typename T_elem>
+class TAO_FixedSeq_Var_T : public TAO_Seq_Var_Base_T<T,T_elem>
+{
+public:
+  TAO_FixedSeq_Var_T (void);
+  TAO_FixedSeq_Var_T (T *);
+  TAO_FixedSeq_Var_T (const TAO_FixedSeq_Var_T<T,T_elem> &);
+  
+  // Fixed-size base types only.
+  TAO_FixedSeq_Var_T (const T &);
+  
+  // Fixed-size base types only.
+  TAO_FixedSeq_Var_T &operator= (const T &);
+};
+
+/**
+ * @class TAO_VarSeq_Var_T
+ *
+ * @brief Parametrized implementation of _var class for sequences
+ * whose element is of variable size..
+ *
+ */
+template <typename T, typename T_elem>
+class TAO_VarSeq_Var_T : public TAO_Seq_Var_Base_T<T,T_elem>
+{
+public:
+  TAO_VarSeq_Var_T (void);
+  TAO_VarSeq_Var_T (T *);
+  TAO_VarSeq_Var_T (const TAO_VarSeq_Var_T<T,T_elem> &);
+  
+  // Variable-size base types only.
+  operator T *& ();
+};
+
+/**
+ * @class TAO_Seq_Out_T
+ *
+ * @brief Parametrized implementation of _out class for sequences.
+ *
+ */
+template <typename T, typename T_var, typename T_elem>
+class TAO_Seq_Out_T
+{
+public:
+  TAO_Seq_Out_T (T *&);
+  TAO_Seq_Out_T (T_var &);
+  TAO_Seq_Out_T (const TAO_Seq_Out_T<T,T_var,T_elem> &);
+
+  TAO_Seq_Out_T &operator= (const TAO_Seq_Out_T<T,T_var,T_elem> &);
+  TAO_Seq_Out_T &operator= (T *);
+
+  operator T *& ();
+  T *& ptr (void);
+  T * operator-> (void);
+
+  T_elem operator[] (CORBA::ULong index);
+
+private:
+  typedef TAO_Seq_Out_T<T,T_var,T_elem> THIS_OUT_TYPE;
+  T *& ptr_;
+  // Assignment from T_var not allowed.
+  void operator= (const T_var &);
+};
+
+#if defined (__ACE_INLINE__)
+#include "Seq_VarOut_T.inl"
+#endif /* defined INLINE */
+
+#if defined (ACE_TEMPLATES_REQUIRE_SOURCE)
+#include "tao/Seq_VarOut_T.cpp"
+#endif /* ACE_TEMPLATES_REQUIRE_SOURCE */
+
+#if defined (ACE_TEMPLATES_REQUIRE_PRAGMA)
+#pragma implementation ("Seq_VarOut_T.cpp")
+#endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */
+
+#include "ace/post.h"
+
+#endif /* TAO_SEQ_VAROUT_T_H */
diff --git a/TAO/tao/Seq_VarOut_T.inl b/TAO/tao/Seq_VarOut_T.inl
new file mode 100644
index 00000000000..bd07c711d75
--- /dev/null
+++ b/TAO/tao/Seq_VarOut_T.inl
@@ -0,0 +1,264 @@
+//$Id$
+
+template<typename T, typename T_elem>
+ACE_INLINE
+TAO_Seq_Var_Base_T<T,T_elem>::TAO_Seq_Var_Base_T (void)
+  : ptr_ (0)
+{}
+
+template<typename T, typename T_elem>
+ACE_INLINE
+TAO_Seq_Var_Base_T<T,T_elem>::TAO_Seq_Var_Base_T (T * p)
+  : ptr_ (p)
+{}
+
+template<typename T, typename T_elem>
+ACE_INLINE
+TAO_Seq_Var_Base_T<T,T_elem>::~TAO_Seq_Var_Base_T (void)
+{
+  delete this->ptr_;
+}
+
+template<typename T, typename T_elem>
+ACE_INLINE
+TAO_Seq_Var_Base_T<T,T_elem> &
+TAO_Seq_Var_Base_T<T,T_elem>::operator= (T * p)
+{
+  delete this->ptr_;
+  this->ptr_ = p;
+  return *this;
+}
+
+template<typename T, typename T_elem>
+ACE_INLINE
+const T *
+TAO_Seq_Var_Base_T<T,T_elem>::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+template<typename T, typename T_elem>
+ACE_INLINE
+T *
+TAO_Seq_Var_Base_T<T,T_elem>::operator-> (void)
+{
+  return this->ptr_;
+}
+
+template<typename T, typename T_elem>
+ACE_INLINE
+TAO_Seq_Var_Base_T<T,T_elem>::operator const T & () const
+{
+  return *this->ptr_;
+}
+
+template<typename T, typename T_elem>
+ACE_INLINE
+TAO_Seq_Var_Base_T<T,T_elem>::operator T & ()
+{
+  return *this->ptr_;
+}
+
+template<typename T, typename T_elem>
+ACE_INLINE
+TAO_Seq_Var_Base_T<T,T_elem>::operator T & () const
+{
+  return *this->ptr_;
+}
+
+template<typename T, typename T_elem>
+ACE_INLINE
+T_elem &
+TAO_Seq_Var_Base_T<T,T_elem>::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+template<typename T, typename T_elem>
+ACE_INLINE
+const T_elem &
+TAO_Seq_Var_Base_T<T,T_elem>::operator[] (CORBA::ULong index) const
+{
+  return ACE_const_cast (const T_elem &, this->ptr_->operator[] (index));
+}
+
+template<typename T, typename T_elem>
+ACE_INLINE
+const T &
+TAO_Seq_Var_Base_T<T,T_elem>::in (void) const
+{
+  return *this->ptr_;
+}
+
+template<typename T, typename T_elem>
+ACE_INLINE
+T &
+TAO_Seq_Var_Base_T<T,T_elem>::inout (void)
+{
+  return *this->ptr_;
+}
+
+template<typename T, typename T_elem>
+ACE_INLINE
+T *&
+TAO_Seq_Var_Base_T<T,T_elem>::out (void)
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+  return this->ptr_;
+}
+
+template<typename T, typename T_elem>
+ACE_INLINE
+T *
+TAO_Seq_Var_Base_T<T,T_elem>::_retn (void)
+{
+  T * Stmp = this->ptr_;
+  this->ptr_ = 0;
+  return tmp;
+}
+
+template<typename T, typename T_elem>
+ACE_INLINE
+T *
+TAO_Seq_Var_Base_T<T,T_elem>::ptr (void) const
+{
+  return this->ptr_;
+}
+
+// ***************************************************************
+
+template<typename T, typename T_elem>
+ACE_INLINE
+TAO_FixedSeq_Var_T<T,T_elem>::TAO_FixedSeq_Var_T (void)
+{}
+
+template<typename T, typename T_elem>
+ACE_INLINE
+TAO_FixedSeq_Var_T<T,T_elem>::TAO_FixedSeq_Var_T (T * p)
+  : TAO_Seq_Var_Base_T<T,T_elem> (p)
+{}
+
+template<typename T, typename T_elem>
+TAO_FixedSeq_Var_T<T,T_elem>::TAO_FixedSeq_Var_T (
+    const TAO_FixedSeq_Var_T<T,T_elem> & p
+  )
+  : TAO_Seq_Var_Base_T<T,T_elem> (p)
+{
+}
+
+// Fixed-size base types only.
+template<typename T, typename T_elem>
+ACE_INLINE
+TAO_FixedSeq_Var_T<T,T_elem>::TAO_FixedSeq_Var_T (const T & p)
+{
+  ACE_NEW (this->ptr_, 
+           T (p));
+}
+
+// ***************************************************************
+
+template<typename T, typename T_elem>
+ACE_INLINE
+TAO_VarSeq_Var_T<T,T_elem>::TAO_VarSeq_Var_T (void)
+{}
+
+template<typename T, typename T_elem>
+ACE_INLINE
+TAO_VarSeq_Var_T<T,T_elem>::TAO_VarSeq_Var_T (T * p)
+  : TAO_Seq_Var_Base_T<T,T_elem> (p)
+{}
+
+template<typename T, typename T_elem>
+TAO_VarSeq_Var_T<T,T_elem>::TAO_VarSeq_Var_T (
+    const TAO_VarSeq_Var_T<T,T_elem> & p
+  )
+  : TAO_Seq_Var_Base_T<T,T_elem> (p)
+{}
+
+// Variable-size types only.
+template<typename T, typename T_elem>
+ACE_INLINE
+TAO_VarSeq_Var_T<T,T_elem>::operator T *& ()
+{
+  return this->ptr_;
+}
+
+// ****************************************************************
+
+template<typename T, typename T_var, typename T_elem>
+ACE_INLINE
+TAO_Seq_Out_T<T,T_var,T_elem>::TAO_Seq_Out_T (T *& p)
+  : ptr_ (p)
+{
+  this->ptr_ = 0;
+}
+
+template<typename T, typename T_var, typename T_elem>
+ACE_INLINE
+TAO_Seq_Out_T<T,T_var,T_elem>::TAO_Seq_Out_T (T_var & p)
+  : ptr_ (p.out ())
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+}
+
+template<typename T, typename T_var, typename T_elem>
+ACE_INLINE
+TAO_Seq_Out_T<T,T_var,T_elem>::TAO_Seq_Out_T (
+    const TAO_Seq_Out_T<T,T_var,T_elem> & p
+  )
+  : ptr_ (ACE_const_cast (THIS_OUT_TYPE &, p).ptr_)
+{}
+
+template<typename T, typename T_var, typename T_elem>
+ACE_INLINE
+TAO_Seq_Out_T<T,T_var,T_elem> &
+TAO_Seq_Out_T<T,T_var,T_elem>::operator= (
+    const TAO_Seq_Out_T<T,T_var,T_elem> & p
+  )
+{
+  this->ptr_ = ACE_const_cast (THIS_OUT_TYPE &, p).ptr_;
+  return *this;
+}
+
+template<typename T, typename T_var, typename T_elem>
+ACE_INLINE
+TAO_Seq_Out_T<T,T_var,T_elem> &
+TAO_Seq_Out_T<T,T_var,T_elem>::operator= (T * p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+template<typename T, typename T_var, typename T_elem>
+ACE_INLINE
+TAO_Seq_Out_T<T,T_var,T_elem>::operator T *& ()
+{
+  return this->ptr_;
+}
+
+template<typename T, typename T_var, typename T_elem>
+ACE_INLINE
+T *&
+TAO_Seq_Out_T<T,T_var,T_elem>::ptr (void)
+{
+  return this->ptr_;
+}
+
+template<typename T, typename T_var, typename T_elem>
+ACE_INLINE
+T *
+TAO_Seq_Out_T<T,T_var,T_elem>::operator-> (void)
+{
+  return this->ptr_;
+}
+
+template<typename T, typename T_var, typename T_elem>
+ACE_INLINE
+T_elem
+TAO_Seq_Out_T<T,T_var,T_elem>::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
diff --git a/TAO/tao/Sequence_T.cpp b/TAO/tao/Sequence_T.cpp
index b84b578ad72..579be2a2a36 100644
--- a/TAO/tao/Sequence_T.cpp
+++ b/TAO/tao/Sequence_T.cpp
@@ -259,9 +259,11 @@ TAO_Bounded_Sequence<T, MAX>::_deallocate_buffer (void)
 // class TAO_Object_Manager
 // *************************************************************
 
-template <class T, class T_var> TAO_Object_Manager<T,T_var>&
-TAO_Object_Manager<T,T_var>::
-    operator= (const TAO_Object_Manager<T,T_var> &rhs)
+template <typename T, typename T_var, typename T_life> 
+TAO_Object_Manager<T,T_var,T_life> &
+TAO_Object_Manager<T,T_var,T_life>::operator= (
+    const TAO_Object_Manager<T,T_var,T_life> & rhs
+  )
 {
   if (this == &rhs)
     {
@@ -270,8 +272,8 @@ TAO_Object_Manager<T,T_var>::
 
   if (this->release_)
     {
-      T_var::tao_release (*this->ptr_);
-      *this->ptr_ = T_var::tao_duplicate (*rhs.ptr_);
+      T_life::tao_release (*this->ptr_);
+      *this->ptr_ = T_life::tao_duplicate (*rhs.ptr_);
     }
   else
     *this->ptr_ = *rhs.ptr_;
@@ -279,8 +281,9 @@ TAO_Object_Manager<T,T_var>::
   return *this;
 }
 
-template <class T, class T_var>TAO_Object_Manager<T,T_var> &
-TAO_Object_Manager<T,T_var>::operator=(T* p)
+template <typename T, typename T_var, typename T_life>
+TAO_Object_Manager<T,T_var,T_life> &
+TAO_Object_Manager<T,T_var,T_life>::operator= (T * p)
 {
   if (this->release_)
     {
@@ -288,7 +291,7 @@ TAO_Object_Manager<T,T_var>::operator=(T* p)
       // that of a var variable.  Therefore we will not duplicate the
       // user provided pointer before assigning it to the internal
       // variable.
-      T_var::tao_release (*this->ptr_);
+      T_life::tao_release (*this->ptr_);
       *this->ptr_ = p;
     }
   else
@@ -297,8 +300,9 @@ TAO_Object_Manager<T,T_var>::operator=(T* p)
   return *this;
 }
 
-template <class T, class T_var>TAO_Object_Manager<T,T_var> &
-TAO_Object_Manager<T,T_var>::operator=(const T_var &p)
+template <typename T, typename T_var, typename T_life>
+TAO_Object_Manager<T,T_var,T_life> &
+TAO_Object_Manager<T,T_var,T_life>::operator= (const T_var & p)
 {
   if (this->release_)
     {
@@ -306,8 +310,8 @@ TAO_Object_Manager<T,T_var>::operator=(const T_var &p)
       // that of a var variable.  Therefore we duplicate p's
       // pointer before assigning it to the internal
       // variable.
-      T_var::tao_release (*this->ptr_);
-      *this->ptr_ = T_var::tao_duplicate (p.in ());
+      T_life::tao_release (*this->ptr_);
+      *this->ptr_ = T_life::tao_duplicate (p.in ());
     }
   else
     {
@@ -317,19 +321,21 @@ TAO_Object_Manager<T,T_var>::operator=(const T_var &p)
   return *this;
 }
 
-template <class T, class T_var> T *&
-TAO_Object_Manager<T,T_var>::out (void)
+template <typename T, typename T_var, typename T_life> 
+T *&
+TAO_Object_Manager<T,T_var,T_life>::out (void)
 {
-  T_var::tao_release (*this->ptr_);
-  *this->ptr_ = T_var::tao_nil ();
+  T_life::tao_release (*this->ptr_);
+  *this->ptr_ = T_life::tao_nil ();
   return *this->ptr_;
 }
 
-template <class T, class T_var> T *
-TAO_Object_Manager<T,T_var>::_retn (void)
+template <typename T, typename T_var, typename T_life> 
+T *
+TAO_Object_Manager<T,T_var,T_life>::_retn (void)
 {
   T *temp = *this->ptr_;
-  *this->ptr_ = T_var::tao_nil ();
+  *this->ptr_ = T_life::tao_nil ();
   return temp;
 }
 
@@ -574,33 +580,37 @@ TAO_Abstract_Manager<T,T_var>::operator= (const T_var &p)
 // *************************************************************
 
 // constructor for unbounded seq
-template <class T, class T_var>
-TAO_Unbounded_Object_Sequence<T,T_var>::TAO_Unbounded_Object_Sequence (
-    CORBA::ULong maximum
-  )
+template <typename T, typename T_var, typename T_life, typename T_cast>
+TAO_Unbounded_Object_Sequence<T,T_var,T_life,T_cast>::
+TAO_Unbounded_Object_Sequence (CORBA::ULong maximum)
   : TAO_Unbounded_Base_Sequence (
-        maximum,
-         TAO_Unbounded_Object_Sequence<T,T_var>::allocbuf (maximum)
+         maximum,
+         TAO_Unbounded_Object_Sequence<T,T_var,T_life,T_cast>::allocbuf (
+             maximum
+           )
        )
 {
 }
 
-template <class T, class T_var>
-TAO_Unbounded_Object_Sequence<T,T_var>::TAO_Unbounded_Object_Sequence (
-    const TAO_Unbounded_Object_Sequence<T,T_var> &rhs
+template <typename T, typename T_var, typename T_life, typename T_cast>
+TAO_Unbounded_Object_Sequence<T,T_var,T_life,T_cast>::
+TAO_Unbounded_Object_Sequence (
+    const TAO_Unbounded_Object_Sequence<T,T_var,T_life,T_cast> &rhs
   )
   : TAO_Unbounded_Base_Sequence (rhs)
 {
   if (rhs.buffer_ != 0)
     {
       T **tmp1 =
-        TAO_Unbounded_Object_Sequence<T,T_var>::allocbuf (this->maximum_);
+        TAO_Unbounded_Object_Sequence<T,T_var,T_life,T_cast>::allocbuf (
+            this->maximum_
+          );
       T ** const tmp2 =
         ACE_reinterpret_cast (T ** ACE_CAST_CONST, rhs.buffer_);
 
       for (CORBA::ULong i = 0; i < rhs.length_; ++i)
         {
-          tmp1[i] = T_var::tao_duplicate (tmp2[i]);
+          tmp1[i] = T_life::tao_duplicate (tmp2[i]);
         }
 
       this->buffer_ = tmp1;
@@ -611,16 +621,18 @@ TAO_Unbounded_Object_Sequence<T,T_var>::TAO_Unbounded_Object_Sequence (
     }
 }
 
-template<class T, class T_var>
-TAO_Unbounded_Object_Sequence<T,T_var>::~TAO_Unbounded_Object_Sequence (void)
+template<typename T, typename T_var, typename T_life, typename T_cast>
+TAO_Unbounded_Object_Sequence<T,T_var,T_life,T_cast>::
+~TAO_Unbounded_Object_Sequence (void)
 {
   this->_deallocate_buffer ();
 }
 
 // Assignment operator.
-template <class T, class T_var>TAO_Unbounded_Object_Sequence<T,T_var>&
-TAO_Unbounded_Object_Sequence<T,T_var>::
-operator= (const TAO_Unbounded_Object_Sequence<T,T_var> &rhs)
+template <typename T, typename T_var, typename T_life, typename T_cast>
+TAO_Unbounded_Object_Sequence<T,T_var,T_life,T_cast>&
+TAO_Unbounded_Object_Sequence<T,T_var,T_life,T_cast>::
+operator= (const TAO_Unbounded_Object_Sequence<T,T_var,T_life,T_cast> &rhs)
 {
   if (this == &rhs)
     {
@@ -634,15 +646,17 @@ operator= (const TAO_Unbounded_Object_Sequence<T,T_var> &rhs)
 
       for (CORBA::ULong i = 0; i < this->length_; ++i)
         {
-          T_var::tao_release (tmp[i]);
-          tmp[i] = T_var::tao_nil ();
+          T_life::tao_release (tmp[i]);
+          tmp[i] = T_life::tao_nil ();
         }
 
       if (this->maximum_ < rhs.maximum_)
         {
-          TAO_Unbounded_Object_Sequence<T,T_var>::freebuf (tmp);
+          TAO_Unbounded_Object_Sequence<T,T_var,T_life,T_cast>::freebuf (tmp);
           this->buffer_ =
-            TAO_Unbounded_Object_Sequence<T,T_var>::allocbuf (rhs.maximum_);
+            TAO_Unbounded_Object_Sequence<T,T_var,T_life,T_cast>::allocbuf (
+                rhs.maximum_
+              );
         }
     }
   else
@@ -654,7 +668,9 @@ operator= (const TAO_Unbounded_Object_Sequence<T,T_var> &rhs)
       else
         {
           this->buffer_ =
-            TAO_Unbounded_Object_Sequence<T,T_var>::allocbuf (rhs.maximum_);
+            TAO_Unbounded_Object_Sequence<T,T_var,T_life,T_cast>::allocbuf (
+                rhs.maximum_
+              );
         }
     }
 
@@ -665,14 +681,16 @@ operator= (const TAO_Unbounded_Object_Sequence<T,T_var> &rhs)
 
   for (CORBA::ULong i = 0; i < rhs.length_; ++i)
     {
-      tmp1[i] = T_var::tao_duplicate (tmp2[i]);
+      tmp1[i] = T_life::tao_duplicate (tmp2[i]);
     }
 
   return *this;
 }
 
-template <class T, class T_var> T **
-TAO_Unbounded_Object_Sequence<T,T_var>::allocbuf (CORBA::ULong nelems)
+template <typename T, typename T_var, typename T_life, typename T_cast> T **
+TAO_Unbounded_Object_Sequence<T,T_var,T_life,T_cast>::allocbuf (
+    CORBA::ULong nelems
+  )
 {
   T **buf = 0;
   ACE_NEW_RETURN (buf, 
@@ -681,14 +699,14 @@ TAO_Unbounded_Object_Sequence<T,T_var>::allocbuf (CORBA::ULong nelems)
 
   for (CORBA::ULong i = 0; i < nelems; i++)
     {
-      buf[i] = T_var::tao_nil ();
+      buf[i] = T_life::tao_nil ();
     }
 
   return buf;
 }
 
-template <class T, class T_var> void
-TAO_Unbounded_Object_Sequence<T,T_var>::freebuf (T **buffer)
+template <typename T, typename T_var, typename T_life, typename T_cast> void
+TAO_Unbounded_Object_Sequence<T,T_var,T_life,T_cast>::freebuf (T* *buffer)
 {
   if (buffer == 0)
     {
@@ -710,10 +728,26 @@ TAO_Unbounded_Object_Sequence<T,T_var>::freebuf (T **buffer)
   delete [] buffer;
 }
 
-template<class T, class T_var> void
-TAO_Unbounded_Object_Sequence<T,T_var>::_allocate_buffer (CORBA::ULong length)
+template<typename T, typename T_var, typename T_life, typename T_cast> 
+void
+TAO_Unbounded_Object_Sequence<T,T_var,T_life,T_cast>::_tao_any_destructor (
+    void * _tao_void_pointer
+  )
 {
-  T **tmp = TAO_Unbounded_Object_Sequence<T,T_var>::allocbuf (length);
+  typedef TAO_Unbounded_Object_Sequence<T,T_var,T_life,T_cast> THIS_SEQ_TYPE;
+  THIS_SEQ_TYPE *tmp = ACE_static_cast (THIS_SEQ_TYPE *,
+                                        _tao_void_pointer);
+  delete tmp;
+}
+
+template<typename T, typename T_var, typename T_life, typename T_cast> 
+void
+TAO_Unbounded_Object_Sequence<T,T_var,T_life,T_cast>::_allocate_buffer (
+    CORBA::ULong length
+  )
+{
+  T **tmp = 
+    TAO_Unbounded_Object_Sequence<T,T_var,T_life,T_cast>::allocbuf (length);
 
   if (this->buffer_ != 0)
     {
@@ -728,7 +762,7 @@ TAO_Unbounded_Object_Sequence<T,T_var>::_allocate_buffer (CORBA::ULong length)
         // the old instances.
         if (!this->release_)
           {
-            tmp[i] = T_var::tao_duplicate (old[i]);
+            tmp[i] = T_life::tao_duplicate (old[i]);
           }
         else
           {
@@ -744,8 +778,11 @@ TAO_Unbounded_Object_Sequence<T,T_var>::_allocate_buffer (CORBA::ULong length)
   this->buffer_ = tmp;
 }
 
-template<class T, class T_var> void
-TAO_Unbounded_Object_Sequence<T,T_var>::_deallocate_buffer (void)
+template<typename T, typename T_var, typename T_life, typename T_cast> 
+void
+TAO_Unbounded_Object_Sequence<T,T_var,T_life,T_cast>::_deallocate_buffer (
+    void
+  )
 {
   if (this->buffer_ == 0 || this->release_ == 0)
     {
@@ -757,70 +794,90 @@ TAO_Unbounded_Object_Sequence<T,T_var>::_deallocate_buffer (void)
 
   for (CORBA::ULong i = 0; i < this->length_; ++i)
     {
-      T_var::tao_release (tmp[i]);
-      tmp[i] = T_var::tao_nil ();
+      T_life::tao_release (tmp[i]);
+      tmp[i] = T_life::tao_nil ();
     }
 
-  TAO_Unbounded_Object_Sequence<T,T_var>::freebuf (tmp);
+  TAO_Unbounded_Object_Sequence<T,T_var,T_life,T_cast>::freebuf (tmp);
   this->buffer_ = 0;
 }
 
-template<class T, class T_var> void
-TAO_Unbounded_Object_Sequence<T,T_var>::_shrink_buffer (CORBA::ULong nl,
-                                                        CORBA::ULong ol)
+template<typename T, typename T_var, typename T_life, typename T_cast> 
+void
+TAO_Unbounded_Object_Sequence<T,T_var,T_life,T_cast>::_shrink_buffer (
+    CORBA::ULong nl,
+    CORBA::ULong ol
+  )
 {
-  T **tmp = ACE_static_cast (T**, this->buffer_);
+  T **tmp = ACE_static_cast (T **, 
+                             this->buffer_);
 
   for (CORBA::ULong i = nl; i < ol; ++i)
     {
-      T_var::tao_release (tmp[i]);
-      tmp[i] = T_var::tao_nil ();
+      T_life::tao_release (tmp[i]);
+      tmp[i] = T_life::tao_nil ();
     }
 }
 
-template <class T, class T_var> void
-TAO_Unbounded_Object_Sequence<T,T_var>::_downcast (void* target,
-                                                   CORBA::Object* src
-                                                   ACE_ENV_ARG_DECL)
+template <typename T, typename T_var, typename T_life, typename T_cast> 
+void
+TAO_Unbounded_Object_Sequence<T,T_var,T_life,T_cast>::_downcast (
+    void * target,
+    CORBA::Object_ptr src
+    ACE_ENV_ARG_DECL
+  )
 {
-  T **tmp = ACE_static_cast (T**, 
+  T **tmp = ACE_static_cast (T **, 
                              target);
 
-  *tmp = T_var::tao_narrow (src 
-                            ACE_ENV_ARG_PARAMETER);
+  *tmp = T_cast::tao_narrow (src 
+                             ACE_ENV_ARG_PARAMETER);
 
   ACE_CHECK;
 }
 
-template <class T, class T_var> CORBA::Object*
-TAO_Unbounded_Object_Sequence<T,T_var>::_upcast (void* src) const
+template <typename T, typename T_var, typename T_life, typename T_cast> 
+CORBA::Object_ptr
+TAO_Unbounded_Object_Sequence<T,T_var,T_life,T_cast>::_upcast (
+    void * src
+  ) const
 {
-  return T_var::tao_upcast (src);
+  return T_cast::tao_upcast (src);
 }
 
 // *************************************************************
 // Operations for class TAO_Bounded_Object_Sequence
 // *************************************************************
 
-template <class T, class T_var, size_t MAX>
-TAO_Bounded_Object_Sequence<T, T_var,MAX>::TAO_Bounded_Object_Sequence (void)
+template <typename T, 
+          typename T_var, 
+          typename T_life, 
+          typename T_cast, 
+          size_t MAX>
+TAO_Bounded_Object_Sequence<T,T_var,T_life,T_cast,MAX>::
+TAO_Bounded_Object_Sequence (void)
   : TAO_Bounded_Base_Sequence (
         MAX,
-        TAO_Bounded_Object_Sequence<T, T_var,MAX>::allocbuf (MAX)
+        TAO_Bounded_Object_Sequence<T,T_var,T_life,T_cast,MAX>::allocbuf (MAX)
       )
 {
 }
 
-template <class T, class T_var, size_t MAX>
-TAO_Bounded_Object_Sequence<T, T_var,MAX>::TAO_Bounded_Object_Sequence (
-    const TAO_Bounded_Object_Sequence<T, T_var,MAX> &rhs
+template <typename T, 
+          typename T_var, 
+          typename T_life, 
+          typename T_cast, 
+          size_t MAX>
+TAO_Bounded_Object_Sequence<T,T_var,T_life,T_cast,MAX>::
+TAO_Bounded_Object_Sequence (
+    const TAO_Bounded_Object_Sequence<T,T_var,T_life,T_cast,MAX> &rhs
   )
   : TAO_Bounded_Base_Sequence (rhs)
 {
   if (rhs.buffer_ != 0)
     {
       T **tmp1 =
-        TAO_Bounded_Object_Sequence<T, T_var,MAX>::allocbuf (MAX);
+        TAO_Bounded_Object_Sequence<T,T_var,T_life,T_cast,MAX>::allocbuf (MAX);
 
       T ** const tmp2 =
         ACE_reinterpret_cast (T** ACE_CAST_CONST, 
@@ -828,7 +885,7 @@ TAO_Bounded_Object_Sequence<T, T_var,MAX>::TAO_Bounded_Object_Sequence (
 
       for (CORBA::ULong i = 0; i < rhs.length_; i++)
         {
-          tmp1[i] = T_var::tao_duplicate (tmp2[i]);
+          tmp1[i] = T_life::tao_duplicate (tmp2[i]);
         }
 
       this->buffer_ = tmp1;
@@ -839,9 +896,14 @@ TAO_Bounded_Object_Sequence<T, T_var,MAX>::TAO_Bounded_Object_Sequence (
     }
 }
 
-template <class T, class T_var, size_t MAX> TAO_Bounded_Object_Sequence<T, T_var,MAX>&
-TAO_Bounded_Object_Sequence<T, T_var,MAX>::operator= (
-    const TAO_Bounded_Object_Sequence<T,T_var, MAX> &rhs
+template <typename T, 
+          typename T_var, 
+          typename T_life, 
+          typename T_cast, 
+          size_t MAX>
+TAO_Bounded_Object_Sequence<T, T_var,T_life,T_cast,MAX> &
+TAO_Bounded_Object_Sequence<T,T_var,T_life,T_cast,MAX>::operator= (
+    const TAO_Bounded_Object_Sequence<T,T_var,T_life,T_cast,MAX> &rhs
   )
 {
   if (this == &rhs)
@@ -851,13 +913,13 @@ TAO_Bounded_Object_Sequence<T, T_var,MAX>::operator= (
 
   if (this->release_)
     {
-      T **tmp = ACE_reinterpret_cast (T **, 
+      T* *tmp = ACE_reinterpret_cast (T* *, 
                                       this->buffer_);
 
       for (CORBA::ULong i = 0; i < this->length_; ++i)
         {
-          T_var::tao_release (tmp[i]);
-          tmp[i] = T_var::tao_nil ();
+          T_life::tao_release (tmp[i]);
+          tmp[i] = T_life::tao_nil ();
         }
       // No need to reallocate the buffer since it is always of size
       // MAX
@@ -871,70 +933,98 @@ TAO_Bounded_Object_Sequence<T, T_var,MAX>::operator= (
       else
         {
           this->buffer_ =
-            TAO_Bounded_Object_Sequence<T,T_var,MAX>::allocbuf (rhs.maximum_);
+            TAO_Bounded_Object_Sequence<T,T_var,T_life,T_cast,MAX>::allocbuf (
+                rhs.maximum_
+              );
         }
     }
 
   TAO_Bounded_Base_Sequence::operator= (rhs);
 
-  T **tmp1 = ACE_reinterpret_cast (T **, 
+  T* *tmp1 = ACE_reinterpret_cast (T* *, 
                                    this->buffer_);
-  T ** const tmp2 = ACE_reinterpret_cast (T ** ACE_CAST_CONST, 
+  T* * const tmp2 = ACE_reinterpret_cast (T* * ACE_CAST_CONST, 
                                           rhs.buffer_);
 
   for (CORBA::ULong i=0; i < rhs.length_; ++i)
     {
-      tmp1[i] = T_var::tao_duplicate (tmp2[i]);
+      tmp1[i] = T_life::tao_duplicate (tmp2[i]);
     }
 
   return *this;
 }
 
-template <class T, class T_var, size_t MAX> T **
-TAO_Bounded_Object_Sequence<T, T_var,MAX>::allocbuf (CORBA::ULong)
+template <typename T, 
+          typename T_var, 
+          typename T_life, 
+          typename T_cast, 
+          size_t MAX>
+T* *
+TAO_Bounded_Object_Sequence<T,T_var,T_life,T_cast,MAX>::allocbuf (
+    CORBA::ULong
+  )
 {
-  T **buf = 0;
+  T* *buf = 0;
   ACE_NEW_RETURN (buf, 
                   T*[MAX], 
                   0);
 
   for (CORBA::ULong i = 0; i < MAX; i++)
     {
-      buf[i] = T_var::tao_nil ();
+      buf[i] = T_life::tao_nil ();
     }
 
   return buf;
 }
 
-template <class T, class T_var, size_t MAX> void
-TAO_Bounded_Object_Sequence<T, T_var,MAX>::freebuf (T **buffer)
+template <typename T, 
+          typename T_var, 
+          typename T_life, 
+          typename T_cast, 
+          size_t MAX>
+void
+TAO_Bounded_Object_Sequence<T,T_var,T_life,T_cast,MAX>::freebuf (T* *buffer)
 {
   // How much do we deallocate? Easy! allocbuf() always creates MAX
   // elements and initialize them to T::_nil().  So we can be
   // complaint and call CORBA::release() on each one.
   for (CORBA::ULong i = 0; i < MAX; ++i)
     {
-      if (buffer[i] != T_var::tao_nil ())
+      if (buffer[i] != T_life::tao_nil ())
         {
-          T_var::tao_release (buffer[i]);
-          buffer[i] = T_var::tao_nil ();
+          T_life::tao_release (buffer[i]);
+          buffer[i] = T_life::tao_nil ();
         }
     }
 
   delete [] buffer;
 }
 
-template<class T, class T_var, size_t MAX> void
-TAO_Bounded_Object_Sequence<T, T_var,MAX>::_allocate_buffer (CORBA::ULong length)
+template<typename T, 
+          typename T_var, 
+          typename T_life, 
+          typename T_cast, 
+          size_t MAX>
+void
+TAO_Bounded_Object_Sequence<T,T_var,T_life,T_cast,MAX>::_allocate_buffer (
+    CORBA::ULong length
+  )
 {
   // For this class memory is never reallocated so the implementation
   // is *really* simple.
   this->buffer_ =
-    TAO_Bounded_Object_Sequence<T, T_var,MAX>::allocbuf (length);
+    TAO_Bounded_Object_Sequence<T,T_var,T_life,T_cast,MAX>::allocbuf (length);
 }
 
-template<class T, class T_var, size_t MAX> void
-TAO_Bounded_Object_Sequence<T,T_var,MAX>::_deallocate_buffer (void)
+template<typename T, 
+          typename T_var, 
+          typename T_life, 
+          typename T_cast, 
+          size_t MAX>
+void
+TAO_Bounded_Object_Sequence<T,T_var,T_life,T_cast,MAX>::_deallocate_buffer (
+    void
+  )
 {
   if (this->release_ == 0)
     {
@@ -943,41 +1033,60 @@ TAO_Bounded_Object_Sequence<T,T_var,MAX>::_deallocate_buffer (void)
 
   T **tmp = ACE_reinterpret_cast (T **, 
                                   this->buffer_);
-  TAO_Bounded_Object_Sequence<T,T_var,MAX>::freebuf (tmp);
+  TAO_Bounded_Object_Sequence<T,T_var,T_life,T_cast,MAX>::freebuf (tmp);
   this->buffer_ = 0;
 }
 
-template<class T, class T_var, size_t MAX> void
-TAO_Bounded_Object_Sequence<T,T_var, MAX>::_shrink_buffer (CORBA::ULong nl,
+template<typename T, 
+          typename T_var, 
+          typename T_life, 
+          typename T_cast, 
+          size_t MAX>
+void
+TAO_Bounded_Object_Sequence<T,T_var,T_life,T_cast,MAX>::_shrink_buffer (CORBA::ULong nl,
                                                            CORBA::ULong ol)
 {
-  T **tmp = ACE_reinterpret_cast (T **, this->buffer_);
+  T* *tmp = ACE_reinterpret_cast (T* *, this->buffer_);
 
   for (CORBA::ULong i = nl; i < ol; ++i)
     {
-      T_var::tao_release (tmp[i]);
-      tmp[i] = T_var::tao_nil ();
+      T_life::tao_release (tmp[i]);
+      tmp[i] = T_life::tao_nil ();
     }
 }
 
-template <class T, class T_var, size_t MAX> void
-TAO_Bounded_Object_Sequence<T, T_var,MAX>::_downcast (void* target,
-                                                      CORBA::Object* src
-                                                      ACE_ENV_ARG_DECL)
+template <typename T, 
+          typename T_var, 
+          typename T_life, 
+          typename T_cast, 
+          size_t MAX>
+void
+TAO_Bounded_Object_Sequence<T,T_var,T_life,T_cast,MAX>::_downcast (
+    void * target,
+    CORBA::Object_ptr src
+    ACE_ENV_ARG_DECL
+  )
 {
-  T **tmp = ACE_static_cast (T**, 
+  T* *tmp = ACE_static_cast (T* *, 
                              target);
 
-  *tmp = T_var::tao_narrow (src 
-                            ACE_ENV_ARG_PARAMETER);
+  *tmp = T_cast::tao_narrow (src 
+                             ACE_ENV_ARG_PARAMETER);
 
   ACE_CHECK;
 }
 
-template <class T, class T_var, size_t MAX> CORBA::Object*
-TAO_Bounded_Object_Sequence<T, T_var,MAX>::_upcast (void* src) const
+template <typename T, 
+          typename T_var, 
+          typename T_life, 
+          typename T_cast, 
+          size_t MAX> 
+CORBA::Object_ptr
+TAO_Bounded_Object_Sequence<T,T_var,T_life,T_cast,MAX>::_upcast (
+    void * src
+  ) const
 {
-  return T_var::tao_upcast (src);
+  return T_cast::tao_upcast (src);
 }
 
 // *************************************************************
diff --git a/TAO/tao/Sequence_T.h b/TAO/tao/Sequence_T.h
index 8999044018c..ad3407281e9 100644
--- a/TAO/tao/Sequence_T.h
+++ b/TAO/tao/Sequence_T.h
@@ -241,10 +241,18 @@ public:
 
 // *************************************************************
 
-template<class T,class T_var> class TAO_Unbounded_Object_Sequence;
+template<typename T,
+         typename T_var, 
+         typename T_life, 
+         typename T_cast> 
+  class TAO_Unbounded_Object_Sequence;
 template<class T,class T_var> class TAO_Unbounded_Pseudo_Sequence;
 template<class T,class T_var> class TAO_Unbounded_Valuetype_Sequence;
-template<class T, class T_var, size_t MAX> class TAO_Bounded_Object_Sequence;
+template<typename T, 
+         typename T_var, 
+         typename T_life, 
+         typename T_cast, 
+         size_t MAX> class TAO_Bounded_Object_Sequence;
 template<class T, class T_var, size_t MAX> class TAO_Bounded_Valuetype_Sequence;
 template<size_t MAX> class TAO_Bounded_String_Sequence;
 
@@ -274,10 +282,9 @@ template<size_t MAX> class TAO_Bounded_String_Sequence;
    * says that T_ptr *could* map to a type different to T* in the
    * particular case of TAO it does map to <T*>.
    */
-template<class T, class T_var>
+template<typename T, typename T_var, typename T_life>
 class TAO_Object_Manager
 {
-  friend class TAO_Unbounded_Object_Sequence<T,T_var>;
 public:
   // @@ Use partial template specialization here to give access only
   // to the right kind of sequence.
@@ -291,7 +298,7 @@ public:
    *   release value on the <rhs>.
    *   + In any case a new reference to the same object is created.
    */
-  TAO_Object_Manager (const TAO_Object_Manager<T,T_var> &rhs);
+  TAO_Object_Manager (const TAO_Object_Manager<T,T_var,T_life> &rhs);
 
   /**
    * Constructor from address of an element, it should be private and
@@ -309,13 +316,15 @@ public:
    * @@ TODO what happens if rhs.release_ is true an this->relase_ is
    * false?
    */
-  TAO_Object_Manager<T,T_var> &operator= (const TAO_Object_Manager<T,T_var> &rhs);
+  TAO_Object_Manager<T,T_var,T_life> &operator= (
+      const TAO_Object_Manager<T,T_var,T_life> &rhs
+    );
 
   /// Assignment from T *.
-  TAO_Object_Manager<T,T_var> &operator= (T *);
+  TAO_Object_Manager<T,T_var,T_life> &operator= (T *);
 
-  /// Assignment from T_var.
-  TAO_Object_Manager<T,T_var> &operator= (const T_var &);
+  /// Assignment from T_life.
+  TAO_Object_Manager<T,T_var,T_life> &operator= (const T_var &);
 
   /// Return pointer.
   T * operator-> (void) const;
@@ -331,21 +340,21 @@ public:
   operator const T_var() const;
 
   /// for in parameter.
-  T *in (void) const;
+  T * in (void) const;
 
   /// for inout parameter.
-  T *&inout (void);
+  T *& inout (void);
 
   /// for out parameter.
-  T *&out (void);
+  T *& out (void);
 
   /// for return type
-  T *_retn (void);
+  T * _retn (void);
 
 private:
   /// data member, notice that it is a pointer, to implement the
   /// reference behavior for assignment.
-  T **ptr_;
+  T* * ptr_;
 
   /// release flag based on parent's flag
   CORBA::Boolean release_;
@@ -618,7 +627,7 @@ private:
  * class, in charge of handling the object lifetime, examples are
  * pseudo objects, object references, valuetypes, and strings.
  */
-template<class T,class T_var>
+template<typename T, typename T_var, typename T_life, typename T_cast>
 class TAO_Unbounded_Object_Sequence : public TAO_Unbounded_Base_Sequence
 {
 
@@ -670,7 +679,7 @@ public:
   TAO_Unbounded_Object_Sequence (CORBA::ULong maximum,
                                  CORBA::ULong length,
                                  T* *data,
-                                 CORBA::Boolean release=0);
+                                 CORBA::Boolean release = 0);
 
   /**
    * The copy constructor performs a deep copy from the existing
@@ -683,7 +692,9 @@ public:
    * elements (items zero through length-1), and sets the release
    * flag to TRUE.
    */
-  TAO_Unbounded_Object_Sequence(const TAO_Unbounded_Object_Sequence<T,T_var> &);
+  TAO_Unbounded_Object_Sequence (
+      const TAO_Unbounded_Object_Sequence<T,T_var,T_life,T_cast> &
+    );
 
   /// The destructor releases all object reference memebrs and frees
   /// all string members.
@@ -707,10 +718,14 @@ public:
    * the reallocation is performed. After reallocation, the release
    * flag is always set to TRUE.
    */
-  TAO_Unbounded_Object_Sequence<T,T_var> &operator= (const TAO_Unbounded_Object_Sequence <T,T_var> &);
+  TAO_Unbounded_Object_Sequence<T,T_var,T_life,T_cast> &operator= (
+      const TAO_Unbounded_Object_Sequence <T,T_var,T_life,T_cast> &
+    );
 
   /// read-write accessor
-  TAO_Object_Manager<T,T_var> operator[] (CORBA::ULong slot) const;
+  TAO_Object_Manager<T,T_var,T_life> operator[] (
+      CORBA::ULong slot
+    ) const;
 
   /**
    * The allocbuf function allocates a vector of T elements that can
@@ -723,7 +738,7 @@ public:
    * reason cannot allocate the requested vector. Vectors allocated by
    * allocbuf should be freed using the freebuf function.
    */
-  static T **allocbuf (CORBA::ULong);
+  static T* *allocbuf (CORBA::ULong);
 
   /**
    * The freebuf function ensures that the destructor for each element
@@ -732,7 +747,10 @@ public:
    * reference elements, which are freed using release(). The freebuf
    * function will ignore null pointers passed to it.
    */
-  static void freebuf (T **);
+  static void freebuf (T* *);
+
+  static void _tao_any_destructor (void *);
+  typedef T_var _var_type;
 
   // The Base_Sequence functions, please see "tao/Sequence.h"
   /// No default to workaround egcs problem with templates and
@@ -741,10 +759,10 @@ public:
   virtual void _deallocate_buffer (void);
   virtual void _shrink_buffer (CORBA::ULong new_length,
                                CORBA::ULong old_length);
-  virtual void _downcast (void* target,
-                          CORBA::Object* src
+  virtual void _downcast (void * target,
+                          CORBA::Object_ptr src
                           ACE_ENV_ARG_DECL_WITH_DEFAULTS);
-  virtual CORBA::Object* _upcast (void* src) const;
+  virtual CORBA::Object_ptr _upcast (void * src) const;
 };
 
 // *************************************************************
@@ -756,7 +774,11 @@ public:
  *
  * Please see the documentation for the unbounded case.
  */
-template<class T, class T_var, size_t MAX>
+template<typename T, 
+         typename T_var, 
+         typename T_life, 
+         typename T_cast, 
+         size_t MAX>
 class TAO_Bounded_Object_Sequence : public TAO_Bounded_Base_Sequence
 {
 public:
@@ -774,26 +796,32 @@ public:
   /// Constructor from data.
   TAO_Bounded_Object_Sequence (CORBA::ULong length,
                                T* *value,
-                               CORBA::Boolean release=0);
+                               CORBA::Boolean release = 0);
 
   /// Copy constructor.
-  TAO_Bounded_Object_Sequence (const TAO_Bounded_Object_Sequence<T,T_var,MAX> &);
+  TAO_Bounded_Object_Sequence (
+      const TAO_Bounded_Object_Sequence<T,T_var,T_life,T_cast,MAX> &
+    );
 
   /// destructor
   ~TAO_Bounded_Object_Sequence (void);
 
   /// Assignment from another Bounded sequence.
-  TAO_Bounded_Object_Sequence &operator= (const TAO_Bounded_Object_Sequence<T,T_var,MAX> &);
+  TAO_Bounded_Object_Sequence &operator= (
+      const TAO_Bounded_Object_Sequence<T,T_var,T_life,T_cast,MAX> &
+    );
 
   /// Read-write accessor.
-  TAO_Object_Manager<T,T_var> operator[] (CORBA::ULong slot) const;
+  TAO_Object_Manager<T,T_var,T_life> operator[] (
+      CORBA::ULong slot
+    ) const;
 
   /// Allocate storage for a sequence..
-  static T **allocbuf (CORBA::ULong length);
+  static T* *allocbuf (CORBA::ULong length);
 
   /// Free a buffer allocated by allocbuf() and release each element on
   /// it.
-  static void freebuf (T **buffer);
+  static void freebuf (T* *buffer);
 
   // The Base_Sequence functions, please see "tao/sequence.h"
   /// No default to workaround egcs problem with templates and
@@ -802,10 +830,10 @@ public:
   virtual void _deallocate_buffer (void);
   virtual void _shrink_buffer (CORBA::ULong new_length,
                                CORBA::ULong old_length);
-  virtual void _downcast (void* target,
-                          CORBA::Object* src
+  virtual void _downcast (void * target,
+                          CORBA::Object_ptr src
                           ACE_ENV_ARG_DECL_WITH_DEFAULTS);
-  virtual CORBA::Object* _upcast (void* src) const;
+  virtual CORBA::Object_ptr _upcast (void * src) const;
 };
 
 // *************************************************************
diff --git a/TAO/tao/Sequence_T.i b/TAO/tao/Sequence_T.i
index 18e213d2323..89fcba5cdd4 100644
--- a/TAO/tao/Sequence_T.i
+++ b/TAO/tao/Sequence_T.i
@@ -212,57 +212,71 @@ TAO_Bounded_Sequence<T, MAX>::operator[] (CORBA::ULong i) const
 // Inline operations for class TAO_Object_Manager<T>
 // *************************************************************
 
-template <class T, class T_var> ACE_INLINE
-TAO_Object_Manager<T,T_var>::~TAO_Object_Manager (void)
+template <typename T, typename T_var, typename T_life> 
+ACE_INLINE
+TAO_Object_Manager<T,T_var,T_life>::~TAO_Object_Manager (void)
 {
 }
 
-template <class T, class T_var> ACE_INLINE
-TAO_Object_Manager<T,T_var>::TAO_Object_Manager (const TAO_Object_Manager<T,T_var> &rhs)
+template <typename T, typename T_var, typename T_life> 
+ACE_INLINE
+TAO_Object_Manager<T,T_var,T_life>::TAO_Object_Manager (
+    const TAO_Object_Manager<T,T_var,T_life> &rhs
+  )
   : ptr_ (rhs.ptr_),
     release_ (rhs.release_)
 {
 }
 
-template <class T, class T_var> ACE_INLINE
-TAO_Object_Manager<T,T_var>::TAO_Object_Manager(T** buffer, CORBA::Boolean release)
+template <typename T, typename T_var, typename T_life> 
+ACE_INLINE
+TAO_Object_Manager<T,T_var,T_life>::TAO_Object_Manager (
+    T** buffer, 
+    CORBA::Boolean release
+  )
   : ptr_ (buffer),
     release_ (release)
 {
 }
 
-template <class T, class T_var> ACE_INLINE T *
-TAO_Object_Manager<T,T_var>::operator-> (void) const
+template <typename T, typename T_var, typename T_life> 
+ACE_INLINE T *
+TAO_Object_Manager<T,T_var,T_life>::operator-> (void) const
 {
   return *this->ptr_;
 }
 
-template <class T, class T_var> ACE_INLINE
-TAO_Object_Manager<T,T_var>::operator const T_var () const
+template <typename T, typename T_var, typename T_life> 
+ACE_INLINE
+TAO_Object_Manager<T,T_var,T_life>::operator const T_var () const
 {
-  return T_var::tao_duplicate (*this->ptr_);
+  return T_life::tao_duplicate (*this->ptr_);
 }
 
-template <class T, class T_var> ACE_INLINE
-TAO_Object_Manager<T,T_var>::operator const T* () const // cast
+template <typename T, typename T_var, typename T_life> 
+ACE_INLINE
+TAO_Object_Manager<T,T_var,T_life>::operator const T *() const
 {
   return *this->ptr_;
 }
 
-template <class T, class T_var> ACE_INLINE
-TAO_Object_Manager<T,T_var>::operator T* &() // cast
+template <typename T, typename T_var, typename T_life> 
+ACE_INLINE
+TAO_Object_Manager<T,T_var,T_life>::operator T *&() // cast
 {
   return *this->ptr_;
 }
 
-template <class T, class T_var> ACE_INLINE T *
-TAO_Object_Manager<T,T_var>::in (void) const
+template <typename T, typename T_var, typename T_life> 
+ACE_INLINE T *
+TAO_Object_Manager<T,T_var,T_life>::in (void) const
 {
   return *this->ptr_;
 }
 
-template <class T, class T_var> ACE_INLINE T *&
-TAO_Object_Manager<T,T_var>::inout (void)
+template <typename T, typename T_var, typename T_life> 
+ACE_INLINE T *&
+TAO_Object_Manager<T,T_var,T_life>::inout (void)
 {
   return *this->ptr_;
 }
@@ -511,13 +525,16 @@ TAO_Abstract_Manager<T,T_var>::_retn (void)
 // *************************************************************
 
 //default constructor
-template <class T, class T_var> ACE_INLINE
-TAO_Unbounded_Object_Sequence<T,T_var>::TAO_Unbounded_Object_Sequence (void)
+template <typename T, typename T_var, typename T_life, typename T_cast> 
+ACE_INLINE
+TAO_Unbounded_Object_Sequence<T,T_var,T_life,T_cast>::
+TAO_Unbounded_Object_Sequence (void)
 {
 }
 
-template <class T, class T_var> ACE_INLINE
-TAO_Unbounded_Object_Sequence<T,T_var>::
+template <typename T, typename T_var, typename T_life, typename T_cast> 
+ACE_INLINE
+TAO_Unbounded_Object_Sequence<T,T_var,T_life,T_cast>::
 TAO_Unbounded_Object_Sequence (CORBA::ULong maximum,
                                CORBA::ULong length,
                                T* *value,
@@ -526,39 +543,66 @@ TAO_Unbounded_Object_Sequence (CORBA::ULong maximum,
 {
 }
 
-template <class T, class T_var> ACE_INLINE TAO_Object_Manager<T,T_var>
-TAO_Unbounded_Object_Sequence<T,T_var>::operator[] (CORBA::ULong slot) const
+template <typename T, typename T_var, typename T_life, typename T_cast> 
+ACE_INLINE 
+TAO_Object_Manager<T,T_var,T_life>
+TAO_Unbounded_Object_Sequence<T,T_var,T_life,T_cast>::operator[] (
+    CORBA::ULong slot
+  ) const
 {
   ACE_ASSERT (slot < this->maximum_);
-  T ** const tmp = ACE_reinterpret_cast (T ** ACE_CAST_CONST, this->buffer_);
-  return TAO_Object_Manager<T,T_var> (tmp + slot, this->release_);
+  T* * const tmp = ACE_reinterpret_cast (T* * ACE_CAST_CONST, 
+					 this->buffer_);
+  return 
+    TAO_Object_Manager<T,T_var,T_life> (tmp + slot, this->release_);
 }
 
 // *************************************************************
 // class TAO_Bounded_Object_Sequence
 // *************************************************************
 
-template<class T, class T_var, size_t MAX> ACE_INLINE
-TAO_Bounded_Object_Sequence<T,T_var,MAX>::~TAO_Bounded_Object_Sequence (void)
+template <typename T, 
+	  typename T_var, 
+	  typename T_life, 
+	  typename T_cast, 
+	  size_t MAX> 
+ACE_INLINE
+TAO_Bounded_Object_Sequence<T,T_var,T_life,T_cast,MAX>::
+~TAO_Bounded_Object_Sequence (void)
 {
   this->_deallocate_buffer ();
 }
 
-template <class T, class T_var, size_t MAX> ACE_INLINE
-TAO_Bounded_Object_Sequence<T,T_var,MAX>::
+template <typename T, 
+	  typename T_var, 
+	  typename T_life, 
+	  typename T_cast, 
+  	  size_t MAX> 
+ACE_INLINE
+TAO_Bounded_Object_Sequence<T,T_var,T_life,T_cast,MAX>::
 TAO_Bounded_Object_Sequence (CORBA::ULong length,
-                             T **value,
-                             CORBA::Boolean release)
+		             T* *value,
+		             CORBA::Boolean release)
   : TAO_Bounded_Base_Sequence (MAX, length, value, release)
 {
 }
 
-template <class T, class T_var, size_t MAX> ACE_INLINE TAO_Object_Manager<T,T_var>
-TAO_Bounded_Object_Sequence<T, T_var,MAX>::operator[] (CORBA::ULong slot) const
+template <typename T, 
+	  typename T_var, 
+  	  typename T_life, 
+	  typename T_cast, 
+	  size_t MAX> 
+ACE_INLINE 
+TAO_Object_Manager<T,T_var,T_life>
+TAO_Bounded_Object_Sequence<T, T_var,T_life,T_cast,MAX>::operator[] (
+    CORBA::ULong slot
+  ) const
 {
   ACE_ASSERT (slot < this->maximum_);
-  T **const tmp = ACE_reinterpret_cast (T ** ACE_CAST_CONST, this->buffer_);
-  return TAO_Object_Manager<T,T_var> (tmp + slot, this->release_);
+  T* *const tmp = ACE_reinterpret_cast (T* * ACE_CAST_CONST, 
+					this->buffer_);
+  return 
+    TAO_Object_Manager<T,T_var,T_life> (tmp + slot, this->release_ );
 }
 
 // *************************************************************
diff --git a/TAO/tao/corba.h b/TAO/tao/corba.h
index 481e92051fc..fffc366437b 100644
--- a/TAO/tao/corba.h
+++ b/TAO/tao/corba.h
@@ -68,6 +68,9 @@
 #include "tao/Object_KeyC.h"
 #include "tao/ObjectIdListC.h"
 
+#include "tao/Objref_VarOut_T.h"
+#include "tao/Seq_VarOut_T.h"
+
 #include "tao/Remote_Object_Proxy_Impl.h"
 
 #include "tao/StringSeqC.h"