ChangeLogTag: Mon May 3 21:39:09 UTC 2010 Jeff Parsons <j.parsons@vanderbilt.edu>

44 files changed, 4568 insertions, 2212 deletions

diff --git a/modules/TAO/ChangeLog b/modules/TAO/ChangeLog
index bd47898e6cf..c17ac015617 100644
--- a/modules/TAO/ChangeLog
+++ b/modules/TAO/ChangeLog
@@ -1,3 +1,54 @@
+Mon May  3 21:39:09 UTC 2010  Jeff Parsons <j.parsons@vanderbilt.edu>
+
+        * tests/Alt_Mapping/driver.h:
+        * tests/Alt_Mapping/options.h:
+        * tests/Alt_Mapping/ub_string.h:
+        * tests/Alt_Mapping/results.cpp:
+        * tests/Alt_Mapping/alt_mapping_i.cpp:
+        * tests/Alt_Mapping/server.cpp:
+        * tests/Alt_Mapping/results.h:
+        * tests/Alt_Mapping/tests.h:
+        * tests/Alt_Mapping/alt_mapping_i.h:
+        * tests/Alt_Mapping/README:
+        * tests/Alt_Mapping/client.cpp:
+        * tests/Alt_Mapping/helper.cpp:
+        * tests/Alt_Mapping/alt_mapping.idl:
+        * tests/Alt_Mapping/ub_struct_seq.cpp:
+        * tests/Alt_Mapping/client.h:
+        * tests/Alt_Mapping/helper.h:
+        * tests/Alt_Mapping/ub_struct_seq.h:
+        * tests/Alt_Mapping/alt_mapping.mpc:
+        * tests/Alt_Mapping/options.cpp:
+        * tests/Alt_Mapping/driver.cpp:
+        * tests/Alt_Mapping/run_test.pl:
+        * tests/Alt_Mapping/ub_string.cpp:
+
+          New test for alternate C++ mapping support.
+          Currently supports unbounded strings and
+          tests unbounded sequence of simple structs.
+
+        * TAO_IDL/be/be_visitor_arg_traits.cpp:
+        * TAO_IDL/be/be_visitor_argument/arglist.cpp:
+        * TAO_IDL/be/be_visitor_operation/arglist.cpp:
+        * TAO_IDL/be/be_visitor_operation/rettype.cpp:
+        * TAO_IDL/be/be_visitor_operation/operation.cpp:
+        * TAO_IDL/be/be_visitor_operation/operation_ss.cpp:
+        * TAO_IDL/be/be_codegen.cpp:
+        * TAO_IDL/be/be_visitor_sequence/sequence_ch.cpp:
+        * TAO_IDL/be/be_visitor_sequence/cdr_op_cs.cpp:
+        * TAO_IDL/be/be_visitor_sequence/sequence_cs.cpp:
+        * TAO_IDL/be/be_sequence.cpp:
+        * tao/Vector_Argument_T.inl:
+        * tao/AnyTypeCode/Any.cpp:
+        * tao/PortableServer/Vector_SArgument_T.inl:
+        * tao/PortableServer/Vector_SArgument_T.cpp:
+        * tao/PortableServer/Vector_SArgument_T.h:
+        * tao/Vector_Argument_T.h:
+        * tao/Fixed_Size_Argument_T.h:
+
+          More tweaks to fully automate the generation of
+          correct code for the alternate C++ mapping.
+
 Mon Apr 12 19:30:47 UTC 2010  Jeff Parsons <j.parsons@vanderbilt.edu>
 
         * TAO_IDL/be/be_codegen.cpp:
diff --git a/modules/TAO/TAO_IDL/be/be_codegen.cpp b/modules/TAO/TAO_IDL/be/be_codegen.cpp
index d8fbb7daeae..022dfcffa65 100644
--- a/modules/TAO/TAO_IDL/be/be_codegen.cpp
+++ b/modules/TAO/TAO_IDL/be/be_codegen.cpp
@@ -2889,6 +2889,12 @@ TAO_CodeGen::gen_skel_arg_file_includes (TAO_OutStream * stream)
     );
 
   this->gen_cond_file_include (
+      idl_global->seq_seen_ && be_global->alt_mapping (),
+      "tao/PortableServer/Vector_SArgument_T.h",
+      stream
+    );
+
+  this->gen_cond_file_include (
       idl_global->any_arg_seen_,
       "tao/PortableServer/Any_SArg_Traits.h",
       stream
diff --git a/modules/TAO/TAO_IDL/be/be_sequence.cpp b/modules/TAO/TAO_IDL/be/be_sequence.cpp
index bb0d944fc18..c7762428dea 100644
--- a/modules/TAO/TAO_IDL/be/be_sequence.cpp
+++ b/modules/TAO/TAO_IDL/be/be_sequence.cpp
@@ -25,9 +25,10 @@
 #include "be_interface_fwd.h"
 #include "be_predefined_type.h"
 #include "be_field.h"
+#include "be_string.h"
 #include "be_visitor.h"
 #include "be_helper.h"
-#include "be_string.h"
+#include "be_extern.h"
 
 #include "utl_identifier.h"
 #include "idl_defines.h"
@@ -576,6 +577,14 @@ be_sequence::gen_base_class_name (TAO_OutStream *os,
                                   AST_Decl *ctx_scope)
 {
   be_type *elem = be_type::narrow_from_decl (this->base_type ());
+  
+  if (be_global->alt_mapping () && this->unbounded ())
+    {
+      *os << "std::vector<" << elem->nested_type_name (ctx_scope)
+          << ">";
+          
+      return 0;
+    }
 
   // Generate the appropriate base class type.
   switch (this->managed_type ())
diff --git a/modules/TAO/TAO_IDL/be/be_visitor_arg_traits.cpp b/modules/TAO/TAO_IDL/be/be_visitor_arg_traits.cpp
index 57f8ada35bb..d67f71e24a1 100644
--- a/modules/TAO/TAO_IDL/be/be_visitor_arg_traits.cpp
+++ b/modules/TAO/TAO_IDL/be/be_visitor_arg_traits.cpp
@@ -629,25 +629,19 @@ be_visitor_arg_traits::visit_sequence (be_sequence *node)
                        guard_suffix.c_str (),
                        false);
                        
-  bool bounded = (node->max_size ()->ev ()->u.ulval != 0);
-  UTL_ScopedName *sn =
-    (bounded ? alias->name () : bt->name ());
+  bool use_vec = (node->unbounded () && be_global->alt_mapping ());
+  UTL_ScopedName *sn = alias->name ();
   
   *os << be_nl << be_nl
       << "template<>" << be_nl
-      << "class "
-      << this->S_ << "Arg_Traits<"
-      << (bounded ? "" : "std::vector<") << sn
-      << (bounded ? "" : "> ") << ">" << be_idt_nl
+      << "class " << this->S_ << "Arg_Traits<" << sn << ">"
+      << be_idt_nl
       << ": public" << be_idt << be_idt_nl
-      << (bounded ? "Var_Size_" : "Vector_")
+      << (use_vec ? "Vector_" : "Var_Size_")
       << this->S_ << "Arg_Traits_T<"
       << be_idt << be_idt_nl
-      << (bounded ? "" : "std::vector<") << sn
-      << (bounded ? "" : ">") << "," << be_nl
-      << this->insert_policy () << "<"
-      << (bounded ? "" : "std::vector<") << sn
-      << (bounded ? "" : "> ") << ">" << be_uidt_nl
+      << sn << "," << be_nl
+      << this->insert_policy () << "<" << sn << ">" << be_uidt_nl
       << ">" << be_uidt << be_uidt << be_uidt << be_uidt_nl
       << "{" << be_nl
       << "};";
diff --git a/modules/TAO/TAO_IDL/be/be_visitor_argument/arglist.cpp b/modules/TAO/TAO_IDL/be/be_visitor_argument/arglist.cpp
index a4a00079b23..ad51b6816de 100644
--- a/modules/TAO/TAO_IDL/be/be_visitor_argument/arglist.cpp
+++ b/modules/TAO/TAO_IDL/be/be_visitor_argument/arglist.cpp
@@ -297,44 +297,25 @@ int be_visitor_args_arglist::visit_sequence (be_sequence *node)
 
   TAO_OutStream *os = this->ctx_->stream ();
 
-  if (be_global->alt_mapping ())
+  switch (this->direction ())
     {
-      /// Temporarily remove and store the context's 'alias'
-      /// member, if any, so we can work with the sequence's
-      /// element type, and restore the alias value when we're done.
-      be_typedef *td = this->ctx_->alias ();
-      this->ctx_->alias (0);
-    
-      const char *elem_name =
-        this->type_name (node->base_type ());
-
-      switch (this->direction ())
+    case AST_Argument::dir_IN:
+      *os << "const " << this->type_name (node) << " &";
+      break;
+    case AST_Argument::dir_INOUT:
+      *os << this->type_name (node) << " &";
+      break;
+    case AST_Argument::dir_OUT:
+      if (be_global->alt_mapping () && node->unbounded ())
         {
-        case AST_Argument::dir_IN:
-          *os << "const std::vector<" << elem_name << "> &";
-          break;
-        case AST_Argument::dir_INOUT:
-        case AST_Argument::dir_OUT:
-          *os << "std::vector<" << elem_name << "> &";
-          break;
+          *os << this->type_name (node) << " &";
         }
-        
-      this->ctx_->alias (td);
-    }
-  else
-    {
-      switch (this->direction ())
+      else
         {
-        case AST_Argument::dir_IN:
-          *os << "const " << this->type_name (node) << " &";
-          break;
-        case AST_Argument::dir_INOUT:
-          *os << this->type_name (node) << " &";
-          break;
-        case AST_Argument::dir_OUT:
           *os << this->type_name (node, "_out");
-          break;
         }
+        
+      break;
     }
 
   return 0;
diff --git a/modules/TAO/TAO_IDL/be/be_visitor_operation/arglist.cpp b/modules/TAO/TAO_IDL/be/be_visitor_operation/arglist.cpp
index b692a14bb75..9ed77596b7c 100644
--- a/modules/TAO/TAO_IDL/be/be_visitor_operation/arglist.cpp
+++ b/modules/TAO/TAO_IDL/be/be_visitor_operation/arglist.cpp
@@ -18,10 +18,6 @@
 //
 // ============================================================================
 
-ACE_RCSID (be_visitor_operation,
-           arglist,
-           "$Id$")
-
 // ************************************************************
 //   operation visitor  to generate the argument list.
 //   We have separated code generation for this from the 4 main
diff --git a/modules/TAO/TAO_IDL/be/be_visitor_operation/operation.cpp b/modules/TAO/TAO_IDL/be/be_visitor_operation/operation.cpp
index 99cef948b27..3f8a99a4cd0 100644
--- a/modules/TAO/TAO_IDL/be/be_visitor_operation/operation.cpp
+++ b/modules/TAO/TAO_IDL/be/be_visitor_operation/operation.cpp
@@ -449,20 +449,6 @@ be_visitor_operation::gen_arg_template_param_name (AST_Decl *scope,
   if (bt->node_type () == AST_Decl::NT_typedef)
     {
       alias = AST_Typedef::narrow_from_decl (bt);
-      
-      AST_Type *pbt = alias->primitive_base_type ();
-      
-      if (pbt->node_type () == AST_Decl::NT_sequence)
-        {
-          AST_Sequence *seq =
-            AST_Sequence::narrow_from_decl (pbt);
-            
-          AST_Type *elem_type = seq->base_type ();
-          
-          *os << "std::vector<" << elem_type->name () << ">";
-          
-          return;
-        }
     }
 
   AST_Decl::NodeType nt = bt->unaliased_type ()->node_type ();
diff --git a/modules/TAO/TAO_IDL/be/be_visitor_operation/operation_ss.cpp b/modules/TAO/TAO_IDL/be/be_visitor_operation/operation_ss.cpp
index 5b0fe601a71..1b713477c42 100644
--- a/modules/TAO/TAO_IDL/be/be_visitor_operation/operation_ss.cpp
+++ b/modules/TAO/TAO_IDL/be/be_visitor_operation/operation_ss.cpp
@@ -18,11 +18,6 @@
 //
 // ============================================================================
 
-
-ACE_RCSID (be_visitor_operation,
-           operation_ss,
-           "$Id$")
-
 // ************************************************************
 // Operation visitor for server skeletons
 // ************************************************************
diff --git a/modules/TAO/TAO_IDL/be/be_visitor_operation/rettype.cpp b/modules/TAO/TAO_IDL/be/be_visitor_operation/rettype.cpp
index 17c5fbd0784..fdf0eca1c3c 100644
--- a/modules/TAO/TAO_IDL/be/be_visitor_operation/rettype.cpp
+++ b/modules/TAO/TAO_IDL/be/be_visitor_operation/rettype.cpp
@@ -18,11 +18,6 @@
 //
 // ============================================================================
 
-ACE_RCSID (be_visitor_operation, 
-           rettype, 
-           "$Id$")
-
-
 // ****************************************************************************
 // Operation visitor for return types. This generates the mapping for a return
 // type in an operation signature
@@ -136,24 +131,11 @@ be_visitor_operation_rettype::visit_predefined_type (be_predefined_type *node)
 int
 be_visitor_operation_rettype::visit_sequence (be_sequence *node)
 {
-  // We should never directly be here because anonymous
-  // sequence return types are not allowed.
-  if (be_global->alt_mapping ())
-    {
-      /// Temporarily remove and store the context's 'alias'
-      /// member, if any, so we can work with the sequence's
-      /// element type, and restore the alias value when we're done.
-      be_typedef *td = this->ctx_->alias ();
-      this->ctx_->alias (0);
-      
-      *os << "std::vector<" << this->type_name (node->base_type ())
-          << ">";
-          
-      this->ctx_->alias (td);
-    }
-  else
+  *os << "::" << this->type_name (node);
+  
+  if (!be_global->alt_mapping () || !node->unbounded ())
     {
-      *os << "::" << this->type_name (node) << " *";
+      *os << " *";
     }
 
   return 0;
diff --git a/modules/TAO/TAO_IDL/be/be_visitor_sequence/cdr_op_cs.cpp b/modules/TAO/TAO_IDL/be/be_visitor_sequence/cdr_op_cs.cpp
index 2fc8d0f42ce..28b175540b6 100644
--- a/modules/TAO/TAO_IDL/be/be_visitor_sequence/cdr_op_cs.cpp
+++ b/modules/TAO/TAO_IDL/be/be_visitor_sequence/cdr_op_cs.cpp
@@ -111,8 +111,8 @@ be_visitor_sequence_cdr_op_cs::visit_sequence (be_sequence *node)
     {
       *os << "::CORBA::Boolean operator<< (" << be_idt_nl
           << "TAO_OutputCDR &strm," << be_nl
-          << "const std:;vector<" << bt->full_name ()
-          << " &_tao_vector)"
+          << "const std::vector<" << bt->full_name ()
+          << "> &_tao_vector)"
           << be_uidt_nl
           << "{" << be_idt_nl
           << "::CORBA::ULong length = _tao_vector.size ();"
@@ -121,10 +121,10 @@ be_visitor_sequence_cdr_op_cs::visit_sequence (be_sequence *node)
           << "for ( ::CORBA::ULong i = 0UL; i < length; ++i)"
           << be_idt_nl
           << "{" << be_idt_nl
-          << "if (! strm << _tao_vector[i]" << be_idt_nl
+          << "if (! (strm << _tao_vector[i]))" << be_idt_nl
           << "{" << be_idt_nl
           << "return false;" << be_uidt_nl
-          << "}" << be_uidt_nl
+          << "}" << be_uidt << be_uidt_nl
           << "}" << be_uidt_nl << be_nl
           << "return true;" << be_uidt_nl
           << "}" << be_nl << be_nl;
@@ -151,7 +151,7 @@ be_visitor_sequence_cdr_op_cs::visit_sequence (be_sequence *node)
       *os << "::CORBA::Boolean operator>> (" << be_idt_nl
           << "TAO_InputCDR &strm," << be_nl
           << "std::vector<" << bt->full_name ()
-          << " &_tao_vector)" << be_uidt_nl
+          << "> &_tao_vector)" << be_uidt_nl
           << "{" << be_idt_nl
           << "::CORBA::ULong length = 0UL;" << be_nl
           << bt->full_name ();
@@ -162,10 +162,14 @@ be_visitor_sequence_cdr_op_cs::visit_sequence (be_sequence *node)
         }
           
       *os << " tmp;" << be_nl << be_nl
+          << "if (! (strm >> length))" << be_idt_nl
+          << "{" << be_idt_nl
+          << "return false;" << be_uidt_nl
+          << "}" << be_uidt_nl << be_nl
           << "for ( ::CORBA::ULong i = 0UL; i < length; ++i)"
           << be_idt_nl
           << "{" << be_idt_nl
-          << "if (! strm >> tmp)" << be_idt_nl
+          << "if (! (strm >> tmp))" << be_idt_nl
           << "{" << be_idt_nl
           << "return false;" << be_uidt_nl
           << "}" << be_uidt_nl << be_nl
diff --git a/modules/TAO/TAO_IDL/be/be_visitor_sequence/sequence_ch.cpp b/modules/TAO/TAO_IDL/be/be_visitor_sequence/sequence_ch.cpp
index 48460d80859..a5c95838a3a 100644
--- a/modules/TAO/TAO_IDL/be/be_visitor_sequence/sequence_ch.cpp
+++ b/modules/TAO/TAO_IDL/be/be_visitor_sequence/sequence_ch.cpp
@@ -109,16 +109,21 @@ int be_visitor_sequence_ch::visit_sequence (be_sequence *node)
 
   os->gen_ifdef_macro (node->flat_name ());
 
-  if (this->ctx_->tdef () != 0)
+  /// If we are using std::vector, we won't be using _vars
+  /// and _outs. They may get redefined and reinstated later.
+  if (!be_global->alt_mapping () || !node->unbounded ())
     {
-      *os << be_nl << be_nl
-          << "class " << node->local_name () << ";";
-    }
+      if (this->ctx_->tdef () != 0)
+        {
+          *os << be_nl << be_nl
+              << "class " << node->local_name () << ";";
+        }
 
-  if (this->ctx_->tdef () != 0)
-    {
-      this->gen_varout_typedefs (node,
-                                 bt);
+      if (this->ctx_->tdef () != 0)
+        {
+          this->gen_varout_typedefs (node,
+                                     bt);
+        }
     }
 
   *os << be_nl << be_nl
@@ -150,51 +155,73 @@ int be_visitor_sequence_ch::visit_sequence (be_sequence *node)
           << node->local_name () << " ( ::CORBA::ULong max);";
     }
 
-  *os << be_nl
-      << node->local_name () << " (" << be_idt;
-
-  if (node->unbounded ())
+  /// If we are using std::vector, we can't implement this
+  /// constructor.
+  if (!be_global->alt_mapping () || !node->unbounded ())
     {
       *os << be_nl
-          << "::CORBA::ULong max,";
-    }
+          << node->local_name () << " (" << be_idt;
 
-  *os << be_nl
-      << "::CORBA::ULong length," << be_nl;
+      if (node->unbounded ())
+        {
+          *os << be_nl
+              << "::CORBA::ULong max,";
+        }
 
-  // Generate the base type for the buffer.
-  be_visitor_context ctx (*this->ctx_);
-  ctx.state (TAO_CodeGen::TAO_SEQUENCE_BUFFER_TYPE_CH);
-  be_visitor_sequence_buffer_type bt_visitor (&ctx);
+      *os << be_nl
+          << "::CORBA::ULong length," << be_nl;
 
-  if (bt->accept (&bt_visitor) == -1)
-    {
-      ACE_ERROR_RETURN ((LM_ERROR,
-                         "(%N:%l) be_visitor_sequence_ch::"
-                         "visit_sequence - "
-                         "base type visit failed\n"),
-                        -1);
-    }
+      // Generate the base type for the buffer.
+      be_visitor_context ctx (*this->ctx_);
+      ctx.state (TAO_CodeGen::TAO_SEQUENCE_BUFFER_TYPE_CH);
+      be_visitor_sequence_buffer_type bt_visitor (&ctx);
+
+      if (bt->accept (&bt_visitor) == -1)
+        {
+          ACE_ERROR_RETURN ((LM_ERROR,
+                             "(%N:%l) be_visitor_sequence_ch::"
+                             "visit_sequence - "
+                             "buffer type visit failed\n"),
+                            -1);
+        }
 
-  *os << "* buffer, " << be_nl
-      << "::CORBA::Boolean release = false);" << be_uidt_nl;
-  *os << node->local_name () << " (const " << node->local_name ()
+      *os << "* buffer, " << be_nl
+          << "::CORBA::Boolean release = false);" << be_uidt;
+  }
+  
+  *os << be_nl
+      << node->local_name () << " (const " << node->local_name ()
       << " &);" << be_nl;
   *os << "virtual ~" << node->local_name () << " (void);";
 
+  if (be_global->alt_mapping () && node->unbounded ())
+    {
+      *os << be_nl << be_nl
+          << "virtual ::CORBA::ULong length (void) const;"
+          << be_nl
+          << "virtual void length ( ::CORBA::ULong);"
+          << be_nl << be_nl
+          << "virtual ::CORBA::ULong maximum (void) const;";
+    }
+
   if (be_global->any_support () && !node->anonymous ())
     {
       *os << be_nl << be_nl
           << "static void _tao_any_destructor (void *);";
     }
 
-  // Generate the _var_type typedef (only if we are not anonymous).
-  if (this->ctx_->tdef () != 0)
+  /// If we are using std::vector, we can't implement this
+  /// constructor.
+  if (!be_global->alt_mapping () || !node->unbounded ())
     {
-      *os << be_nl << be_nl
-          << "typedef " << node->local_name () << "_var _var_type;"
-          << be_nl
-          << "typedef " << node->local_name () << "_out _out_type;";
+      // Generate the _var_type typedef (only if we are not anonymous).
+      if (this->ctx_->tdef () != 0)
+        {
+          *os << be_nl << be_nl
+              << "typedef " << node->local_name () << "_var _var_type;"
+              << be_nl
+              << "typedef " << node->local_name () << "_out _out_type;";
+        }
     }
 
   // TAO provides extensions for octet sequences, first find out if
@@ -220,8 +247,10 @@ int be_visitor_sequence_ch::visit_sequence (be_sequence *node)
     }
 
   // Now generate the extension...
-  if (predef != 0 && predef->pt () == AST_PredefinedType::PT_octet
-      && node->unbounded ())
+  if (predef != 0
+      && predef->pt () == AST_PredefinedType::PT_octet
+      && node->unbounded ()
+      && !be_global->alt_mapping ())
     {
       *os << be_nl << be_nl
           << "\n\n#if (TAO_NO_COPY_OCTET_SEQUENCES == 1)" << be_nl
diff --git a/modules/TAO/TAO_IDL/be/be_visitor_sequence/sequence_cs.cpp b/modules/TAO/TAO_IDL/be/be_visitor_sequence/sequence_cs.cpp
index c96fb72bab1..e1eba02246b 100644
--- a/modules/TAO/TAO_IDL/be/be_visitor_sequence/sequence_cs.cpp
+++ b/modules/TAO/TAO_IDL/be/be_visitor_sequence/sequence_cs.cpp
@@ -76,9 +76,8 @@ int be_visitor_sequence_cs::visit_sequence (be_sequence *node)
     {
       *os << be_nl << be_nl
           << node->name () << "::" << node->local_name () << " ("
-          << be_idt << be_idt_nl
-          << "::CORBA::ULong max" << be_uidt_nl
-          << ")" << be_nl
+          << be_idt << be_idt << be_idt_nl
+          << "::CORBA::ULong max)" << be_uidt << be_uidt_nl
           << ": " << be_idt;
 
       // Pass it to the base constructor.
@@ -92,69 +91,73 @@ int be_visitor_sequence_cs::visit_sequence (be_sequence *node)
         }
 
 
-      *os << be_nl << "(max)" << be_uidt << be_uidt_nl
+      *os << " (max)" << be_uidt << be_uidt_nl
           << "{}";
     }
 
-  // constructor with the buffer
-  *os << be_nl << be_nl
-      << node->name () << "::" << node->local_name () << " ("
-      << be_idt << be_idt_nl;
-
-  if (node->unbounded ())
+  /// If we are using std::vector, we can't implement this
+  /// constructor.
+  if (!be_global->alt_mapping () || !node->unbounded ())
     {
-      // Unbounded seq takes this extra parameter.
-      *os << "::CORBA::ULong max," << be_nl;
-    }
+      // constructor with the buffer
+      *os << be_nl << be_nl
+          << node->name () << "::" << node->local_name () << " ("
+          << be_idt << be_idt_nl;
 
-  *os << "::CORBA::ULong length," << be_nl;
+      if (node->unbounded ())
+        {
+          // Unbounded seq takes this extra parameter.
+          *os << "::CORBA::ULong max," << be_nl;
+        }
 
-  // generate the base type for the buffer
-  be_visitor_context ctx (*this->ctx_);
-  be_visitor_sequence_buffer_type bt_visitor (&ctx);
+      *os << "::CORBA::ULong length," << be_nl;
 
-  if (bt->accept (&bt_visitor) == -1)
-    {
-      ACE_ERROR_RETURN ((LM_ERROR,
-                         "(%N:%l) be_visitor_sequence_cs::"
-                         "visit_sequence - "
-                         "base type visit failed\n"),
-                        -1);
-    }
+      // generate the base type for the buffer
+      be_visitor_context ctx (*this->ctx_);
+      be_visitor_sequence_buffer_type bt_visitor (&ctx);
 
-  *os << " * buffer," << be_nl
-      << "::CORBA::Boolean release" << be_uidt_nl
-      << ")" << be_uidt_nl
-      << "  : " << be_idt << be_idt;
+      if (bt->accept (&bt_visitor) == -1)
+        {
+          ACE_ERROR_RETURN ((LM_ERROR,
+                             "(%N:%l) be_visitor_sequence_cs::"
+                             "visit_sequence - "
+                             "base type visit failed\n"),
+                            -1);
+        }
 
-  // Pass it to the base constructor.
-  if (node->gen_base_class_name (os, "", this->ctx_->scope ()) == -1)
-    {
-      ACE_ERROR_RETURN ((LM_ERROR,
-                         "(%N:%l) be_visitor_sequence_cs::"
-                         "visit_sequence - "
-                         "codegen for base sequence class\n"),
-                        -1);
-    }
+      *os << " * buffer," << be_nl
+          << "::CORBA::Boolean release" << be_uidt_nl
+          << ")" << be_uidt_nl
+          << "  : " << be_idt << be_idt;
 
-  *os << be_nl << "(";
+      // Pass it to the base constructor.
+      if (node->gen_base_class_name (os, "", this->ctx_->scope ()) == -1)
+        {
+          ACE_ERROR_RETURN ((LM_ERROR,
+                             "(%N:%l) be_visitor_sequence_cs::"
+                             "visit_sequence - "
+                             "codegen for base sequence class\n"),
+                            -1);
+        }
 
-  if (node->unbounded ())
-    {
-      *os << "max, ";
-    }
+      *os << be_nl << "(";
 
-  *os << "length, buffer, release)" << be_uidt << be_uidt_nl
-      << "{}";
+      if (node->unbounded ())
+        {
+          *os << "max, ";
+        }
+
+      *os << "length, buffer, release)" << be_uidt << be_uidt_nl
+          << "{}";
+  }
 
   // Copy constructor.
   *os << be_nl << be_nl
       << node->name () << "::" << node->local_name ()
-      << " (" << be_idt << be_idt_nl
+      << " (" << be_idt << be_idt << be_idt_nl
       << "const " << node->local_name ()
-      << " &seq" << be_uidt_nl
-      << ")" << be_uidt_nl
-      << "  : " << be_idt << be_idt;
+      << " &seq)" << be_uidt << be_uidt_nl
+      << ": " << be_idt;
 
   // Pass it to the base constructor.
   if (node->gen_base_class_name (os, "", this->ctx_->scope ()) == -1)
@@ -166,7 +169,7 @@ int be_visitor_sequence_cs::visit_sequence (be_sequence *node)
                         -1);
     }
 
-  *os << be_nl << "(seq)" << be_uidt << be_uidt_nl
+  *os << " (seq)" << be_uidt << be_uidt_nl
       << "{}";
 
   // Destructor.
@@ -175,14 +178,38 @@ int be_visitor_sequence_cs::visit_sequence (be_sequence *node)
       << " (void)" << be_nl
       << "{}";
 
+  if (be_global->alt_mapping () && node->unbounded ())
+    {
+      *os << be_nl << be_nl
+          << "::CORBA::ULong" << be_nl
+          << node->name () << "::length (void) const" << be_nl
+          << "{" << be_idt_nl
+          << "return this->size ();" << be_uidt_nl
+          << "}";
+          
+      *os << be_nl << be_nl
+          << "void" << be_nl
+          << node->name () << "::length ( ::CORBA::ULong length)"
+          << be_nl
+          << "{" << be_idt_nl
+          << "this->reserve (length);" << be_uidt_nl
+          << "}";
+          
+      *os << be_nl << be_nl
+          << "::CORBA::ULong" << be_nl
+          << node->name () << "::maximum (void) const" << be_nl
+          << "{" << be_idt_nl
+          << "return this->capacity ();" << be_uidt_nl
+          << "}";
+    }
 
   if (be_global->any_support () && !node->anonymous ())
     {
       *os << be_nl << be_nl
           << "void "
-          << node->name () << "::_tao_any_destructor (" << be_idt << be_idt_nl
-          << "void * _tao_void_pointer" << be_uidt_nl
-          << ")" << be_uidt_nl
+          << node->name () << "::_tao_any_destructor ("
+          << be_idt_nl
+          << "void * _tao_void_pointer)" << be_uidt_nl
           << "{" << be_idt_nl
           << node->local_name () << " * _tao_tmp_pointer =" << be_idt_nl
           << "static_cast<" << node->local_name ()
diff --git a/modules/TAO/tao/AnyTypeCode/Any.cpp b/modules/TAO/tao/AnyTypeCode/Any.cpp
index 683ecc585ab..bc967972886 100644
--- a/modules/TAO/tao/AnyTypeCode/Any.cpp
+++ b/modules/TAO/tao/AnyTypeCode/Any.cpp
@@ -517,7 +517,7 @@ operator<<= (CORBA::Any &any, const CORBA::WChar *ws)
 }
 
 ACE_INLINE void
-operator <<= (CORBA::Any &any, std::string & str)
+operator <<= (CORBA::Any &any, const std::string & str)
 {
   any <<= str.c_str ();
 }
diff --git a/modules/TAO/tao/Fixed_Size_Argument_T.h b/modules/TAO/tao/Fixed_Size_Argument_T.h
index 21e51db5f46..2b0ae22c92d 100644
--- a/modules/TAO/tao/Fixed_Size_Argument_T.h
+++ b/modules/TAO/tao/Fixed_Size_Argument_T.h
@@ -10,7 +10,6 @@
  */
 //=============================================================================
 
-
 #ifndef TAO_FIXED_SIZE_ARGUMENT_T_H
 #define TAO_FIXED_SIZE_ARGUMENT_T_H
 
@@ -113,7 +112,6 @@ namespace TAO
     S & arg (void);
 
   private:
-
     S & x_;
   };
 
diff --git a/modules/TAO/tao/PortableServer/Vector_SArgument_T.cpp b/modules/TAO/tao/PortableServer/Vector_SArgument_T.cpp
index 2e1aa182ce4..bcc2053fe83 100644
--- a/modules/TAO/tao/PortableServer/Vector_SArgument_T.cpp
+++ b/modules/TAO/tao/PortableServer/Vector_SArgument_T.cpp
@@ -73,10 +73,7 @@ template<typename S,
 CORBA::Boolean
 TAO::Out_Vector_SArgument_T<S,Insert_Policy>::marshal (TAO_OutputCDR &cdr)
 {
-  if (0 == this->x_.ptr())
-    throw ::CORBA::BAD_PARAM(0, CORBA::COMPLETED_MAYBE);
-
-  return cdr << this->x_.in ();
+  return cdr << this->x_;
 }
 
 #if TAO_HAS_INTERCEPTORS == 1
@@ -87,7 +84,7 @@ void
 TAO::Out_Vector_SArgument_T<S,Insert_Policy>::interceptor_value (
   CORBA::Any *any) const
 {
-  Insert_Policy::any_insert (any, this->x_.in ());
+  Insert_Policy::any_insert (any, this->x_);
 }
 
 #endif /* TAO_HAS_INTERCEPTORS */
@@ -99,7 +96,7 @@ template<typename S,
 CORBA::Boolean
 TAO::Ret_Vector_SArgument_T<S,Insert_Policy>::marshal (TAO_OutputCDR &cdr)
 {
-  return cdr << this->x_.in ();
+  return cdr << this->x_;
 }
 
 #if TAO_HAS_INTERCEPTORS == 1
@@ -110,7 +107,7 @@ void
 TAO::Ret_Vector_SArgument_T<S,Insert_Policy>::interceptor_value (
   CORBA::Any *any) const
 {
-  Insert_Policy::any_insert (any, this->x_.in ());
+  Insert_Policy::any_insert (any, this->x_);
 }
 
 #endif /* TAO_HAS_INTERCEPTORS */
diff --git a/modules/TAO/tao/PortableServer/Vector_SArgument_T.h b/modules/TAO/tao/PortableServer/Vector_SArgument_T.h
index c380c623a22..cf9cabba5d3 100644
--- a/modules/TAO/tao/PortableServer/Vector_SArgument_T.h
+++ b/modules/TAO/tao/PortableServer/Vector_SArgument_T.h
@@ -36,7 +36,6 @@ namespace TAO
   class In_Vector_SArgument_T : public InArgument
   {
   public:
-
     virtual CORBA::Boolean demarshal (TAO_InputCDR &);
 #if TAO_HAS_INTERCEPTORS == 1
     virtual void interceptor_value (CORBA::Any *any) const;
@@ -90,10 +89,10 @@ namespace TAO
 #if TAO_HAS_INTERCEPTORS == 1
     virtual void interceptor_value (CORBA::Any *any) const;
 #endif /* TAO_HAS_INTERCEPTORS == 1 */
-    S *& arg (void);
+    S & arg (void);
 
   private:
-    typename S::_var_type x_;
+    S x_;
   };
 
   /**
@@ -114,10 +113,10 @@ namespace TAO
 #if TAO_HAS_INTERCEPTORS == 1
     virtual void interceptor_value (CORBA::Any *any) const;
 #endif /* TAO_HAS_INTERCEPTORS == 1 */
-    S *& arg (void);
+    S & arg (void);
 
   private:
-    typename S::_var_type x_;
+    S x_;
   };
 
   /**
diff --git a/modules/TAO/tao/PortableServer/Vector_SArgument_T.inl b/modules/TAO/tao/PortableServer/Vector_SArgument_T.inl
index 9ef9986f90b..0f0356302fa 100644
--- a/modules/TAO/tao/PortableServer/Vector_SArgument_T.inl
+++ b/modules/TAO/tao/PortableServer/Vector_SArgument_T.inl
@@ -40,10 +40,10 @@ TAO::Out_Vector_SArgument_T<S,Insert_Policy>::Out_Vector_SArgument_T (void)
 
 template<typename S,
          class Insert_Policy>
-S *&
+S &
 TAO::Out_Vector_SArgument_T<S,Insert_Policy>::arg (void)
 {
-  return this->x_.out ();
+  return this->x_;
 }
 
 // ==========================================================================
@@ -58,10 +58,10 @@ TAO::Ret_Vector_SArgument_T<S,Insert_Policy>::Ret_Vector_SArgument_T (void)
 template<typename S,
          class Insert_Policy>
 ACE_INLINE
-S *&
+S &
 TAO::Ret_Vector_SArgument_T<S,Insert_Policy>::arg (void)
 {
-  return this->x_.out ();
+  return this->x_;
 }
 
 TAO_END_VERSIONED_NAMESPACE_DECL
diff --git a/modules/TAO/tao/Vector_Argument_T.h b/modules/TAO/tao/Vector_Argument_T.h
index 65001064159..cf40240a218 100644
--- a/modules/TAO/tao/Vector_Argument_T.h
+++ b/modules/TAO/tao/Vector_Argument_T.h
@@ -137,13 +137,13 @@ namespace TAO
 #if TAO_HAS_INTERCEPTORS == 1
     virtual void interceptor_value (CORBA::Any *any) const;
 #endif /* TAO_HAS_INTERCEPTORS == 1 */
-    S arg (void);
+    S & arg (void);
 
     S excp (void);
     S retn (void);
 
   protected:
-    typename S x_;
+    S x_;
   };
 
   /**
diff --git a/modules/TAO/tao/Vector_Argument_T.inl b/modules/TAO/tao/Vector_Argument_T.inl
index 32665b63ba1..ad052d1a0db 100644
--- a/modules/TAO/tao/Vector_Argument_T.inl
+++ b/modules/TAO/tao/Vector_Argument_T.inl
@@ -80,7 +80,7 @@ TAO::Ret_Vector_Argument_T<S,Insert_Policy>::Ret_Vector_Argument_T (void)
 template<typename S,
          class Insert_Policy>
 ACE_INLINE
-S
+S &
 TAO::Ret_Vector_Argument_T<S,Insert_Policy>::arg (void)
 {
   return this->x_;
diff --git a/modules/TAO/tests/Alt_Mapping/README b/modules/TAO/tests/Alt_Mapping/README
new file mode 100644
index 00000000000..a1aae3b61a1
--- /dev/null
+++ b/modules/TAO/tests/Alt_Mapping/README
@@ -0,0 +1,77 @@
+// $Id$
+
+// ============================================================================
+// This test covers the use of std::string as an alternate C++  mapping for
+// CORBA strings, and the use of std::vector<T> as an alternate C++ mapping
+// for sequences of type T. The current version of the test uses a struct
+// containing several simple date types - more types of sequences will be
+// added in the future.
+// ============================================================================
+
+This directory contains an application that tests all the parameter
+passing conventions in CORBA for the supported OMG IDL data types.
+
+Type "make" to make the application. The server executable is called
+"server" and the client executable is called "client".
+
+You should have the TAO IDL compiler and the TAO library installed
+before using this application.
+
+The -GA options has been added the IDL compiler command line for this
+test. This option moves the generation of implementations for type
+codes and Any insertion/extraction operators to a separate file with
+the extension *A.cpp. Adding this option tests that it is handled
+correctly for all the various IDL types used in this test.
+
+To run the server, type
+
+   server [arguments to ORB_init] [-d] [-o <ior_output_file>]
+
+          arguments to ORB_init start with the letters -ORB. Please
+          see TAO documentattion on all the supported arguments
+
+          -d for debugging. 
+	  -o <ior_output_file> for outputting the servant IOR to a file.
+
+To run the client, type
+
+   client [arguments to ORB_init] [options for this application]
+
+   Supported options are:
+
+   [-d]                                 debugging
+   [-n loopcount]                       number of times to run the test
+   [-f servant-IOR-file]		            reads the servant-IOR from the
+                                        specified file. 
+   [-k Param_Test-obj-ref-key]          object key of Param_Test object
+   [-i invocation (sii/dii)]            default is static invocation
+                                        interface. To use DII, type
+                                        -i dii
+   [-t data type]
+       Data types supported in this version are:
+
+       ubstring             for unbounded string
+       ub_struct_seq        for sequences of structs
+
+
+	There are 2 options of giving the IOR to the client:
+
+	1. Using the -f option to read the IOR from a file.
+
+	2. Using the -k option to read the IOR from the 	
+	   command line.
+
+run_test.pl:
+-----------
+	There is a perl script in this directory named run_test.pl to
+        test all the types. It starts the server first and then runs
+        the client with the different data type parameters. The
+        arguments it takes are: 
+	
+	      -n num              -- runs the client num times (default is 5)
+        -d                  -- runs each in debug mode
+        -onewin             -- keeps all tests in one window on NT
+        -h                  -- prints this information
+        -t type             -- runs only one type of param test
+        -i (dii|sii)        -- Changes the type of invocation (default is sii)
+                               (as of 5/3/10 DII is not yet supported)
diff --git a/modules/TAO/tests/Alt_Mapping/alt_mapping.idl b/modules/TAO/tests/Alt_Mapping/alt_mapping.idl
new file mode 100644
index 00000000000..bd70a846da0
--- /dev/null
+++ b/modules/TAO/tests/Alt_Mapping/alt_mapping.idl
@@ -0,0 +1,30 @@
+// $Id$
+
+interface Alt_Mapping
+{
+  string test_unbounded_string (in string s1,
+                                inout string s2,
+                                out string s3);
+
+  struct Fixed_Struct
+  {
+    long l;
+    char c;
+    short s;
+    octet o;
+    float f;
+    boolean b;
+    double d;
+  };
+
+
+  typedef sequence<Fixed_Struct> StructSeq;
+  StructSeq test_struct_sequence (in StructSeq s1,
+                                  inout StructSeq s2,
+                                  out StructSeq s3);
+
+  void shutdown ();
+  // Shutdown the server: this is useful to check for memory leaks,
+  // performance results and in general to verify that orderly
+  // shutdown is possible.
+};
diff --git a/modules/TAO/tests/Alt_Mapping/alt_mapping.mpc b/modules/TAO/tests/Alt_Mapping/alt_mapping.mpc
new file mode 100644
index 00000000000..302f66953ee
--- /dev/null
+++ b/modules/TAO/tests/Alt_Mapping/alt_mapping.mpc
@@ -0,0 +1,70 @@
+// -*- MPC -*-
+// $Id$
+
+project(*idl): taoidldefaults {
+  IDL_Files {
+    idlflags -= -Sa -St
+    idlflags += -Gstl
+    alt_mapping.idl
+  }
+  custom_only = 1
+}
+
+project(*Server): taoserver, codeset, avoids_minimum_corba, avoids_corba_e_compact, avoids_corba_e_micro {
+  after  += *idl
+  
+  IDL_Files {
+  }
+
+  Source_Files {
+    alt_mappingS.cpp
+    alt_mappingC.cpp
+    alt_mapping_i.cpp
+    server.cpp
+  }
+  
+  Header_Files {
+    alt_mappingS.h
+    alt_mappingC.h
+    alt_mapping_i.h
+  }
+  
+  Inline_Files {
+    alt_mappingS.inl
+    alt_mappingC.inl
+  }
+}
+
+project(*Client): taoserver, codeset, avoids_minimum_corba, avoids_ace_for_tao {
+  exename = client
+  after  += *idl
+
+  IDL_Files {
+  }
+
+  Source_Files {
+    alt_mappingC.cpp
+    client.cpp
+    driver.cpp
+    helper.cpp
+    options.cpp
+    results.cpp
+    ub_string.cpp
+    ub_struct_seq.cpp
+  }
+  
+  Header_Files {
+    alt_mappingC.h
+    driver.h
+    helper.h
+    options.h
+    results.h
+    ub_string.h
+    ub_struct_seq.h
+  }
+  
+  Inline_Files {
+    alt_mappingC.inl
+  }
+}
+
diff --git a/modules/TAO/tests/Alt_Mapping/alt_mapping_i.cpp b/modules/TAO/tests/Alt_Mapping/alt_mapping_i.cpp
new file mode 100644
index 00000000000..f9392cbfda5
--- /dev/null
+++ b/modules/TAO/tests/Alt_Mapping/alt_mapping_i.cpp
@@ -0,0 +1,63 @@
+// $Id$
+
+// ============================================================================
+//
+// = FILENAME
+//    alt_mapping_i.cpp
+//
+// = AUTHOR
+//    Jeff Parsons
+//
+// ============================================================================
+
+#include "alt_mapping_i.h"
+
+#include "tao/debug.h"
+#include "ace/OS_NS_stdio.h"
+#include "ace/OS_NS_wchar.h"
+#include "ace/OS_NS_string.h"
+
+Alt_Mapping_i::Alt_Mapping_i (CORBA::ORB_ptr orb)
+  : orb_ (CORBA::ORB::_duplicate (orb))
+{
+}
+
+Alt_Mapping_i::~Alt_Mapping_i (void)
+{
+}
+
+// test unbounded strings. For return and out types, we return duplicates of
+// the in string. For the inout, we append the same string to itself and send
+// it back
+std::string
+Alt_Mapping_i::test_unbounded_string (const std::string s1,
+                                      std::string &s2,
+                                      std::string &s3)
+{
+  std::string retstr = s1;
+  s3 = s1;
+  s2 = s1 + s1;
+  return retstr;
+}
+
+// test for struct sequences
+Alt_Mapping::StructSeq
+Alt_Mapping_i::test_struct_sequence (
+  const Alt_Mapping::StructSeq & s1,
+  Alt_Mapping::StructSeq & s2,
+  Alt_Mapping::StructSeq & s3)
+{
+  // We copy the "in" sequences into all the inout, out and return sequences.
+
+  // now copy all elements of s1 into the others using the assignment operator
+  s2 = s1;
+  s3 = s1;
+  return s1;
+}
+
+void
+Alt_Mapping_i::shutdown (void)
+{
+  this->orb_->shutdown ();
+}
+
diff --git a/modules/TAO/tests/Alt_Mapping/alt_mapping_i.h b/modules/TAO/tests/Alt_Mapping/alt_mapping_i.h
new file mode 100644
index 00000000000..5360f329137
--- /dev/null
+++ b/modules/TAO/tests/Alt_Mapping/alt_mapping_i.h
@@ -0,0 +1,45 @@
+// $Id$
+
+// ============================================================================
+//
+// = FILENAME
+//    alt_mapping_i.h
+//
+// = AUTHOR
+//    Jeff Parsons
+//
+// ============================================================================
+
+#ifndef ALT_MAPPING_I_H
+#define ALT_MAPPING_I_H
+
+#include "alt_mappingS.h"
+
+class Alt_Mapping_i : public POA_Alt_Mapping
+{
+  // = TITLE
+  //    Alt_Mapping_i
+  // = DESCRIPTION
+  //    Implementation of the Alt_Mapping_i test suite.
+public:
+  Alt_Mapping_i (CORBA::ORB_ptr orb);
+
+  ~Alt_Mapping_i (void);
+
+  virtual std::string
+  test_unbounded_string (const std::string s1,
+                         std::string &s2,
+                         std::string &s3);
+
+  virtual Alt_Mapping::StructSeq test_struct_sequence (
+    const Alt_Mapping::StructSeq & s1,
+    Alt_Mapping::StructSeq & s2,
+    Alt_Mapping::StructSeq & s3);
+      
+  void shutdown (void);
+
+private:
+  CORBA::ORB_var orb_;
+};
+
+#endif /* ALT_MAPPING_I_H */
diff --git a/modules/TAO/tests/Alt_Mapping/client.cpp b/modules/TAO/tests/Alt_Mapping/client.cpp
new file mode 100644
index 00000000000..ff7cfae34e7
--- /dev/null
+++ b/modules/TAO/tests/Alt_Mapping/client.cpp
@@ -0,0 +1,152 @@
+// $Id$
+
+// ============================================================================
+//
+// = FILENAME
+//    client.cpp
+//
+// = DESCRIPTION
+//    This file contains the implementation of the client-side of the
+//    Alt_Mapping application.
+//
+// = AUTHORS
+//      Jeff Parsons
+//
+// ============================================================================
+
+#ifndef CLIENT_CPP
+#define CLIENT_CPP
+
+#include "options.h"
+#include "results.h"
+#include "client.h"
+
+// Constructor.p
+template <class T>
+Alt_Mapping_Client<T>::Alt_Mapping_Client (CORBA::ORB_ptr orb,
+                                           Alt_Mapping_ptr objref,
+                                           T *t)
+  : orb_ (orb),
+    alt_mapping_test_ (objref),
+    test_object_ (t)
+{
+}
+
+// destructor
+template <class T>
+Alt_Mapping_Client<T>::~Alt_Mapping_Client (void)
+{
+  delete this->test_object_;
+}
+
+// All the individual tests.
+template <class T> int
+Alt_Mapping_Client<T>::run_sii_test (void)
+{
+  CORBA::ULong i = 0;  // loop index
+  Options *opt = OPTIONS::instance (); // get the options
+  const char *opname = this->test_object_->opname (); // operation
+
+  if (opt->debug ())
+    ACE_DEBUG ((LM_DEBUG,
+                "********** %s SII *********\n",
+                opname));
+
+  // Initialize call count and error count.
+  this->results_.call_count (0);
+  this->results_.error_count (0);
+  this->results_.iterations (opt->loop_count ());
+
+  // Declare the Env
+  // Initialize parameters for the test.
+  int check = this->test_object_->init_parameters (this->alt_mapping_test_);
+
+  if (check == -1)
+    {
+      ACE_ERROR_RETURN ((LM_ERROR,
+                         "(%N:%l) client.cpp - run_sii_test:"
+                         "init_parameters failed for opname - %s",
+                         opname),
+                        -1);
+    }
+
+
+  // Make the calls in a loop.
+  for (i = 0; i < opt->loop_count (); i++)
+    {
+      try
+        {
+          this->results_.call_count (this->results_.call_count () + 1);
+          if (opt->debug ())
+            {
+              ACE_DEBUG ((LM_DEBUG, "\n****** Before call values *****\n"));
+              this->test_object_->print_values ();
+            }
+
+          // start the timing
+          this->results_.start_timer ();
+
+          // make the call
+          this->test_object_->run_sii_test (this->alt_mapping_test_);
+
+          // stop the timer.
+          this->results_.stop_timer ();
+
+          // now check if the values returned are as expected
+          if (opt->debug ())
+            {
+              ACE_DEBUG ((LM_DEBUG, "\n****** After call values *****\n"));
+              this->test_object_->print_values ();
+            }
+        }
+      catch (const CORBA::Exception& ex)
+        {
+
+          this->results_.error_count (this->results_.error_count () + 1);
+          ex._tao_print_exception (opname);
+          ACE_ERROR ((LM_ERROR,
+                      "(%N:%l) client.cpp - run_sii_test:"
+                      "run_sii_test exception in iteration %d",
+                      i));
+          goto loop_around;
+
+        }
+
+      if (!this->test_object_->check_validity ())
+        {
+          this->results_.error_count (this->results_.error_count () + 1);
+          ACE_ERROR ((LM_ERROR,
+                      "(%N:%l) client.cpp - run_sii_test: "
+                      "Invalid results in iteration %d\n",
+                      i));
+          continue;
+        }
+      // reset parameters for the test.
+      if (this->test_object_->reset_parameters () == -1)
+        ACE_ERROR_RETURN ((LM_ERROR,
+                           "(%N:%l) client.cpp - run_sii_test:"
+                           "init_parameters failed for opname - %s",
+                           opname), -1);
+    loop_around: continue;
+    }
+
+  // print statistics
+  this->results_.print_stats ();
+
+  if (this->results_.error_count () != 0)
+    {
+      ACE_DEBUG ((LM_DEBUG,
+                  "********** Error running %s SII *********\n",
+                  opname));
+    }
+  else if (opt->debug ())
+    {
+      ACE_DEBUG ((LM_DEBUG,
+                  "********** Finished running %s SII *********\n",
+                  opname));
+    }
+    
+  return this->results_.error_count ()? -1 : 0;
+}
+
+#endif /* CLIENT_CPP */
diff --git a/modules/TAO/tests/Alt_Mapping/client.h b/modules/TAO/tests/Alt_Mapping/client.h
new file mode 100644
index 00000000000..acdb2a18612
--- /dev/null
+++ b/modules/TAO/tests/Alt_Mapping/client.h
@@ -0,0 +1,74 @@
+// -*- c++ -*-
+// $Id$
+
+// ============================================================================
+//
+// = LIBRARY
+//    TAO/tests/Alt_Mapping_Test
+//
+// = FILENAME
+//    client.h
+//
+// = DESCRIPTION
+//    Header file for the Alt_Mapping_Test client application.
+//
+// = AUTHORS
+//    Aniruddha Gokhale
+//
+// ============================================================================
+
+#ifndef ALT_MAPPING_CLIENT_H
+#define ALT_MAPPING_CLIENT_H
+
+#include "tao/Codeset/Codeset.h"
+#include "alt_mappingC.h"
+#include "results.h"
+
+template <class T>
+class Alt_Mapping_Client
+{
+  // = TITLE
+  //    Alt_Mapping_Client
+  //
+  // = DESCRIPTION
+  //    This class declares an interface to run the example client for
+  //    Alt_Mapping CORBA server.  All the complexity for initializing
+  //    the client is hidden in the class.  Just the run () interface
+  //    is needed. The template class does the specific work of making
+  //    the request of the desired data type
+public:
+  typedef T TEST_OBJECT;
+
+  // = Constructor and destructor.
+  Alt_Mapping_Client (CORBA::ORB_ptr orb,
+                     Alt_Mapping_ptr objref,
+                     T *);
+
+  ~Alt_Mapping_Client (void);
+
+  int run_sii_test (void);
+  // run the SII test
+
+private:
+  CORBA::ORB_ptr orb_;
+  // underlying ORB
+
+  Alt_Mapping_ptr alt_mapping_test_;
+  // alt mapping object reference
+
+  TEST_OBJECT *test_object_;
+  // object doing the actual work
+
+  Results results_;
+  // results
+};
+
+#if defined (ACE_TEMPLATES_REQUIRE_SOURCE)
+#include "client.cpp"
+#endif /* ACE_TEMPLATES_REQUIRE_SOURCE */
+
+#if defined (ACE_TEMPLATES_REQUIRE_PRAGMA)
+#pragma implementation ("client.cpp")
+#endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */
+
+#endif /* ALT_MAPPING_CLIENT_H */
diff --git a/modules/TAO/tests/Alt_Mapping/driver.cpp b/modules/TAO/tests/Alt_Mapping/driver.cpp
new file mode 100644
index 00000000000..1a5c6380d8c
--- /dev/null
+++ b/modules/TAO/tests/Alt_Mapping/driver.cpp
@@ -0,0 +1,171 @@
+// $Id$
+
+// ============================================================================
+//
+// = FILENAME
+//    driver.cpp
+//
+// = DESCRIPTION
+//    Driver program
+//
+// = AUTHORS
+//      Jeff Parsons
+//
+// ============================================================================
+
+#include "client.h"
+#include "driver.h"
+#include "results.h"
+#include "tests.h"
+#include "ace/Get_Opt.h"
+
+// This function runs the test (main program)
+int
+ACE_TMAIN(int argc, ACE_TCHAR *argv[])
+{
+  // get an instance of the driver object
+  Driver drv;
+
+  // initialize the driver
+  if (drv.init (argc, argv) == -1)
+    ACE_ERROR_RETURN ((LM_ERROR,
+                       "(%N:%l) driver.cpp - "
+                       "Driver initialization failed\n"),
+                      -1);
+
+  // run various tests
+  if (drv.run () == -1)
+    ACE_ERROR_RETURN ((LM_ERROR,
+                       "(%N:%l) driver.cpp - "
+                       "tests failed\n"),
+                      -1);
+  return 0;
+}
+
+// constructor
+Driver::Driver (void)
+{
+}
+
+Driver::~Driver (void)
+{
+}
+
+// initialize the driver
+int
+Driver::init (int argc, ACE_TCHAR **argv)
+{
+  // environment to track exceptions
+
+  // retrieve the instance of Options
+  Options *opt = OPTIONS::instance ();
+
+  char exception_string[256];
+
+  try
+    {
+      ACE_OS::strcpy (exception_string, "ORB Initialization");
+
+      // Retrieve the underlying ORB
+      this->orb_ = CORBA::ORB_init (argc,
+                                    argv,
+                                    "internet");
+
+      // Parse command line and verify parameters.
+      if (opt->parse_args (argc, argv) == -1)
+        ACE_ERROR_RETURN ((LM_ERROR,
+                           "(%N:%l) driver.cpp - "
+                           "parse_args failed\n"),
+                          -1);
+      // Retrieve a Param_Test object reference
+      ACE_OS::strcpy (exception_string,"ORB::string_to_object() failed.");
+
+      CORBA::Object_var temp =
+        this->orb_->string_to_object (opt->param_test_ior ());
+
+
+      if (CORBA::is_nil (temp.in()))
+        ACE_ERROR_RETURN ((LM_ERROR,
+                           "ORB::string_to_object() returned null object for IOR <%s>\n",
+                           opt->param_test_ior ()),
+                          -1);
+
+      // Get the object reference
+      ACE_OS::strcpy (exception_string,"Param_Test::_narrow () failed.");
+
+      this->objref_ = Alt_Mapping::_narrow (temp.in());
+
+    }
+  catch (const CORBA::Exception& ex)
+    {
+      ex._tao_print_exception (exception_string);
+      return -1;
+    }
+
+  return 0;
+}
+
+int
+Driver::run (void)
+{
+  // serves as a factory of Param_Client objects. It is also responsible to
+  // start the test
+
+  Options *opt = OPTIONS::instance ();  // get the options object
+  int retstatus = -1;
+
+  switch (opt->test_type ())
+    {
+    case Options::TEST_UB_STRING:
+      {
+        Alt_Mapping_Client<Test_Unbounded_String> *client = new
+          Alt_Mapping_Client<Test_Unbounded_String> (this->orb_.in (),
+                                                    this->objref_.in(),
+                                                    new Test_Unbounded_String);
+        retstatus = client->run_sii_test ();
+        
+        delete client;
+      }
+      break;
+    case Options::TEST_UB_STRUCT_SEQUENCE:
+      {
+        Alt_Mapping_Client<Test_Unbounded_Struct_Sequence> *client = new
+          Alt_Mapping_Client<Test_Unbounded_Struct_Sequence> (
+            this->orb_.in (),
+            this->objref_.in(),
+            new Test_Unbounded_Struct_Sequence);
+                                                   
+        retstatus = client->run_sii_test ();
+        
+        delete client;
+
+        Alt_Mapping_Client<Test_Unbounded_Struct_Sequence> *client2 = new
+          Alt_Mapping_Client<Test_Unbounded_Struct_Sequence>
+          (this->orb_.in (),
+           this->objref_.in(),
+           new Test_Unbounded_Struct_Sequence);
+
+        retstatus = client2->run_sii_test ();
+
+        delete client2;
+      }
+      break;
+    default:
+      break;
+    }
+
+  // Get in a new environment variable
+  try
+    {
+      if (opt->shutdown ())
+        {
+          this->objref_->shutdown ();
+        }
+    }
+  catch (const CORBA::Exception& ex)
+    {
+      ex._tao_print_exception ("during shutdown");
+    }
+
+  return retstatus;
+}
diff --git a/modules/TAO/tests/Alt_Mapping/driver.h b/modules/TAO/tests/Alt_Mapping/driver.h
new file mode 100644
index 00000000000..e3f488c1181
--- /dev/null
+++ b/modules/TAO/tests/Alt_Mapping/driver.h
@@ -0,0 +1,52 @@
+// -*- c++ -*-
+// $Id$
+
+// ============================================================================
+//
+// = LIBRARY
+//    TAO/tests/Param_Test
+//
+// = FILENAME
+//    driver.h
+//
+// = DESCRIPTION
+//    Header file for the driver program. The driver is a singleton.
+//
+// = AUTHORS
+//    Aniruddha Gokhale
+//
+// ============================================================================
+
+#ifndef DRIVER_H
+#define DRIVER_H
+
+#include "options.h"
+#include "Alt_MappingC.h"
+
+class Driver
+{
+  // = TITLE
+  //    Driver
+  //
+  // = DESCRIPTION
+  //    Driver program for the client
+public:
+  // = Constructor and destructor.
+  Driver (void);
+  ~Driver (void);
+
+  int init (int argc, ACE_TCHAR **argv);
+  // Initialize the driver object
+
+  int run (void);
+  // Execute client example code.
+
+private:
+  CORBA::ORB_var orb_;
+  // underlying ORB (we do not own it)
+
+  Alt_Mapping_var objref_;
+  // object reference (we do not own it)
+};
+
+#endif /* !defined */
diff --git a/modules/TAO/tests/Alt_Mapping/helper.cpp b/modules/TAO/tests/Alt_Mapping/helper.cpp
new file mode 100644
index 00000000000..26f38b4ce3a
--- /dev/null
+++ b/modules/TAO/tests/Alt_Mapping/helper.cpp
@@ -0,0 +1,112 @@
+// $Id$
+
+// ============================================================================
+//
+// = FILENAME
+//    helper.cpp
+//
+// = DESCRIPTION
+//    Defines a helper class that can generate values for the parameters used
+//    for the Alt_Mapping example
+//
+// = AUTHORS
+//    Jeff Parsons
+//
+// ============================================================================
+
+#include "helper.h"
+#include "ace/OS_NS_ctype.h"
+
+const CORBA::ULong TEST_BUFSIZE = 128;
+
+Generator::Generator (void)
+{
+}
+
+Generator::~Generator (void)
+{
+}
+
+CORBA::Short
+Generator::gen_short (void)
+{
+  return (CORBA::Short) (ACE_OS::rand () % TEST_BUFSIZE);
+}
+
+CORBA::Long
+Generator::gen_long (void)
+{
+  return ::ACE_OS::rand () % TEST_BUFSIZE;
+}
+
+char *
+Generator::gen_string (void)
+{
+  return gen_string (TEST_BUFSIZE);
+}
+
+char *
+Generator::gen_string (int max_length)
+{
+  CORBA::ULong len = (CORBA::ULong) (::ACE_OS::rand () % max_length);
+  char *buf = CORBA::string_alloc (len);
+  CORBA::ULong i = 0;
+
+  while (i < len)
+    {
+      int c = ACE_OS::rand () % 128;
+      if (ACE_OS::ace_isprint (c) && !ACE_OS::ace_isspace (c))
+        {
+          buf [i] = c;
+          i++;
+        }
+    }
+
+  buf[i] = 0;
+  return buf;
+}
+
+CORBA::WChar *
+Generator::gen_wstring (void)
+{
+  return gen_wstring (TEST_BUFSIZE);
+}
+
+CORBA::WChar *
+Generator::gen_wstring (int max_length)
+{
+  CORBA::ULong len = (CORBA::ULong) (::ACE_OS::rand () % max_length);
+  CORBA::WChar *buf = CORBA::wstring_alloc (len);
+  CORBA::ULong i = 0;
+  CORBA::WChar limit =
+    ACE_OutputCDR::wchar_maxbytes() == 1 ? ACE_OCTET_MAX : ACE_WCHAR_MAX;
+  while (i < len)
+    {
+      CORBA::WChar wc = ACE_OS::rand () % limit;
+      if (wc)
+        {
+          buf[i] = wc;
+          i++;
+        }
+    }
+
+  buf[i] = 0;
+  return buf;
+}
+
+const Alt_Mapping::Fixed_Struct
+Generator::gen_fixed_struct (void)
+{
+  this->fixed_struct_.l = ACE_OS::rand ();
+  this->fixed_struct_.c = ACE_OS::rand () % 128;
+  this->fixed_struct_.s = (CORBA::Short) ACE_OS::rand ();
+  this->fixed_struct_.o = ACE_OS::rand () % 128;
+  this->fixed_struct_.f = (CORBA::Float) (ACE_OS::rand () * 1.0);
+  this->fixed_struct_.b = (CORBA::Boolean) (ACE_OS::rand () % 2);
+  this->fixed_struct_.d = (ACE_OS::rand () * 1.0);
+  return this->fixed_struct_;
+}
+
+#if defined (ACE_HAS_EXPLICIT_STATIC_TEMPLATE_MEMBER_INSTANTIATION)
+template ACE_Singleton<Generator, ACE_Recursive_Thread_Mutex> *ACE_Singleton<Generator, ACE_Recursive_Thread_Mutex>::singleton_;
+#endif /* ACE_HAS_EXPLICIT_STATIC_TEMPLATE_MEMBER_INSTANTIATION */
diff --git a/modules/TAO/tests/Alt_Mapping/helper.h b/modules/TAO/tests/Alt_Mapping/helper.h
new file mode 100644
index 00000000000..3165a376941
--- /dev/null
+++ b/modules/TAO/tests/Alt_Mapping/helper.h
@@ -0,0 +1,47 @@
+// $Id$
+
+// ============================================================================
+//
+// = LIBRARY
+//    TAO/tests/Param_Test
+//
+// = FILENAME
+//    helper.h
+//
+// = DESCRIPTION
+//    Defines a helper class that can generate values for the parameters used
+//    for the Param_Test example
+//
+// = AUTHORS
+//    Aniruddha Gokhale
+//
+// ============================================================================
+
+#ifndef HELPER_H
+#define HELPER_H
+
+#include "alt_mappingC.h"
+#include "ace/Singleton.h"
+
+class Generator
+{
+public:
+  Generator (void);
+
+  ~Generator (void);
+
+  CORBA::Short gen_short (void);
+  CORBA::Long gen_long (void);
+  char* gen_string (void);
+  char* gen_string (int maxlength);
+  CORBA::WChar* gen_wstring (void);
+  CORBA::WChar* gen_wstring (int maxlength);
+  const Alt_Mapping::Fixed_Struct gen_fixed_struct (void);
+  
+ private:
+  Alt_Mapping::Fixed_Struct fixed_struct_;
+};
+
+typedef ACE_Singleton<Generator, TAO_SYNCH_RECURSIVE_MUTEX> GENERATOR;
+
+#endif /* HELPER_H */
diff --git a/modules/TAO/tests/Alt_Mapping/options.cpp b/modules/TAO/tests/Alt_Mapping/options.cpp
new file mode 100644
index 00000000000..66055e12438
--- /dev/null
+++ b/modules/TAO/tests/Alt_Mapping/options.cpp
@@ -0,0 +1,176 @@
+// $Id$
+
+// ============================================================================
+//
+// = LIBRARY
+//    TAO/tests/Param_Test
+//
+// = FILENAME
+//    options.cpp
+//
+// = DESCRIPTION
+//    Options for the Param_Test application
+//
+// = AUTHORS
+//    Jeff Parsonss
+//
+// ============================================================================
+
+#include "options.h"
+#include "tao/debug.h"
+#include "ace/Read_Buffer.h"
+#include "ace/Get_Opt.h"
+#include "ace/OS_NS_string.h"
+#include "ace/OS_NS_fcntl.h"
+#include "ace/Log_Msg.h"
+
+ACE_RCSID (Param_Test,
+           options,
+           "$Id$")
+
+// Constructor.p
+Options::Options (void)
+  : ior_ (CORBA::string_dup ("file://test.ior")),
+    test_type_ (Options::NO_TEST),
+    invoke_type_ (Options::SII),
+    loop_count_ (1),
+    debug_ (0),
+    shutdown_ (0)
+{
+}
+
+Options::~Options (void)
+{
+}
+
+// Parses the command line arguments and returns an error status.
+
+int
+Options::parse_args (int argc, ACE_TCHAR **argv)
+{
+  ACE_Get_Opt get_opts (argc, argv, ACE_TEXT("xdn:f:i:t:k:"));
+  int c;
+  int result;
+
+  while ((c = get_opts ()) != -1)
+    switch (c)
+      {
+      case 'd':  // debug flag
+        TAO_debug_level++;
+        this->debug_ = 1;
+        break;
+
+      case 'x':
+        this->shutdown_ = 1;
+        break;
+
+      case 'n':                 // loop count
+        this->loop_count_ = (CORBA::ULong) ACE_OS::atoi (get_opts.opt_arg ());
+        break;
+
+      case 'f':
+        result = this->read_ior (get_opts.opt_arg ());
+
+        if (result < 0)
+          ACE_ERROR_RETURN ((LM_ERROR,
+                             "Unable to read ior from %s : %p\n",
+                             get_opts.opt_arg ()),
+                            -1);
+
+        break;
+
+     case 'k':
+        this->ior_ = CORBA::string_dup (ACE_TEXT_ALWAYS_CHAR(get_opts.opt_arg ()));
+        break;
+
+      case 'i':  // invocation
+        if (!ACE_OS::strcmp (get_opts.opt_arg (), ACE_TEXT("dii")))
+          this->invoke_type_ = Options::DII;
+        break;
+
+      case 't': // data type
+        if (!ACE_OS::strcmp (get_opts.opt_arg (), ACE_TEXT("ubstring")))
+          this->test_type_ = Options::TEST_UB_STRING;
+        else if (!ACE_OS::strcmp (get_opts.opt_arg (), ACE_TEXT("ub_struct_seq")))
+          this->test_type_ = Options::TEST_UB_STRUCT_SEQUENCE;
+        break;
+
+      case '?':
+      default:
+        ACE_ERROR_RETURN ((LM_ERROR,
+                           "usage:  %s"
+                           " [-d]"
+                           " [-n loopcount]"
+                           " [-f servant-IOR-file]"
+                           " [-i invocation (sii/dii)]"
+                           " [-t data type]"
+                           "\n",
+                           argv [0]),
+                          -1);
+      }
+
+  // Indicates successful parsing of command line.
+  return 0;
+}
+
+// Get the factory IOR from the file created by the server.
+int
+Options::read_ior (ACE_TCHAR *filename)
+{
+  // Open the file for reading.
+  ACE_HANDLE f_handle = ACE_OS::open (filename, 0);
+
+  if (f_handle == ACE_INVALID_HANDLE)
+    ACE_ERROR_RETURN ((LM_ERROR,
+                       "Unable to open %s for writing: %p\n",
+                       filename),
+                      -1);
+  ACE_Read_Buffer ior_buffer (f_handle, true);
+  this->ior_ = ior_buffer.read ();
+
+  if (this->ior_.in () == 0)
+    ACE_ERROR_RETURN ((LM_ERROR,
+                       "Unable to allocate memory to read ior: %p\n"),
+                      -1);
+  return 0;
+}
+
+char const *
+Options::param_test_ior (void) const
+{
+  return this->ior_.in ();
+}
+
+Options::TEST_TYPE
+Options::test_type (void)
+{
+  return this->test_type_;
+}
+
+Options::INVOKE_TYPE
+Options::invoke_type (void)
+{
+  return this->invoke_type_;
+}
+
+CORBA::ULong
+Options::loop_count (void)
+{
+  return this->loop_count_;
+}
+
+CORBA::Boolean
+Options::debug (void) const
+{
+  return this->debug_;
+}
+
+CORBA::Boolean
+Options::shutdown (void) const
+{
+  return this->shutdown_;
+}
+
+#if defined (ACE_HAS_EXPLICIT_STATIC_TEMPLATE_MEMBER_INSTANTIATION)
+template ACE_Singleton<Options, ACE_Recursive_Thread_Mutex> *ACE_Singleton<Options, ACE_Recursive_Thread_Mutex>::singleton_;
+#endif /* ACE_HAS_EXPLICIT_STATIC_TEMPLATE_MEMBER_INSTANTIATION */
diff --git a/modules/TAO/tests/Alt_Mapping/options.h b/modules/TAO/tests/Alt_Mapping/options.h
new file mode 100644
index 00000000000..c01ecc8e9a4
--- /dev/null
+++ b/modules/TAO/tests/Alt_Mapping/options.h
@@ -0,0 +1,101 @@
+// -*- c++ -*-
+// $Id$
+
+// ============================================================================
+//
+// = LIBRARY
+//    TAO/tests/Param_Test
+//
+// = FILENAME
+//    options.h
+//
+// = DESCRIPTION
+//    Options for the Param_Test application
+//
+// = AUTHORS
+//    Aniruddha Gokhale
+//
+// ============================================================================
+
+#ifndef OPTIONS_H
+#define OPTIONS_H
+
+#include "ace/Singleton.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+# pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+#include "tao/Basic_Types.h"
+#include "tao/CORBA_String.h"
+#include "tao/orbconf.h"
+
+class Options
+{
+public:
+  enum TEST_TYPE
+  {
+    NO_TEST,
+    TEST_UB_STRING,
+    TEST_UB_STRUCT_SEQUENCE,
+  };
+
+  enum INVOKE_TYPE
+  {
+    SII,
+    DII
+  };
+
+  Options (void);
+  // constructor
+
+  ~Options (void);
+  // destructor
+
+  int parse_args (int argc, ACE_TCHAR **argv);
+  // Parses the arguments passed on the command line.
+
+  char const * param_test_ior (void) const;
+  // return the IOR for the servant
+
+  TEST_TYPE test_type (void);
+  // what test to run
+
+  INVOKE_TYPE invoke_type (void);
+  // whether to use SII or DII
+
+  CORBA::ULong loop_count (void);
+  // number of times to run the test
+
+  CORBA::Boolean debug (void) const;
+  // whether debug option is on or not
+
+  CORBA::Boolean shutdown (void) const;
+  // If we should request the server to shutdown.
+
+private:
+  int read_ior (ACE_TCHAR *filename);
+  // Function to read the servant IOR from a file.
+
+  CORBA::String_var ior_;
+  // IOR for the servant
+
+  TEST_TYPE test_type_;
+  // what test to run
+
+  INVOKE_TYPE invoke_type_;
+  // whether SII or DII
+
+  CORBA::ULong loop_count_;
+  // Number of times to do the "test_*" operations.
+
+  CORBA::Boolean debug_;
+  // debugging output values
+
+  CORBA::Boolean shutdown_;
+  // server shutdown flag.
+};
+
+typedef ACE_Singleton<Options, TAO_SYNCH_RECURSIVE_MUTEX> OPTIONS;
+
+#endif /* OPTIONS_H */
diff --git a/modules/TAO/tests/Alt_Mapping/results.cpp b/modules/TAO/tests/Alt_Mapping/results.cpp
new file mode 100644
index 00000000000..56d38e2a92e
--- /dev/null
+++ b/modules/TAO/tests/Alt_Mapping/results.cpp
@@ -0,0 +1,149 @@
+// $Id$
+
+// ============================================================================
+//
+// = FILENAME
+//    results.cpp
+//
+// = DESCRIPTION
+//    Printing the results
+//
+// = AUTHORS
+//    Jeff Parsons
+//
+// ============================================================================
+
+#include "results.h"
+#include "tao/debug.h"
+#include "ace/Log_Msg.h"
+
+Results::Results (void)
+{
+}
+
+Results::~Results (void)
+{
+  delete [] this->elapsed_time_;
+}
+
+void
+Results::print_stats (void)
+{
+  double
+    avg_real_time = 0,
+    avg_user_time = 0,
+    avg_system_time = 0,
+    cps; // calls per sec
+
+  CORBA::ULong i;
+
+  if (TAO_debug_level > 0 && this->error_count_ == 0)
+    {
+      //FUZZ: disable check_for_lack_ACE_OS
+      ACE_DEBUG ((LM_DEBUG,
+                  "Iteration\tReal time (msec)\tUser time (msec)"
+                  "\tSystem time (msec)\n\n"));
+      //FUZZ: enable check_for_lack_ACE_OS
+
+      for (i = 0; i < this->call_count_; i++)
+        {
+          this->elapsed_time_[i].real_time *= ACE_ONE_SECOND_IN_MSECS;
+          this->elapsed_time_[i].user_time *= ACE_ONE_SECOND_IN_MSECS;
+          this->elapsed_time_[i].system_time *= ACE_ONE_SECOND_IN_MSECS;
+          avg_real_time += this->elapsed_time_[i].real_time;
+          avg_user_time += this->elapsed_time_[i].user_time;
+          avg_system_time += this->elapsed_time_[i].system_time;
+
+          ACE_DEBUG ((LM_DEBUG,
+                      "%u\t\t%0.06f\t\t%0.06f\t\t%0.06f\n",
+                      i,
+                      (this->elapsed_time_[i].real_time < 0.0?
+                       0.0:this->elapsed_time_[i].real_time),
+                      (this->elapsed_time_[i].user_time < 0.0?
+                       0.0:this->elapsed_time_[i].user_time),
+                      (this->elapsed_time_[i].system_time < 0.0?
+                       0.0:this->elapsed_time_[i].system_time)));
+        } // end of for loop
+
+      // compute average
+      avg_real_time /= this->call_count_;
+      avg_user_time /= this->call_count_;
+      avg_system_time /= this->call_count_;
+      cps = 1000 / (avg_real_time < 0.01 ? 0.01 : avg_real_time);
+
+      ACE_DEBUG ((LM_DEBUG,
+                  "\n*=*=*=*=*= Average *=*=*=*=*=*=\n"
+                  "\treal_time\t= %0.06f ms,\n"
+                  "\tuser_time\t= %0.06f ms,\n"
+                  "\tsystem_time\t= %0.06f ms\n"
+                  "\t%0.00f calls/second\n"
+                  "*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=\n",
+                  (avg_real_time < 0.0? 0.0:avg_real_time),
+                  (avg_user_time < 0.0? 0.0:avg_user_time),
+                  (avg_system_time < 0.0? 0.0:avg_system_time),
+                  (cps < 0.0? 0.0 : cps)));
+
+      ACE_DEBUG ((LM_DEBUG,
+                  "\t%d calls, %d errors\n"
+                  "*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=\n",
+                  this->call_count_,
+                  this->error_count_));
+    }
+  else if (this->error_count_ != 0)
+    {
+      ACE_DEBUG ((LM_DEBUG,
+                  "\tERROR %d faults in %d calls\n"
+                  "*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=\n",
+                  this->error_count_,
+                  this->call_count_));
+    }
+}
+
+void
+Results::print_exception (const char * /* call_name */)
+{
+  //ACE_PRINT_EXCEPTION (call_name);
+}
+
+void
+Results::start_timer (void)
+{
+  this->timer_.start ();
+}
+
+void
+Results::stop_timer (void)
+{
+  this->timer_.stop ();
+  this->timer_.elapsed_time (this->elapsed_time_[this->call_count_-1]);
+}
+
+CORBA::ULong
+Results::call_count (void)
+{
+  return this->call_count_;
+}
+
+void
+Results::call_count (CORBA::ULong c)
+{
+  this->call_count_ = c;
+}
+
+CORBA::ULong
+Results::error_count (void)
+{
+  return this->error_count_;
+}
+
+void
+Results::error_count (CORBA::ULong c)
+{
+  this->error_count_ = c;
+}
+
+void
+Results::iterations (CORBA::ULong iters)
+{
+  this->elapsed_time_ = new ACE_Profile_Timer::ACE_Elapsed_Time [iters];
+}
diff --git a/modules/TAO/tests/Alt_Mapping/results.h b/modules/TAO/tests/Alt_Mapping/results.h
new file mode 100644
index 00000000000..e04e26e5f3c
--- /dev/null
+++ b/modules/TAO/tests/Alt_Mapping/results.h
@@ -0,0 +1,88 @@
+// $Id$
+
+// ============================================================================
+//
+// = LIBRARY
+//    TAO/tests/Param_Test
+//
+// = FILENAME
+//    results.h
+//
+// = DESCRIPTION
+//    Printing the results
+//
+// = AUTHORS
+//    Aniruddha Gokhale
+//
+// ============================================================================
+
+#ifndef RESULTS_H
+#define RESULTS_H
+
+#include "tao/Basic_Types.h"
+
+#include "ace/Profile_Timer.h"
+#include "ace/CORBA_macros.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+# pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+TAO_BEGIN_VERSIONED_NAMESPACE_DECL
+namespace CORBA
+{
+  class Environment;
+}
+TAO_END_VERSIONED_NAMESPACE_DECL
+
+class Results
+{
+public:
+  Results (void);
+  // ctor
+
+  ~Results (void);
+  // destructor
+
+  void print_stats (void);
+  // prints the time stats
+
+  void print_exception (const char *call_name);
+  // print the exception
+
+  void start_timer (void);
+  // start timing
+
+  void stop_timer (void);
+  // stop timing
+
+  CORBA::ULong call_count (void);
+  // return call count
+
+  void call_count (CORBA::ULong);
+  // set the call count
+
+  CORBA::ULong error_count (void);
+  // return the error count
+
+  void error_count (CORBA::ULong);
+  // set error count
+
+  void iterations (CORBA::ULong iters);
+  // set the number of times the test will be run
+
+private:
+  CORBA::ULong call_count_;
+  // # of calls made to functions
+
+  CORBA::ULong error_count_;
+  // # of errors incurred in the lifetime of the application.
+
+  ACE_Profile_Timer timer_;
+  // for timing the test
+
+  ACE_Profile_Timer::ACE_Elapsed_Time *elapsed_time_;
+  // holds the elapsed time for each iteration
+};
+
+#endif /* RESULTS_H */
diff --git a/modules/TAO/tests/Alt_Mapping/run_test.pl b/modules/TAO/tests/Alt_Mapping/run_test.pl
new file mode 100755
index 00000000000..a39ea895ae8
--- /dev/null
+++ b/modules/TAO/tests/Alt_Mapping/run_test.pl
@@ -0,0 +1,119 @@
+eval '(exit $?0)' && eval 'exec perl -S $0 ${1+"$@"}'
+    & eval 'exec perl -S $0 $argv:q'
+    if 0;
+
+# $Id$
+# -*- perl -*-
+
+use lib "$ENV{ACE_ROOT}/bin";
+use PerlACE::TestTarget;
+
+my $server = PerlACE::TestTarget::create_target(1) || die "Create target 1 failed\n";
+my $client = PerlACE::TestTarget::create_target(2) || die "Create target 2 failed\n";
+
+$iorbase = "server.ior";
+my $server_iorfile = $server->LocalFile ($iorbase);
+my $client_iorfile = $client->LocalFile ($iorbase);
+$server->DeleteFile($iorbase);
+$client->DeleteFile($iorbase);
+
+$invocation = "sii";
+$num = 5;
+$debug = "";
+$status = 0;
+
+# Parse the arguments
+
+@types = ("ubstring", "ub_struct_seq");
+
+
+for ($i = 0; $i <= $#ARGV; $i++) {
+    if ($ARGV[$i] eq "-h" || $ARGV[$i] eq "-?") {
+      print "Run_Test Perl script for TAO Param Test\n\n";
+      print "run_test [-n num] [-d] [-onewin] [-h] [-t type] [-i (dii|sii)] [-chorus <target>]\n";
+      print "\n";
+      print "-n num              -- runs the client num times\n";
+      print "-d                  -- runs each in debug mode\n";
+      print "-h                  -- prints this information\n";
+      print "-t type             -- runs only one type of param test\n";
+      print "-i (dii|sii)        -- Changes the type of invocation\n";
+      print "-chorus <target>    -- Run tests on chorus target\n";
+      exit 0;
+    }
+    elsif ($ARGV[$i] eq "-n") {
+      $num = $ARGV[$i + 1];
+      $i++;
+    }
+    elsif ($ARGV[$i] eq "-d") {
+      $debug = $debug." -d";
+    }
+    elsif ($ARGV[$i] eq "-t") {
+      @types = split (',', $ARGV[$i + 1]);
+      $i++;
+    }
+    elsif ($ARGV[$i] eq "-i") {
+      $invocation = $ARGV[$i + 1];
+      $i++;
+    }
+}
+
+$SV = $server->CreateProcess ("server", "$debug -o $server_iorfile");
+$CL = $client->CreateProcess ("client");
+
+foreach $type (@types) {
+    $server->DeleteFile($iorbase); # Ignore errors
+    $client->DeleteFile($iorbase);
+
+    print STDERR "==== Testing $type === wait....\n";
+
+    $server_status = $SV->Spawn ();
+
+    if ($server_status != 0) {
+        print STDERR "ERROR: server returned $server_status\n";
+        $status = 1;
+    } else {
+        if ($server->WaitForFileTimed ($iorbase,
+                                       $server->ProcessStartWaitInterval()) == -1) {
+            print STDERR "ERROR: cannot find file <$server_iorfile>\n";
+            $SV->Kill ();
+            exit 1;
+        }
+
+        if ($server->GetFile ($iorbase) == -1) {
+            print STDERR "ERROR: cannot retrieve file <$server_iorfile>\n";
+            $SV->Kill (); $SV->TimedWait (1);
+            exit 1;
+        }
+        if ($client->PutFile ($iorbase) == -1) {
+            print STDERR "ERROR: cannot set file <$client_iorfile>\n";
+            $SV->Kill (); $SV->TimedWait (1);
+            exit 1;
+        }
+
+        $CL->Arguments ("$debug -f $client_iorfile  -i $invocation -t $type -n $num -x");
+        $client_status = $CL->SpawnWaitKill ($server->ProcessStartWaitInterval() + 45);
+
+        if ($client_status != 0) {
+            print STDERR "ERROR: client returned $client_status\n";
+            $status = 1;
+        }
+
+        $server_status = $SV->WaitKill ($server->ProcessStopWaitInterval());
+
+        if ($server_status != 0) {
+            print STDERR "ERROR: server returned $server_status\n";
+            $status = 1;
+        }
+
+        $server->GetStderrLog();
+    }
+
+    $server->DeleteFile($iorbase);
+    $client->DeleteFile($iorbase);
+
+    print STDERR "==== Test for $type finished ===\n";
+}
+
+$server->DeleteFile($iorbase);
+
+exit $status;
diff --git a/modules/TAO/tests/Alt_Mapping/server.cpp b/modules/TAO/tests/Alt_Mapping/server.cpp
new file mode 100644
index 00000000000..8d86a2403bb
--- /dev/null
+++ b/modules/TAO/tests/Alt_Mapping/server.cpp
@@ -0,0 +1,155 @@
+// $Id$
+
+// ============================================================================
+//
+// = LIBRARY
+//    TAO/tests/Param_Test
+//
+// = FILENAME
+//    server.cpp
+//
+// = AUTHOR
+//    Jeff Parsons
+//
+// ============================================================================
+
+#include "alt_mapping_i.h"
+#include "tao/Codeset/Codeset.h"
+#include "tao/debug.h"
+#include "ace/Get_Opt.h"
+#include "ace/Log_Msg.h"
+#include "ace/OS_NS_stdio.h"
+
+// Parses the command line arguments and returns an error status.
+static FILE *ior_output_file = 0;
+static const ACE_TCHAR *ior_output_filename = ACE_TEXT("test.ior");
+
+static int
+parse_args (int argc, ACE_TCHAR *argv[])
+{
+  ACE_Get_Opt get_opts (argc, argv, ACE_TEXT("do:"));
+  int c;
+
+  while ((c = get_opts ()) != -1)
+    switch (c)
+      {
+      case 'd':  // debug flag
+        TAO_debug_level++;
+        break;
+      case 'o':
+        ior_output_filename = get_opts.opt_arg ();
+        break;
+      case '?':
+      default:
+        ACE_ERROR_RETURN ((LM_ERROR,
+                           "usage:  %s"
+                           " [-d]"
+                           "\n", argv [0]), 1);
+      }
+
+  return 0;  // Indicates successful parsing of command line
+}
+
+// Standard command line parsing utilities used.
+
+int
+ACE_TMAIN(int argc, ACE_TCHAR *argv[])
+{
+  PortableServer::POA_var oa_ptr;
+  Alt_Mapping_i *svnt = 0;
+
+  try
+    {
+      const char *orb_name = "";
+      CORBA::ORB_var orb_ptr =
+        CORBA::ORB_init (argc, argv, orb_name);
+
+      CORBA::Object_var temp; // holder for the myriad of times we get
+                              // an object which we then have to narrow.
+
+      // Get the Root POA
+
+      temp = orb_ptr->resolve_initial_references ("RootPOA");
+
+      if (CORBA::is_nil (temp.in()))
+        ACE_ERROR_RETURN ((LM_ERROR,
+                           "(%P|%t) Unable to get root poa reference.\n"),
+                          1);
+
+      oa_ptr = PortableServer::POA::_narrow (temp.in());
+
+      PortableServer::POAManager_var poa_manager =
+        oa_ptr->the_POAManager ();
+
+      // Parse remaining command line and verify parameters.
+      parse_args (argc, argv);
+
+      // initialize a param_test target object and register it with the object
+      // adapter
+
+      // Create the implementation object
+      ACE_NEW_RETURN (svnt,
+                      Alt_Mapping_i (orb_ptr.in ()),
+                     -1);
+
+      // Register with GoodPOA with a specific name
+      PortableServer::ObjectId_var id =
+        PortableServer::string_to_ObjectId ("alt_mapping");
+      oa_ptr->activate_object_with_id (id.in (),
+                                       svnt);
+
+      // Stringify the objref we'll be implementing, and print it to
+      // stdout.  Someone will take that string and give it to a
+      // client.  Then release the object.
+
+      temp = oa_ptr->id_to_reference (id.in ());
+
+      CORBA::String_var str =
+        orb_ptr->object_to_string (temp.in ());
+
+      if (TAO_debug_level > 0)
+        {
+          ACE_DEBUG ((LM_DEBUG,
+                      "(%P|%t) The IOR is <%s>\n",
+                      str.in ()));
+        }
+
+      ior_output_file = ACE_OS::fopen (ior_output_filename, "w");
+
+      if (ior_output_file == 0)
+        {
+          ACE_ERROR_RETURN ((LM_ERROR,
+                             "Unable to open %s for writing: %p\n",
+                             ior_output_filename),
+                            -1);
+        }
+
+      ACE_OS::fprintf (ior_output_file,
+                       "%s",
+                       str.in ());
+      ACE_OS::fclose (ior_output_file);
+
+
+      // Make the POAs controlled by this manager active
+      poa_manager->activate ();
+
+      orb_ptr->run ();
+
+      oa_ptr->destroy (true, true);
+    }
+  catch (const CORBA::SystemException& sysex)
+    {
+      sysex._tao_print_exception ("System Exception");
+      return -1;
+    }
+  catch (const CORBA::UserException& userex)
+    {
+      userex._tao_print_exception ("User Exception");
+      return -1;
+    }
+    
+  /// Free resources.
+  delete svnt;
+
+  return 0;
+}
diff --git a/modules/TAO/tests/Alt_Mapping/tests.h b/modules/TAO/tests/Alt_Mapping/tests.h
new file mode 100644
index 00000000000..ed6cdb30ef8
--- /dev/null
+++ b/modules/TAO/tests/Alt_Mapping/tests.h
@@ -0,0 +1,22 @@
+// $Id$
+
+// ============================================================================
+//
+// = FILENAME
+//    tests.h
+//
+// = DESCRIPTION
+//    All the test objects header files included here
+//
+// = AUTHORS
+//      Jeff Parsons
+//
+// ============================================================================
+
+#ifndef TESTS_H
+#define TESTS_H
+
+#include "ub_struct_seq.h"
+#include "ub_string.h"
+
+#endif /* if !defined */
diff --git a/modules/TAO/tests/Alt_Mapping/ub_string.cpp b/modules/TAO/tests/Alt_Mapping/ub_string.cpp
new file mode 100644
index 00000000000..cdf3746d71c
--- /dev/null
+++ b/modules/TAO/tests/Alt_Mapping/ub_string.cpp
@@ -0,0 +1,124 @@
+// $Id$
+
+// ============================================================================
+//
+// = LIBRARY
+//    TAO/tests/Param_Test
+//
+// = FILENAME
+//    ub_string.cpp
+//
+// = DESCRIPTION
+//    tests unbounded strings
+//
+// = AUTHORS
+//      Aniruddha Gokhale
+//
+// ============================================================================
+
+#include "helper.h"
+#include "ub_string.h"
+
+// ************************************************************************
+//               Test_Unbounded_String
+// ************************************************************************
+
+Test_Unbounded_String::Test_Unbounded_String (void)
+  : opname_ (CORBA::string_dup ("test_unbounded_string"))
+{
+}
+
+Test_Unbounded_String::~Test_Unbounded_String (void)
+{
+  CORBA::string_free (this->opname_);
+  this->opname_ = 0;
+}
+
+const char *
+Test_Unbounded_String::opname (void) const
+{
+  return this->opname_;
+}
+
+int
+Test_Unbounded_String::init_parameters (Alt_Mapping_ptr)
+{
+  Generator *gen = GENERATOR::instance (); // value generator
+
+  this->in_ = gen->gen_string ();
+  this->inout_ = this->in_.c_str ();
+  
+  return 0;
+}
+
+int
+Test_Unbounded_String::reset_parameters (void)
+{
+  this->inout_ = this->in_.c_str ();
+  this->out_.clear ();
+  this->ret_.clear ();
+  
+  return 0;
+}
+
+int
+Test_Unbounded_String::run_sii_test (Alt_Mapping_ptr objref)
+{
+  try
+    {
+      this->ret_ = objref->test_unbounded_string (this->in_,
+                                                  this->inout_,
+                                                  this->out_);//str_out);
+
+      return 0;
+    }
+  catch (const CORBA::Exception& ex)
+    {
+      ex._tao_print_exception ("Test_Unbounded_String::run_sii_test\n");
+    }
+    
+  return -1;
+}
+
+CORBA::Boolean
+Test_Unbounded_String::check_validity (void)
+{
+  CORBA::ULong len = this->in_.length ();
+
+  std::string first_half = this->inout_.substr (0, len);
+  std::string second_half = this->inout_.substr (len, len);
+  
+  return (this->in_ == this->out_
+          && this->in_ == this->ret_
+          && this->inout_.length () == 2 * len
+          && this->in_ == first_half
+          && this->in_ == second_half);
+}
+
+CORBA::Boolean
+Test_Unbounded_String::check_validity (CORBA::Request_ptr )
+{
+  // No need to retrieve anything because, for all the args and
+  // the return, we provided the memory and we own it.
+  return this->check_validity ();
+}
+
+void
+Test_Unbounded_String::print_values (void)
+{
+  ACE_DEBUG ((LM_DEBUG,
+              "\n=*=*=*=*=*=*\n"
+              "in with len (%d) = %s\n"
+              "inout with len (%d) = %s\n"
+              "out with len (%d) = %s\n"
+              "ret with len (%d) = %s\n"
+              "\n=*=*=*=*=*=*\n",
+              this->in_.length (),
+              this->in_.c_str (),
+              this->inout_.length (),
+              this->inout_.c_str (),
+              this->out_.length (),
+              this->out_.c_str (),
+              this->ret_.length (),
+              this->ret_.c_str ()));
+}
diff --git a/modules/TAO/tests/Alt_Mapping/ub_string.h b/modules/TAO/tests/Alt_Mapping/ub_string.h
new file mode 100644
index 00000000000..b3f4037173b
--- /dev/null
+++ b/modules/TAO/tests/Alt_Mapping/ub_string.h
@@ -0,0 +1,67 @@
+// $Id$
+
+// ============================================================================
+//
+// = LIBRARY
+//    TAO/tests/Param_Test
+//
+// = FILENAME
+//    unbounded_string.h
+//
+// = DESCRIPTION
+//     Tests unbounded string
+//
+// = AUTHORS
+//      Aniruddha Gokhale
+//
+// ============================================================================
+
+#ifndef PARAM_TEST_UNBOUNDED_STRING_H
+#define PARAM_TEST_UNBOUNDED_STRING_H
+
+#include "Alt_MappingC.h"
+
+// =*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*
+//                        test unbounded strings
+// =*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*
+class Test_Unbounded_String
+{
+public:
+  Test_Unbounded_String (void);
+  // ctor
+
+  ~Test_Unbounded_String (void);
+  // dtor
+
+  int run_sii_test (Alt_Mapping_ptr objref);
+  // run the SII test
+
+  const char *opname (void) const;
+  // return operation name
+
+  int init_parameters (Alt_Mapping_ptr objref);
+  // set values for parameters
+
+  int reset_parameters (void);
+  // reset values for CORBA
+
+  CORBA::Boolean check_validity (void);
+  // check if results are valid
+
+  CORBA::Boolean check_validity (CORBA::Request_ptr req);
+  // check if results are valid. This is used for DII results
+
+  void print_values (void);
+  // print all the values
+
+private:
+  char *opname_;
+  // operation name
+  
+  std::string in_;
+  std::string inout_;
+  std::string out_;
+  std::string ret_;
+};
+
+#endif /* PARAM_TEST_UNBOUNDED_STRING_H */
diff --git a/modules/TAO/tests/Alt_Mapping/ub_struct_seq.cpp b/modules/TAO/tests/Alt_Mapping/ub_struct_seq.cpp
new file mode 100644
index 00000000000..6e4777726ef
--- /dev/null
+++ b/modules/TAO/tests/Alt_Mapping/ub_struct_seq.cpp
@@ -0,0 +1,183 @@
+// $Id$
+
+// ============================================================================
+//
+// = LIBRARY
+//    TAO/tests/Param_Test
+//
+// = FILENAME
+//    ub_struct_seq.cpp
+//
+// = DESCRIPTION
+//    tests unbounded struct sequences
+//
+// = AUTHORS
+//      Aniruddha Gokhale
+//
+// ============================================================================
+
+#include "helper.h"
+#include "ub_struct_seq.h"
+
+// ************************************************************************
+//               Test_Struct_Sequence
+// ************************************************************************
+
+Test_Unbounded_Struct_Sequence::Test_Unbounded_Struct_Sequence (
+  void)
+  : opname_ (CORBA::string_dup ("test_struct_sequence"))
+{
+}
+
+Test_Unbounded_Struct_Sequence::~Test_Unbounded_Struct_Sequence (
+  void)
+{
+  CORBA::string_free (this->opname_);
+  this->opname_ = 0;
+  // the other data members will be freed as they are "_var"s and objects
+  // (rather than pointers to objects)
+}
+
+const char *
+Test_Unbounded_Struct_Sequence::opname (void) const
+{
+  return this->opname_;
+}
+
+int
+Test_Unbounded_Struct_Sequence::init_parameters (Alt_Mapping_ptr)
+{
+  Generator *gen = GENERATOR::instance (); // value generator
+
+  // get some sequence length (not more than 10)
+  CORBA::ULong len = (CORBA::ULong) (gen->gen_long () % 10) + 1;
+
+  // set the length of the sequence
+  this->in_.length (len);
+  this->inout_.length (len);
+  // now set each individual element
+  for (CORBA::ULong i = 0; i < this->in_.length (); i++)
+    {
+      // generate some arbitrary struct to be filled into the ith location in
+      // the sequence
+      this->in_[i] = gen->gen_fixed_struct ();
+      this->inout_[i] = gen->gen_fixed_struct ();
+    }
+  return 0;
+}
+
+int
+Test_Unbounded_Struct_Sequence::reset_parameters (void)
+{
+  this->inout_.clear ();
+  this->out_.clear ();
+  this->ret_.clear ();
+  
+  return 0;
+}
+
+int
+Test_Unbounded_Struct_Sequence::run_sii_test (
+  Alt_Mapping_ptr objref)
+{
+  try
+    {
+      this->ret_.swap (objref->test_struct_sequence (this->in_,
+                                                 this->inout_,
+                                                 this->out_));
+
+      return 0;
+    }
+  catch (const CORBA::Exception& ex)
+    {
+      ex._tao_print_exception ("Test_Struct_Sequence::run_sii_test\n");
+
+    }
+  return -1;
+}
+
+CORBA::Boolean
+Test_Unbounded_Struct_Sequence::check_validity (void)
+{
+  return (this->compare (this->in_, this->inout_)
+          && this->compare (this->in_, this->out_)
+          && this->compare (this->in_, this->ret_));
+}
+
+void
+Test_Unbounded_Struct_Sequence::print_values (void)
+{
+  ACE_DEBUG ((LM_DEBUG,
+              "*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*\n"
+              "IN sequence\n"));
+  this->print_sequence (this->in_);
+  ACE_DEBUG ((LM_DEBUG,
+              "*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*\n"
+              "INOUT sequence\n"));
+  this->print_sequence (this->inout_);
+  ACE_DEBUG ((LM_DEBUG,
+              "*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*\n"
+              "OUT sequence\n"));
+  this->print_sequence (this->out_);
+  ACE_DEBUG ((LM_DEBUG,
+              "*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*\n"
+              "RET sequence\n"));
+  this->print_sequence (this->ret_);
+}
+
+CORBA::Boolean
+Test_Unbounded_Struct_Sequence::compare (
+  const Alt_Mapping::StructSeq &s1,
+  const Alt_Mapping::StructSeq &s2)
+{
+  if (s1.maximum () != s2.maximum ())
+      return 0;
+  if (s1.length () != s2.length ())
+    return 0;
+
+  for (CORBA::ULong i=0; i < s1.length (); i++)
+    {
+      const Alt_Mapping::Fixed_Struct& vs1 = s1[i];
+      const Alt_Mapping::Fixed_Struct& vs2 = s2[i];
+
+      if (vs1.l != vs2.l
+          || vs1.c != vs2.c
+          || vs1.s != vs2.s
+          || vs1.o != vs2.o
+          || vs1.f != vs2.f
+          || vs1.b != vs2.b
+          || vs1.d != vs2.d )
+        return 0;
+    }
+
+  return 1; // success
+}
+
+void
+Test_Unbounded_Struct_Sequence::print_sequence (
+  const Alt_Mapping::StructSeq &s)
+{
+  ACE_DEBUG ((LM_DEBUG,
+              "maximum = %d\n"
+              "length = %d\n",
+              s.maximum (),
+              s.length ()));
+  ACE_DEBUG ((LM_DEBUG, "Elements -\n"));
+  
+  for (CORBA::ULong i=0; i < s.length (); i++)
+    {
+      const Alt_Mapping::Fixed_Struct& vs = s[i];
+
+      ACE_DEBUG ((LM_DEBUG,
+                  "Element #%d\n"
+                  "\tl = %d\n"
+                  "\tc = %c\n"
+                  "\ts = %d\n"
+                  "\to = %x\n"
+                  "\tf = %f\n"
+                  "\tb = %d\n"
+                  "\td = %f\n",
+                  i,
+                  vs.l, vs.c, vs.s, vs.o, vs.f, vs.b, vs.d));
+    }
+}
diff --git a/modules/TAO/tests/Alt_Mapping/ub_struct_seq.h b/modules/TAO/tests/Alt_Mapping/ub_struct_seq.h
new file mode 100644
index 00000000000..a79a5fcf70a
--- /dev/null
+++ b/modules/TAO/tests/Alt_Mapping/ub_struct_seq.h
@@ -0,0 +1,75 @@
+// $Id$
+
+// ============================================================================
+//
+// = LIBRARY
+//    TAO/tests/Param_Test
+//
+// = FILENAME
+//    ub_struct_seq.h
+//
+// = DESCRIPTION
+//     Tests unbounded struct sequence
+//
+// = AUTHORS
+//      Aniruddha Gokhale
+//
+// ============================================================================
+
+#ifndef ALT_MAPPING_TEST_UNBOUNED_STRUCT_SEQUENCE_H
+#define ALT_MAPPING_TEST_UNBOUNED_STRUCT_SEQUENCE_H
+
+#include "alt_mappingC.h"
+
+// =*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*
+//           test unbounded sequence of structs
+// =*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*
+
+class Test_Unbounded_Struct_Sequence
+{
+public:
+  Test_Unbounded_Struct_Sequence (void);
+  // ctor
+
+  ~Test_Unbounded_Struct_Sequence (void);
+  // dtor
+
+  int run_sii_test (Alt_Mapping_ptr objref);
+  // run the SII test
+
+  const char *opname (void) const;
+  // return operation name
+
+  int init_parameters (Alt_Mapping_ptr objref);
+  // set values for parameters
+
+  int reset_parameters (void);
+  // reset values for CORBA
+
+  CORBA::Boolean check_validity (void);
+  // check if results are valid
+
+  void print_values (void);
+  // print all the values
+
+protected:
+  CORBA::Boolean compare (const Alt_Mapping::StructSeq &s1,
+                          const Alt_Mapping::StructSeq &s2);
+  // compare
+
+  void print_sequence (const Alt_Mapping::StructSeq &s);
+  // print individual sequence
+
+private:
+ char *opname_;
+
+  Alt_Mapping::StructSeq in_;
+
+  Alt_Mapping::StructSeq inout_;
+
+  Alt_Mapping::StructSeq out_;
+
+  Alt_Mapping::StructSeq ret_;
+};
+
+#endif /* ALT_MAPPING_TEST_UNBOUNED_STRUCT_SEQUENCE_H */
diff --git a/modules/TAO/tests/Param_Test/param_testC.cpp b/modules/TAO/tests/Param_Test/param_testC.cpp
index c83469f9e74..c57d6db4cbf 100644
--- a/modules/TAO/tests/Param_Test/param_testC.cpp
+++ b/modules/TAO/tests/Param_Test/param_testC.cpp
@@ -65,6 +65,7 @@
 #include "tao/UB_String_Arguments.h"
 #include "tao/Var_Array_Argument_T.h"
 #include "tao/Var_Size_Argument_T.h"
+#include "tao/Vector_Argument_T.h"
 #include "tao/AnyTypeCode/Any_Arg_Traits.h"
 #include "ace/OS_NS_string.h"
 
@@ -1513,41 +1514,32 @@ Param_Test::PathSpec::PathSpec (void)
 {}
 
 Param_Test::PathSpec::PathSpec (
-    ::CORBA::ULong max
-  )
-  : TAO::unbounded_value_sequence<
-        Step
-      >
-    (max)
-{}
-
-Param_Test::PathSpec::PathSpec (
-    ::CORBA::ULong max,
-    ::CORBA::ULong length,
-    Param_Test::Step * buffer,
-    ::CORBA::Boolean release
-  )
-  : TAO::unbounded_value_sequence<
-        Step
-      >
-    (max, length, buffer, release)
+      ::CORBA::ULong max)
+  : std::vector<Step> (max)
 {}
 
 Param_Test::PathSpec::PathSpec (
-    const PathSpec &seq
-  )
-  : TAO::unbounded_value_sequence<
-        Step
-      >
-    (seq)
+      const PathSpec &seq)
+  : std::vector<Step> (seq)
 {}
 
 Param_Test::PathSpec::~PathSpec (void)
 {}
 
+::CORBA::ULong
+Param_Test::PathSpec::length (void) const
+{
+  return this->size ();
+}
+
+void
+Param_Test::PathSpec::length (::CORBA::ULong length)
+{
+  this->reserve (length);
+}
+
 void Param_Test::PathSpec::_tao_any_destructor (
-    void * _tao_void_pointer
-  )
+  void * _tao_void_pointer)
 {
   PathSpec * _tao_tmp_pointer =
     static_cast<PathSpec *> (_tao_void_pointer);
@@ -1719,21 +1711,18 @@ Param_Test::Bounded_Short_Seq::Bounded_Short_Seq (
 {}
 
 Param_Test::Bounded_Short_Seq::Bounded_Short_Seq (
-    const Bounded_Short_Seq &seq
-  )
+      const Bounded_Short_Seq &seq)
   : TAO::bounded_value_sequence<
         ::CORBA::Short,
         32
-      >
-    (seq)
+      > (seq)
 {}
 
 Param_Test::Bounded_Short_Seq::~Bounded_Short_Seq (void)
 {}
 
 void Param_Test::Bounded_Short_Seq::_tao_any_destructor (
-    void * _tao_void_pointer
-  )
+  void * _tao_void_pointer)
 {
   Bounded_Short_Seq * _tao_tmp_pointer =
     static_cast<Bounded_Short_Seq *> (_tao_void_pointer);
@@ -1905,21 +1894,18 @@ Param_Test::Bounded_Long_Seq::Bounded_Long_Seq (
 {}
 
 Param_Test::Bounded_Long_Seq::Bounded_Long_Seq (
-    const Bounded_Long_Seq &seq
-  )
+      const Bounded_Long_Seq &seq)
   : TAO::bounded_value_sequence<
         ::CORBA::Long,
         32
-      >
-    (seq)
+      > (seq)
 {}
 
 Param_Test::Bounded_Long_Seq::~Bounded_Long_Seq (void)
 {}
 
 void Param_Test::Bounded_Long_Seq::_tao_any_destructor (
-    void * _tao_void_pointer
-  )
+  void * _tao_void_pointer)
 {
   Bounded_Long_Seq * _tao_tmp_pointer =
     static_cast<Bounded_Long_Seq *> (_tao_void_pointer);
@@ -2088,18 +2074,15 @@ Param_Test::Bounded_StrSeq::Bounded_StrSeq (
 {}
 
 Param_Test::Bounded_StrSeq::Bounded_StrSeq (
-    const Bounded_StrSeq &seq
-  )
-  : TAO::bounded_basic_string_sequence<char, 32>
-    (seq)
+      const Bounded_StrSeq &seq)
+  : TAO::bounded_basic_string_sequence<char, 32> (seq)
 {}
 
 Param_Test::Bounded_StrSeq::~Bounded_StrSeq (void)
 {}
 
 void Param_Test::Bounded_StrSeq::_tao_any_destructor (
-    void * _tao_void_pointer
-  )
+  void * _tao_void_pointer)
 {
   Bounded_StrSeq * _tao_tmp_pointer =
     static_cast<Bounded_StrSeq *> (_tao_void_pointer);
@@ -2268,18 +2251,15 @@ Param_Test::Bounded_WStrSeq::Bounded_WStrSeq (
 {}
 
 Param_Test::Bounded_WStrSeq::Bounded_WStrSeq (
-    const Bounded_WStrSeq &seq
-  )
-  : TAO::bounded_basic_string_sequence<CORBA::WChar, 32>
-    (seq)
+      const Bounded_WStrSeq &seq)
+  : TAO::bounded_basic_string_sequence<CORBA::WChar, 32> (seq)
 {}
 
 Param_Test::Bounded_WStrSeq::~Bounded_WStrSeq (void)
 {}
 
 void Param_Test::Bounded_WStrSeq::_tao_any_destructor (
-    void * _tao_void_pointer
-  )
+  void * _tao_void_pointer)
 {
   Bounded_WStrSeq * _tao_tmp_pointer =
     static_cast<Bounded_WStrSeq *> (_tao_void_pointer);
@@ -2393,41 +2373,32 @@ Param_Test::StructSeq::StructSeq (void)
 {}
 
 Param_Test::StructSeq::StructSeq (
-    ::CORBA::ULong max
-  )
-  : TAO::unbounded_value_sequence<
-        Fixed_Struct
-      >
-    (max)
+      ::CORBA::ULong max)
+  : std::vector<Fixed_Struct> (max)
 {}
 
 Param_Test::StructSeq::StructSeq (
-    ::CORBA::ULong max,
-    ::CORBA::ULong length,
-    Param_Test::Fixed_Struct * buffer,
-    ::CORBA::Boolean release
-  )
-  : TAO::unbounded_value_sequence<
-        Fixed_Struct
-      >
-    (max, length, buffer, release)
-{}
-
-Param_Test::StructSeq::StructSeq (
-    const StructSeq &seq
-  )
-  : TAO::unbounded_value_sequence<
-        Fixed_Struct
-      >
-    (seq)
+      const StructSeq &seq)
+  : std::vector<Fixed_Struct> (seq)
 {}
 
 Param_Test::StructSeq::~StructSeq (void)
 {}
 
+::CORBA::ULong
+Param_Test::StructSeq::length (void) const
+{
+  return this->size ();
+}
+
+void
+Param_Test::StructSeq::length (::CORBA::ULong length)
+{
+  this->reserve (length);
+}
+
 void Param_Test::StructSeq::_tao_any_destructor (
-    void * _tao_void_pointer
-  )
+  void * _tao_void_pointer)
 {
   StructSeq * _tao_tmp_pointer =
     static_cast<StructSeq *> (_tao_void_pointer);
@@ -2553,21 +2524,18 @@ Param_Test::Bounded_StructSeq::Bounded_StructSeq (
 {}
 
 Param_Test::Bounded_StructSeq::Bounded_StructSeq (
-    const Bounded_StructSeq &seq
-  )
+      const Bounded_StructSeq &seq)
   : TAO::bounded_value_sequence<
         Fixed_Struct,
         32
-      >
-    (seq)
+      > (seq)
 {}
 
 Param_Test::Bounded_StructSeq::~Bounded_StructSeq (void)
 {}
 
 void Param_Test::Bounded_StructSeq::_tao_any_destructor (
-    void * _tao_void_pointer
-  )
+  void * _tao_void_pointer)
 {
   Bounded_StructSeq * _tao_tmp_pointer =
     static_cast<Bounded_StructSeq *> (_tao_void_pointer);
@@ -2681,44 +2649,32 @@ Param_Test::Coffee_Mix::Coffee_Mix (void)
 {}
 
 Param_Test::Coffee_Mix::Coffee_Mix (
-    ::CORBA::ULong max
-  )
-  : TAO::unbounded_object_reference_sequence<
-        Coffee,
-        Coffee_var
-      >
-    (max)
+      ::CORBA::ULong max)
+  : std::vector<Coffee> (max)
 {}
 
 Param_Test::Coffee_Mix::Coffee_Mix (
-    ::CORBA::ULong max,
-    ::CORBA::ULong length,
-    Coffee_ptr * buffer,
-    ::CORBA::Boolean release
-  )
-  : TAO::unbounded_object_reference_sequence<
-        Coffee,
-        Coffee_var
-      >
-    (max, length, buffer, release)
-{}
-
-Param_Test::Coffee_Mix::Coffee_Mix (
-    const Coffee_Mix &seq
-  )
-  : TAO::unbounded_object_reference_sequence<
-        Coffee,
-        Coffee_var
-      >
-    (seq)
+      const Coffee_Mix &seq)
+  : std::vector<Coffee> (seq)
 {}
 
 Param_Test::Coffee_Mix::~Coffee_Mix (void)
 {}
 
+::CORBA::ULong
+Param_Test::Coffee_Mix::length (void) const
+{
+  return this->size ();
+}
+
+void
+Param_Test::Coffee_Mix::length (::CORBA::ULong length)
+{
+  this->reserve (length);
+}
+
 void Param_Test::Coffee_Mix::_tao_any_destructor (
-    void * _tao_void_pointer
-  )
+  void * _tao_void_pointer)
 {
   Coffee_Mix * _tao_tmp_pointer =
     static_cast<Coffee_Mix *> (_tao_void_pointer);
@@ -2845,22 +2801,19 @@ Param_Test::Bounded_Coffee_Mix::Bounded_Coffee_Mix (
 {}
 
 Param_Test::Bounded_Coffee_Mix::Bounded_Coffee_Mix (
-    const Bounded_Coffee_Mix &seq
-  )
+      const Bounded_Coffee_Mix &seq)
   : TAO::bounded_object_reference_sequence<
         Coffee,
         Coffee_var,
         32
-      >
-    (seq)
+      > (seq)
 {}
 
 Param_Test::Bounded_Coffee_Mix::~Bounded_Coffee_Mix (void)
 {}
 
 void Param_Test::Bounded_Coffee_Mix::_tao_any_destructor (
-    void * _tao_void_pointer
-  )
+  void * _tao_void_pointer)
 {
   Bounded_Coffee_Mix * _tao_tmp_pointer =
     static_cast<Bounded_Coffee_Mix *> (_tao_void_pointer);
@@ -3778,47 +3731,32 @@ Param_Test::ArraySeq::ArraySeq (void)
 {}
 
 Param_Test::ArraySeq::ArraySeq (
-    ::CORBA::ULong max
-  )
-  : TAO::unbounded_array_sequence<
-        Fixed_Array,
-        Fixed_Array_slice,
-        Fixed_Array_tag
-      >
-    (max)
-{}
-
-Param_Test::ArraySeq::ArraySeq (
-    ::CORBA::ULong max,
-    ::CORBA::ULong length,
-    Param_Test::Fixed_Array * buffer,
-    ::CORBA::Boolean release
-  )
-  : TAO::unbounded_array_sequence<
-        Fixed_Array,
-        Fixed_Array_slice,
-        Fixed_Array_tag
-      >
-    (max, length, buffer, release)
+      ::CORBA::ULong max)
+  : std::vector<Fixed_Array> (max)
 {}
 
 Param_Test::ArraySeq::ArraySeq (
-    const ArraySeq &seq
-  )
-  : TAO::unbounded_array_sequence<
-        Fixed_Array,
-        Fixed_Array_slice,
-        Fixed_Array_tag
-      >
-    (seq)
+      const ArraySeq &seq)
+  : std::vector<Fixed_Array> (seq)
 {}
 
 Param_Test::ArraySeq::~ArraySeq (void)
 {}
 
+::CORBA::ULong
+Param_Test::ArraySeq::length (void) const
+{
+  return this->size ();
+}
+
+void
+Param_Test::ArraySeq::length (::CORBA::ULong length)
+{
+  this->reserve (length);
+}
+
 void Param_Test::ArraySeq::_tao_any_destructor (
-    void * _tao_void_pointer
-  )
+  void * _tao_void_pointer)
 {
   ArraySeq * _tao_tmp_pointer =
     static_cast<ArraySeq *> (_tao_void_pointer);
@@ -3946,23 +3884,20 @@ Param_Test::Bounded_ArraySeq::Bounded_ArraySeq (
 {}
 
 Param_Test::Bounded_ArraySeq::Bounded_ArraySeq (
-    const Bounded_ArraySeq &seq
-  )
+      const Bounded_ArraySeq &seq)
   : TAO::bounded_array_sequence<
         Fixed_Array,
         Fixed_Array_slice,
         Fixed_Array_tag,
         32
-      >
-    (seq)
+      > (seq)
 {}
 
 Param_Test::Bounded_ArraySeq::~Bounded_ArraySeq (void)
 {}
 
 void Param_Test::Bounded_ArraySeq::_tao_any_destructor (
-    void * _tao_void_pointer
-  )
+  void * _tao_void_pointer)
 {
   Bounded_ArraySeq * _tao_tmp_pointer =
     static_cast<Bounded_ArraySeq *> (_tao_void_pointer);
@@ -5297,38 +5232,30 @@ Param_Test::Recursive_Struct::_tao_seq_Param_Test_Recursive_Struct_::_tao_seq_Pa
 {}
 
 Param_Test::Recursive_Struct::_tao_seq_Param_Test_Recursive_Struct_::_tao_seq_Param_Test_Recursive_Struct_ (
-    ::CORBA::ULong max
-  )
-  : TAO::unbounded_value_sequence<
-        Param_Test::Recursive_Struct
-      >
-    (max)
+      ::CORBA::ULong max)
+  : std::vector<Param_Test::Recursive_Struct> (max)
 {}
 
 Param_Test::Recursive_Struct::_tao_seq_Param_Test_Recursive_Struct_::_tao_seq_Param_Test_Recursive_Struct_ (
-    ::CORBA::ULong max,
-    ::CORBA::ULong length,
-    Param_Test::Recursive_Struct * buffer,
-    ::CORBA::Boolean release
-  )
-  : TAO::unbounded_value_sequence<
-        Param_Test::Recursive_Struct
-      >
-    (max, length, buffer, release)
-{}
-
-Param_Test::Recursive_Struct::_tao_seq_Param_Test_Recursive_Struct_::_tao_seq_Param_Test_Recursive_Struct_ (
-    const _tao_seq_Param_Test_Recursive_Struct_ &seq
-  )
-  : TAO::unbounded_value_sequence<
-        Param_Test::Recursive_Struct
-      >
-    (seq)
+      const _tao_seq_Param_Test_Recursive_Struct_ &seq)
+  : std::vector<Param_Test::Recursive_Struct> (seq)
 {}
 
 Param_Test::Recursive_Struct::_tao_seq_Param_Test_Recursive_Struct_::~_tao_seq_Param_Test_Recursive_Struct_ (void)
 {}
 
+::CORBA::ULong
+Param_Test::Recursive_Struct::_tao_seq_Param_Test_Recursive_Struct_::length (void) const
+{
+  return this->size ();
+}
+
+void
+Param_Test::Recursive_Struct::_tao_seq_Param_Test_Recursive_Struct_::length (::CORBA::ULong length)
+{
+  this->reserve (length);
+}
+
 #endif /* end #if !defined */
 
 // TAO_IDL - Generated from
@@ -5387,38 +5314,30 @@ Param_Test::nested_rec_union::_tao_seq_Param_Test_nested_rec_union_::_tao_seq_Pa
 {}
 
 Param_Test::nested_rec_union::_tao_seq_Param_Test_nested_rec_union_::_tao_seq_Param_Test_nested_rec_union_ (
-    ::CORBA::ULong max
-  )
-  : TAO::unbounded_value_sequence<
-        Param_Test::nested_rec_union
-      >
-    (max)
+      ::CORBA::ULong max)
+  : std::vector<Param_Test::nested_rec_union> (max)
 {}
 
 Param_Test::nested_rec_union::_tao_seq_Param_Test_nested_rec_union_::_tao_seq_Param_Test_nested_rec_union_ (
-    ::CORBA::ULong max,
-    ::CORBA::ULong length,
-    Param_Test::nested_rec_union * buffer,
-    ::CORBA::Boolean release
-  )
-  : TAO::unbounded_value_sequence<
-        Param_Test::nested_rec_union
-      >
-    (max, length, buffer, release)
-{}
-
-Param_Test::nested_rec_union::_tao_seq_Param_Test_nested_rec_union_::_tao_seq_Param_Test_nested_rec_union_ (
-    const _tao_seq_Param_Test_nested_rec_union_ &seq
-  )
-  : TAO::unbounded_value_sequence<
-        Param_Test::nested_rec_union
-      >
-    (seq)
+      const _tao_seq_Param_Test_nested_rec_union_ &seq)
+  : std::vector<Param_Test::nested_rec_union> (seq)
 {}
 
 Param_Test::nested_rec_union::_tao_seq_Param_Test_nested_rec_union_::~_tao_seq_Param_Test_nested_rec_union_ (void)
 {}
 
+::CORBA::ULong
+Param_Test::nested_rec_union::_tao_seq_Param_Test_nested_rec_union_::length (void) const
+{
+  return this->size ();
+}
+
+void
+Param_Test::nested_rec_union::_tao_seq_Param_Test_nested_rec_union_::length (::CORBA::ULong length)
+{
+  this->reserve (length);
+}
+
 #endif /* end #if !defined */
 
 // TAO_IDL - Generated from
@@ -5606,38 +5525,30 @@ Param_Test::Recursive_Union::_tao_seq_Param_Test_Recursive_Union_::_tao_seq_Para
 {}
 
 Param_Test::Recursive_Union::_tao_seq_Param_Test_Recursive_Union_::_tao_seq_Param_Test_Recursive_Union_ (
-    ::CORBA::ULong max
-  )
-  : TAO::unbounded_value_sequence<
-        Param_Test::Recursive_Union
-      >
-    (max)
-{}
-
-Param_Test::Recursive_Union::_tao_seq_Param_Test_Recursive_Union_::_tao_seq_Param_Test_Recursive_Union_ (
-    ::CORBA::ULong max,
-    ::CORBA::ULong length,
-    Param_Test::Recursive_Union * buffer,
-    ::CORBA::Boolean release
-  )
-  : TAO::unbounded_value_sequence<
-        Param_Test::Recursive_Union
-      >
-    (max, length, buffer, release)
+      ::CORBA::ULong max)
+  : std::vector<Param_Test::Recursive_Union> (max)
 {}
 
 Param_Test::Recursive_Union::_tao_seq_Param_Test_Recursive_Union_::_tao_seq_Param_Test_Recursive_Union_ (
-    const _tao_seq_Param_Test_Recursive_Union_ &seq
-  )
-  : TAO::unbounded_value_sequence<
-        Param_Test::Recursive_Union
-      >
-    (seq)
+      const _tao_seq_Param_Test_Recursive_Union_ &seq)
+  : std::vector<Param_Test::Recursive_Union> (seq)
 {}
 
 Param_Test::Recursive_Union::_tao_seq_Param_Test_Recursive_Union_::~_tao_seq_Param_Test_Recursive_Union_ (void)
 {}
 
+::CORBA::ULong
+Param_Test::Recursive_Union::_tao_seq_Param_Test_Recursive_Union_::length (void) const
+{
+  return this->size ();
+}
+
+void
+Param_Test::Recursive_Union::_tao_seq_Param_Test_Recursive_Union_::length (::CORBA::ULong length)
+{
+  this->reserve (length);
+}
+
 #endif /* end #if !defined */
 
 // TAO_IDL - Generated from
@@ -6606,7 +6517,7 @@ TAO_BEGIN_VERSIONED_NAMESPACE_DECL
 
 void operator<<= (
   ::CORBA::Any &_tao_any,
-  const std::vector<Param_Test::Step> &_tao_elem
+  const std::vector<Param_Test::Step> &_tao_elem)
 {
   TAO::insert_value_vector<Param_Test::Step> (
     _tao_any,
@@ -6615,7 +6526,7 @@ void operator<<= (
 
 ::CORBA::Boolean operator>>= (
   const ::CORBA::Any &_tao_any,
-  std::vector<Param_Test::Step> &_tao_elem
+  std::vector<Param_Test::Step> &_tao_elem)
 {
   return
     TAO::extract_value_vector<Param_Test::Step> (
@@ -6634,25 +6545,63 @@ TAO_END_VERSIONED_NAMESPACE_DECL
 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
 
 
+// Copying insertion.
 void operator<<= (
-  ::CORBA::Any &_tao_any,
-  const std::vector<CORBA::Short> &_tao_elem
+    ::CORBA::Any &_tao_any,
+    const Param_Test::Bounded_Short_Seq &_tao_elem
+  )
 {
-  TAO::insert_value_vector<CORBA::Short> (
-    _tao_any,
-    _tao_elem);
+  if (0 == &_tao_elem) // Trying to de-reference NULL object
+    _tao_any <<= static_cast<Param_Test::Bounded_Short_Seq *>( 0 ); // Use non-copying insertion of a NULL
+  else
+    TAO::Any_Dual_Impl_T<Param_Test::Bounded_Short_Seq>::insert_copy (
+        _tao_any,
+        Param_Test::Bounded_Short_Seq::_tao_any_destructor,
+        Param_Test::_tc_Bounded_Short_Seq,
+        _tao_elem
+      );
 }
 
-::CORBA::Boolean operator>>= (
-  const ::CORBA::Any &_tao_any,
-  std::vector<CORBA::Short> &_tao_elem
+// Non-copying insertion.
+void operator<<= (
+    ::CORBA::Any &_tao_any,
+    Param_Test::Bounded_Short_Seq *_tao_elem
+  )
 {
-  return
-    TAO::extract_value_vector<CORBA::Short> (
+  TAO::Any_Dual_Impl_T<Param_Test::Bounded_Short_Seq>::insert (
       _tao_any,
-      _tao_elem);
+      Param_Test::Bounded_Short_Seq::_tao_any_destructor,
+      Param_Test::_tc_Bounded_Short_Seq,
+      _tao_elem
+    );
+}
+
+// Extraction to non-const pointer (deprecated).
+::CORBA::Boolean operator>>= (
+    const ::CORBA::Any &_tao_any,
+    Param_Test::Bounded_Short_Seq *&_tao_elem
+  )
+{
+  return _tao_any >>= const_cast<
+      const Param_Test::Bounded_Short_Seq *&> (
+      _tao_elem
+    );
 }
 
+// Extraction to const pointer.
+::CORBA::Boolean operator>>= (
+    const ::CORBA::Any &_tao_any,
+    const Param_Test::Bounded_Short_Seq *&_tao_elem
+  )
+{
+  return
+    TAO::Any_Dual_Impl_T<Param_Test::Bounded_Short_Seq>::extract (
+        _tao_any,
+        Param_Test::Bounded_Short_Seq::_tao_any_destructor,
+        Param_Test::_tc_Bounded_Short_Seq,
+        _tao_elem
+      );
+}
 TAO_END_VERSIONED_NAMESPACE_DECL
 
 
@@ -6664,25 +6613,63 @@ TAO_END_VERSIONED_NAMESPACE_DECL
 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
 
 
+// Copying insertion.
 void operator<<= (
-  ::CORBA::Any &_tao_any,
-  const std::vector<CORBA::Long> &_tao_elem
+    ::CORBA::Any &_tao_any,
+    const Param_Test::Bounded_Long_Seq &_tao_elem
+  )
 {
-  TAO::insert_value_vector<CORBA::Long> (
-    _tao_any,
-    _tao_elem);
+  if (0 == &_tao_elem) // Trying to de-reference NULL object
+    _tao_any <<= static_cast<Param_Test::Bounded_Long_Seq *>( 0 ); // Use non-copying insertion of a NULL
+  else
+    TAO::Any_Dual_Impl_T<Param_Test::Bounded_Long_Seq>::insert_copy (
+        _tao_any,
+        Param_Test::Bounded_Long_Seq::_tao_any_destructor,
+        Param_Test::_tc_Bounded_Long_Seq,
+        _tao_elem
+      );
 }
 
-::CORBA::Boolean operator>>= (
-  const ::CORBA::Any &_tao_any,
-  std::vector<CORBA::Long> &_tao_elem
+// Non-copying insertion.
+void operator<<= (
+    ::CORBA::Any &_tao_any,
+    Param_Test::Bounded_Long_Seq *_tao_elem
+  )
 {
-  return
-    TAO::extract_value_vector<CORBA::Long> (
+  TAO::Any_Dual_Impl_T<Param_Test::Bounded_Long_Seq>::insert (
       _tao_any,
-      _tao_elem);
+      Param_Test::Bounded_Long_Seq::_tao_any_destructor,
+      Param_Test::_tc_Bounded_Long_Seq,
+      _tao_elem
+    );
+}
+
+// Extraction to non-const pointer (deprecated).
+::CORBA::Boolean operator>>= (
+    const ::CORBA::Any &_tao_any,
+    Param_Test::Bounded_Long_Seq *&_tao_elem
+  )
+{
+  return _tao_any >>= const_cast<
+      const Param_Test::Bounded_Long_Seq *&> (
+      _tao_elem
+    );
 }
 
+// Extraction to const pointer.
+::CORBA::Boolean operator>>= (
+    const ::CORBA::Any &_tao_any,
+    const Param_Test::Bounded_Long_Seq *&_tao_elem
+  )
+{
+  return
+    TAO::Any_Dual_Impl_T<Param_Test::Bounded_Long_Seq>::extract (
+        _tao_any,
+        Param_Test::Bounded_Long_Seq::_tao_any_destructor,
+        Param_Test::_tc_Bounded_Long_Seq,
+        _tao_elem
+      );
+}
 TAO_END_VERSIONED_NAMESPACE_DECL
 
 
@@ -6694,25 +6681,63 @@ TAO_END_VERSIONED_NAMESPACE_DECL
 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
 
 
+// Copying insertion.
 void operator<<= (
-  ::CORBA::Any &_tao_any,
-  const std::vector<char *> &_tao_elem
+    ::CORBA::Any &_tao_any,
+    const Param_Test::Bounded_StrSeq &_tao_elem
+  )
 {
-  TAO::insert_value_vector<char *> (
-    _tao_any,
-    _tao_elem);
+  if (0 == &_tao_elem) // Trying to de-reference NULL object
+    _tao_any <<= static_cast<Param_Test::Bounded_StrSeq *>( 0 ); // Use non-copying insertion of a NULL
+  else
+    TAO::Any_Dual_Impl_T<Param_Test::Bounded_StrSeq>::insert_copy (
+        _tao_any,
+        Param_Test::Bounded_StrSeq::_tao_any_destructor,
+        Param_Test::_tc_Bounded_StrSeq,
+        _tao_elem
+      );
 }
 
-::CORBA::Boolean operator>>= (
-  const ::CORBA::Any &_tao_any,
-  std::vector<char *> &_tao_elem
+// Non-copying insertion.
+void operator<<= (
+    ::CORBA::Any &_tao_any,
+    Param_Test::Bounded_StrSeq *_tao_elem
+  )
 {
-  return
-    TAO::extract_value_vector<char *> (
+  TAO::Any_Dual_Impl_T<Param_Test::Bounded_StrSeq>::insert (
       _tao_any,
-      _tao_elem);
+      Param_Test::Bounded_StrSeq::_tao_any_destructor,
+      Param_Test::_tc_Bounded_StrSeq,
+      _tao_elem
+    );
 }
 
+// Extraction to non-const pointer (deprecated).
+::CORBA::Boolean operator>>= (
+    const ::CORBA::Any &_tao_any,
+    Param_Test::Bounded_StrSeq *&_tao_elem
+  )
+{
+  return _tao_any >>= const_cast<
+      const Param_Test::Bounded_StrSeq *&> (
+      _tao_elem
+    );
+}
+
+// Extraction to const pointer.
+::CORBA::Boolean operator>>= (
+    const ::CORBA::Any &_tao_any,
+    const Param_Test::Bounded_StrSeq *&_tao_elem
+  )
+{
+  return
+    TAO::Any_Dual_Impl_T<Param_Test::Bounded_StrSeq>::extract (
+        _tao_any,
+        Param_Test::Bounded_StrSeq::_tao_any_destructor,
+        Param_Test::_tc_Bounded_StrSeq,
+        _tao_elem
+      );
+}
 TAO_END_VERSIONED_NAMESPACE_DECL
 
 
@@ -6724,25 +6749,63 @@ TAO_END_VERSIONED_NAMESPACE_DECL
 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
 
 
+// Copying insertion.
 void operator<<= (
-  ::CORBA::Any &_tao_any,
-  const std::vector<CORBA::WChar *> &_tao_elem
+    ::CORBA::Any &_tao_any,
+    const Param_Test::Bounded_WStrSeq &_tao_elem
+  )
 {
-  TAO::insert_value_vector<CORBA::WChar *> (
-    _tao_any,
-    _tao_elem);
+  if (0 == &_tao_elem) // Trying to de-reference NULL object
+    _tao_any <<= static_cast<Param_Test::Bounded_WStrSeq *>( 0 ); // Use non-copying insertion of a NULL
+  else
+    TAO::Any_Dual_Impl_T<Param_Test::Bounded_WStrSeq>::insert_copy (
+        _tao_any,
+        Param_Test::Bounded_WStrSeq::_tao_any_destructor,
+        Param_Test::_tc_Bounded_WStrSeq,
+        _tao_elem
+      );
 }
 
-::CORBA::Boolean operator>>= (
-  const ::CORBA::Any &_tao_any,
-  std::vector<CORBA::WChar *> &_tao_elem
+// Non-copying insertion.
+void operator<<= (
+    ::CORBA::Any &_tao_any,
+    Param_Test::Bounded_WStrSeq *_tao_elem
+  )
 {
-  return
-    TAO::extract_value_vector<CORBA::WChar *> (
+  TAO::Any_Dual_Impl_T<Param_Test::Bounded_WStrSeq>::insert (
       _tao_any,
-      _tao_elem);
+      Param_Test::Bounded_WStrSeq::_tao_any_destructor,
+      Param_Test::_tc_Bounded_WStrSeq,
+      _tao_elem
+    );
 }
 
+// Extraction to non-const pointer (deprecated).
+::CORBA::Boolean operator>>= (
+    const ::CORBA::Any &_tao_any,
+    Param_Test::Bounded_WStrSeq *&_tao_elem
+  )
+{
+  return _tao_any >>= const_cast<
+      const Param_Test::Bounded_WStrSeq *&> (
+      _tao_elem
+    );
+}
+
+// Extraction to const pointer.
+::CORBA::Boolean operator>>= (
+    const ::CORBA::Any &_tao_any,
+    const Param_Test::Bounded_WStrSeq *&_tao_elem
+  )
+{
+  return
+    TAO::Any_Dual_Impl_T<Param_Test::Bounded_WStrSeq>::extract (
+        _tao_any,
+        Param_Test::Bounded_WStrSeq::_tao_any_destructor,
+        Param_Test::_tc_Bounded_WStrSeq,
+        _tao_elem
+      );
+}
 TAO_END_VERSIONED_NAMESPACE_DECL
 
 
@@ -6756,7 +6819,7 @@ TAO_BEGIN_VERSIONED_NAMESPACE_DECL
 
 void operator<<= (
   ::CORBA::Any &_tao_any,
-  const std::vector<Param_Test::Fixed_Struct> &_tao_elem
+  const std::vector<Param_Test::Fixed_Struct> &_tao_elem)
 {
   TAO::insert_value_vector<Param_Test::Fixed_Struct> (
     _tao_any,
@@ -6765,7 +6828,7 @@ void operator<<= (
 
 ::CORBA::Boolean operator>>= (
   const ::CORBA::Any &_tao_any,
-  std::vector<Param_Test::Fixed_Struct> &_tao_elem
+  std::vector<Param_Test::Fixed_Struct> &_tao_elem)
 {
   return
     TAO::extract_value_vector<Param_Test::Fixed_Struct> (
@@ -6784,25 +6847,63 @@ TAO_END_VERSIONED_NAMESPACE_DECL
 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
 
 
+// Copying insertion.
 void operator<<= (
-  ::CORBA::Any &_tao_any,
-  const std::vector<Param_Test::Fixed_Struct> &_tao_elem
+    ::CORBA::Any &_tao_any,
+    const Param_Test::Bounded_StructSeq &_tao_elem
+  )
 {
-  TAO::insert_value_vector<Param_Test::Fixed_Struct> (
-    _tao_any,
-    _tao_elem);
+  if (0 == &_tao_elem) // Trying to de-reference NULL object
+    _tao_any <<= static_cast<Param_Test::Bounded_StructSeq *>( 0 ); // Use non-copying insertion of a NULL
+  else
+    TAO::Any_Dual_Impl_T<Param_Test::Bounded_StructSeq>::insert_copy (
+        _tao_any,
+        Param_Test::Bounded_StructSeq::_tao_any_destructor,
+        Param_Test::_tc_Bounded_StructSeq,
+        _tao_elem
+      );
 }
 
-::CORBA::Boolean operator>>= (
-  const ::CORBA::Any &_tao_any,
-  std::vector<Param_Test::Fixed_Struct> &_tao_elem
+// Non-copying insertion.
+void operator<<= (
+    ::CORBA::Any &_tao_any,
+    Param_Test::Bounded_StructSeq *_tao_elem
+  )
 {
-  return
-    TAO::extract_value_vector<Param_Test::Fixed_Struct> (
+  TAO::Any_Dual_Impl_T<Param_Test::Bounded_StructSeq>::insert (
       _tao_any,
-      _tao_elem);
+      Param_Test::Bounded_StructSeq::_tao_any_destructor,
+      Param_Test::_tc_Bounded_StructSeq,
+      _tao_elem
+    );
+}
+
+// Extraction to non-const pointer (deprecated).
+::CORBA::Boolean operator>>= (
+    const ::CORBA::Any &_tao_any,
+    Param_Test::Bounded_StructSeq *&_tao_elem
+  )
+{
+  return _tao_any >>= const_cast<
+      const Param_Test::Bounded_StructSeq *&> (
+      _tao_elem
+    );
 }
 
+// Extraction to const pointer.
+::CORBA::Boolean operator>>= (
+    const ::CORBA::Any &_tao_any,
+    const Param_Test::Bounded_StructSeq *&_tao_elem
+  )
+{
+  return
+    TAO::Any_Dual_Impl_T<Param_Test::Bounded_StructSeq>::extract (
+        _tao_any,
+        Param_Test::Bounded_StructSeq::_tao_any_destructor,
+        Param_Test::_tc_Bounded_StructSeq,
+        _tao_elem
+      );
+}
 TAO_END_VERSIONED_NAMESPACE_DECL
 
 
@@ -6816,7 +6917,7 @@ TAO_BEGIN_VERSIONED_NAMESPACE_DECL
 
 void operator<<= (
   ::CORBA::Any &_tao_any,
-  const std::vector<Coffee> &_tao_elem
+  const std::vector<Coffee> &_tao_elem)
 {
   TAO::insert_objref_vector<Coffee_ptr> (
     _tao_any,
@@ -6825,7 +6926,7 @@ void operator<<= (
 
 ::CORBA::Boolean operator>>= (
   const ::CORBA::Any &_tao_any,
-  std::vector<Coffee> &_tao_elem
+  std::vector<Coffee> &_tao_elem)
 {
   return
     TAO::extract_objref_vector<Coffee_ptr> (
@@ -6844,25 +6945,63 @@ TAO_END_VERSIONED_NAMESPACE_DECL
 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
 
 
+// Copying insertion.
 void operator<<= (
-  ::CORBA::Any &_tao_any,
-  const std::vector<Coffee> &_tao_elem
+    ::CORBA::Any &_tao_any,
+    const Param_Test::Bounded_Coffee_Mix &_tao_elem
+  )
 {
-  TAO::insert_objref_vector<Coffee_ptr> (
-    _tao_any,
-    _tao_elem);
+  if (0 == &_tao_elem) // Trying to de-reference NULL object
+    _tao_any <<= static_cast<Param_Test::Bounded_Coffee_Mix *>( 0 ); // Use non-copying insertion of a NULL
+  else
+    TAO::Any_Dual_Impl_T<Param_Test::Bounded_Coffee_Mix>::insert_copy (
+        _tao_any,
+        Param_Test::Bounded_Coffee_Mix::_tao_any_destructor,
+        Param_Test::_tc_Bounded_Coffee_Mix,
+        _tao_elem
+      );
 }
 
-::CORBA::Boolean operator>>= (
-  const ::CORBA::Any &_tao_any,
-  std::vector<Coffee> &_tao_elem
+// Non-copying insertion.
+void operator<<= (
+    ::CORBA::Any &_tao_any,
+    Param_Test::Bounded_Coffee_Mix *_tao_elem
+  )
 {
-  return
-    TAO::extract_objref_vector<Coffee_ptr> (
+  TAO::Any_Dual_Impl_T<Param_Test::Bounded_Coffee_Mix>::insert (
       _tao_any,
-      _tao_elem);
+      Param_Test::Bounded_Coffee_Mix::_tao_any_destructor,
+      Param_Test::_tc_Bounded_Coffee_Mix,
+      _tao_elem
+    );
 }
 
+// Extraction to non-const pointer (deprecated).
+::CORBA::Boolean operator>>= (
+    const ::CORBA::Any &_tao_any,
+    Param_Test::Bounded_Coffee_Mix *&_tao_elem
+  )
+{
+  return _tao_any >>= const_cast<
+      const Param_Test::Bounded_Coffee_Mix *&> (
+      _tao_elem
+    );
+}
+
+// Extraction to const pointer.
+::CORBA::Boolean operator>>= (
+    const ::CORBA::Any &_tao_any,
+    const Param_Test::Bounded_Coffee_Mix *&_tao_elem
+  )
+{
+  return
+    TAO::Any_Dual_Impl_T<Param_Test::Bounded_Coffee_Mix>::extract (
+        _tao_any,
+        Param_Test::Bounded_Coffee_Mix::_tao_any_destructor,
+        Param_Test::_tc_Bounded_Coffee_Mix,
+        _tao_elem
+      );
+}
 TAO_END_VERSIONED_NAMESPACE_DECL
 
 
@@ -7165,7 +7304,7 @@ TAO_BEGIN_VERSIONED_NAMESPACE_DECL
 
 void operator<<= (
   ::CORBA::Any &_tao_any,
-  const std::vector<Param_Test::Fixed_Array> &_tao_elem
+  const std::vector<Param_Test::Fixed_Array> &_tao_elem)
 {
   TAO::insert_array_vector<Param_Test::Fixed_Array_forany> (
     _tao_any,
@@ -7174,7 +7313,7 @@ void operator<<= (
 
 ::CORBA::Boolean operator>>= (
   const ::CORBA::Any &_tao_any,
-  std::vector<Param_Test::Fixed_Array> &_tao_elem
+  std::vector<Param_Test::Fixed_Array> &_tao_elem)
 {
   return
     TAO::extract_array_vector<Param_Test::Fixed_Array_forany> (
@@ -7193,25 +7332,63 @@ TAO_END_VERSIONED_NAMESPACE_DECL
 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
 
 
+// Copying insertion.
 void operator<<= (
-  ::CORBA::Any &_tao_any,
-  const std::vector<Param_Test::Fixed_Array> &_tao_elem
+    ::CORBA::Any &_tao_any,
+    const Param_Test::Bounded_ArraySeq &_tao_elem
+  )
 {
-  TAO::insert_array_vector<Param_Test::Fixed_Array_forany> (
-    _tao_any,
-    _tao_elem);
+  if (0 == &_tao_elem) // Trying to de-reference NULL object
+    _tao_any <<= static_cast<Param_Test::Bounded_ArraySeq *>( 0 ); // Use non-copying insertion of a NULL
+  else
+    TAO::Any_Dual_Impl_T<Param_Test::Bounded_ArraySeq>::insert_copy (
+        _tao_any,
+        Param_Test::Bounded_ArraySeq::_tao_any_destructor,
+        Param_Test::_tc_Bounded_ArraySeq,
+        _tao_elem
+      );
 }
 
-::CORBA::Boolean operator>>= (
-  const ::CORBA::Any &_tao_any,
-  std::vector<Param_Test::Fixed_Array> &_tao_elem
+// Non-copying insertion.
+void operator<<= (
+    ::CORBA::Any &_tao_any,
+    Param_Test::Bounded_ArraySeq *_tao_elem
+  )
 {
-  return
-    TAO::extract_array_vector<Param_Test::Fixed_Array_forany> (
+  TAO::Any_Dual_Impl_T<Param_Test::Bounded_ArraySeq>::insert (
       _tao_any,
-      _tao_elem);
+      Param_Test::Bounded_ArraySeq::_tao_any_destructor,
+      Param_Test::_tc_Bounded_ArraySeq,
+      _tao_elem
+    );
+}
+
+// Extraction to non-const pointer (deprecated).
+::CORBA::Boolean operator>>= (
+    const ::CORBA::Any &_tao_any,
+    Param_Test::Bounded_ArraySeq *&_tao_elem
+  )
+{
+  return _tao_any >>= const_cast<
+      const Param_Test::Bounded_ArraySeq *&> (
+      _tao_elem
+    );
 }
 
+// Extraction to const pointer.
+::CORBA::Boolean operator>>= (
+    const ::CORBA::Any &_tao_any,
+    const Param_Test::Bounded_ArraySeq *&_tao_elem
+  )
+{
+  return
+    TAO::Any_Dual_Impl_T<Param_Test::Bounded_ArraySeq>::extract (
+        _tao_any,
+        Param_Test::Bounded_ArraySeq::_tao_any_destructor,
+        Param_Test::_tc_Bounded_ArraySeq,
+        _tao_elem
+      );
+}
 TAO_END_VERSIONED_NAMESPACE_DECL
 
 
@@ -8123,1718 +8300,1788 @@ TAO_BEGIN_VERSIONED_NAMESPACE_DECL
 
 ::CORBA::Boolean operator<< (
   TAO_OutputCDR &strm,
-  const std:;vector<Param_Test::Step &_tao_vector)
+  const std::vector<Param_Test::Step> &_tao_vector)
 {
   ::CORBA::ULong length = _tao_vector.size ();
   strm << length;
   
   for ( ::CORBA::ULong i = 0UL; i < length; ++i)
     {
-      if (! strm << _tao_vector[i]
+      if (! (strm << _tao_vector[i]))
         {
           return false;
         }
-      }
-    
-    return true;
-  }
+    }
   
-  ::CORBA::Boolean operator>> (
-    TAO_InputCDR &strm,
-    std::vector<Param_Test::Step &_tao_vector)
-  {
-    ::CORBA::ULong length = 0UL;
-    Param_Test::Step * tmp;
-    
-    for ( ::CORBA::ULong i = 0UL; i < length; ++i)
-      {
-        if (! strm >> tmp)
-          {
-            return false;
-          }
-        
-        _tao_vector[i] = tmp;
-      }
-    
-    return true;
-  }
+  return true;
+}
+
+::CORBA::Boolean operator>> (
+  TAO_InputCDR &strm,
+  std::vector<Param_Test::Step> &_tao_vector)
+{
+  ::CORBA::ULong length = 0UL;
+  Param_Test::Step * tmp;
   
+  if (! (strm >> length))
+    {
+      return false;
+    }
   
+  for ( ::CORBA::ULong i = 0UL; i < length; ++i)
+    {
+      if (! (strm >> tmp))
+        {
+          return false;
+        }
+      
+      _tao_vector[i] = tmp;
+    }
+  
+  return true;
+}
+
+
 TAO_END_VERSIONED_NAMESPACE_DECL
 
-  #endif /* _TAO_CDR_OP_Param_Test_PathSpec_CPP_ */
-  
-  // TAO_IDL - Generated from
-  // w:\tao\tao_idl\be\be_visitor_sequence/cdr_op_cs.cpp:96
-  #if !defined _TAO_CDR_OP_Param_Test_Bounded_Short_Seq_CPP_
-  #define _TAO_CDR_OP_Param_Test_Bounded_Short_Seq_CPP_
-  
+#endif /* _TAO_CDR_OP_Param_Test_PathSpec_CPP_ */
+
+// TAO_IDL - Generated from
+// w:\tao\tao_idl\be\be_visitor_sequence/cdr_op_cs.cpp:96
+#if !defined _TAO_CDR_OP_Param_Test_Bounded_Short_Seq_CPP_
+#define _TAO_CDR_OP_Param_Test_Bounded_Short_Seq_CPP_
+
 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
 
-  ::CORBA::Boolean operator<< (
-    TAO_OutputCDR &strm,
-    const std:;vector<CORBA::Short &_tao_vector)
-  {
-    ::CORBA::ULong length = _tao_vector.size ();
-    strm << length;
-    
-    for ( ::CORBA::ULong i = 0UL; i < length; ++i)
-      {
-        if (! strm << _tao_vector[i]
-          {
-            return false;
-          }
+::CORBA::Boolean operator<< (
+  TAO_OutputCDR &strm,
+  const std::vector<CORBA::Short> &_tao_vector)
+{
+  ::CORBA::ULong length = _tao_vector.size ();
+  strm << length;
+  
+  for ( ::CORBA::ULong i = 0UL; i < length; ++i)
+    {
+      if (! (strm << _tao_vector[i]))
+        {
+          return false;
         }
-      
-      return true;
     }
-    
-    ::CORBA::Boolean operator>> (
-      TAO_InputCDR &strm,
-      std::vector<CORBA::Short &_tao_vector)
+  
+  return true;
+}
+
+::CORBA::Boolean operator>> (
+  TAO_InputCDR &strm,
+  std::vector<CORBA::Short> &_tao_vector)
+{
+  ::CORBA::ULong length = 0UL;
+  CORBA::Short tmp;
+  
+  if (! (strm >> length))
     {
-      ::CORBA::ULong length = 0UL;
-      CORBA::Short tmp;
-      
-      for ( ::CORBA::ULong i = 0UL; i < length; ++i)
+      return false;
+    }
+  
+  for ( ::CORBA::ULong i = 0UL; i < length; ++i)
+    {
+      if (! (strm >> tmp))
         {
-          if (! strm >> tmp)
-            {
-              return false;
-            }
-          
-          _tao_vector[i] = tmp;
+          return false;
         }
       
-      return true;
+      _tao_vector[i] = tmp;
     }
-    
-    
+  
+  return true;
+}
+
+
 TAO_END_VERSIONED_NAMESPACE_DECL
 
-    #endif /* _TAO_CDR_OP_Param_Test_Bounded_Short_Seq_CPP_ */
-    
-    // TAO_IDL - Generated from
-    // w:\tao\tao_idl\be\be_visitor_sequence/cdr_op_cs.cpp:96
-    #if !defined _TAO_CDR_OP_Param_Test_Bounded_Long_Seq_CPP_
-    #define _TAO_CDR_OP_Param_Test_Bounded_Long_Seq_CPP_
-    
+#endif /* _TAO_CDR_OP_Param_Test_Bounded_Short_Seq_CPP_ */
+
+// TAO_IDL - Generated from
+// w:\tao\tao_idl\be\be_visitor_sequence/cdr_op_cs.cpp:96
+#if !defined _TAO_CDR_OP_Param_Test_Bounded_Long_Seq_CPP_
+#define _TAO_CDR_OP_Param_Test_Bounded_Long_Seq_CPP_
+
 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
 
-    ::CORBA::Boolean operator<< (
-      TAO_OutputCDR &strm,
-      const std:;vector<CORBA::Long &_tao_vector)
+::CORBA::Boolean operator<< (
+  TAO_OutputCDR &strm,
+  const std::vector<CORBA::Long> &_tao_vector)
+{
+  ::CORBA::ULong length = _tao_vector.size ();
+  strm << length;
+  
+  for ( ::CORBA::ULong i = 0UL; i < length; ++i)
     {
-      ::CORBA::ULong length = _tao_vector.size ();
-      strm << length;
-      
-      for ( ::CORBA::ULong i = 0UL; i < length; ++i)
+      if (! (strm << _tao_vector[i]))
         {
-          if (! strm << _tao_vector[i]
-            {
-              return false;
-            }
-          }
-        
-        return true;
-      }
-      
-      ::CORBA::Boolean operator>> (
-        TAO_InputCDR &strm,
-        std::vector<CORBA::Long &_tao_vector)
-      {
-        ::CORBA::ULong length = 0UL;
-        CORBA::Long tmp;
-        
-        for ( ::CORBA::ULong i = 0UL; i < length; ++i)
-          {
-            if (! strm >> tmp)
-              {
-                return false;
-              }
-            
-            _tao_vector[i] = tmp;
-          }
-        
-        return true;
-      }
-      
+          return false;
+        }
+    }
+  
+  return true;
+}
+
+::CORBA::Boolean operator>> (
+  TAO_InputCDR &strm,
+  std::vector<CORBA::Long> &_tao_vector)
+{
+  ::CORBA::ULong length = 0UL;
+  CORBA::Long tmp;
+  
+  if (! (strm >> length))
+    {
+      return false;
+    }
+  
+  for ( ::CORBA::ULong i = 0UL; i < length; ++i)
+    {
+      if (! (strm >> tmp))
+        {
+          return false;
+        }
       
+      _tao_vector[i] = tmp;
+    }
+  
+  return true;
+}
+
+
 TAO_END_VERSIONED_NAMESPACE_DECL
 
-      #endif /* _TAO_CDR_OP_Param_Test_Bounded_Long_Seq_CPP_ */
-      
-      // TAO_IDL - Generated from
-      // w:\tao\tao_idl\be\be_visitor_sequence/cdr_op_cs.cpp:96
-      #if !defined _TAO_CDR_OP_Param_Test_Bounded_StrSeq_CPP_
-      #define _TAO_CDR_OP_Param_Test_Bounded_StrSeq_CPP_
-      
+#endif /* _TAO_CDR_OP_Param_Test_Bounded_Long_Seq_CPP_ */
+
+// TAO_IDL - Generated from
+// w:\tao\tao_idl\be\be_visitor_sequence/cdr_op_cs.cpp:96
+#if !defined _TAO_CDR_OP_Param_Test_Bounded_StrSeq_CPP_
+#define _TAO_CDR_OP_Param_Test_Bounded_StrSeq_CPP_
+
 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
 
-      ::CORBA::Boolean operator<< (
-        TAO_OutputCDR &strm,
-        const std:;vector<char * &_tao_vector)
-      {
-        ::CORBA::ULong length = _tao_vector.size ();
-        strm << length;
-        
-        for ( ::CORBA::ULong i = 0UL; i < length; ++i)
-          {
-            if (! strm << _tao_vector[i]
-              {
-                return false;
-              }
-            }
-          
-          return true;
+::CORBA::Boolean operator<< (
+  TAO_OutputCDR &strm,
+  const std::vector<char *> &_tao_vector)
+{
+  ::CORBA::ULong length = _tao_vector.size ();
+  strm << length;
+  
+  for ( ::CORBA::ULong i = 0UL; i < length; ++i)
+    {
+      if (! (strm << _tao_vector[i]))
+        {
+          return false;
         }
-        
-        ::CORBA::Boolean operator>> (
-          TAO_InputCDR &strm,
-          std::vector<char * &_tao_vector)
+    }
+  
+  return true;
+}
+
+::CORBA::Boolean operator>> (
+  TAO_InputCDR &strm,
+  std::vector<char *> &_tao_vector)
+{
+  ::CORBA::ULong length = 0UL;
+  char * * tmp;
+  
+  if (! (strm >> length))
+    {
+      return false;
+    }
+  
+  for ( ::CORBA::ULong i = 0UL; i < length; ++i)
+    {
+      if (! (strm >> tmp))
         {
-          ::CORBA::ULong length = 0UL;
-          char * * tmp;
-          
-          for ( ::CORBA::ULong i = 0UL; i < length; ++i)
-            {
-              if (! strm >> tmp)
-                {
-                  return false;
-                }
-              
-              _tao_vector[i] = tmp;
-            }
-          
-          return true;
+          return false;
         }
-        
-        
+      
+      _tao_vector[i] = tmp;
+    }
+  
+  return true;
+}
+
+
 TAO_END_VERSIONED_NAMESPACE_DECL
 
-        #endif /* _TAO_CDR_OP_Param_Test_Bounded_StrSeq_CPP_ */
-        
-        // TAO_IDL - Generated from
-        // w:\tao\tao_idl\be\be_visitor_sequence/cdr_op_cs.cpp:96
-        #if !defined _TAO_CDR_OP_Param_Test_Bounded_WStrSeq_CPP_
-        #define _TAO_CDR_OP_Param_Test_Bounded_WStrSeq_CPP_
-        
+#endif /* _TAO_CDR_OP_Param_Test_Bounded_StrSeq_CPP_ */
+
+// TAO_IDL - Generated from
+// w:\tao\tao_idl\be\be_visitor_sequence/cdr_op_cs.cpp:96
+#if !defined _TAO_CDR_OP_Param_Test_Bounded_WStrSeq_CPP_
+#define _TAO_CDR_OP_Param_Test_Bounded_WStrSeq_CPP_
+
 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
 
-        ::CORBA::Boolean operator<< (
-          TAO_OutputCDR &strm,
-          const std:;vector<CORBA::WChar * &_tao_vector)
+::CORBA::Boolean operator<< (
+  TAO_OutputCDR &strm,
+  const std::vector<CORBA::WChar *> &_tao_vector)
+{
+  ::CORBA::ULong length = _tao_vector.size ();
+  strm << length;
+  
+  for ( ::CORBA::ULong i = 0UL; i < length; ++i)
+    {
+      if (! (strm << _tao_vector[i]))
         {
-          ::CORBA::ULong length = _tao_vector.size ();
-          strm << length;
-          
-          for ( ::CORBA::ULong i = 0UL; i < length; ++i)
-            {
-              if (! strm << _tao_vector[i]
-                {
-                  return false;
-                }
-              }
-            
-            return true;
-          }
-          
-          ::CORBA::Boolean operator>> (
-            TAO_InputCDR &strm,
-            std::vector<CORBA::WChar * &_tao_vector)
-          {
-            ::CORBA::ULong length = 0UL;
-            CORBA::WChar * * tmp;
-            
-            for ( ::CORBA::ULong i = 0UL; i < length; ++i)
-              {
-                if (! strm >> tmp)
-                  {
-                    return false;
-                  }
-                
-                _tao_vector[i] = tmp;
-              }
-            
-            return true;
-          }
-          
-          
+          return false;
+        }
+    }
+  
+  return true;
+}
+
+::CORBA::Boolean operator>> (
+  TAO_InputCDR &strm,
+  std::vector<CORBA::WChar *> &_tao_vector)
+{
+  ::CORBA::ULong length = 0UL;
+  CORBA::WChar * * tmp;
+  
+  if (! (strm >> length))
+    {
+      return false;
+    }
+  
+  for ( ::CORBA::ULong i = 0UL; i < length; ++i)
+    {
+      if (! (strm >> tmp))
+        {
+          return false;
+        }
+      
+      _tao_vector[i] = tmp;
+    }
+  
+  return true;
+}
+
+
 TAO_END_VERSIONED_NAMESPACE_DECL
 
-          #endif /* _TAO_CDR_OP_Param_Test_Bounded_WStrSeq_CPP_ */
-          
-          // TAO_IDL - Generated from
-          // w:\tao\tao_idl\be\be_visitor_sequence/cdr_op_cs.cpp:96
-          #if !defined _TAO_CDR_OP_Param_Test_StructSeq_CPP_
-          #define _TAO_CDR_OP_Param_Test_StructSeq_CPP_
-          
+#endif /* _TAO_CDR_OP_Param_Test_Bounded_WStrSeq_CPP_ */
+
+// TAO_IDL - Generated from
+// w:\tao\tao_idl\be\be_visitor_sequence/cdr_op_cs.cpp:96
+#if !defined _TAO_CDR_OP_Param_Test_StructSeq_CPP_
+#define _TAO_CDR_OP_Param_Test_StructSeq_CPP_
+
 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
 
-          ::CORBA::Boolean operator<< (
-            TAO_OutputCDR &strm,
-            const std:;vector<Param_Test::Fixed_Struct &_tao_vector)
-          {
-            ::CORBA::ULong length = _tao_vector.size ();
-            strm << length;
-            
-            for ( ::CORBA::ULong i = 0UL; i < length; ++i)
-              {
-                if (! strm << _tao_vector[i]
-                  {
-                    return false;
-                  }
-                }
-              
-              return true;
-            }
-            
-            ::CORBA::Boolean operator>> (
-              TAO_InputCDR &strm,
-              std::vector<Param_Test::Fixed_Struct &_tao_vector)
-            {
-              ::CORBA::ULong length = 0UL;
-              Param_Test::Fixed_Struct tmp;
-              
-              for ( ::CORBA::ULong i = 0UL; i < length; ++i)
-                {
-                  if (! strm >> tmp)
-                    {
-                      return false;
-                    }
-                  
-                  _tao_vector[i] = tmp;
-                }
-              
-              return true;
-            }
-            
-            
+::CORBA::Boolean operator<< (
+  TAO_OutputCDR &strm,
+  const std::vector<Param_Test::Fixed_Struct> &_tao_vector)
+{
+  ::CORBA::ULong length = _tao_vector.size ();
+  strm << length;
+  
+  for ( ::CORBA::ULong i = 0UL; i < length; ++i)
+    {
+      if (! (strm << _tao_vector[i]))
+        {
+          return false;
+        }
+    }
+  
+  return true;
+}
+
+::CORBA::Boolean operator>> (
+  TAO_InputCDR &strm,
+  std::vector<Param_Test::Fixed_Struct> &_tao_vector)
+{
+  ::CORBA::ULong length = 0UL;
+  Param_Test::Fixed_Struct tmp;
+  
+  if (! (strm >> length))
+    {
+      return false;
+    }
+  
+  for ( ::CORBA::ULong i = 0UL; i < length; ++i)
+    {
+      if (! (strm >> tmp))
+        {
+          return false;
+        }
+      
+      _tao_vector[i] = tmp;
+    }
+  
+  return true;
+}
+
+
 TAO_END_VERSIONED_NAMESPACE_DECL
 
-            #endif /* _TAO_CDR_OP_Param_Test_StructSeq_CPP_ */
-            
-            // TAO_IDL - Generated from
-            // w:\tao\tao_idl\be\be_visitor_sequence/cdr_op_cs.cpp:96
-            #if !defined _TAO_CDR_OP_Param_Test_Bounded_StructSeq_CPP_
-            #define _TAO_CDR_OP_Param_Test_Bounded_StructSeq_CPP_
-            
+#endif /* _TAO_CDR_OP_Param_Test_StructSeq_CPP_ */
+
+// TAO_IDL - Generated from
+// w:\tao\tao_idl\be\be_visitor_sequence/cdr_op_cs.cpp:96
+#if !defined _TAO_CDR_OP_Param_Test_Bounded_StructSeq_CPP_
+#define _TAO_CDR_OP_Param_Test_Bounded_StructSeq_CPP_
+
 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
 
-            ::CORBA::Boolean operator<< (
-              TAO_OutputCDR &strm,
-              const std:;vector<Param_Test::Fixed_Struct &_tao_vector)
-            {
-              ::CORBA::ULong length = _tao_vector.size ();
-              strm << length;
-              
-              for ( ::CORBA::ULong i = 0UL; i < length; ++i)
-                {
-                  if (! strm << _tao_vector[i]
-                    {
-                      return false;
-                    }
-                  }
-                
-                return true;
-              }
-              
-              ::CORBA::Boolean operator>> (
-                TAO_InputCDR &strm,
-                std::vector<Param_Test::Fixed_Struct &_tao_vector)
-              {
-                ::CORBA::ULong length = 0UL;
-                Param_Test::Fixed_Struct tmp;
-                
-                for ( ::CORBA::ULong i = 0UL; i < length; ++i)
-                  {
-                    if (! strm >> tmp)
-                      {
-                        return false;
-                      }
-                    
-                    _tao_vector[i] = tmp;
-                  }
-                
-                return true;
-              }
-              
-              
+::CORBA::Boolean operator<< (
+  TAO_OutputCDR &strm,
+  const std::vector<Param_Test::Fixed_Struct> &_tao_vector)
+{
+  ::CORBA::ULong length = _tao_vector.size ();
+  strm << length;
+  
+  for ( ::CORBA::ULong i = 0UL; i < length; ++i)
+    {
+      if (! (strm << _tao_vector[i]))
+        {
+          return false;
+        }
+    }
+  
+  return true;
+}
+
+::CORBA::Boolean operator>> (
+  TAO_InputCDR &strm,
+  std::vector<Param_Test::Fixed_Struct> &_tao_vector)
+{
+  ::CORBA::ULong length = 0UL;
+  Param_Test::Fixed_Struct tmp;
+  
+  if (! (strm >> length))
+    {
+      return false;
+    }
+  
+  for ( ::CORBA::ULong i = 0UL; i < length; ++i)
+    {
+      if (! (strm >> tmp))
+        {
+          return false;
+        }
+      
+      _tao_vector[i] = tmp;
+    }
+  
+  return true;
+}
+
+
 TAO_END_VERSIONED_NAMESPACE_DECL
 
-              #endif /* _TAO_CDR_OP_Param_Test_Bounded_StructSeq_CPP_ */
-              
-              // TAO_IDL - Generated from
-              // w:\tao\tao_idl\be\be_visitor_sequence/cdr_op_cs.cpp:96
-              #if !defined _TAO_CDR_OP_Param_Test_Coffee_Mix_CPP_
-              #define _TAO_CDR_OP_Param_Test_Coffee_Mix_CPP_
-              
+#endif /* _TAO_CDR_OP_Param_Test_Bounded_StructSeq_CPP_ */
+
+// TAO_IDL - Generated from
+// w:\tao\tao_idl\be\be_visitor_sequence/cdr_op_cs.cpp:96
+#if !defined _TAO_CDR_OP_Param_Test_Coffee_Mix_CPP_
+#define _TAO_CDR_OP_Param_Test_Coffee_Mix_CPP_
+
 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
 
-              ::CORBA::Boolean operator<< (
-                TAO_OutputCDR &strm,
-                const std:;vector<Coffee &_tao_vector)
-              {
-                ::CORBA::ULong length = _tao_vector.size ();
-                strm << length;
-                
-                for ( ::CORBA::ULong i = 0UL; i < length; ++i)
-                  {
-                    if (! strm << _tao_vector[i]
-                      {
-                        return false;
-                      }
-                    }
-                  
-                  return true;
-                }
-                
-                ::CORBA::Boolean operator>> (
-                  TAO_InputCDR &strm,
-                  std::vector<Coffee &_tao_vector)
-                {
-                  ::CORBA::ULong length = 0UL;
-                  Coffee * tmp;
-                  
-                  for ( ::CORBA::ULong i = 0UL; i < length; ++i)
-                    {
-                      if (! strm >> tmp)
-                        {
-                          return false;
-                        }
-                      
-                      _tao_vector[i] = tmp;
-                    }
-                  
-                  return true;
-                }
-                
-                
+::CORBA::Boolean operator<< (
+  TAO_OutputCDR &strm,
+  const std::vector<Coffee> &_tao_vector)
+{
+  ::CORBA::ULong length = _tao_vector.size ();
+  strm << length;
+  
+  for ( ::CORBA::ULong i = 0UL; i < length; ++i)
+    {
+      if (! (strm << _tao_vector[i]))
+        {
+          return false;
+        }
+    }
+  
+  return true;
+}
+
+::CORBA::Boolean operator>> (
+  TAO_InputCDR &strm,
+  std::vector<Coffee> &_tao_vector)
+{
+  ::CORBA::ULong length = 0UL;
+  Coffee * tmp;
+  
+  if (! (strm >> length))
+    {
+      return false;
+    }
+  
+  for ( ::CORBA::ULong i = 0UL; i < length; ++i)
+    {
+      if (! (strm >> tmp))
+        {
+          return false;
+        }
+      
+      _tao_vector[i] = tmp;
+    }
+  
+  return true;
+}
+
+
 TAO_END_VERSIONED_NAMESPACE_DECL
 
-                #endif /* _TAO_CDR_OP_Param_Test_Coffee_Mix_CPP_ */
-                
-                // TAO_IDL - Generated from
-                // w:\tao\tao_idl\be\be_visitor_sequence/cdr_op_cs.cpp:96
-                #if !defined _TAO_CDR_OP_Param_Test_Bounded_Coffee_Mix_CPP_
-                #define _TAO_CDR_OP_Param_Test_Bounded_Coffee_Mix_CPP_
-                
+#endif /* _TAO_CDR_OP_Param_Test_Coffee_Mix_CPP_ */
+
+// TAO_IDL - Generated from
+// w:\tao\tao_idl\be\be_visitor_sequence/cdr_op_cs.cpp:96
+#if !defined _TAO_CDR_OP_Param_Test_Bounded_Coffee_Mix_CPP_
+#define _TAO_CDR_OP_Param_Test_Bounded_Coffee_Mix_CPP_
+
 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
 
-                ::CORBA::Boolean operator<< (
-                  TAO_OutputCDR &strm,
-                  const std:;vector<Coffee &_tao_vector)
-                {
-                  ::CORBA::ULong length = _tao_vector.size ();
-                  strm << length;
-                  
-                  for ( ::CORBA::ULong i = 0UL; i < length; ++i)
-                    {
-                      if (! strm << _tao_vector[i]
-                        {
-                          return false;
-                        }
-                      }
-                    
-                    return true;
-                  }
-                  
-                  ::CORBA::Boolean operator>> (
-                    TAO_InputCDR &strm,
-                    std::vector<Coffee &_tao_vector)
-                  {
-                    ::CORBA::ULong length = 0UL;
-                    Coffee * tmp;
-                    
-                    for ( ::CORBA::ULong i = 0UL; i < length; ++i)
-                      {
-                        if (! strm >> tmp)
-                          {
-                            return false;
-                          }
-                        
-                        _tao_vector[i] = tmp;
-                      }
-                    
-                    return true;
-                  }
-                  
-                  
+::CORBA::Boolean operator<< (
+  TAO_OutputCDR &strm,
+  const std::vector<Coffee> &_tao_vector)
+{
+  ::CORBA::ULong length = _tao_vector.size ();
+  strm << length;
+  
+  for ( ::CORBA::ULong i = 0UL; i < length; ++i)
+    {
+      if (! (strm << _tao_vector[i]))
+        {
+          return false;
+        }
+    }
+  
+  return true;
+}
+
+::CORBA::Boolean operator>> (
+  TAO_InputCDR &strm,
+  std::vector<Coffee> &_tao_vector)
+{
+  ::CORBA::ULong length = 0UL;
+  Coffee * tmp;
+  
+  if (! (strm >> length))
+    {
+      return false;
+    }
+  
+  for ( ::CORBA::ULong i = 0UL; i < length; ++i)
+    {
+      if (! (strm >> tmp))
+        {
+          return false;
+        }
+      
+      _tao_vector[i] = tmp;
+    }
+  
+  return true;
+}
+
+
 TAO_END_VERSIONED_NAMESPACE_DECL
 
-                  #endif /* _TAO_CDR_OP_Param_Test_Bounded_Coffee_Mix_CPP_ */
-                  
-                  // TAO_IDL - Generated from
-                  // w:\tao\tao_idl\be\be_visitor_structure/cdr_op_cs.cpp:61
-                  
-                  
+#endif /* _TAO_CDR_OP_Param_Test_Bounded_Coffee_Mix_CPP_ */
+
+// TAO_IDL - Generated from
+// w:\tao\tao_idl\be\be_visitor_structure/cdr_op_cs.cpp:61
+
+
 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
 
-                  ::CORBA::Boolean operator<< (
-                      TAO_OutputCDR &strm,
-                      const Param_Test::Var_Struct &_tao_aggregate
-                    )
-                  {
-                    return
-                      (strm << _tao_aggregate.dbl) &&
-                      (strm << _tao_aggregate.dummy1.in ()) &&
-                      (strm << ::ACE_OutputCDR::from_boolean (_tao_aggregate.boole)) &&
-                      (strm << _tao_aggregate.dummy2.in ()) &&
-                      (strm << _tao_aggregate.shrt) &&
-                      (strm << _tao_aggregate.seq);
-                  }
-                  
-                  ::CORBA::Boolean operator>> (
-                      TAO_InputCDR &strm,
-                      Param_Test::Var_Struct &_tao_aggregate
-                    )
-                  {
-                    return
-                      (strm >> _tao_aggregate.dbl) &&
-                      (strm >> _tao_aggregate.dummy1.out ()) &&
-                      (strm >> ::ACE_InputCDR::to_boolean (_tao_aggregate.boole)) &&
-                      (strm >> _tao_aggregate.dummy2.out ()) &&
-                      (strm >> _tao_aggregate.shrt) &&
-                      (strm >> _tao_aggregate.seq);
-                }
-                
+::CORBA::Boolean operator<< (
+    TAO_OutputCDR &strm,
+    const Param_Test::Var_Struct &_tao_aggregate
+  )
+{
+  return
+    (strm << _tao_aggregate.dbl) &&
+    (strm << _tao_aggregate.dummy1.in ()) &&
+    (strm << ::ACE_OutputCDR::from_boolean (_tao_aggregate.boole)) &&
+    (strm << _tao_aggregate.dummy2.in ()) &&
+    (strm << _tao_aggregate.shrt) &&
+    (strm << _tao_aggregate.seq);
+}
+
+::CORBA::Boolean operator>> (
+    TAO_InputCDR &strm,
+    Param_Test::Var_Struct &_tao_aggregate
+  )
+{
+  return
+    (strm >> _tao_aggregate.dbl) &&
+    (strm >> _tao_aggregate.dummy1.out ()) &&
+    (strm >> ::ACE_InputCDR::to_boolean (_tao_aggregate.boole)) &&
+    (strm >> _tao_aggregate.dummy2.out ()) &&
+    (strm >> _tao_aggregate.shrt) &&
+    (strm >> _tao_aggregate.seq);
+}
+
 TAO_END_VERSIONED_NAMESPACE_DECL
 
-                
-                
-                // TAO_IDL - Generated from
-                // w:\tao\tao_idl\be\be_visitor_structure/cdr_op_cs.cpp:61
-                
-                
+
+
+// TAO_IDL - Generated from
+// w:\tao\tao_idl\be\be_visitor_structure/cdr_op_cs.cpp:61
+
+
 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
 
-                ::CORBA::Boolean operator<< (
-                    TAO_OutputCDR &strm,
-                    const Param_Test::Nested_Struct &_tao_aggregate
-                  )
-                {
-                  return
-                    (strm << _tao_aggregate.vs);
-                }
-                
-                ::CORBA::Boolean operator>> (
-                    TAO_InputCDR &strm,
-                    Param_Test::Nested_Struct &_tao_aggregate
-                  )
-                {
-                  return
-                    (strm >> _tao_aggregate.vs);
-              }
-              
+::CORBA::Boolean operator<< (
+    TAO_OutputCDR &strm,
+    const Param_Test::Nested_Struct &_tao_aggregate
+  )
+{
+  return
+    (strm << _tao_aggregate.vs);
+}
+
+::CORBA::Boolean operator>> (
+    TAO_InputCDR &strm,
+    Param_Test::Nested_Struct &_tao_aggregate
+  )
+{
+  return
+    (strm >> _tao_aggregate.vs);
+}
+
 TAO_END_VERSIONED_NAMESPACE_DECL
 
-              
-              
-              // TAO_IDL - Generated from
-              // w:\tao\tao_idl\be\be_visitor_structure/cdr_op_cs.cpp:61
-              
-              
+
+
+// TAO_IDL - Generated from
+// w:\tao\tao_idl\be\be_visitor_structure/cdr_op_cs.cpp:61
+
+
 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
 
-              ::CORBA::Boolean operator<< (
-                  TAO_OutputCDR &strm,
-                  const Param_Test::Objref_Struct &_tao_aggregate
-                )
-              {
-                return
-                  (strm << _tao_aggregate.x) &&
-                  ::CORBA::Object::marshal (
-                      _tao_aggregate.y.in (),
-                      strm
-                    );
-              }
-              
-              ::CORBA::Boolean operator>> (
-                  TAO_InputCDR &strm,
-                  Param_Test::Objref_Struct &_tao_aggregate
-                )
-              {
-                return
-                  (strm >> _tao_aggregate.x) &&
-                  (strm >> _tao_aggregate.y.out ());
-            }
-            
+::CORBA::Boolean operator<< (
+    TAO_OutputCDR &strm,
+    const Param_Test::Objref_Struct &_tao_aggregate
+  )
+{
+  return
+    (strm << _tao_aggregate.x) &&
+    ::CORBA::Object::marshal (
+        _tao_aggregate.y.in (),
+        strm
+      );
+}
+
+::CORBA::Boolean operator>> (
+    TAO_InputCDR &strm,
+    Param_Test::Objref_Struct &_tao_aggregate
+  )
+{
+  return
+    (strm >> _tao_aggregate.x) &&
+    (strm >> _tao_aggregate.y.out ());
+}
+
 TAO_END_VERSIONED_NAMESPACE_DECL
 
-            
-            
-            // TAO_IDL - Generated from
-            // w:\tao\tao_idl\be\be_visitor_array/cdr_op_cs.cpp:178
-            
-            
+
+
+// TAO_IDL - Generated from
+// w:\tao\tao_idl\be\be_visitor_array/cdr_op_cs.cpp:178
+
+
 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
 
-            ::CORBA::Boolean operator<< (
-                TAO_OutputCDR &strm,
-                const Param_Test::Fixed_Array_forany &_tao_array
-              )
-            {
-              return
-                strm.write_long_array (
-                    reinterpret_cast <const ACE_CDR::Long *> (_tao_array.in ()),
-                    10
-                  );
-            }
-            
-            ::CORBA::Boolean operator>> (
-                TAO_InputCDR &strm,
-                Param_Test::Fixed_Array_forany &_tao_array
-              )
-            {
-              return
-                strm.read_long_array (
-                    reinterpret_cast <ACE_CDR::Long *> (_tao_array.out ()),
-                    10
-                  );
-            }
-            
+::CORBA::Boolean operator<< (
+    TAO_OutputCDR &strm,
+    const Param_Test::Fixed_Array_forany &_tao_array
+  )
+{
+  return
+    strm.write_long_array (
+        reinterpret_cast <const ACE_CDR::Long *> (_tao_array.in ()),
+        10
+      );
+}
+
+::CORBA::Boolean operator>> (
+    TAO_InputCDR &strm,
+    Param_Test::Fixed_Array_forany &_tao_array
+  )
+{
+  return
+    strm.read_long_array (
+        reinterpret_cast <ACE_CDR::Long *> (_tao_array.out ()),
+        10
+      );
+}
+
 TAO_END_VERSIONED_NAMESPACE_DECL
 
-            
-            
-            // TAO_IDL - Generated from
-            // w:\tao\tao_idl\be\be_visitor_array/cdr_op_cs.cpp:178
-            
-            
+
+
+// TAO_IDL - Generated from
+// w:\tao\tao_idl\be\be_visitor_array/cdr_op_cs.cpp:178
+
+
 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
 
-            ::CORBA::Boolean operator<< (
-                TAO_OutputCDR &strm,
-                const Param_Test::Var_Array_forany &_tao_array
-              )
-            {
-              CORBA::Boolean _tao_marshal_flag = true;
-              
-              for ( ::CORBA::ULong i0 = 0; i0 < 5 && _tao_marshal_flag; ++i0)
-                {
-                  _tao_marshal_flag = (strm << _tao_array [i0].in ());
-                }
-              
-              return _tao_marshal_flag;
-            }
-            
-            ::CORBA::Boolean operator>> (
-                TAO_InputCDR &strm,
-                Param_Test::Var_Array_forany &_tao_array
-              )
-            {
-              CORBA::Boolean _tao_marshal_flag = true;
-              
-              for ( ::CORBA::ULong i0 = 0; i0 < 5 && _tao_marshal_flag; ++i0)
-                {
-                  _tao_marshal_flag = (strm >> _tao_array [i0].out ());
-                }
-              
-              return _tao_marshal_flag;
-            }
-            
+::CORBA::Boolean operator<< (
+    TAO_OutputCDR &strm,
+    const Param_Test::Var_Array_forany &_tao_array
+  )
+{
+  CORBA::Boolean _tao_marshal_flag = true;
+  
+  for ( ::CORBA::ULong i0 = 0; i0 < 5 && _tao_marshal_flag; ++i0)
+    {
+      _tao_marshal_flag = (strm << _tao_array [i0].in ());
+    }
+  
+  return _tao_marshal_flag;
+}
+
+::CORBA::Boolean operator>> (
+    TAO_InputCDR &strm,
+    Param_Test::Var_Array_forany &_tao_array
+  )
+{
+  CORBA::Boolean _tao_marshal_flag = true;
+  
+  for ( ::CORBA::ULong i0 = 0; i0 < 5 && _tao_marshal_flag; ++i0)
+    {
+      _tao_marshal_flag = (strm >> _tao_array [i0].out ());
+    }
+  
+  return _tao_marshal_flag;
+}
+
 TAO_END_VERSIONED_NAMESPACE_DECL
 
-            
-            
-            // TAO_IDL - Generated from
-            // w:\tao\tao_idl\be\be_visitor_sequence/cdr_op_cs.cpp:96
-            #if !defined _TAO_CDR_OP_Param_Test_ArraySeq_CPP_
-            #define _TAO_CDR_OP_Param_Test_ArraySeq_CPP_
-            
+
+
+// TAO_IDL - Generated from
+// w:\tao\tao_idl\be\be_visitor_sequence/cdr_op_cs.cpp:96
+#if !defined _TAO_CDR_OP_Param_Test_ArraySeq_CPP_
+#define _TAO_CDR_OP_Param_Test_ArraySeq_CPP_
+
 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
 
-            ::CORBA::Boolean operator<< (
-              TAO_OutputCDR &strm,
-              const std:;vector<Param_Test::Fixed_Array &_tao_vector)
-            {
-              ::CORBA::ULong length = _tao_vector.size ();
-              strm << length;
-              
-              for ( ::CORBA::ULong i = 0UL; i < length; ++i)
-                {
-                  if (! strm << _tao_vector[i]
-                    {
-                      return false;
-                    }
-                  }
-                
-                return true;
-              }
-              
-              ::CORBA::Boolean operator>> (
-                TAO_InputCDR &strm,
-                std::vector<Param_Test::Fixed_Array &_tao_vector)
-              {
-                ::CORBA::ULong length = 0UL;
-                Param_Test::Fixed_Array tmp;
-                
-                for ( ::CORBA::ULong i = 0UL; i < length; ++i)
-                  {
-                    if (! strm >> tmp)
-                      {
-                        return false;
-                      }
-                    
-                    _tao_vector[i] = tmp;
-                  }
-                
-                return true;
-              }
-              
-              
+::CORBA::Boolean operator<< (
+  TAO_OutputCDR &strm,
+  const std::vector<Param_Test::Fixed_Array> &_tao_vector)
+{
+  ::CORBA::ULong length = _tao_vector.size ();
+  strm << length;
+  
+  for ( ::CORBA::ULong i = 0UL; i < length; ++i)
+    {
+      if (! (strm << _tao_vector[i]))
+        {
+          return false;
+        }
+    }
+  
+  return true;
+}
+
+::CORBA::Boolean operator>> (
+  TAO_InputCDR &strm,
+  std::vector<Param_Test::Fixed_Array> &_tao_vector)
+{
+  ::CORBA::ULong length = 0UL;
+  Param_Test::Fixed_Array tmp;
+  
+  if (! (strm >> length))
+    {
+      return false;
+    }
+  
+  for ( ::CORBA::ULong i = 0UL; i < length; ++i)
+    {
+      if (! (strm >> tmp))
+        {
+          return false;
+        }
+      
+      _tao_vector[i] = tmp;
+    }
+  
+  return true;
+}
+
+
 TAO_END_VERSIONED_NAMESPACE_DECL
 
-              #endif /* _TAO_CDR_OP_Param_Test_ArraySeq_CPP_ */
-              
-              // TAO_IDL - Generated from
-              // w:\tao\tao_idl\be\be_visitor_sequence/cdr_op_cs.cpp:96
-              #if !defined _TAO_CDR_OP_Param_Test_Bounded_ArraySeq_CPP_
-              #define _TAO_CDR_OP_Param_Test_Bounded_ArraySeq_CPP_
-              
+#endif /* _TAO_CDR_OP_Param_Test_ArraySeq_CPP_ */
+
+// TAO_IDL - Generated from
+// w:\tao\tao_idl\be\be_visitor_sequence/cdr_op_cs.cpp:96
+#if !defined _TAO_CDR_OP_Param_Test_Bounded_ArraySeq_CPP_
+#define _TAO_CDR_OP_Param_Test_Bounded_ArraySeq_CPP_
+
 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
 
-              ::CORBA::Boolean operator<< (
-                TAO_OutputCDR &strm,
-                const std:;vector<Param_Test::Fixed_Array &_tao_vector)
-              {
-                ::CORBA::ULong length = _tao_vector.size ();
-                strm << length;
-                
-                for ( ::CORBA::ULong i = 0UL; i < length; ++i)
-                  {
-                    if (! strm << _tao_vector[i]
-                      {
-                        return false;
-                      }
-                    }
-                  
-                  return true;
-                }
-                
-                ::CORBA::Boolean operator>> (
-                  TAO_InputCDR &strm,
-                  std::vector<Param_Test::Fixed_Array &_tao_vector)
-                {
-                  ::CORBA::ULong length = 0UL;
-                  Param_Test::Fixed_Array tmp;
-                  
-                  for ( ::CORBA::ULong i = 0UL; i < length; ++i)
-                    {
-                      if (! strm >> tmp)
-                        {
-                          return false;
-                        }
-                      
-                      _tao_vector[i] = tmp;
-                    }
-                  
-                  return true;
-                }
-                
-                
+::CORBA::Boolean operator<< (
+  TAO_OutputCDR &strm,
+  const std::vector<Param_Test::Fixed_Array> &_tao_vector)
+{
+  ::CORBA::ULong length = _tao_vector.size ();
+  strm << length;
+  
+  for ( ::CORBA::ULong i = 0UL; i < length; ++i)
+    {
+      if (! (strm << _tao_vector[i]))
+        {
+          return false;
+        }
+    }
+  
+  return true;
+}
+
+::CORBA::Boolean operator>> (
+  TAO_InputCDR &strm,
+  std::vector<Param_Test::Fixed_Array> &_tao_vector)
+{
+  ::CORBA::ULong length = 0UL;
+  Param_Test::Fixed_Array tmp;
+  
+  if (! (strm >> length))
+    {
+      return false;
+    }
+  
+  for ( ::CORBA::ULong i = 0UL; i < length; ++i)
+    {
+      if (! (strm >> tmp))
+        {
+          return false;
+        }
+      
+      _tao_vector[i] = tmp;
+    }
+  
+  return true;
+}
+
+
 TAO_END_VERSIONED_NAMESPACE_DECL
 
-                #endif /* _TAO_CDR_OP_Param_Test_Bounded_ArraySeq_CPP_ */
-                
-                // TAO_IDL - Generated from
-                // w:\tao\tao_idl\be\be_visitor_exception/cdr_op_cs.cpp:60
+#endif /* _TAO_CDR_OP_Param_Test_Bounded_ArraySeq_CPP_ */
+
+// TAO_IDL - Generated from
+// w:\tao\tao_idl\be\be_visitor_exception/cdr_op_cs.cpp:60
 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
 
-                
-                
-                ::CORBA::Boolean operator<< (
-                    TAO_OutputCDR &strm,
-                    const Param_Test::Ooops &_tao_aggregate
-                  )
-                {
-                  // First marshal the repository ID.
-                  if (strm << _tao_aggregate._rep_id ())
-                    {
-                      // Now marshal the members (if any).
-                      return (
-                        (strm << _tao_aggregate.reason.in ()) &&
-                        (strm << _tao_aggregate.input)
-                       );
-                    }
-                  else
-                    {
-                      return false;
-                    }
-                }
-                
-                ::CORBA::Boolean operator>> (
-                    TAO_InputCDR &strm,
-                    Param_Test::Ooops &_tao_aggregate
-                  )
-                {
-                  // Demarshal the members.
-                  return (
-                    (strm >> _tao_aggregate.reason.out ()) &&
-                    (strm >> _tao_aggregate.input)
-                  );
-                }
-                
+
+
+::CORBA::Boolean operator<< (
+    TAO_OutputCDR &strm,
+    const Param_Test::Ooops &_tao_aggregate
+  )
+{
+  // First marshal the repository ID.
+  if (strm << _tao_aggregate._rep_id ())
+    {
+      // Now marshal the members (if any).
+      return (
+        (strm << _tao_aggregate.reason.in ()) &&
+        (strm << _tao_aggregate.input)
+       );
+    }
+  else
+    {
+      return false;
+    }
+}
+
+::CORBA::Boolean operator>> (
+    TAO_InputCDR &strm,
+    Param_Test::Ooops &_tao_aggregate
+  )
+{
+  // Demarshal the members.
+  return (
+    (strm >> _tao_aggregate.reason.out ()) &&
+    (strm >> _tao_aggregate.input)
+  );
+}
+
 TAO_END_VERSIONED_NAMESPACE_DECL
 
-                
-                
-                // TAO_IDL - Generated from
-                // w:\tao\tao_idl\be\be_visitor_exception/cdr_op_cs.cpp:60
+
+
+// TAO_IDL - Generated from
+// w:\tao\tao_idl\be\be_visitor_exception/cdr_op_cs.cpp:60
 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
 
-                
-                
-                ::CORBA::Boolean operator<< (
-                    TAO_OutputCDR &strm,
-                    const Param_Test::BadBoy &_tao_aggregate
-                  )
-                {
-                  // Marshal the repository ID.
-                  return (strm << _tao_aggregate._rep_id ());
-                }
-                
-                ::CORBA::Boolean operator>> (
-                    TAO_InputCDR &,
-                    Param_Test::BadBoy&
-                  )
-                {
-                  return true;
-                }
-                
+
+
+::CORBA::Boolean operator<< (
+    TAO_OutputCDR &strm,
+    const Param_Test::BadBoy &_tao_aggregate
+  )
+{
+  // Marshal the repository ID.
+  return (strm << _tao_aggregate._rep_id ());
+}
+
+::CORBA::Boolean operator>> (
+    TAO_InputCDR &,
+    Param_Test::BadBoy&
+  )
+{
+  return true;
+}
+
 TAO_END_VERSIONED_NAMESPACE_DECL
 
-                
-                
-                // TAO_IDL - Generated from
-                // w:\tao\tao_idl\be\be_visitor_array/cdr_op_cs.cpp:178
-                
-                
+
+
+// TAO_IDL - Generated from
+// w:\tao\tao_idl\be\be_visitor_array/cdr_op_cs.cpp:178
+
+
 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
 
-                ::CORBA::Boolean operator<< (
-                    TAO_OutputCDR &strm,
-                    const Param_Test::Big_Union::_another_array_forany &_tao_array
-                  )
-                {
-                  return
-                    strm.write_short_array (
-                        reinterpret_cast <const ACE_CDR::Short *> (_tao_array.in ()),
-                        32
-                      );
-                }
-                
-                ::CORBA::Boolean operator>> (
-                    TAO_InputCDR &strm,
-                    Param_Test::Big_Union::_another_array_forany &_tao_array
-                  )
-                {
-                  return
-                    strm.read_short_array (
-                        reinterpret_cast <ACE_CDR::Short *> (_tao_array.out ()),
-                        32
-                      );
-                }
-                
+::CORBA::Boolean operator<< (
+    TAO_OutputCDR &strm,
+    const Param_Test::Big_Union::_another_array_forany &_tao_array
+  )
+{
+  return
+    strm.write_short_array (
+        reinterpret_cast <const ACE_CDR::Short *> (_tao_array.in ()),
+        32
+      );
+}
+
+::CORBA::Boolean operator>> (
+    TAO_InputCDR &strm,
+    Param_Test::Big_Union::_another_array_forany &_tao_array
+  )
+{
+  return
+    strm.read_short_array (
+        reinterpret_cast <ACE_CDR::Short *> (_tao_array.out ()),
+        32
+      );
+}
+
 TAO_END_VERSIONED_NAMESPACE_DECL
 
-                
-                
-                // TAO_IDL - Generated from
-                // w:\tao\tao_idl\be\be_visitor_union/cdr_op_cs.cpp:67
-                
-                
+
+
+// TAO_IDL - Generated from
+// w:\tao\tao_idl\be\be_visitor_union/cdr_op_cs.cpp:67
+
+
 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
 
-                ::CORBA::Boolean operator<< (
-                    TAO_OutputCDR &strm,
-                    const Param_Test::Big_Union &_tao_union
-                  )
-                {
-                  if ( !(strm << _tao_union._d ()) )
-                    {
-                      return false;
-                    }
-                  
-                  ::CORBA::Boolean result = true;
-                  
-                  switch (_tao_union._d ())
-                  {
-                    case 0:
-                      {
-                        Param_Test::Fixed_Array_forany _tao_union_tmp (
-                            _tao_union.the_array ()
-                          );
-                        result = strm << _tao_union_tmp;
-                      }
-                      break;
-                    case 1:
-                      {
-                        result =
-                          TAO::Objref_Traits<Coffee>::marshal (
-                              _tao_union.the_interface (),
-                              strm
-                            );
-                      }
-                      break;
-                    case 2:
-                      {
-                        result = strm << _tao_union.the_long ();
-                      }
-                      break;
-                    case 3:
-                      {
-                        Param_Test::Big_Union::_another_array_forany _tao_union_tmp (
-                            _tao_union.another_array ()
-                          );
-                        result = strm << _tao_union_tmp;
-                      }
-                      break;
-                    case 4:
-                      {
-                        result = strm << _tao_union.the_string ();
-                      }
-                      break;
-                    case 5:
-                      {
-                        result = strm << _tao_union.the_sequence ();
-                      }
-                      break;
-                    case 6:
-                      {
-                        result = strm << _tao_union.the_any ();
-                      }
-                      break;
-                    case 7:
-                      {
-                        result = strm << ::ACE_OutputCDR::from_octet (_tao_union.the_octet ());
-                      }
-                      break;
-                    case 8:
-                      {
-                        result = strm << ::ACE_OutputCDR::from_char (_tao_union.the_char ());
-                      }
-                      break;
-                    case 9:
-                      {
-                        result = strm << ::ACE_OutputCDR::from_boolean (_tao_union.the_boolean ());
-                      }
-                      break;
-                    case 10:
-                      {
-                        result = strm << _tao_union.the_var_struct ();
-                      }
-                      break;
-                    case 11:
-                      {
-                        result = strm << _tao_union.the_fixed_struct ();
-                      }
-                      break;
-                    default:
-                      break;
-                  }
-                  
-                  return result;
-                }
-                
-                ::CORBA::Boolean operator>> (
-                    TAO_InputCDR &strm,
-                    Param_Test::Big_Union &_tao_union
-                  )
-                {
-                  CORBA::Short _tao_discriminant;
-                  if ( !(strm >> _tao_discriminant) )
-                    {
-                      return false;
-                    }
-                  
-                  ::CORBA::Boolean result = true;
-                  
-                  switch (_tao_discriminant)
-                  {
-                    case 0:
-                      {
-                        Param_Test::Fixed_Array _tao_union_tmp;
-                        Param_Test::Fixed_Array_forany _tao_union_helper (
-                            _tao_union_tmp
-                          );
-                        result = strm >> _tao_union_helper;
-                        
-                        if (result)
-                          {
-                            _tao_union.the_array (_tao_union_tmp);
-                            _tao_union._d (_tao_discriminant);
-                          }
-                      }
-                      break;
-                    case 1:
-                      {
-                        Coffee_var _tao_union_tmp;
-                        result = strm >> _tao_union_tmp.inout ();
-                        
-                        if (result)
-                          {
-                            _tao_union.the_interface (_tao_union_tmp.in ());
-                            _tao_union._d (_tao_discriminant);
-                          }
-                      }
-                      break;
-                    case 2:
-                      {
-                        CORBA::Long _tao_union_tmp;
-                        result = strm >> _tao_union_tmp;
-                        
-                        if (result)
-                          {
-                            _tao_union.the_long (_tao_union_tmp);
-                            _tao_union._d (_tao_discriminant);
-                          }
-                      }
-                      break;
-                    case 3:
-                      {
-                        Param_Test::Big_Union::_another_array _tao_union_tmp;
-                        Param_Test::Big_Union::_another_array_forany _tao_union_helper (
-                            _tao_union_tmp
-                          );
-                        result = strm >> _tao_union_helper;
-                        
-                        if (result)
-                          {
-                            _tao_union.another_array (_tao_union_tmp);
-                            _tao_union._d (_tao_discriminant);
-                          }
-                      }
-                      break;
-                    case 4:
-                      {
-                        ::CORBA::String_var _tao_union_tmp;
-                        result = strm >> _tao_union_tmp.out ();
-                        
-                        if (result)
-                          {
-                            _tao_union.the_string (_tao_union_tmp);
-                            _tao_union._d (_tao_discriminant);
-                          }
-                      }
-                      break;
-                    case 5:
-                      {
-                        CORBA::ShortSeq _tao_union_tmp;
-                        result = strm >> _tao_union_tmp;
-                        
-                        if (result)
-                          {
-                            _tao_union.the_sequence (_tao_union_tmp);
-                            _tao_union._d (_tao_discriminant);
-                          }
-                      }
-                      break;
-                    case 6:
-                      {
-                        CORBA::Any _tao_union_tmp;
-                        result = strm >> _tao_union_tmp;
-                        
-                        if (result)
-                          {
-                            _tao_union.the_any (_tao_union_tmp);
-                            _tao_union._d (_tao_discriminant);
-                          }
-                      }
-                      break;
-                    case 7:
-                      {
-                        ::CORBA::Octet _tao_union_tmp;
-                        ::ACE_InputCDR::to_octet _tao_union_helper (_tao_union_tmp);
-                        result = strm >> _tao_union_helper;
-                        
-                        if (result)
-                          {
-                            _tao_union.the_octet (_tao_union_tmp);
-                            _tao_union._d (_tao_discriminant);
-                          }
-                      }
-                      break;
-                    case 8:
-                      {
-                        ::CORBA::Char _tao_union_tmp;
-                        ::ACE_InputCDR::to_char _tao_union_helper (_tao_union_tmp);
-                        result = strm >> _tao_union_helper;
-                        
-                        if (result)
-                          {
-                            _tao_union.the_char (_tao_union_tmp);
-                            _tao_union._d (_tao_discriminant);
-                          }
-                      }
-                      break;
-                    case 9:
-                      {
-                        ::CORBA::Boolean _tao_union_tmp;
-                        ::ACE_InputCDR::to_boolean _tao_union_helper (_tao_union_tmp);
-                        result = strm >> _tao_union_helper;
-                        
-                        if (result)
-                          {
-                            _tao_union.the_boolean (_tao_union_tmp);
-                            _tao_union._d (_tao_discriminant);
-                          }
-                      }
-                      break;
-                    case 10:
-                      {
-                        Param_Test::Var_Struct _tao_union_tmp;
-                        result = strm >> _tao_union_tmp;
-                        
-                        if (result)
-                          {
-                            _tao_union.the_var_struct (_tao_union_tmp);
-                            _tao_union._d (_tao_discriminant);
-                          }
-                      }
-                      break;
-                    case 11:
-                      {
-                        Param_Test::Fixed_Struct _tao_union_tmp;
-                        result = strm >> _tao_union_tmp;
-                        
-                        if (result)
-                          {
-                            _tao_union.the_fixed_struct (_tao_union_tmp);
-                            _tao_union._d (_tao_discriminant);
-                          }
-                      }
-                      break;
-                    default:
-                      _tao_union._d (_tao_discriminant);
-                      break;
-                  }
-                  
-                  return result;
-                }
-                
+::CORBA::Boolean operator<< (
+    TAO_OutputCDR &strm,
+    const Param_Test::Big_Union &_tao_union
+  )
+{
+  if ( !(strm << _tao_union._d ()) )
+    {
+      return false;
+    }
+  
+  ::CORBA::Boolean result = true;
+  
+  switch (_tao_union._d ())
+  {
+    case 0:
+      {
+        Param_Test::Fixed_Array_forany _tao_union_tmp (
+            _tao_union.the_array ()
+          );
+        result = strm << _tao_union_tmp;
+      }
+      break;
+    case 1:
+      {
+        result =
+          TAO::Objref_Traits<Coffee>::marshal (
+              _tao_union.the_interface (),
+              strm
+            );
+      }
+      break;
+    case 2:
+      {
+        result = strm << _tao_union.the_long ();
+      }
+      break;
+    case 3:
+      {
+        Param_Test::Big_Union::_another_array_forany _tao_union_tmp (
+            _tao_union.another_array ()
+          );
+        result = strm << _tao_union_tmp;
+      }
+      break;
+    case 4:
+      {
+        result = strm << _tao_union.the_string ();
+      }
+      break;
+    case 5:
+      {
+        result = strm << _tao_union.the_sequence ();
+      }
+      break;
+    case 6:
+      {
+        result = strm << _tao_union.the_any ();
+      }
+      break;
+    case 7:
+      {
+        result = strm << ::ACE_OutputCDR::from_octet (_tao_union.the_octet ());
+      }
+      break;
+    case 8:
+      {
+        result = strm << ::ACE_OutputCDR::from_char (_tao_union.the_char ());
+      }
+      break;
+    case 9:
+      {
+        result = strm << ::ACE_OutputCDR::from_boolean (_tao_union.the_boolean ());
+      }
+      break;
+    case 10:
+      {
+        result = strm << _tao_union.the_var_struct ();
+      }
+      break;
+    case 11:
+      {
+        result = strm << _tao_union.the_fixed_struct ();
+      }
+      break;
+    default:
+      break;
+  }
+  
+  return result;
+}
+
+::CORBA::Boolean operator>> (
+    TAO_InputCDR &strm,
+    Param_Test::Big_Union &_tao_union
+  )
+{
+  CORBA::Short _tao_discriminant;
+  if ( !(strm >> _tao_discriminant) )
+    {
+      return false;
+    }
+  
+  ::CORBA::Boolean result = true;
+  
+  switch (_tao_discriminant)
+  {
+    case 0:
+      {
+        Param_Test::Fixed_Array _tao_union_tmp;
+        Param_Test::Fixed_Array_forany _tao_union_helper (
+            _tao_union_tmp
+          );
+        result = strm >> _tao_union_helper;
+        
+        if (result)
+          {
+            _tao_union.the_array (_tao_union_tmp);
+            _tao_union._d (_tao_discriminant);
+          }
+      }
+      break;
+    case 1:
+      {
+        Coffee_var _tao_union_tmp;
+        result = strm >> _tao_union_tmp.inout ();
+        
+        if (result)
+          {
+            _tao_union.the_interface (_tao_union_tmp.in ());
+            _tao_union._d (_tao_discriminant);
+          }
+      }
+      break;
+    case 2:
+      {
+        CORBA::Long _tao_union_tmp;
+        result = strm >> _tao_union_tmp;
+        
+        if (result)
+          {
+            _tao_union.the_long (_tao_union_tmp);
+            _tao_union._d (_tao_discriminant);
+          }
+      }
+      break;
+    case 3:
+      {
+        Param_Test::Big_Union::_another_array _tao_union_tmp;
+        Param_Test::Big_Union::_another_array_forany _tao_union_helper (
+            _tao_union_tmp
+          );
+        result = strm >> _tao_union_helper;
+        
+        if (result)
+          {
+            _tao_union.another_array (_tao_union_tmp);
+            _tao_union._d (_tao_discriminant);
+          }
+      }
+      break;
+    case 4:
+      {
+        ::CORBA::String_var _tao_union_tmp;
+        result = strm >> _tao_union_tmp.out ();
+        
+        if (result)
+          {
+            _tao_union.the_string (_tao_union_tmp);
+            _tao_union._d (_tao_discriminant);
+          }
+      }
+      break;
+    case 5:
+      {
+        CORBA::ShortSeq _tao_union_tmp;
+        result = strm >> _tao_union_tmp;
+        
+        if (result)
+          {
+            _tao_union.the_sequence (_tao_union_tmp);
+            _tao_union._d (_tao_discriminant);
+          }
+      }
+      break;
+    case 6:
+      {
+        CORBA::Any _tao_union_tmp;
+        result = strm >> _tao_union_tmp;
+        
+        if (result)
+          {
+            _tao_union.the_any (_tao_union_tmp);
+            _tao_union._d (_tao_discriminant);
+          }
+      }
+      break;
+    case 7:
+      {
+        ::CORBA::Octet _tao_union_tmp;
+        ::ACE_InputCDR::to_octet _tao_union_helper (_tao_union_tmp);
+        result = strm >> _tao_union_helper;
+        
+        if (result)
+          {
+            _tao_union.the_octet (_tao_union_tmp);
+            _tao_union._d (_tao_discriminant);
+          }
+      }
+      break;
+    case 8:
+      {
+        ::CORBA::Char _tao_union_tmp;
+        ::ACE_InputCDR::to_char _tao_union_helper (_tao_union_tmp);
+        result = strm >> _tao_union_helper;
+        
+        if (result)
+          {
+            _tao_union.the_char (_tao_union_tmp);
+            _tao_union._d (_tao_discriminant);
+          }
+      }
+      break;
+    case 9:
+      {
+        ::CORBA::Boolean _tao_union_tmp;
+        ::ACE_InputCDR::to_boolean _tao_union_helper (_tao_union_tmp);
+        result = strm >> _tao_union_helper;
+        
+        if (result)
+          {
+            _tao_union.the_boolean (_tao_union_tmp);
+            _tao_union._d (_tao_discriminant);
+          }
+      }
+      break;
+    case 10:
+      {
+        Param_Test::Var_Struct _tao_union_tmp;
+        result = strm >> _tao_union_tmp;
+        
+        if (result)
+          {
+            _tao_union.the_var_struct (_tao_union_tmp);
+            _tao_union._d (_tao_discriminant);
+          }
+      }
+      break;
+    case 11:
+      {
+        Param_Test::Fixed_Struct _tao_union_tmp;
+        result = strm >> _tao_union_tmp;
+        
+        if (result)
+          {
+            _tao_union.the_fixed_struct (_tao_union_tmp);
+            _tao_union._d (_tao_discriminant);
+          }
+      }
+      break;
+    default:
+      _tao_union._d (_tao_discriminant);
+      break;
+  }
+  
+  return result;
+}
+
 TAO_END_VERSIONED_NAMESPACE_DECL
 
-                
-                
-                // TAO_IDL - Generated from
-                // w:\tao\tao_idl\be\be_visitor_enum/cdr_op_cs.cpp:51
-                
-                
+
+
+// TAO_IDL - Generated from
+// w:\tao\tao_idl\be\be_visitor_enum/cdr_op_cs.cpp:51
+
+
 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
 
-                ::CORBA::Boolean operator<< (TAO_OutputCDR &strm, Param_Test::Small_Union_Switch _tao_enumerator)
-                {
-                  return strm << static_cast< ::CORBA::ULong> (_tao_enumerator);
-                }
-                
-                ::CORBA::Boolean operator>> (TAO_InputCDR &strm, Param_Test::Small_Union_Switch & _tao_enumerator)
-                {
-                  ::CORBA::ULong _tao_temp = 0;
-                  ::CORBA::Boolean const _tao_success = strm >> _tao_temp;
-                  
-                  if (_tao_success)
-                    {
-                      _tao_enumerator = static_cast<Param_Test::Small_Union_Switch> (_tao_temp);
-                    }
-                  
-                  return _tao_success;
-                }
-                
+::CORBA::Boolean operator<< (TAO_OutputCDR &strm, Param_Test::Small_Union_Switch _tao_enumerator)
+{
+  return strm << static_cast< ::CORBA::ULong> (_tao_enumerator);
+}
+
+::CORBA::Boolean operator>> (TAO_InputCDR &strm, Param_Test::Small_Union_Switch & _tao_enumerator)
+{
+  ::CORBA::ULong _tao_temp = 0;
+  ::CORBA::Boolean const _tao_success = strm >> _tao_temp;
+  
+  if (_tao_success)
+    {
+      _tao_enumerator = static_cast<Param_Test::Small_Union_Switch> (_tao_temp);
+    }
+  
+  return _tao_success;
+}
+
 TAO_END_VERSIONED_NAMESPACE_DECL
 
-                
-                
-                // TAO_IDL - Generated from
-                // w:\tao\tao_idl\be\be_visitor_union/cdr_op_cs.cpp:67
-                
-                
+
+
+// TAO_IDL - Generated from
+// w:\tao\tao_idl\be\be_visitor_union/cdr_op_cs.cpp:67
+
+
 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
 
-                ::CORBA::Boolean operator<< (
-                    TAO_OutputCDR &strm,
-                    const Param_Test::Small_Union &_tao_union
-                  )
-                {
-                  if ( !(strm << _tao_union._d ()) )
-                    {
-                      return false;
-                    }
-                  
-                  ::CORBA::Boolean result = true;
-                  
-                  switch (_tao_union._d ())
-                  {
-                    case Param_Test::A_LONG:
-                      {
-                        result = strm << _tao_union.the_long ();
-                      }
-                      break;
-                    case Param_Test::A_SHORT:
-                      {
-                        result = strm << _tao_union.the_short ();
-                      }
-                      break;
-                  }
-                  
-                  return result;
-                }
-                
-                ::CORBA::Boolean operator>> (
-                    TAO_InputCDR &strm,
-                    Param_Test::Small_Union &_tao_union
-                  )
-                {
-                  Param_Test::Small_Union_Switch _tao_discriminant;
-                  if ( !(strm >> _tao_discriminant) )
-                    {
-                      return false;
-                    }
-                  
-                  ::CORBA::Boolean result = true;
-                  
-                  switch (_tao_discriminant)
-                  {
-                    case Param_Test::A_LONG:
-                      {
-                        CORBA::Long _tao_union_tmp;
-                        result = strm >> _tao_union_tmp;
-                        
-                        if (result)
-                          {
-                            _tao_union.the_long (_tao_union_tmp);
-                            _tao_union._d (_tao_discriminant);
-                          }
-                      }
-                      break;
-                    case Param_Test::A_SHORT:
-                      {
-                        CORBA::Short _tao_union_tmp;
-                        result = strm >> _tao_union_tmp;
-                        
-                        if (result)
-                          {
-                            _tao_union.the_short (_tao_union_tmp);
-                            _tao_union._d (_tao_discriminant);
-                          }
-                      }
-                      break;
-                  }
-                  
-                  return result;
-                }
-                
+::CORBA::Boolean operator<< (
+    TAO_OutputCDR &strm,
+    const Param_Test::Small_Union &_tao_union
+  )
+{
+  if ( !(strm << _tao_union._d ()) )
+    {
+      return false;
+    }
+  
+  ::CORBA::Boolean result = true;
+  
+  switch (_tao_union._d ())
+  {
+    case Param_Test::A_LONG:
+      {
+        result = strm << _tao_union.the_long ();
+      }
+      break;
+    case Param_Test::A_SHORT:
+      {
+        result = strm << _tao_union.the_short ();
+      }
+      break;
+  }
+  
+  return result;
+}
+
+::CORBA::Boolean operator>> (
+    TAO_InputCDR &strm,
+    Param_Test::Small_Union &_tao_union
+  )
+{
+  Param_Test::Small_Union_Switch _tao_discriminant;
+  if ( !(strm >> _tao_discriminant) )
+    {
+      return false;
+    }
+  
+  ::CORBA::Boolean result = true;
+  
+  switch (_tao_discriminant)
+  {
+    case Param_Test::A_LONG:
+      {
+        CORBA::Long _tao_union_tmp;
+        result = strm >> _tao_union_tmp;
+        
+        if (result)
+          {
+            _tao_union.the_long (_tao_union_tmp);
+            _tao_union._d (_tao_discriminant);
+          }
+      }
+      break;
+    case Param_Test::A_SHORT:
+      {
+        CORBA::Short _tao_union_tmp;
+        result = strm >> _tao_union_tmp;
+        
+        if (result)
+          {
+            _tao_union.the_short (_tao_union_tmp);
+            _tao_union._d (_tao_discriminant);
+          }
+      }
+      break;
+  }
+  
+  return result;
+}
+
 TAO_END_VERSIONED_NAMESPACE_DECL
 
-                
-                
-                // TAO_IDL - Generated from
-                // w:\tao\tao_idl\be\be_visitor_structure/cdr_op_cs.cpp:61
-                
-                
+
+
+// TAO_IDL - Generated from
+// w:\tao\tao_idl\be\be_visitor_structure/cdr_op_cs.cpp:61
+
+
 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
 
-                ::CORBA::Boolean operator<< (
-                    TAO_OutputCDR &strm,
-                    const Param_Test::level4 &_tao_aggregate
-                  )
-                {
-                  return
-                    (strm << _tao_aggregate.level5_string.in ()) &&
-                    (strm << _tao_aggregate.level5_any);
-                }
-                
-                ::CORBA::Boolean operator>> (
-                    TAO_InputCDR &strm,
-                    Param_Test::level4 &_tao_aggregate
-                  )
-                {
-                  return
-                    (strm >> _tao_aggregate.level5_string.out ()) &&
-                    (strm >> _tao_aggregate.level5_any);
-              }
-              
+::CORBA::Boolean operator<< (
+    TAO_OutputCDR &strm,
+    const Param_Test::level4 &_tao_aggregate
+  )
+{
+  return
+    (strm << _tao_aggregate.level5_string.in ()) &&
+    (strm << _tao_aggregate.level5_any);
+}
+
+::CORBA::Boolean operator>> (
+    TAO_InputCDR &strm,
+    Param_Test::level4 &_tao_aggregate
+  )
+{
+  return
+    (strm >> _tao_aggregate.level5_string.out ()) &&
+    (strm >> _tao_aggregate.level5_any);
+}
+
 TAO_END_VERSIONED_NAMESPACE_DECL
 
-              
-              
-              // TAO_IDL - Generated from
-              // w:\tao\tao_idl\be\be_visitor_structure/cdr_op_cs.cpp:61
-              
-              
+
+
+// TAO_IDL - Generated from
+// w:\tao\tao_idl\be\be_visitor_structure/cdr_op_cs.cpp:61
+
+
 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
 
-              ::CORBA::Boolean operator<< (
-                  TAO_OutputCDR &strm,
-                  const Param_Test::level8 &_tao_aggregate
-                )
-              {
-                return
-                  (strm << _tao_aggregate.level9_string.in ()) &&
-                  (strm << ::ACE_OutputCDR::from_boolean (_tao_aggregate.level9_boolean)) &&
-                  (strm << _tao_aggregate.level9_short);
-              }
-              
-              ::CORBA::Boolean operator>> (
-                  TAO_InputCDR &strm,
-                  Param_Test::level8 &_tao_aggregate
-                )
-              {
-                return
-                  (strm >> _tao_aggregate.level9_string.out ()) &&
-                  (strm >> ::ACE_InputCDR::to_boolean (_tao_aggregate.level9_boolean)) &&
-                  (strm >> _tao_aggregate.level9_short);
-            }
-            
+::CORBA::Boolean operator<< (
+    TAO_OutputCDR &strm,
+    const Param_Test::level8 &_tao_aggregate
+  )
+{
+  return
+    (strm << _tao_aggregate.level9_string.in ()) &&
+    (strm << ::ACE_OutputCDR::from_boolean (_tao_aggregate.level9_boolean)) &&
+    (strm << _tao_aggregate.level9_short);
+}
+
+::CORBA::Boolean operator>> (
+    TAO_InputCDR &strm,
+    Param_Test::level8 &_tao_aggregate
+  )
+{
+  return
+    (strm >> _tao_aggregate.level9_string.out ()) &&
+    (strm >> ::ACE_InputCDR::to_boolean (_tao_aggregate.level9_boolean)) &&
+    (strm >> _tao_aggregate.level9_short);
+}
+
 TAO_END_VERSIONED_NAMESPACE_DECL
 
-            
-            
-            // TAO_IDL - Generated from
-            // w:\tao\tao_idl\be\be_visitor_sequence/cdr_op_cs.cpp:96
-            #if !defined _TAO_CDR_OP_Param_Test_Recursive_Struct__tao_seq_Param_Test_Recursive_Struct__CPP_
-            #define _TAO_CDR_OP_Param_Test_Recursive_Struct__tao_seq_Param_Test_Recursive_Struct__CPP_
-            
+
+
+// TAO_IDL - Generated from
+// w:\tao\tao_idl\be\be_visitor_sequence/cdr_op_cs.cpp:96
+#if !defined _TAO_CDR_OP_Param_Test_Recursive_Struct__tao_seq_Param_Test_Recursive_Struct__CPP_
+#define _TAO_CDR_OP_Param_Test_Recursive_Struct__tao_seq_Param_Test_Recursive_Struct__CPP_
+
 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
 
-            ::CORBA::Boolean operator<< (
-              TAO_OutputCDR &strm,
-              const std:;vector<Param_Test::Recursive_Struct &_tao_vector)
-            {
-              ::CORBA::ULong length = _tao_vector.size ();
-              strm << length;
-              
-              for ( ::CORBA::ULong i = 0UL; i < length; ++i)
-                {
-                  if (! strm << _tao_vector[i]
-                    {
-                      return false;
-                    }
-                  }
-                
-                return true;
-              }
-              
-              ::CORBA::Boolean operator>> (
-                TAO_InputCDR &strm,
-                std::vector<Param_Test::Recursive_Struct &_tao_vector)
-              {
-                ::CORBA::ULong length = 0UL;
-                Param_Test::Recursive_Struct * tmp;
-                
-                for ( ::CORBA::ULong i = 0UL; i < length; ++i)
-                  {
-                    if (! strm >> tmp)
-                      {
-                        return false;
-                      }
-                    
-                    _tao_vector[i] = tmp;
-                  }
-                
-                return true;
-              }
-              
-              
+::CORBA::Boolean operator<< (
+  TAO_OutputCDR &strm,
+  const std::vector<Param_Test::Recursive_Struct> &_tao_vector)
+{
+  ::CORBA::ULong length = _tao_vector.size ();
+  strm << length;
+  
+  for ( ::CORBA::ULong i = 0UL; i < length; ++i)
+    {
+      if (! (strm << _tao_vector[i]))
+        {
+          return false;
+        }
+    }
+  
+  return true;
+}
+
+::CORBA::Boolean operator>> (
+  TAO_InputCDR &strm,
+  std::vector<Param_Test::Recursive_Struct> &_tao_vector)
+{
+  ::CORBA::ULong length = 0UL;
+  Param_Test::Recursive_Struct * tmp;
+  
+  if (! (strm >> length))
+    {
+      return false;
+    }
+  
+  for ( ::CORBA::ULong i = 0UL; i < length; ++i)
+    {
+      if (! (strm >> tmp))
+        {
+          return false;
+        }
+      
+      _tao_vector[i] = tmp;
+    }
+  
+  return true;
+}
+
+
 TAO_END_VERSIONED_NAMESPACE_DECL
 
-              #endif /* _TAO_CDR_OP_Param_Test_Recursive_Struct__tao_seq_Param_Test_Recursive_Struct__CPP_ */
-              
-              // TAO_IDL - Generated from
-              // w:\tao\tao_idl\be\be_visitor_structure/cdr_op_cs.cpp:61
-              
-              
+#endif /* _TAO_CDR_OP_Param_Test_Recursive_Struct__tao_seq_Param_Test_Recursive_Struct__CPP_ */
+
+// TAO_IDL - Generated from
+// w:\tao\tao_idl\be\be_visitor_structure/cdr_op_cs.cpp:61
+
+
 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
 
-              ::CORBA::Boolean operator<< (
-                  TAO_OutputCDR &strm,
-                  const Param_Test::Recursive_Struct &_tao_aggregate
-                )
-              {
-                return
-                  (strm << _tao_aggregate.x) &&
-                  (strm << _tao_aggregate.children);
-              }
-              
-              ::CORBA::Boolean operator>> (
-                  TAO_InputCDR &strm,
-                  Param_Test::Recursive_Struct &_tao_aggregate
-                )
-              {
-                return
-                  (strm >> _tao_aggregate.x) &&
-                  (strm >> _tao_aggregate.children);
-            }
-            
+::CORBA::Boolean operator<< (
+    TAO_OutputCDR &strm,
+    const Param_Test::Recursive_Struct &_tao_aggregate
+  )
+{
+  return
+    (strm << _tao_aggregate.x) &&
+    (strm << _tao_aggregate.children);
+}
+
+::CORBA::Boolean operator>> (
+    TAO_InputCDR &strm,
+    Param_Test::Recursive_Struct &_tao_aggregate
+  )
+{
+  return
+    (strm >> _tao_aggregate.x) &&
+    (strm >> _tao_aggregate.children);
+}
+
 TAO_END_VERSIONED_NAMESPACE_DECL
 
-            
-            
-            // TAO_IDL - Generated from
-            // w:\tao\tao_idl\be\be_visitor_sequence/cdr_op_cs.cpp:96
-            #if !defined _TAO_CDR_OP_Param_Test_nested_rec_union__tao_seq_Param_Test_nested_rec_union__CPP_
-            #define _TAO_CDR_OP_Param_Test_nested_rec_union__tao_seq_Param_Test_nested_rec_union__CPP_
-            
+
+
+// TAO_IDL - Generated from
+// w:\tao\tao_idl\be\be_visitor_sequence/cdr_op_cs.cpp:96
+#if !defined _TAO_CDR_OP_Param_Test_nested_rec_union__tao_seq_Param_Test_nested_rec_union__CPP_
+#define _TAO_CDR_OP_Param_Test_nested_rec_union__tao_seq_Param_Test_nested_rec_union__CPP_
+
 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
 
-            ::CORBA::Boolean operator<< (
-              TAO_OutputCDR &strm,
-              const std:;vector<Param_Test::nested_rec_union &_tao_vector)
-            {
-              ::CORBA::ULong length = _tao_vector.size ();
-              strm << length;
-              
-              for ( ::CORBA::ULong i = 0UL; i < length; ++i)
-                {
-                  if (! strm << _tao_vector[i]
-                    {
-                      return false;
-                    }
-                  }
-                
-                return true;
-              }
-              
-              ::CORBA::Boolean operator>> (
-                TAO_InputCDR &strm,
-                std::vector<Param_Test::nested_rec_union &_tao_vector)
-              {
-                ::CORBA::ULong length = 0UL;
-                Param_Test::nested_rec_union * tmp;
-                
-                for ( ::CORBA::ULong i = 0UL; i < length; ++i)
-                  {
-                    if (! strm >> tmp)
-                      {
-                        return false;
-                      }
-                    
-                    _tao_vector[i] = tmp;
-                  }
-                
-                return true;
-              }
-              
-              
+::CORBA::Boolean operator<< (
+  TAO_OutputCDR &strm,
+  const std::vector<Param_Test::nested_rec_union> &_tao_vector)
+{
+  ::CORBA::ULong length = _tao_vector.size ();
+  strm << length;
+  
+  for ( ::CORBA::ULong i = 0UL; i < length; ++i)
+    {
+      if (! (strm << _tao_vector[i]))
+        {
+          return false;
+        }
+    }
+  
+  return true;
+}
+
+::CORBA::Boolean operator>> (
+  TAO_InputCDR &strm,
+  std::vector<Param_Test::nested_rec_union> &_tao_vector)
+{
+  ::CORBA::ULong length = 0UL;
+  Param_Test::nested_rec_union * tmp;
+  
+  if (! (strm >> length))
+    {
+      return false;
+    }
+  
+  for ( ::CORBA::ULong i = 0UL; i < length; ++i)
+    {
+      if (! (strm >> tmp))
+        {
+          return false;
+        }
+      
+      _tao_vector[i] = tmp;
+    }
+  
+  return true;
+}
+
+
 TAO_END_VERSIONED_NAMESPACE_DECL
 
-              #endif /* _TAO_CDR_OP_Param_Test_nested_rec_union__tao_seq_Param_Test_nested_rec_union__CPP_ */
-              
-              // TAO_IDL - Generated from
-              // w:\tao\tao_idl\be\be_visitor_union/cdr_op_cs.cpp:67
-              
-              
+#endif /* _TAO_CDR_OP_Param_Test_nested_rec_union__tao_seq_Param_Test_nested_rec_union__CPP_ */
+
+// TAO_IDL - Generated from
+// w:\tao\tao_idl\be\be_visitor_union/cdr_op_cs.cpp:67
+
+
 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
 
-              ::CORBA::Boolean operator<< (
-                  TAO_OutputCDR &strm,
-                  const Param_Test::nested_rec_union &_tao_union
-                )
-              {
-                if ( !(strm << _tao_union._d ()) )
-                  {
-                    return false;
-                  }
-                
-                ::CORBA::Boolean result = true;
-                
-                switch (_tao_union._d ())
-                {
-                  case 0:
-                    {
-                      result = strm << _tao_union.value ();
-                    }
-                    break;
-                  case 1:
-                    {
-                      result = strm << _tao_union.nested_rec_member ();
-                    }
-                    break;
-                  default:
-                    break;
-                }
-                
-                return result;
-              }
-              
-              ::CORBA::Boolean operator>> (
-                  TAO_InputCDR &strm,
-                  Param_Test::nested_rec_union &_tao_union
-                )
-              {
-                CORBA::Short _tao_discriminant;
-                if ( !(strm >> _tao_discriminant) )
-                  {
-                    return false;
-                  }
-                
-                ::CORBA::Boolean result = true;
-                
-                switch (_tao_discriminant)
-                {
-                  case 0:
-                    {
-                      CORBA::Long _tao_union_tmp;
-                      result = strm >> _tao_union_tmp;
-                      
-                      if (result)
-                        {
-                          _tao_union.value (_tao_union_tmp);
-                          _tao_union._d (_tao_discriminant);
-                        }
-                    }
-                    break;
-                  case 1:
-                    {
-                      Param_Test::nested_rec_union::_tao_seq_Param_Test_nested_rec_union_ _tao_union_tmp;
-                      result = strm >> _tao_union_tmp;
-                      
-                      if (result)
-                        {
-                          _tao_union.nested_rec_member (_tao_union_tmp);
-                          _tao_union._d (_tao_discriminant);
-                        }
-                    }
-                    break;
-                  default:
-                    _tao_union._d (_tao_discriminant);
-                    break;
-                }
-                
-                return result;
-              }
-              
+::CORBA::Boolean operator<< (
+    TAO_OutputCDR &strm,
+    const Param_Test::nested_rec_union &_tao_union
+  )
+{
+  if ( !(strm << _tao_union._d ()) )
+    {
+      return false;
+    }
+  
+  ::CORBA::Boolean result = true;
+  
+  switch (_tao_union._d ())
+  {
+    case 0:
+      {
+        result = strm << _tao_union.value ();
+      }
+      break;
+    case 1:
+      {
+        result = strm << _tao_union.nested_rec_member ();
+      }
+      break;
+    default:
+      break;
+  }
+  
+  return result;
+}
+
+::CORBA::Boolean operator>> (
+    TAO_InputCDR &strm,
+    Param_Test::nested_rec_union &_tao_union
+  )
+{
+  CORBA::Short _tao_discriminant;
+  if ( !(strm >> _tao_discriminant) )
+    {
+      return false;
+    }
+  
+  ::CORBA::Boolean result = true;
+  
+  switch (_tao_discriminant)
+  {
+    case 0:
+      {
+        CORBA::Long _tao_union_tmp;
+        result = strm >> _tao_union_tmp;
+        
+        if (result)
+          {
+            _tao_union.value (_tao_union_tmp);
+            _tao_union._d (_tao_discriminant);
+          }
+      }
+      break;
+    case 1:
+      {
+        Param_Test::nested_rec_union::_tao_seq_Param_Test_nested_rec_union_ _tao_union_tmp;
+        result = strm >> _tao_union_tmp;
+        
+        if (result)
+          {
+            _tao_union.nested_rec_member (_tao_union_tmp);
+            _tao_union._d (_tao_discriminant);
+          }
+      }
+      break;
+    default:
+      _tao_union._d (_tao_discriminant);
+      break;
+  }
+  
+  return result;
+}
+
 TAO_END_VERSIONED_NAMESPACE_DECL
 
-              
-              
-              // TAO_IDL - Generated from
-              // w:\tao\tao_idl\be\be_visitor_sequence/cdr_op_cs.cpp:96
-              #if !defined _TAO_CDR_OP_Param_Test_Recursive_Union__tao_seq_Param_Test_Recursive_Union__CPP_
-              #define _TAO_CDR_OP_Param_Test_Recursive_Union__tao_seq_Param_Test_Recursive_Union__CPP_
-              
+
+
+// TAO_IDL - Generated from
+// w:\tao\tao_idl\be\be_visitor_sequence/cdr_op_cs.cpp:96
+#if !defined _TAO_CDR_OP_Param_Test_Recursive_Union__tao_seq_Param_Test_Recursive_Union__CPP_
+#define _TAO_CDR_OP_Param_Test_Recursive_Union__tao_seq_Param_Test_Recursive_Union__CPP_
+
 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
 
-              ::CORBA::Boolean operator<< (
-                TAO_OutputCDR &strm,
-                const std:;vector<Param_Test::Recursive_Union &_tao_vector)
-              {
-                ::CORBA::ULong length = _tao_vector.size ();
-                strm << length;
-                
-                for ( ::CORBA::ULong i = 0UL; i < length; ++i)
-                  {
-                    if (! strm << _tao_vector[i]
-                      {
-                        return false;
-                      }
-                    }
-                  
-                  return true;
-                }
-                
-                ::CORBA::Boolean operator>> (
-                  TAO_InputCDR &strm,
-                  std::vector<Param_Test::Recursive_Union &_tao_vector)
-                {
-                  ::CORBA::ULong length = 0UL;
-                  Param_Test::Recursive_Union * tmp;
-                  
-                  for ( ::CORBA::ULong i = 0UL; i < length; ++i)
-                    {
-                      if (! strm >> tmp)
-                        {
-                          return false;
-                        }
-                      
-                      _tao_vector[i] = tmp;
-                    }
-                  
-                  return true;
-                }
-                
-                
+::CORBA::Boolean operator<< (
+  TAO_OutputCDR &strm,
+  const std::vector<Param_Test::Recursive_Union> &_tao_vector)
+{
+  ::CORBA::ULong length = _tao_vector.size ();
+  strm << length;
+  
+  for ( ::CORBA::ULong i = 0UL; i < length; ++i)
+    {
+      if (! (strm << _tao_vector[i]))
+        {
+          return false;
+        }
+    }
+  
+  return true;
+}
+
+::CORBA::Boolean operator>> (
+  TAO_InputCDR &strm,
+  std::vector<Param_Test::Recursive_Union> &_tao_vector)
+{
+  ::CORBA::ULong length = 0UL;
+  Param_Test::Recursive_Union * tmp;
+  
+  if (! (strm >> length))
+    {
+      return false;
+    }
+  
+  for ( ::CORBA::ULong i = 0UL; i < length; ++i)
+    {
+      if (! (strm >> tmp))
+        {
+          return false;
+        }
+      
+      _tao_vector[i] = tmp;
+    }
+  
+  return true;
+}
+
+
 TAO_END_VERSIONED_NAMESPACE_DECL
 
-                #endif /* _TAO_CDR_OP_Param_Test_Recursive_Union__tao_seq_Param_Test_Recursive_Union__CPP_ */
-                
-                // TAO_IDL - Generated from
-                // w:\tao\tao_idl\be\be_visitor_union/cdr_op_cs.cpp:67
-                
-                
+#endif /* _TAO_CDR_OP_Param_Test_Recursive_Union__tao_seq_Param_Test_Recursive_Union__CPP_ */
+
+// TAO_IDL - Generated from
+// w:\tao\tao_idl\be\be_visitor_union/cdr_op_cs.cpp:67
+
+
 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
 
-                ::CORBA::Boolean operator<< (
-                    TAO_OutputCDR &strm,
-                    const Param_Test::Recursive_Union &_tao_union
-                  )
-                {
-                  if ( !(strm << _tao_union._d ()) )
-                    {
-                      return false;
-                    }
-                  
-                  ::CORBA::Boolean result = true;
-                  
-                  switch (_tao_union._d ())
-                  {
-                    case 0:
-                      {
-                        result = strm << _tao_union.rec_member ();
-                      }
-                      break;
-                    case 1:
-                      {
-                        result = strm << _tao_union.nested_member ();
-                      }
-                      break;
-                    default:
-                      break;
-                  }
-                  
-                  return result;
-                }
-                
-                ::CORBA::Boolean operator>> (
-                    TAO_InputCDR &strm,
-                    Param_Test::Recursive_Union &_tao_union
-                  )
-                {
-                  CORBA::Short _tao_discriminant;
-                  if ( !(strm >> _tao_discriminant) )
-                    {
-                      return false;
-                    }
-                  
-                  ::CORBA::Boolean result = true;
-                  
-                  switch (_tao_discriminant)
-                  {
-                    case 0:
-                      {
-                        Param_Test::Recursive_Union::_tao_seq_Param_Test_Recursive_Union_ _tao_union_tmp;
-                        result = strm >> _tao_union_tmp;
-                        
-                        if (result)
-                          {
-                            _tao_union.rec_member (_tao_union_tmp);
-                            _tao_union._d (_tao_discriminant);
-                          }
-                      }
-                      break;
-                    case 1:
-                      {
-                        Param_Test::nested_rec_union _tao_union_tmp;
-                        result = strm >> _tao_union_tmp;
-                        
-                        if (result)
-                          {
-                            _tao_union.nested_member (_tao_union_tmp);
-                            _tao_union._d (_tao_discriminant);
-                          }
-                        
-                      }
-                      break;
-                    default:
-                      _tao_union._d (_tao_discriminant);
-                      break;
-                  }
-                  
-                  return result;
-                }
-                
+::CORBA::Boolean operator<< (
+    TAO_OutputCDR &strm,
+    const Param_Test::Recursive_Union &_tao_union
+  )
+{
+  if ( !(strm << _tao_union._d ()) )
+    {
+      return false;
+    }
+  
+  ::CORBA::Boolean result = true;
+  
+  switch (_tao_union._d ())
+  {
+    case 0:
+      {
+        result = strm << _tao_union.rec_member ();
+      }
+      break;
+    case 1:
+      {
+        result = strm << _tao_union.nested_member ();
+      }
+      break;
+    default:
+      break;
+  }
+  
+  return result;
+}
+
+::CORBA::Boolean operator>> (
+    TAO_InputCDR &strm,
+    Param_Test::Recursive_Union &_tao_union
+  )
+{
+  CORBA::Short _tao_discriminant;
+  if ( !(strm >> _tao_discriminant) )
+    {
+      return false;
+    }
+  
+  ::CORBA::Boolean result = true;
+  
+  switch (_tao_discriminant)
+  {
+    case 0:
+      {
+        Param_Test::Recursive_Union::_tao_seq_Param_Test_Recursive_Union_ _tao_union_tmp;
+        result = strm >> _tao_union_tmp;
+        
+        if (result)
+          {
+            _tao_union.rec_member (_tao_union_tmp);
+            _tao_union._d (_tao_discriminant);
+          }
+      }
+      break;
+    case 1:
+      {
+        Param_Test::nested_rec_union _tao_union_tmp;
+        result = strm >> _tao_union_tmp;
+        
+        if (result)
+          {
+            _tao_union.nested_member (_tao_union_tmp);
+            _tao_union._d (_tao_discriminant);
+          }
+        
+      }
+      break;
+    default:
+      _tao_union._d (_tao_discriminant);
+      break;
+  }
+  
+  return result;
+}
+
 TAO_END_VERSIONED_NAMESPACE_DECL
 
-                
-                
-                // TAO_IDL - Generated from
-                // w:\tao\tao_idl\be\be_visitor_array/cdr_op_cs.cpp:178
-                
-                
+
+
+// TAO_IDL - Generated from
+// w:\tao\tao_idl\be\be_visitor_array/cdr_op_cs.cpp:178
+
+
 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
 
-                ::CORBA::Boolean operator<< (
-                    TAO_OutputCDR &strm,
-                    const Param_Test::Multdim_Array_forany &_tao_array
-                  )
-                {
-                  CORBA::Boolean _tao_marshal_flag = true;
-                  
-                  for ( ::CORBA::ULong i0 = 0; i0 < 5 && _tao_marshal_flag; ++i0)
-                    {
-                      for ( ::CORBA::ULong i1 = 0; i1 < 3 && _tao_marshal_flag; ++i1)
-                        {
-                          Param_Test::Fixed_Array_var tmp_var (Param_Test::Fixed_Array_dup (_tao_array[i0][i1]));
-                          Param_Test::Fixed_Array_forany tmp (tmp_var.inout ());
-                          _tao_marshal_flag = (strm << tmp);
-                        }
-                    }
-                  
-                  return _tao_marshal_flag;
-                }
-                
-                ::CORBA::Boolean operator>> (
-                    TAO_InputCDR &strm,
-                    Param_Test::Multdim_Array_forany &_tao_array
-                  )
-                {
-                  CORBA::Boolean _tao_marshal_flag = true;
-                  
-                  for ( ::CORBA::ULong i0 = 0; i0 < 5 && _tao_marshal_flag; ++i0)
-                    {
-                      for ( ::CORBA::ULong i1 = 0; i1 < 3 && _tao_marshal_flag; ++i1)
-                        {
-                          Param_Test::Fixed_Array_forany tmp (Param_Test::Fixed_Array_alloc ());
-                          _tao_marshal_flag = (strm >> tmp);
-                          Param_Test::Fixed_Array_copy (_tao_array[i0][i1], tmp.in ());
-                          Param_Test::Fixed_Array_free (tmp.inout ());
-                        }
-                    }
-                  
-                  return _tao_marshal_flag;
-                }
-                
+::CORBA::Boolean operator<< (
+    TAO_OutputCDR &strm,
+    const Param_Test::Multdim_Array_forany &_tao_array
+  )
+{
+  CORBA::Boolean _tao_marshal_flag = true;
+  
+  for ( ::CORBA::ULong i0 = 0; i0 < 5 && _tao_marshal_flag; ++i0)
+    {
+      for ( ::CORBA::ULong i1 = 0; i1 < 3 && _tao_marshal_flag; ++i1)
+        {
+          Param_Test::Fixed_Array_var tmp_var (Param_Test::Fixed_Array_dup (_tao_array[i0][i1]));
+          Param_Test::Fixed_Array_forany tmp (tmp_var.inout ());
+          _tao_marshal_flag = (strm << tmp);
+        }
+    }
+  
+  return _tao_marshal_flag;
+}
+
+::CORBA::Boolean operator>> (
+    TAO_InputCDR &strm,
+    Param_Test::Multdim_Array_forany &_tao_array
+  )
+{
+  CORBA::Boolean _tao_marshal_flag = true;
+  
+  for ( ::CORBA::ULong i0 = 0; i0 < 5 && _tao_marshal_flag; ++i0)
+    {
+      for ( ::CORBA::ULong i1 = 0; i1 < 3 && _tao_marshal_flag; ++i1)
+        {
+          Param_Test::Fixed_Array_forany tmp (Param_Test::Fixed_Array_alloc ());
+          _tao_marshal_flag = (strm >> tmp);
+          Param_Test::Fixed_Array_copy (_tao_array[i0][i1], tmp.in ());
+          Param_Test::Fixed_Array_free (tmp.inout ());
+        }
+    }
+  
+  return _tao_marshal_flag;
+}
+
 TAO_END_VERSIONED_NAMESPACE_DECL
 
-                
-                
-                // TAO_IDL - Generated from
-                // w:\tao\tao_idl\be\be_visitor_interface/cdr_op_cs.cpp:63
-                
+
+
+// TAO_IDL - Generated from
+// w:\tao\tao_idl\be\be_visitor_interface/cdr_op_cs.cpp:63
+
 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
 
-                ::CORBA::Boolean operator<< (
-                    TAO_OutputCDR &strm,
-                    const Param_Test_ptr _tao_objref)
-                {
-                  ::CORBA::Object_ptr _tao_corba_obj = _tao_objref;
-                  return (strm << _tao_corba_obj);
-                }
-                
-                ::CORBA::Boolean operator>> (
-                    TAO_InputCDR &strm,
-                    Param_Test_ptr &_tao_objref)
-                {
-                  ::CORBA::Object_var obj;
-                  
-                  if (!(strm >> obj.inout ()))
-                    {
-                      return false;
-                    }
-                  
-                  typedef ::Param_Test RHS_SCOPED_NAME;
-                  
-                  // Narrow to the right type.
-                  _tao_objref =
-                    TAO::Narrow_Utils<RHS_SCOPED_NAME>::unchecked_narrow (
-                        obj.in (),
-                        _TAO_Param_Test_Proxy_Broker_Factory_function_pointer
-                      );
-                    
-                  return true;
-                }
-                
+::CORBA::Boolean operator<< (
+    TAO_OutputCDR &strm,
+    const Param_Test_ptr _tao_objref)
+{
+  ::CORBA::Object_ptr _tao_corba_obj = _tao_objref;
+  return (strm << _tao_corba_obj);
+}
+
+::CORBA::Boolean operator>> (
+    TAO_InputCDR &strm,
+    Param_Test_ptr &_tao_objref)
+{
+  ::CORBA::Object_var obj;
+  
+  if (!(strm >> obj.inout ()))
+    {
+      return false;
+    }
+  
+  typedef ::Param_Test RHS_SCOPED_NAME;
+  
+  // Narrow to the right type.
+  _tao_objref =
+    TAO::Narrow_Utils<RHS_SCOPED_NAME>::unchecked_narrow (
+        obj.in (),
+        _TAO_Param_Test_Proxy_Broker_Factory_function_pointer
+      );
+    
+  return true;
+}
+
 TAO_END_VERSIONED_NAMESPACE_DECL
 
-                
+
 
diff --git a/modules/TAO/tests/Param_Test/param_testC.h b/modules/TAO/tests/Param_Test/param_testC.h
index ce2ccbc1611..01808a3a163 100644
--- a/modules/TAO/tests/Param_Test/param_testC.h
+++ b/modules/TAO/tests/Param_Test/param_testC.h
@@ -521,41 +521,20 @@ public:
 #if !defined (_PARAM_TEST_PATHSPEC_CH_)
 #define _PARAM_TEST_PATHSPEC_CH_
   
-  class PathSpec;
-  
-  typedef
-    TAO_VarSeq_Var_T<
-        PathSpec
-      >
-    PathSpec_var;
-  
-  typedef
-    TAO_Seq_Out_T<
-        PathSpec
-      >
-    PathSpec_out;
-  
   class  PathSpec
     : public
-        TAO::unbounded_value_sequence<
-            Step
-          >
+        std::vector<Step>
   {
   public:
     PathSpec (void);
     PathSpec ( ::CORBA::ULong max);
-    PathSpec (
-      ::CORBA::ULong max,
-      ::CORBA::ULong length,
-      Step* buffer, 
-      ::CORBA::Boolean release = false);
     PathSpec (const PathSpec &);
     virtual ~PathSpec (void);
     
-    static void _tao_any_destructor (void *);
+    virtual ::CORBA::ULong length (void) const;
+    virtual void length (::CORBA::ULong);
     
-    typedef PathSpec_var _var_type;
-    typedef PathSpec_out _out_type;
+    static void _tao_any_destructor (void *);
   };
 
 #endif /* end #if !defined */
@@ -842,41 +821,20 @@ public:
 #if !defined (_PARAM_TEST_STRUCTSEQ_CH_)
 #define _PARAM_TEST_STRUCTSEQ_CH_
   
-  class StructSeq;
-  
-  typedef
-    TAO_FixedSeq_Var_T<
-        StructSeq
-      >
-    StructSeq_var;
-  
-  typedef
-    TAO_Seq_Out_T<
-        StructSeq
-      >
-    StructSeq_out;
-  
   class  StructSeq
     : public
-        TAO::unbounded_value_sequence<
-            Fixed_Struct
-          >
+        std::vector<Fixed_Struct>
   {
   public:
     StructSeq (void);
     StructSeq ( ::CORBA::ULong max);
-    StructSeq (
-      ::CORBA::ULong max,
-      ::CORBA::ULong length,
-      Fixed_Struct* buffer, 
-      ::CORBA::Boolean release = false);
     StructSeq (const StructSeq &);
     virtual ~StructSeq (void);
     
-    static void _tao_any_destructor (void *);
+    virtual ::CORBA::ULong length (void) const;
+    virtual void length (::CORBA::ULong);
     
-    typedef StructSeq_var _var_type;
-    typedef StructSeq_out _out_type;
+    static void _tao_any_destructor (void *);
   };
 
 #endif /* end #if !defined */
@@ -959,42 +917,20 @@ public:
 #if !defined (_PARAM_TEST_COFFEE_MIX_CH_)
 #define _PARAM_TEST_COFFEE_MIX_CH_
   
-  class Coffee_Mix;
-  
-  typedef
-    TAO_VarSeq_Var_T<
-        Coffee_Mix
-      >
-    Coffee_Mix_var;
-  
-  typedef
-    TAO_Seq_Out_T<
-        Coffee_Mix
-      >
-    Coffee_Mix_out;
-  
   class  Coffee_Mix
     : public
-        TAO::unbounded_object_reference_sequence<
-            Coffee,
-            Coffee_var
-          >
+        std::vector<Coffee>
   {
   public:
     Coffee_Mix (void);
     Coffee_Mix ( ::CORBA::ULong max);
-    Coffee_Mix (
-      ::CORBA::ULong max,
-      ::CORBA::ULong length,
-      Coffee_ptr* buffer, 
-      ::CORBA::Boolean release = false);
     Coffee_Mix (const Coffee_Mix &);
     virtual ~Coffee_Mix (void);
     
-    static void _tao_any_destructor (void *);
+    virtual ::CORBA::ULong length (void) const;
+    virtual void length (::CORBA::ULong);
     
-    typedef Coffee_Mix_var _var_type;
-    typedef Coffee_Mix_out _out_type;
+    static void _tao_any_destructor (void *);
   };
 
 #endif /* end #if !defined */
@@ -1406,43 +1342,20 @@ public:
 #if !defined (_PARAM_TEST_ARRAYSEQ_CH_)
 #define _PARAM_TEST_ARRAYSEQ_CH_
   
-  class ArraySeq;
-  
-  typedef
-    TAO_FixedSeq_Var_T<
-        ArraySeq
-      >
-    ArraySeq_var;
-  
-  typedef
-    TAO_Seq_Out_T<
-        ArraySeq
-      >
-    ArraySeq_out;
-  
   class  ArraySeq
     : public
-        TAO::unbounded_array_sequence<
-            Fixed_Array,
-            Fixed_Array_slice,
-            Fixed_Array_tag
-          >
+        std::vector<Fixed_Array>
   {
   public:
     ArraySeq (void);
     ArraySeq ( ::CORBA::ULong max);
-    ArraySeq (
-      ::CORBA::ULong max,
-      ::CORBA::ULong length,
-      Fixed_Array* buffer, 
-      ::CORBA::Boolean release = false);
     ArraySeq (const ArraySeq &);
     virtual ~ArraySeq (void);
     
-    static void _tao_any_destructor (void *);
+    virtual ::CORBA::ULong length (void) const;
+    virtual void length (::CORBA::ULong);
     
-    typedef ArraySeq_var _var_type;
-    typedef ArraySeq_out _out_type;
+    static void _tao_any_destructor (void *);
   };
 
 #endif /* end #if !defined */
@@ -2043,20 +1956,16 @@ public:
     
     class  _tao_seq_Param_Test_Recursive_Struct_
       : public
-          TAO::unbounded_value_sequence<
-              Param_Test::Recursive_Struct
-            >
+          std::vector<Param_Test::Recursive_Struct>
     {
     public:
       _tao_seq_Param_Test_Recursive_Struct_ (void);
       _tao_seq_Param_Test_Recursive_Struct_ ( ::CORBA::ULong max);
-      _tao_seq_Param_Test_Recursive_Struct_ (
-        ::CORBA::ULong max,
-        ::CORBA::ULong length,
-        Param_Test::Recursive_Struct* buffer, 
-        ::CORBA::Boolean release = false);
       _tao_seq_Param_Test_Recursive_Struct_ (const _tao_seq_Param_Test_Recursive_Struct_ &);
       virtual ~_tao_seq_Param_Test_Recursive_Struct_ (void);
+      
+      virtual ::CORBA::ULong length (void) const;
+      virtual void length (::CORBA::ULong);
     };
 
 #endif /* end #if !defined */
@@ -2135,20 +2044,16 @@ public:
     
     class  _tao_seq_Param_Test_nested_rec_union_
       : public
-          TAO::unbounded_value_sequence<
-              Param_Test::nested_rec_union
-            >
+          std::vector<Param_Test::nested_rec_union>
     {
     public:
       _tao_seq_Param_Test_nested_rec_union_ (void);
       _tao_seq_Param_Test_nested_rec_union_ ( ::CORBA::ULong max);
-      _tao_seq_Param_Test_nested_rec_union_ (
-        ::CORBA::ULong max,
-        ::CORBA::ULong length,
-        Param_Test::nested_rec_union* buffer, 
-        ::CORBA::Boolean release = false);
       _tao_seq_Param_Test_nested_rec_union_ (const _tao_seq_Param_Test_nested_rec_union_ &);
       virtual ~_tao_seq_Param_Test_nested_rec_union_ (void);
+      
+      virtual ::CORBA::ULong length (void) const;
+      virtual void length (::CORBA::ULong);
     };
 
 #endif /* end #if !defined */
@@ -2239,20 +2144,16 @@ public:
     
     class  _tao_seq_Param_Test_Recursive_Union_
       : public
-          TAO::unbounded_value_sequence<
-              Param_Test::Recursive_Union
-            >
+          std::vector<Param_Test::Recursive_Union>
     {
     public:
       _tao_seq_Param_Test_Recursive_Union_ (void);
       _tao_seq_Param_Test_Recursive_Union_ ( ::CORBA::ULong max);
-      _tao_seq_Param_Test_Recursive_Union_ (
-        ::CORBA::ULong max,
-        ::CORBA::ULong length,
-        Param_Test::Recursive_Union* buffer, 
-        ::CORBA::Boolean release = false);
       _tao_seq_Param_Test_Recursive_Union_ (const _tao_seq_Param_Test_Recursive_Union_ &);
       virtual ~_tao_seq_Param_Test_Recursive_Union_ (void);
+      
+      virtual ::CORBA::ULong length (void) const;
+      virtual void length (::CORBA::ULong);
     };
 
 #endif /* end #if !defined */
diff --git a/modules/TAO/tests/Param_Test/param_testS.cpp b/modules/TAO/tests/Param_Test/param_testS.cpp
index cf0d1a616f8..79e90c5a0d6 100644
--- a/modules/TAO/tests/Param_Test/param_testS.cpp
+++ b/modules/TAO/tests/Param_Test/param_testS.cpp
@@ -59,6 +59,7 @@
 #include "tao/PortableServer/UB_String_SArguments.h"
 #include "tao/PortableServer/Var_Array_SArgument_T.h"
 #include "tao/PortableServer/Var_Size_SArgument_T.h"
+#include "tao/PortableServer/Vector_SArgument_T.h"
 #include "tao/PortableServer/Any_SArg_Traits.h"
 #include "tao/PortableServer/TypeCode_SArg_Traits.h"
 #include "tao/PortableServer/Object_SArg_Traits.h"
@@ -74,6 +75,7 @@
 #include "tao/UB_String_Arguments.h"
 #include "tao/Var_Array_Argument_T.h"
 #include "tao/Var_Size_Argument_T.h"
+#include "tao/Vector_Argument_T.h"
 #include "tao/AnyTypeCode/Any_Arg_Traits.h"
 #include "ace/Dynamic_Service.h"
 #include "ace/Malloc_Allocator.h"