ChangeLogTag:Mon Aug 13 16:48:05 2001 Nanbor Wang <nanbor@cs.wustl.edu>

18 files changed, 5186 insertions, 24 deletions

diff --git a/TAO/ChangeLogs/ChangeLog-02a b/TAO/ChangeLogs/ChangeLog-02a
index f300d872c1b..6d2e2b2520a 100644
--- a/TAO/ChangeLogs/ChangeLog-02a
+++ b/TAO/ChangeLogs/ChangeLog-02a
@@ -1,3 +1,33 @@
+Mon Aug 13 16:48:05 2001  Nanbor Wang  <nanbor@cs.wustl.edu>
+
+	* tao/Sequence_T.h:
+	* tao/Sequence_T.i:
+	* tao/Sequence_T.cpp: Added TAO_Valuetype_Manager,
+	  TAO_Unbounded_Valuetype_Sequence, and
+	  TAO_Bounded_Valuetype_Sequence.  Valuetype's memory is managed
+	  thru _add_ref and _remove_ref (as oppose to _duplicate and
+	  release.)
+
+	* examples/OBV/Sequence/README:
+	* examples/OBV/Sequence/client.cpp:
+	* examples/OBV/Sequence/client.dsp:
+	* examples/OBV/Sequence/registry_i.cpp:
+	* examples/OBV/Sequence/registry_i.h:
+	* examples/OBV/Sequence/sequence.dsw:
+	* examples/OBV/Sequence/series.idl:
+	* examples/OBV/Sequence/series_i.cpp:
+	* examples/OBV/Sequence/series_i.h:
+	* examples/OBV/Sequence/server.cpp:
+	* examples/OBV/Sequence/server.dsp: New example to show how to use
+	  valuetypes in structured data type.  Currently only sequence is
+	  tested and we'll need to hack the IDL compiler to get this to
+	  work out of the box.
+
+	* examples/OBV/Sequence/seriesC.cpp.bak:
+	* examples/OBV/Sequence/seriesC.h.bak:
+	* examples/OBV/Sequence/seriesC.i.bak: These files showed what
+	  needs to be done for the test to run.
+
 Thu Aug  9 16:15:03 2001  Balachandran Natarajan  <bala@cs.wustl.edu>
 
 	* tests/RTCORBA/ORB_init/ORB_init.cpp: Fixed a warning in KCC
@@ -16,7 +46,7 @@ Thu Aug  9 11:46:27 2001  Balachandran Natarajan  <bala@cs.wustl.edu>
 	* tao/CDR.h: Fixed the ambigous constructor problem. The InputCDR
 	  class had two constructors which were  similar if the default
 	  values for the arguments were exercised. Thanks to Torbjorn
-	  Backstrom <torbjorn.k.backstrom@volvo.com>  for reporting this. 
+	  Backstrom <torbjorn.k.backstrom@volvo.com>  for reporting this.
 
 Wed Aug  8 22:53:37 2001  Balachandran Natarajan  <bala@cs.wustl.edu>
 
diff --git a/TAO/examples/OBV/Sequence/README b/TAO/examples/OBV/Sequence/README
new file mode 100644
index 00000000000..bfe3e50d208
--- /dev/null
+++ b/TAO/examples/OBV/Sequence/README
@@ -0,0 +1,11 @@
+This example demonstrate how to use valuetypes with some
+structured data type like sequence.
+
+To run the test, run:
+
+  server -f ior
+  client -f ior
+
+At this moment, TAO_IDL compiler does not support putting valuetype in
+a sequence.  Make sure you copy seriesC.*.bak to seriesC.* after
+running the IDL compiler.
diff --git a/TAO/examples/OBV/Sequence/client.cpp b/TAO/examples/OBV/Sequence/client.cpp
new file mode 100644
index 00000000000..bd40b175106
--- /dev/null
+++ b/TAO/examples/OBV/Sequence/client.cpp
@@ -0,0 +1,181 @@
+// $Id$
+//
+//===================================================================
+//  = LIBRARY
+//      TAO/examples/OBV/Sequence
+//
+//  = FILENAME
+//     client.cpp
+//
+//  = DESCRIPTION
+//      A client program for the numerical series module
+//
+//  = AUTHOR
+//     Nanbor Wang
+//
+//====================================================================
+
+#include "ace/streams.h"
+#include "ace/Get_Opt.h"
+#include "ace/Read_Buffer.h"
+#include "seriesC.h"
+#include "Registry_i.h"
+
+ACE_RCSID(series, client, "$Id$")
+
+static char *ior = 0;
+static char *ior_input_file = 0;
+static int do_shutdown = 0;
+
+static int
+parse_args (int argc, char **argv)
+{
+  ACE_Get_Opt get_opts (argc, argv, "k:f:x");
+  int c;
+
+  while ((c = get_opts ()) != -1)
+    switch (c)
+      {
+      case 'k':
+        ior = get_opts.optarg;
+        break;
+      case 'f':
+        ior_input_file = get_opts.optarg;
+        break;
+      case 'x':
+        do_shutdown = 1;
+        break;
+      case '?':
+      default:
+        ACE_ERROR_RETURN ((LM_ERROR,
+                           "\nusage:  %s "
+                           "-i <ior_input_file> "
+                           "-k IOR "
+                           "\n",
+                           argv [0]),
+                          -1);
+      }
+
+  if (ior == 0 && ior_input_file == 0)
+    ACE_ERROR_RETURN ((LM_ERROR,
+                       "\nPlease specify the IOR or IOR input file"
+                       " for the servant"),
+                      -1);
+  if (ior != 0 && ior_input_file != 0)
+    ACE_ERROR_RETURN ((LM_ERROR,
+                       "\nPlease specify only an IOR or only an IOR"
+                       " input file but not both"),
+                      -1);
+
+  // Indicates successful parsing of the command line.
+  return 0;
+}
+
+int
+main (int argc, char **argv)
+{
+  ACE_DECLARE_NEW_CORBA_ENV;
+  ACE_TRY
+    {
+      // Initialize the ORB
+      CORBA::ORB_var orb = CORBA::ORB_init (argc, argv, 0,
+                                            ACE_TRY_ENV);
+      ACE_TRY_CHECK;
+
+#if 1
+      CORBA_ValueFactory_ptr factory = new registry_factory;
+      CORBA_ValueFactory_ptr prev_factory =
+        orb->register_value_factory (factory->tao_repository_id (),
+                                     factory);
+      if (prev_factory)
+        prev_factory->_remove_ref ();
+      factory->_remove_ref ();
+#endif /* 0 */
+
+      // Parse the command-line arguments to get the IOR
+      parse_args (argc, argv);
+
+      // If ior_input_file exists, Read the file, and get the IOR
+      // else, it must have been specified on the command line
+      if (ior_input_file != 0)
+        {
+          ACE_HANDLE input_file = ACE_OS::open (ior_input_file, 0);
+          if (input_file == ACE_INVALID_HANDLE)
+            ACE_ERROR_RETURN ((LM_ERROR,
+                               "Cannot open input file for reading IOR: %s\n",
+                               ior_input_file),
+                              -1);
+          ACE_Read_Buffer ior_buffer (input_file);
+          char *data = ior_buffer.read ();
+          if (data == 0)
+            ACE_ERROR_RETURN ((LM_ERROR,
+                               "Unable to read ior\n"),
+                              -1);
+          ior = ACE_OS::strdup (data);
+          ior_buffer.alloc ()-> free (data);
+          ACE_OS::close (input_file);
+        }
+
+      // Get the object reference with the IOR
+      CORBA::Object_var object = orb->string_to_object (ior, ACE_TRY_ENV);
+      ACE_TRY_CHECK;
+
+      series_var series_op = series::_narrow (object.in (), ACE_TRY_ENV);
+      ACE_TRY_CHECK;
+
+      registry_impl reg;
+
+      reg.value (5);
+
+      registry_var retn;
+
+      retn = series_op->cube (&reg, ACE_TRY_ENV);
+      ACE_TRY_CHECK;
+
+      if (retn->value () == 125)
+        {
+          ACE_DEBUG ((LM_DEBUG, "Sent %d and received %d.  Operation cube succeeded.\n",
+                      reg.value (), retn->value ()));
+        }
+      else
+        {
+          ACE_DEBUG ((LM_ERROR, "Sent %d and received %d.  Operation cube failed.\n",
+                      reg.value (), retn->value ()));
+        }
+
+
+      // Now test a sequence of valuetype.
+      registries reg_seq (10);
+
+      reg_seq.length (5);
+
+      for (int i = 0; i < 5; i++)
+        {
+          registry_var tmp = new registry_impl;
+
+          tmp->value (i);
+
+          reg_seq[i] = tmp;
+        }
+
+      registries_var ret_seq;
+
+      ret_seq = series_op->sum (reg_seq, ACE_TRY_ENV);
+      ACE_TRY_CHECK;
+
+      print_registries (reg_seq);
+      print_registries (ret_seq.in ());
+
+      if (do_shutdown)
+        series_op->shutdown (ACE_TRY_ENV);
+      ACE_TRY_CHECK;
+    }
+  ACE_CATCHANY
+    {
+      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, "client");
+      return 1;
+    }
+  ACE_ENDTRY;
+
+  return 0;
+}
diff --git a/TAO/examples/OBV/Sequence/client.dsp b/TAO/examples/OBV/Sequence/client.dsp
new file mode 100644
index 00000000000..8b067603143
--- /dev/null
+++ b/TAO/examples/OBV/Sequence/client.dsp
@@ -0,0 +1,203 @@
+# Microsoft Developer Studio Project File - Name="OBV Sequence client" - Package Owner=<4>

+# Microsoft Developer Studio Generated Build File, Format Version 6.00

+# ** DO NOT EDIT **

+

+# TARGTYPE "Win32 (x86) Console Application" 0x0103

+

+CFG=OBV Sequence client - Win32 Debug

+!MESSAGE This is not a valid makefile. To build this project using NMAKE,

+!MESSAGE use the Export Makefile command and run

+!MESSAGE

+!MESSAGE NMAKE /f "client.mak".

+!MESSAGE

+!MESSAGE You can specify a configuration when running NMAKE

+!MESSAGE by defining the macro CFG on the command line. For example:

+!MESSAGE

+!MESSAGE NMAKE /f "client.mak" CFG="OBC Sequence client - Win32 Debug"

+!MESSAGE

+!MESSAGE Possible choices for configuration are:

+!MESSAGE

+!MESSAGE "OBV Sequence client - Win32 Release" (based on "Win32 (x86) Console Application")

+!MESSAGE "OBV Sequence client - Win32 Debug" (based on "Win32 (x86) Console Application")

+!MESSAGE

+

+# Begin Project

+# PROP AllowPerConfigDependencies 0

+# PROP Scc_ProjName ""

+# PROP Scc_LocalPath ""

+CPP=cl.exe

+RSC=rc.exe

+

+!IF  "$(CFG)" == "OBV Sequence client - Win32 Release"

+

+# PROP BASE Use_MFC 0

+# PROP BASE Use_Debug_Libraries 0

+# PROP BASE Output_Dir "Release"

+# PROP BASE Intermediate_Dir "Release"

+# PROP BASE Target_Dir ""

+# PROP Use_MFC 0

+# PROP Use_Debug_Libraries 0

+# PROP Output_Dir "Release"

+# PROP Intermediate_Dir "Release"

+# PROP Target_Dir ""

+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c

+# ADD CPP /nologo /MD /W3 /GX /O2 /I "..\..\..\\" /I "..\..\..\..\\" /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c

+# ADD BASE RSC /l 0x409 /d "NDEBUG"

+# ADD RSC /l 0x409 /d "NDEBUG"

+BSC32=bscmake.exe

+# ADD BASE BSC32 /nologo

+# ADD BSC32 /nologo

+LINK32=link.exe

+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386

+# ADD LINK32 ace.lib tao.lib tao_portableserver.lib /nologo /subsystem:console /machine:I386 /libpath:"..\..\..\..\ace" /libpath:"..\..\..\tao" /libpath:"..\..\..\tao\portableserver"

+

+!ELSEIF  "$(CFG)" == "OBV Sequence client - Win32 Debug"

+

+# PROP BASE Use_MFC 0

+# PROP BASE Use_Debug_Libraries 1

+# PROP BASE Output_Dir "client___Win32_Debug"

+# PROP BASE Intermediate_Dir "client___Win32_Debug"

+# PROP BASE Target_Dir ""

+# PROP Use_MFC 0

+# PROP Use_Debug_Libraries 1

+# PROP Output_Dir ""

+# PROP Intermediate_Dir "Debug"

+# PROP Target_Dir ""

+# ADD BASE CPP /nologo /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD  /c

+# ADD CPP /nologo /MDd /W3 /Gm /GX /Zi /Od /I "..\..\..\\" /I "..\..\..\..\\" /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD  /c

+# ADD BASE RSC /l 0x409 /d "_DEBUG"

+# ADD RSC /l 0x409 /d "_DEBUG"

+BSC32=bscmake.exe

+# ADD BASE BSC32 /nologo

+# ADD BSC32 /nologo

+LINK32=link.exe

+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept

+# ADD LINK32 aced.lib taod.lib tao_portableserverd.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept /libpath:"..\..\..\..\ace" /libpath:"..\..\..\tao" /libpath:"..\..\..\tao\portableserver"

+

+!ENDIF

+

+# Begin Target

+

+# Name "OBV Sequence client - Win32 Release"

+# Name "OBV Sequence client - Win32 Debug"

+# Begin Group "Source Files"

+

+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"

+# Begin Source File

+

+SOURCE=.\client.cpp

+# End Source File

+# Begin Source File

+

+SOURCE=.\registry_i.cpp

+# End Source File

+# Begin Source File

+

+SOURCE=.\seriesC.cpp

+# End Source File

+# End Group

+# Begin Group "Header Files"

+

+# PROP Default_Filter "h;hpp;hxx;hm;inl"

+# Begin Source File

+

+SOURCE=.\registry_i.h

+# End Source File

+# Begin Source File

+

+SOURCE=.\seriesC.h

+# End Source File

+# End Group

+# Begin Group "Resource Files"

+

+# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"

+# End Group

+# Begin Group "IDL Files"

+

+# PROP Default_Filter ""

+# Begin Source File

+

+SOURCE=.\series.idl

+

+!IF  "$(CFG)" == "OBV Sequence client - Win32 Release"

+

+# PROP Ignore_Default_Tool 1

+# Begin Custom Build - Invoking TAO_IDL Compiler on $(InputName)

+InputPath=.\series.idl

+InputName=series

+

+BuildCmds= \

+	..\..\.\..\bin\Release\tao_idl -Ge 1 -Gv 1 $(InputName).idl

+

+"$(InputName)C.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"

+   $(BuildCmds)

+

+"$(InputName)C.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"

+   $(BuildCmds)

+

+"$(InputName)C.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"

+   $(BuildCmds)

+

+"$(InputName)S.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"

+   $(BuildCmds)

+

+"$(InputName)S.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"

+   $(BuildCmds)

+

+"$(InputName)S.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"

+   $(BuildCmds)

+

+"$(InputName)S_T.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"

+   $(BuildCmds)

+

+"$(InputName)S_T.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"

+   $(BuildCmds)

+

+"$(InputName)S_T.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"

+   $(BuildCmds)

+# End Custom Build

+

+!ELSEIF  "$(CFG)" == "OBV Sequence client - Win32 Debug"

+

+# PROP Ignore_Default_Tool 1

+# Begin Custom Build - Invoking TAO_IDL Compiler on $(InputName)

+InputPath=.\series.idl

+InputName=series

+

+BuildCmds= \

+	..\..\..\..\bin\tao_idl -Ge 1 -Gv 1 $(InputName).idl

+

+"$(InputName)C.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"

+   $(BuildCmds)

+

+"$(InputName)C.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"

+   $(BuildCmds)

+

+"$(InputName)C.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"

+   $(BuildCmds)

+

+"$(InputName)S.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"

+   $(BuildCmds)

+

+"$(InputName)S.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"

+   $(BuildCmds)

+

+"$(InputName)S.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"

+   $(BuildCmds)

+

+"$(InputName)S_T.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"

+   $(BuildCmds)

+

+"$(InputName)S_T.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"

+   $(BuildCmds)

+

+"$(InputName)S_T.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"

+   $(BuildCmds)

+# End Custom Build

+

+!ENDIF

+

+# End Source File

+# End Group

+# End Target

+# End Project

diff --git a/TAO/examples/OBV/Sequence/registry_i.cpp b/TAO/examples/OBV/Sequence/registry_i.cpp
new file mode 100644
index 00000000000..8ea89ce2b65
--- /dev/null
+++ b/TAO/examples/OBV/Sequence/registry_i.cpp
@@ -0,0 +1,35 @@
+// $Id$
+
+#include "Registry_i.h"
+
+/*
+registry_impl::registry_impl ()
+{
+}
+
+registry_impl::registry_impl (CORBA::Long x)
+{
+  this->value (x);
+} */
+
+registry_factory::registry_factory ()
+{
+}
+
+TAO_OBV_CREATE_RETURN_TYPE (registry)
+registry_factory::create_for_unmarshal ()
+{
+  return new registry_impl;
+}
+
+void print_registries (const registries &v)
+{
+  ACE_DEBUG ((LM_DEBUG, "sequence<registry>: "));
+
+  for (unsigned int i = 0 ; i < v.length (); i++)
+    {
+      ACE_DEBUG ((LM_DEBUG, "%d ", v[i]->value ()));
+    }
+
+  ACE_DEBUG ((LM_DEBUG, "\n"));
+}
diff --git a/TAO/examples/OBV/Sequence/registry_i.h b/TAO/examples/OBV/Sequence/registry_i.h
new file mode 100644
index 00000000000..e116533e60e
--- /dev/null
+++ b/TAO/examples/OBV/Sequence/registry_i.h
@@ -0,0 +1,36 @@
+// $Id$
+
+#if !defined (REGISTRY_I_H)
+#define REGISTRY_I_H
+#include "seriesC.h"
+
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable:4250)
+#endif /* _MSC_VER */
+
+class registry_factory;
+
+class registry_impl : public virtual OBV_registry,
+                      public virtual CORBA::DefaultValueRefCountBase
+{
+public:
+  registery_impl ();
+  registery_impl (CORBA::Long v);
+};
+
+class registry_factory : public registry_init
+{
+public:
+  registry_factory ();
+
+private:
+  TAO_OBV_CREATE_RETURN_TYPE(registry) create_for_unmarshal ();
+};
+
+void print_registries (const registries &v);
+
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif /* _MSC_VER */
+#endif /* REGISTRY_I_H */
diff --git a/TAO/examples/OBV/Sequence/sequence.dsw b/TAO/examples/OBV/Sequence/sequence.dsw
new file mode 100644
index 00000000000..d17cf7c9604
--- /dev/null
+++ b/TAO/examples/OBV/Sequence/sequence.dsw
@@ -0,0 +1,41 @@
+Microsoft Developer Studio Workspace File, Format Version 6.00

+# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!

+

+###############################################################################

+

+Project: "client"=.\client.dsp - Package Owner=<4>

+

+Package=<5>

+{{{

+}}}

+

+Package=<4>

+{{{

+}}}

+

+###############################################################################

+

+Project: "server"=.\server.dsp - Package Owner=<4>

+

+Package=<5>

+{{{

+}}}

+

+Package=<4>

+{{{

+}}}

+

+###############################################################################

+

+Global:

+

+Package=<5>

+{{{

+}}}

+

+Package=<3>

+{{{

+}}}

+

+###############################################################################

+

diff --git a/TAO/examples/OBV/Sequence/series.idl b/TAO/examples/OBV/Sequence/series.idl
new file mode 100644
index 00000000000..c9ad41aba24
--- /dev/null
+++ b/TAO/examples/OBV/Sequence/series.idl
@@ -0,0 +1,27 @@
+// $Id$
+
+// OBV Factorial test.
+
+valuetype registry
+{
+  public long value;
+
+  //  factory init (in long x);
+};
+
+typedef sequence<registry> registries;
+
+interface series
+{
+  // Basic value type check.
+  registry cube (in registry v);
+
+  // Add series
+  registries sum (in registries x);
+
+  // Factorial operation.
+  //  registries factorial (in registries init);
+
+  // shutting down the server
+  void shutdown ();
+};
diff --git a/TAO/examples/OBV/Sequence/seriesC.cpp.bak b/TAO/examples/OBV/Sequence/seriesC.cpp.bak
new file mode 100644
index 00000000000..9f241b556d0
--- /dev/null
+++ b/TAO/examples/OBV/Sequence/seriesC.cpp.bak
@@ -0,0 +1,1866 @@
+// -*- C++ -*-
+//
+// $Id$
+
+// ****  Code generated by the The ACE ORB (TAO) IDL Compiler ****
+// TAO and the TAO IDL Compiler have been developed by:
+//       Center for Distributed Object Computing
+//       Washington University
+//       St. Louis, MO
+//       USA
+//       http://www.cs.wustl.edu/~schmidt/doc-center.html
+// and
+//       Distributed Object Computing Laboratory
+//       University of California at Irvine
+//       Irvine, CA
+//       USA
+//       http://doc.ece.uci.edu/
+//
+// Information about TAO is available at:
+//     http://www.cs.wustl.edu/~schmidt/TAO.html
+
+#include "seriesC.h"
+
+#include "tao/Stub.h"
+#include "tao/Invocation.h"
+#include "tao/PortableInterceptor.h"
+
+#if TAO_HAS_INTERCEPTORS == 1
+#include "tao/RequestInfo_Util.h"
+#include "tao/ClientRequestInfo.h"
+#include "tao/ClientInterceptorAdapter.h"
+#endif  /* TAO_HAS_INTERCEPTORS == 1 */
+
+#if defined (__BORLANDC__)
+#pragma option -w-rvl -w-rch -w-ccc -w-aus
+#endif /* __BORLANDC__ */
+
+#if !defined (__ACE_INLINE__)
+#include "seriesC.i"
+#endif /* !defined INLINE */
+
+registry* registry::_downcast (CORBA::ValueBase* v)
+{
+  if (v == 0) return 0;
+  return (registry* ) v->_tao_obv_narrow ((ptr_arith_t) &_downcast);
+}
+
+const char* registry::_tao_obv_repository_id () const
+{
+  return this->_tao_obv_static_repository_id ();
+}
+
+void* registry::_tao_obv_narrow (ptr_arith_t type_id)
+{
+  if (type_id == (ptr_arith_t) &_downcast)
+    return this;
+  void *rval = 0;
+  return rval;
+}
+
+CORBA::Boolean registry::_tao_marshal_v (TAO_OutputCDR & strm)
+{
+  return this->_tao_marshal__registry (strm);
+}
+
+CORBA::Boolean registry::_tao_unmarshal_v (TAO_InputCDR & strm)
+{
+  return this->_tao_unmarshal__registry (strm);
+}
+
+CORBA::Boolean registry::_tao_unmarshal (TAO_InputCDR &strm, registry *&new_object)
+{
+  CORBA::Boolean retval = 1;
+  CORBA::ValueBase *base;   // %! should be a _var
+  CORBA::ValueFactory_ptr factory;   // %! should be a _var
+  if (!CORBA::ValueBase::_tao_unmarshal_pre (strm, factory, base,
+          registry::_tao_obv_static_repository_id ()) )
+    {
+      return 0;
+    }
+  if (factory != 0)
+    {
+      base = factory->create_for_unmarshal ();
+      factory->_remove_ref ();
+      if (base == 0)  return 0;  // %! except.?
+      //%! ACE_DEBUG ((LM_DEBUG, "registry::_tao_unmarshal %s\n", base->_tao_obv_repository_id () ));
+      retval = base->_tao_unmarshal_v (strm);
+      //%! ACE_DEBUG ((LM_DEBUG, "registry::_tao_unmarshal retval unmarshal_v is %d\n", retval));
+      if (!retval) return 0;
+    }
+  // Now base must be null or point to the unmarshaled object.
+  // Align the pointer to the right subobject.
+  new_object = registry::_downcast (base);
+  // %! unmarshal_post
+  return 1;
+}
+
+
+#if !defined (_REGISTRY___INIT_CS_)
+#define _REGISTRY___INIT_CS_
+
+registry_init::~registry_init (void)
+{
+}
+
+const char*
+registry_init::tao_repository_id (void)
+{
+  return registry::_tao_obv_static_repository_id ();
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_REGISTRIES_CS_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_REGISTRIES_CS_
+
+// The Base_Sequence functions, please see tao/Sequence.h
+void
+_TAO_Unbounded_Valuetype_Sequence_registries::_allocate_buffer (CORBA::ULong length)
+{
+   **tmp = 0;
+  tmp = _TAO_Unbounded_Valuetype_Sequence_registries::allocbuf (length);
+
+  if (this->buffer_ != 0)
+  {
+     **old = ACE_reinterpret_cast (**, this->buffer_);
+    for (CORBA::ULong i = 0; i < this->length_; ++i)
+      {
+        if (!this->release_)
+          {
+            old[i]->_add_ref ();
+            tmp[i] = old[i];
+          }
+        else
+          {
+            tmp[i] = old[i];
+          }
+      }
+
+    if (this->release_)
+      {
+        delete[] old;
+      }
+  }
+  this->buffer_ = tmp;
+}
+
+void
+_TAO_Unbounded_Valuetype_Sequence_registries::_deallocate_buffer (void)
+{
+  if (this->buffer_ == 0 || this->release_ == 0)
+    return;
+   **tmp = ACE_reinterpret_cast (**, this->buffer_);
+
+  for (CORBA::ULong i = 0; i < this->length_; ++i)
+    {
+      tmp[i]->_remove_ref ();
+      tmp[i] = 0;
+    }
+
+  _TAO_Unbounded_Valuetype_Sequence_registries::freebuf (tmp);
+  this->buffer_ = 0;
+}
+
+_TAO_Unbounded_Valuetype_Sequence_registries::~_TAO_Unbounded_Valuetype_Sequence_registries (void)
+{
+  this->_deallocate_buffer ();
+}
+
+void
+_TAO_Unbounded_Valuetype_Sequence_registries::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol)
+{
+   **tmp = ACE_reinterpret_cast (**, this->buffer_);
+
+  for (CORBA::ULong i = nl; i < ol; ++i)
+    {
+      tmp[i]->_remove_ref ();
+      tmp[i] = 0;
+    }
+}
+
+/*
+void
+_TAO_Unbounded_Valuetype_Sequence_registries::_downcast (
+    void* target,
+    CORBA_Object *src,
+    CORBA_Environment &ACE_TRY_ENV
+  )
+{
+   **tmp = ACE_static_cast (**, target);
+  *tmp = ::_narrow (src, ACE_TRY_ENV);
+  ACE_CHECK;
+}
+
+CORBA_Object*
+_TAO_Unbounded_Object_Sequence_registries::_upcast (void *src) const
+{
+   **tmp = ACE_static_cast (**, src);
+  return *tmp;
+}
+*/
+
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+
+#if !defined (_REGISTRIES_CS_)
+#define _REGISTRIES_CS_
+
+// *************************************************************
+// registries
+// *************************************************************
+
+registries::registries (void)
+{}
+
+registries::registries (CORBA::ULong max) // uses max size
+  :
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+_TAO_Unbounded_Valuetype_Sequence_registries
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+TAO_Unbounded_Valuetype_Sequence<registry,registry_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+ (max)
+{}
+
+registries::registries (CORBA::ULong max, CORBA::ULong length, registry_ptr *buffer, CORBA::Boolean release)
+  :
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+_TAO_Unbounded_Valuetype_Sequence_registries
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+TAO_Unbounded_Valuetype_Sequence<registry,registry_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+ (max, length, buffer, release)
+{}
+
+registries::registries (const registries &seq) // copy ctor
+  :
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+_TAO_Unbounded_Valuetype_Sequence_registries
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+TAO_Unbounded_Valuetype_Sequence<registry,registry_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+ (seq)
+{}
+
+registries::~registries (void) // dtor
+{}
+
+void registries::_tao_any_destructor (void *_tao_void_pointer)
+{
+  registries *tmp = ACE_static_cast (registries*, _tao_void_pointer);
+  delete tmp;
+}
+
+
+#endif /* end #if !defined */
+
+static const CORBA::Long _oc_registries[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  19,
+  ACE_NTOHL (0x49444c3a),
+  ACE_NTOHL (0x72656769),
+  ACE_NTOHL (0x73747269),
+  ACE_NTOHL (0x65733a31),
+  ACE_NTOHL (0x2e300000),  // repository ID = IDL:registries:1.0
+  11,
+  ACE_NTOHL (0x72656769),
+  ACE_NTOHL (0x73747269),
+  ACE_NTOHL (0x65730000),  // name = registries
+  CORBA::tk_sequence, // typecode kind
+  8, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    0U,
+
+};
+
+static CORBA::TypeCode _tc_TAO_tc_registries (
+    CORBA::tk_alias,
+    sizeof (_oc_registries),
+    (char *) &_oc_registries,
+    0,
+    sizeof (registries)
+  );
+
+CORBA::TypeCode_ptr _tc_registries =
+  &_tc_TAO_tc_registries;
+
+int series::_tao_class_id = 0;
+
+series_ptr
+tao_series_duplicate (
+    series_ptr p
+  )
+{
+  return series::_duplicate (p);
+}
+
+void
+tao_series_release (
+    series_ptr p
+  )
+{
+  CORBA::release (p);
+}
+
+series_ptr
+tao_series_nil (
+    void
+  )
+{
+  return series::_nil ();
+}
+
+series_ptr
+tao_series_narrow (
+    CORBA::Object *p,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+{
+  return series::_narrow (p, ACE_TRY_ENV);
+}
+
+CORBA::Object *
+tao_series_upcast (
+    void *src
+  )
+{
+  series **tmp =
+    ACE_static_cast (series **, src);
+  return *tmp;
+}
+
+// *************************************************************
+// Operations for class series_var
+// *************************************************************
+
+series_var::series_var (void) // default constructor
+  : ptr_ (series::_nil ())
+{}
+
+::series_ptr
+series_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+series_var::series_var (const ::series_var &p) // copy constructor
+  : TAO_Base_var (),
+    ptr_ (series::_duplicate (p.ptr ()))
+{}
+
+series_var::~series_var (void) // destructor
+{
+  CORBA::release (this->ptr_);
+}
+
+series_var &
+series_var::operator= (series_ptr p)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = p;
+  return *this;
+}
+
+series_var &
+series_var::operator= (const ::series_var &p)
+{
+  if (this != &p)
+  {
+    CORBA::release (this->ptr_);
+    this->ptr_ = ::series::_duplicate (p.ptr ());
+  }
+  return *this;
+}
+
+series_var::operator const ::series_ptr &() const // cast
+{
+  return this->ptr_;
+}
+
+series_var::operator ::series_ptr &() // cast
+{
+  return this->ptr_;
+}
+
+::series_ptr
+series_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+::series_ptr
+series_var::in (void) const
+{
+  return this->ptr_;
+}
+
+::series_ptr &
+series_var::inout (void)
+{
+  return this->ptr_;
+}
+
+::series_ptr &
+series_var::out (void)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = ::series::_nil ();
+  return this->ptr_;
+}
+
+::series_ptr
+series_var::_retn (void)
+{
+  // yield ownership of managed obj reference
+  ::series_ptr val = this->ptr_;
+  this->ptr_ = ::series::_nil ();
+  return val;
+}
+
+::series_ptr
+series_var::duplicate (series_ptr p)
+{
+  return ::series::_duplicate (p);
+}
+
+void
+series_var::release (series_ptr p)
+{
+  CORBA::release (p);
+}
+
+::series_ptr
+series_var::nil (void)
+{
+  return ::series::_nil ();
+}
+
+::series_ptr
+series_var::narrow (
+    CORBA::Object *p,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+{
+  return ::series::_narrow (p, ACE_TRY_ENV);
+}
+
+CORBA::Object *
+series_var::upcast (void *src)
+{
+  series **tmp =
+    ACE_static_cast (series **, src);
+  return *tmp;
+}
+
+// *************************************************************
+// Operations for class series_out
+// *************************************************************
+
+series_out::series_out (series_ptr &p)
+  : ptr_ (p)
+{
+  this->ptr_ = ::series::_nil ();
+}
+
+series_out::series_out (series_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = ::series::_nil ();
+}
+
+series_out::series_out (const ::series_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (series_out &, p).ptr_)
+{}
+
+::series_out &
+series_out::operator= (const ::series_out &p)
+{
+  this->ptr_ = ACE_const_cast (series_out&, p).ptr_;
+  return *this;
+}
+
+series_out &
+series_out::operator= (const ::series_var &p)
+{
+  this->ptr_ = ::series::_duplicate (p.ptr ());
+  return *this;
+}
+
+series_out &
+series_out::operator= (series_ptr p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+series_out::operator ::series_ptr &() // cast
+{
+  return this->ptr_;
+}
+
+::series_ptr &
+series_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+::series_ptr
+series_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+class TAO_ClientRequestInfo_series_cube : public TAO_ClientRequestInfo
+{
+public:
+  TAO_ClientRequestInfo_series_cube (
+      TAO_GIOP_Invocation *_tao_invocation,
+      CORBA::Object_ptr _tao_target,
+      registry * v,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    );
+
+  virtual Dynamic::ParameterList * arguments (
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  virtual Dynamic::ExceptionList * exceptions (
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  virtual CORBA::Any * result (
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  void result (registry * result);
+
+private:
+  TAO_ClientRequestInfo_series_cube (const TAO_ClientRequestInfo_series_cube &);
+  void operator= (const TAO_ClientRequestInfo_series_cube &);
+
+  registry * v_;
+  registry * _result;
+};
+
+TAO_ClientRequestInfo_series_cube::TAO_ClientRequestInfo_series_cube (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    registry * v,
+    CORBA::Environment &
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    v_ (v)
+{}
+
+Dynamic::ParameterList *
+TAO_ClientRequestInfo_series_cube::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+
+  return parameter_list;
+}
+
+Dynamic::ExceptionList *
+TAO_ClientRequestInfo_series_cube::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+
+  return exception_list;
+}
+
+
+CORBA::Any *
+TAO_ClientRequestInfo_series_cube::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+
+  CORBA::Any_var safe_result_any = result_any;
+
+  return safe_result_any._retn ();
+}
+
+void
+TAO_ClientRequestInfo_series_cube::result (registry * result)
+{
+  // update the result
+  this->_result = result;
+}
+
+class TAO_ClientRequestInfo_series_sum : public TAO_ClientRequestInfo
+{
+public:
+  TAO_ClientRequestInfo_series_sum (
+      TAO_GIOP_Invocation *_tao_invocation,
+      CORBA::Object_ptr _tao_target,
+      const registries & x,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    );
+
+  virtual Dynamic::ParameterList * arguments (
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  virtual Dynamic::ExceptionList * exceptions (
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  virtual CORBA::Any * result (
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  void result (registries * result);
+
+private:
+  TAO_ClientRequestInfo_series_sum (const TAO_ClientRequestInfo_series_sum &);
+  void operator= (const TAO_ClientRequestInfo_series_sum &);
+
+  const registries & x_;
+  registries * _result;
+};
+
+TAO_ClientRequestInfo_series_sum::TAO_ClientRequestInfo_series_sum (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const registries & x,
+    CORBA::Environment &
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    x_ (x)
+{}
+
+Dynamic::ParameterList *
+TAO_ClientRequestInfo_series_sum::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+
+  parameter_list->length (1);
+  CORBA::ULong len = 0;
+
+    (*parameter_list)[len].argument <<=  this->x_;
+  (*parameter_list)[len].mode = CORBA::PARAM_IN;
+  len++;
+
+  return safe_parameter_list._retn ();
+}
+
+Dynamic::ExceptionList *
+TAO_ClientRequestInfo_series_sum::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+
+  return exception_list;
+}
+
+
+CORBA::Any *
+TAO_ClientRequestInfo_series_sum::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+
+  CORBA::Any_var safe_result_any = result_any;
+
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void
+TAO_ClientRequestInfo_series_sum::result (registries * result)
+{
+  // update the result
+  this->_result = result;
+}
+
+class TAO_ClientRequestInfo_series_shutdown : public TAO_ClientRequestInfo
+{
+public:
+  TAO_ClientRequestInfo_series_shutdown (
+      TAO_GIOP_Invocation *_tao_invocation,
+      CORBA::Object_ptr _tao_target,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    );
+
+  virtual Dynamic::ParameterList * arguments (
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  virtual Dynamic::ExceptionList * exceptions (
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  virtual CORBA::Any * result (
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+private:
+  TAO_ClientRequestInfo_series_shutdown (const TAO_ClientRequestInfo_series_shutdown &);
+  void operator= (const TAO_ClientRequestInfo_series_shutdown &);
+
+
+};
+
+TAO_ClientRequestInfo_series_shutdown::TAO_ClientRequestInfo_series_shutdown (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::Environment &
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
+{}
+
+Dynamic::ParameterList *
+TAO_ClientRequestInfo_series_shutdown::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+
+  return parameter_list;
+}
+
+Dynamic::ExceptionList *
+TAO_ClientRequestInfo_series_shutdown::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+
+  return exception_list;
+}
+
+
+CORBA::Any *
+TAO_ClientRequestInfo_series_shutdown::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 1;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+
+  return result_any;
+}
+
+#endif /* TAO_HAS_INTERCEPTORS */
+
+///////////////////////////////////////////////////////////////////////
+//                Base & Remote Proxy  Implementation.
+//
+
+_TAO_series_Proxy_Impl::_TAO_series_Proxy_Impl (void)
+{}
+
+_TAO_series_Remote_Proxy_Impl::_TAO_series_Remote_Proxy_Impl (void)
+{}
+
+// Remote Implementation of the IDL interface methods
+
+registry * _TAO_series_Remote_Proxy_Impl::cube (
+    CORBA_Object *_collocated_tao_target_,
+    registry * v,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+
+  registry_ptr _tao_retval = 0;
+  registry_var _tao_safe_retval (_tao_retval);
+
+
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "cube",
+      4,
+      1,
+      istub->orb_core ()
+    );
+
+  int _invoke_status;
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors (),
+      &_tao_call,
+      _invoke_status
+    );
+
+#endif  /* TAO_HAS_INTERCEPTORS */
+
+  for (;;)
+    {
+      _invoke_status = TAO_INVOKE_EXCEPTION;
+
+#if TAO_HAS_INTERCEPTORS == 1
+      TAO_ClientRequestInfo_series_cube ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        v,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+
+#endif /* TAO_HAS_INTERCEPTORS */
+
+
+      CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+      TAO_INTERCEPTOR (ri.response_expected (1));
+
+#if TAO_HAS_INTERCEPTORS == 1
+
+      ACE_TRY
+        {
+          _tao_vfr.send_request (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+
+          if (_invoke_status == TAO_INVOKE_RESTART)
+            {
+              _tao_call.restart_flag (1);
+              continue;
+            }
+
+#endif /* TAO_HAS_INTERCEPTORS */
+
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << v)
+            ))
+            TAO_INTERCEPTOR_THROW_RETURN (
+              CORBA::MARSHAL (),
+              0
+            );
+
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_OMG_VMCID | 1, CORBA::COMPLETED_YES),
+                0
+              );
+
+            }
+          else if (_invoke_status == TAO_INVOKE_RESTART)
+            {
+              TAO_INTERCEPTOR (
+                ri.reply_status (_invoke_status);
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+                ACE_TRY_CHECK;
+              )
+
+              continue;
+            }
+
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+
+            }
+
+#if TAO_HAS_INTERCEPTORS == 1
+          registry * _tao_retval_info = _tao_safe_retval._retn ();
+          ri.result (_tao_retval_info);
+          _tao_safe_retval = _tao_retval_info;
+
+          ri.reply_status (_invoke_status);
+          _tao_vfr.receive_reply (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+
+      }
+    ACE_CATCHANY
+      {
+        ri.exception (&ACE_ANY_EXCEPTION);
+        _tao_vfr.receive_exception (
+          &ri,
+          ACE_TRY_ENV
+        );
+        ACE_TRY_CHECK;
+
+        PortableInterceptor::ReplyStatus _tao_status =
+          ri.reply_status (ACE_TRY_ENV);
+        ACE_TRY_CHECK;
+
+        if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION
+            || _tao_status == PortableInterceptor::USER_EXCEPTION)
+          ACE_RE_THROW;
+      }
+    ACE_ENDTRY;
+    ACE_CHECK_RETURN (0);
+
+    PortableInterceptor::ReplyStatus _tao_status =
+      ri.reply_status (ACE_TRY_ENV);
+    ACE_CHECK_RETURN (0);
+
+    if (_tao_status == PortableInterceptor::LOCATION_FORWARD
+        || _tao_status == PortableInterceptor::TRANSPORT_RETRY)
+      continue;
+
+#endif  /* TAO_HAS_INTERCEPTORS */
+
+    break;
+  }
+return _tao_safe_retval._retn ();
+}
+
+registries * _TAO_series_Remote_Proxy_Impl::sum (
+    CORBA_Object *_collocated_tao_target_,
+    const registries & x,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+
+  registries *_tao_retval = 0;
+
+
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+
+  ACE_NEW_RETURN (_tao_retval, registries, _tao_retval);
+  registries_var _tao_safe_retval (_tao_retval);
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "sum",
+      3,
+      1,
+      istub->orb_core ()
+    );
+
+  int _invoke_status;
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors (),
+      &_tao_call,
+      _invoke_status
+    );
+
+#endif  /* TAO_HAS_INTERCEPTORS */
+
+  for (;;)
+    {
+      _invoke_status = TAO_INVOKE_EXCEPTION;
+
+#if TAO_HAS_INTERCEPTORS == 1
+      TAO_ClientRequestInfo_series_sum ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        x,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+
+#endif /* TAO_HAS_INTERCEPTORS */
+
+
+      CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+      TAO_INTERCEPTOR (ri.response_expected (1));
+
+#if TAO_HAS_INTERCEPTORS == 1
+
+      ACE_TRY
+        {
+          _tao_vfr.send_request (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+
+          if (_invoke_status == TAO_INVOKE_RESTART)
+            {
+              _tao_call.restart_flag (1);
+              continue;
+            }
+
+#endif /* TAO_HAS_INTERCEPTORS */
+
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << x)
+            ))
+            TAO_INTERCEPTOR_THROW_RETURN (
+              CORBA::MARSHAL (),
+              0
+            );
+
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_OMG_VMCID | 1, CORBA::COMPLETED_YES),
+                0
+              );
+
+            }
+          else if (_invoke_status == TAO_INVOKE_RESTART)
+            {
+              TAO_INTERCEPTOR (
+                ri.reply_status (_invoke_status);
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+                ACE_TRY_CHECK;
+              )
+
+              continue;
+            }
+
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+
+            }
+
+#if TAO_HAS_INTERCEPTORS == 1
+          registries * _tao_retval_info = _tao_safe_retval._retn ();
+          ri.result (_tao_retval_info);
+          _tao_safe_retval = _tao_retval_info;
+
+          ri.reply_status (_invoke_status);
+          _tao_vfr.receive_reply (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+
+      }
+    ACE_CATCHANY
+      {
+        ri.exception (&ACE_ANY_EXCEPTION);
+        _tao_vfr.receive_exception (
+          &ri,
+          ACE_TRY_ENV
+        );
+        ACE_TRY_CHECK;
+
+        PortableInterceptor::ReplyStatus _tao_status =
+          ri.reply_status (ACE_TRY_ENV);
+        ACE_TRY_CHECK;
+
+        if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION
+            || _tao_status == PortableInterceptor::USER_EXCEPTION)
+          ACE_RE_THROW;
+      }
+    ACE_ENDTRY;
+    ACE_CHECK_RETURN (0);
+
+    PortableInterceptor::ReplyStatus _tao_status =
+      ri.reply_status (ACE_TRY_ENV);
+    ACE_CHECK_RETURN (0);
+
+    if (_tao_status == PortableInterceptor::LOCATION_FORWARD
+        || _tao_status == PortableInterceptor::TRANSPORT_RETRY)
+      continue;
+
+#endif  /* TAO_HAS_INTERCEPTORS */
+
+    break;
+  }
+return _tao_safe_retval._retn ();
+}
+
+void _TAO_series_Remote_Proxy_Impl::shutdown (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+
+
+
+
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW (CORBA::INTERNAL ());
+
+
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "shutdown",
+      8,
+      0,
+      istub->orb_core ()
+    );
+
+  int _invoke_status;
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors (),
+      &_tao_call,
+      _invoke_status
+    );
+
+#endif  /* TAO_HAS_INTERCEPTORS */
+
+  for (;;)
+    {
+      _invoke_status = TAO_INVOKE_EXCEPTION;
+
+#if TAO_HAS_INTERCEPTORS == 1
+      TAO_ClientRequestInfo_series_shutdown ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK;
+
+#endif /* TAO_HAS_INTERCEPTORS */
+
+
+      CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+      TAO_INTERCEPTOR (ri.response_expected (1));
+
+#if TAO_HAS_INTERCEPTORS == 1
+
+      ACE_TRY
+        {
+          _tao_vfr.send_request (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+
+          if (_invoke_status == TAO_INVOKE_RESTART)
+            {
+              _tao_call.restart_flag (1);
+              continue;
+            }
+
+#endif /* TAO_HAS_INTERCEPTORS */
+
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK;
+
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW (
+                CORBA::UNKNOWN (TAO_OMG_VMCID | 1, CORBA::COMPLETED_YES)
+              );
+
+            }
+          else if (_invoke_status == TAO_INVOKE_RESTART)
+            {
+              TAO_INTERCEPTOR (
+                ri.reply_status (_invoke_status);
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+                ACE_TRY_CHECK;
+              )
+
+              continue;
+            }
+
+
+#if TAO_HAS_INTERCEPTORS == 1
+
+          ri.reply_status (_invoke_status);
+          _tao_vfr.receive_reply (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+
+      }
+    ACE_CATCHANY
+      {
+        ri.exception (&ACE_ANY_EXCEPTION);
+        _tao_vfr.receive_exception (
+          &ri,
+          ACE_TRY_ENV
+        );
+        ACE_TRY_CHECK;
+
+        PortableInterceptor::ReplyStatus _tao_status =
+          ri.reply_status (ACE_TRY_ENV);
+        ACE_TRY_CHECK;
+
+        if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION
+            || _tao_status == PortableInterceptor::USER_EXCEPTION)
+          ACE_RE_THROW;
+      }
+    ACE_ENDTRY;
+    ACE_CHECK;
+
+    PortableInterceptor::ReplyStatus _tao_status =
+      ri.reply_status (ACE_TRY_ENV);
+    ACE_CHECK;
+
+    if (_tao_status == PortableInterceptor::LOCATION_FORWARD
+        || _tao_status == PortableInterceptor::TRANSPORT_RETRY)
+      continue;
+
+#endif  /* TAO_HAS_INTERCEPTORS */
+
+    break;
+  }
+
+}
+
+
+//
+//            End  Base & Remote  Proxy Implemeentation.
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//           Remote & Base  Proxy Broker Implementation
+//
+
+_TAO_series_Proxy_Broker::_TAO_series_Proxy_Broker (void)
+{
+}
+
+_TAO_series_Proxy_Broker::~_TAO_series_Proxy_Broker (void)
+{
+}
+
+_TAO_series_Proxy_Broker * (*_TAO_series_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  ) = 0;
+
+// Factory Member function Implementation.
+_TAO_series_Remote_Proxy_Broker *
+_TAO_series_Remote_Proxy_Broker::the_TAO_series_Remote_Proxy_Broker (void)
+{
+  static ::_TAO_series_Remote_Proxy_Broker remote_proxy_broker;
+  return &remote_proxy_broker;
+}
+
+_TAO_series_Remote_Proxy_Broker::_TAO_series_Remote_Proxy_Broker (void)
+{
+}
+
+_TAO_series_Remote_Proxy_Broker::~_TAO_series_Remote_Proxy_Broker (void)
+{
+}
+
+_TAO_series_Proxy_Impl&
+_TAO_series_Remote_Proxy_Broker::select_proxy (
+  ::series *,
+  CORBA::Environment &
+)
+{
+  return this->remote_proxy_impl_;
+}
+
+
+//
+//           End Remote & Base Proxy Broker Implementation
+///////////////////////////////////////////////////////////////////////
+
+
+// default constructor
+series::series (int collocated)
+{
+  this->series_setup_collocation (collocated);
+}
+
+// destructor
+series::~series (void)
+{}
+
+void
+series::series_setup_collocation (int collocated)
+{
+  if (collocated)
+    this->the_TAO_series_Proxy_Broker_ =
+      ::_TAO_series_Proxy_Broker_Factory_function_pointer (this);
+  else
+    this->the_TAO_series_Proxy_Broker_ =
+      ::_TAO_series_Remote_Proxy_Broker::the_TAO_series_Remote_Proxy_Broker ();
+}
+
+void series::_tao_any_destructor (void *_tao_void_pointer)
+{
+  series *tmp = ACE_static_cast (series*, _tao_void_pointer);
+  CORBA::release (tmp);
+}
+
+series_ptr series::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+{
+  if (CORBA::is_nil (obj))
+    return series::_nil ();
+  if (! obj->_is_local ())
+    {
+      CORBA::Boolean is_a = obj->_is_a ("IDL:series:1.0", ACE_TRY_ENV);
+      ACE_CHECK_RETURN (series::_nil ());
+      if (is_a == 0)
+        return series::_nil ();
+    }
+  return series::_unchecked_narrow (obj, ACE_TRY_ENV);
+}
+
+series_ptr series::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
+  )
+{
+  if (CORBA::is_nil (obj))
+    return series::_nil ();
+  if (! obj->_is_local ())
+    {
+      TAO_Stub* stub = obj->_stubobj ();
+      if (stub)
+        stub->_incr_refcnt ();
+      series_ptr default_proxy = series::_nil ();
+
+      if (
+          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
+          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
+          obj->_is_collocated () &&
+          _TAO_series_Proxy_Broker_Factory_function_pointer != 0
+        )
+        {
+          ACE_NEW_RETURN (
+              default_proxy,
+              ::series (
+                  stub,
+                  1,
+                  obj->_servant ()
+                ),
+              series::_nil ()
+            );
+        }
+
+      if (CORBA::is_nil (default_proxy))
+        {
+          ACE_NEW_RETURN (
+              default_proxy,
+              ::series (
+                  stub,
+                  0,
+                  obj->_servant ()
+                ),
+              series::_nil ()
+            );
+        }
+
+      return default_proxy;
+    }
+  else
+    return
+      ACE_reinterpret_cast
+        (
+          series_ptr,
+            obj->_tao_QueryInterface
+              (
+                ACE_reinterpret_cast
+                  (
+                    ptr_arith_t,
+                    &series::_tao_class_id
+                  )
+              )
+        );
+}
+
+series_ptr
+series::_duplicate (series_ptr obj)
+{
+  if (!CORBA::is_nil (obj))
+    obj->_add_ref ();
+  return obj;
+}
+
+CORBA::Boolean series::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
+{
+  if (
+    (!ACE_OS::strcmp ((char *)value, "IDL:series:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
+  return 1; // success using local knowledge
+  else
+    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
+}
+
+void *series::_tao_QueryInterface (ptr_arith_t type)
+{
+  void *retv = 0;
+  if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &series::_tao_class_id))
+    retv = ACE_reinterpret_cast (void*, this);
+  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_tao_class_id))
+    retv = ACE_reinterpret_cast (void *,
+      ACE_static_cast (CORBA::Object_ptr, this));
+
+  if (retv)
+    this->_add_ref ();
+  return retv;
+}
+
+const char* series::_interface_repository_id (void) const
+{
+  return "IDL:series:1.0";
+}
+
+registry * series::cube (
+    registry * v,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_series_Proxy_Impl &proxy =
+    this->the_TAO_series_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+
+  return proxy.cube (
+      this,
+      v,
+      ACE_TRY_ENV
+    );
+}
+
+registries * series::sum (
+    const registries & x,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_series_Proxy_Impl &proxy =
+    this->the_TAO_series_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+
+  return proxy.sum (
+      this,
+      x,
+      ACE_TRY_ENV
+    );
+}
+
+void series::shutdown (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_series_Proxy_Impl &proxy =
+    this->the_TAO_series_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK;
+
+  proxy.shutdown (
+      this,
+      ACE_TRY_ENV
+    );
+}
+
+static const CORBA::Long _oc_series[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  15,
+  ACE_NTOHL (0x49444c3a),
+  ACE_NTOHL (0x73657269),
+  ACE_NTOHL (0x65733a31),
+  ACE_NTOHL (0x2e300000),  // repository ID = IDL:series:1.0
+  7,
+  ACE_NTOHL (0x73657269),
+  ACE_NTOHL (0x65730000),  // name = series
+};
+
+static CORBA::TypeCode _tc_TAO_tc_series (
+    CORBA::tk_objref,
+    sizeof (_oc_series),
+    (char *) &_oc_series,
+    0,
+    sizeof (series)
+  );
+
+CORBA::TypeCode_ptr _tc_series =
+  &_tc_TAO_tc_series;
+
+CORBA::Boolean
+OBV_registry::_tao_marshal__registry (TAO_OutputCDR &strm){
+  return _tao_marshal_state (strm);
+
+}
+CORBA::Boolean OBV_registry::_tao_unmarshal__registry (TAO_InputCDR &strm){
+  return _tao_unmarshal_state (strm);
+
+}
+// accessor to set the member
+void
+OBV_registry::value (CORBA::Long val) // set
+{
+  // set the value
+  this->_pd_value = val;
+}
+// retrieve the member
+CORBA::Long
+OBV_registry::value (void) const
+{
+  return this->_pd_value;
+}
+
+void operator<<= (
+    CORBA::Any &_tao_any,
+    const registries &_tao_elem
+  ) // copying
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        _tc_registries,
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin ()
+      );
+  }
+}
+
+void operator<<= (CORBA::Any &_tao_any, registries *_tao_elem) // non copying
+{
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      _tc_registries,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      registries::_tao_any_destructor
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, registries *&_tao_elem)
+{
+  return _tao_any >>= ACE_const_cast(
+      const registries*&,
+      _tao_elem
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const registries *&_tao_elem)
+{
+  _tao_elem = 0;
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::TypeCode_var type = _tao_any.type ();
+
+    CORBA::Boolean result = type->equivalent (_tc_registries, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+
+    if (!result)
+      return 0; // not equivalent
+
+    if (_tao_any.any_owns_data ())
+    {
+      _tao_elem = ACE_static_cast(
+          const registries*,
+          _tao_any.value ()
+        );
+      return 1;
+    }
+    else
+    {
+      registries *tmp;
+      ACE_NEW_RETURN (tmp, registries, 0);
+      TAO_InputCDR stream (
+          _tao_any._tao_get_cdr (),
+          _tao_any._tao_byte_order ()
+        );
+      if (stream >> *tmp)
+      {
+        ((CORBA::Any *)&_tao_any)->_tao_replace (
+            _tc_registries,
+            1,
+            ACE_static_cast (void *, tmp),
+            registries::_tao_any_destructor
+          );
+        _tao_elem = tmp;
+        return 1;
+      }
+      else
+      {
+        delete tmp;
+      }
+    }
+  }
+  ACE_CATCHANY
+  {
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+void operator<<= (CORBA::Any &_tao_any, series_ptr _tao_elem)
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        _tc_series,
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin (),
+        1,
+        series::_duplicate (_tao_elem),
+        series::_tao_any_destructor
+      );
+  }
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, series_ptr &_tao_elem)
+{
+  ACE_TRY_NEW_ENV
+  {
+    _tao_elem = series::_nil ();
+    CORBA::TypeCode_var type = _tao_any.type ();
+
+    CORBA::Boolean result = type->equivalent (_tc_series, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+
+    if (!result)
+      return 0; // not equivalent
+
+    TAO_InputCDR stream (
+        _tao_any._tao_get_cdr (),
+        _tao_any._tao_byte_order ()
+      );
+    if (stream >> _tao_elem)
+    {
+      ((CORBA::Any *)&_tao_any)->_tao_replace (
+          _tc_series,
+          1,
+          _tao_elem,
+          series::_tao_any_destructor
+        );
+      return 1;
+    }
+  }
+  ACE_CATCHANY
+  {
+    _tao_elem = series::_nil ();
+    return 0;
+  }
+  ACE_ENDTRY;
+  _tao_elem = series::_nil ();
+  return 0;
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
+    defined (ACE_HAS_GNU_REPO)
+    template class TAO_Object_Manager<series,series_var>;
+  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+  #  pragma instantiate TAO_Object_Manager<series,series_var>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+CORBA::Boolean operator<< (
+    TAO_OutputCDR &strm,
+    const registries &_tao_sequence
+  )
+{
+  if (strm << _tao_sequence.length ())
+  {
+    // encode all elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm << _tao_sequence[i].in ());
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
+CORBA::Boolean operator>> (
+    TAO_InputCDR &strm,
+    registries &_tao_sequence
+  )
+{
+  CORBA::ULong _tao_seq_len;
+  if (strm >> _tao_seq_len)
+    {
+      // set the length of the sequence
+      _tao_sequence.length (_tao_seq_len);
+      // If length is 0 we return true.
+      if (0 >= _tao_seq_len)
+        return 1;
+      // Add a check to the length of the sequence
+      // to make sure it does not exceed the length
+      // of the stream. (See bug 58.)
+      if (_tao_seq_len > strm.length())
+        return 0;
+      // retrieve all the elements
+      CORBA::Boolean _tao_marshal_flag = 1;
+      for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+        {
+          _tao_marshal_flag = (strm >> _tao_sequence[i].out ());
+        }
+      return _tao_marshal_flag;
+    }
+  return 0; // error
+}
+
+CORBA::Boolean operator<< (
+        TAO_OutputCDR &strm,
+        const series_ptr _tao_objref
+      )
+{
+  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
+  return (strm << _tao_corba_obj);
+}
+
+CORBA::Boolean operator>> (
+        TAO_InputCDR &strm,
+        series_ptr &_tao_objref
+      )
+{
+  ACE_TRY_NEW_ENV
+    {
+      CORBA::Object_var obj;
+      if ((strm >> obj.inout ()) == 0)
+        return 0;
+      // narrow to the right type
+      _tao_objref =
+        series::_unchecked_narrow (
+                                   obj.in (),
+                                   ACE_TRY_ENV
+                                   );
+      ACE_TRY_CHECK;
+      return 1;
+    }
+  ACE_CATCHANY
+    {
+      // do nothing
+    }
+  ACE_ENDTRY;
+  return 0;
+}
diff --git a/TAO/examples/OBV/Sequence/seriesC.h.bak b/TAO/examples/OBV/Sequence/seriesC.h.bak
new file mode 100644
index 00000000000..d63450621c6
--- /dev/null
+++ b/TAO/examples/OBV/Sequence/seriesC.h.bak
@@ -0,0 +1,774 @@
+// -*- C++ -*-
+//
+// $Id$
+
+// ****  Code generated by the The ACE ORB (TAO) IDL Compiler ****
+// TAO and the TAO IDL Compiler have been developed by:
+//       Center for Distributed Object Computing
+//       Washington University
+//       St. Louis, MO
+//       USA
+//       http://www.cs.wustl.edu/~schmidt/doc-center.html
+// and
+//       Distributed Object Computing Laboratory
+//       University of California at Irvine
+//       Irvine, CA
+//       USA
+//       http://doc.ece.uci.edu/
+//
+// Information about TAO is available at:
+//     http://www.cs.wustl.edu/~schmidt/TAO.html
+
+#ifndef _TAO_IDL_SERIESC_H_
+#define _TAO_IDL_SERIESC_H_
+
+#include "tao/corba.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+# pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+
+#if defined (TAO_EXPORT_MACRO)
+#undef TAO_EXPORT_MACRO
+#endif
+#define TAO_EXPORT_MACRO
+
+#if defined (TAO_EXPORT_NESTED_CLASSES)
+#  if defined (TAO_EXPORT_NESTED_MACRO)
+#    undef TAO_EXPORT_NESTED_MACRO
+#  endif /* defined (TAO_EXPORT_NESTED_MACRO) */
+#  define TAO_EXPORT_NESTED_MACRO
+#endif /* TAO_EXPORT_NESTED_CLASSES */
+
+#if defined(_MSC_VER)
+#if (_MSC_VER >= 1200)
+#pragma warning(push)
+#endif /* _MSC_VER >= 1200 */
+#pragma warning(disable:4250)
+#endif /* _MSC_VER */
+
+#if defined (__BORLANDC__)
+#pragma option push -w-rvl -w-rch -w-ccc -w-inl
+#endif /* __BORLANDC__ */
+
+// Valuetype class
+class registry;
+typedef registry *registry_ptr;
+
+#if !defined (_REGISTRY___VAR_CH_)
+#define _REGISTRY___VAR_CH_
+
+class  registry_var
+{
+public:
+  registry_var (void); // default constructor
+  registry_var (registry*);
+  registry_var (const registry*); // (TAO extension)
+  registry_var (const registry_var &); // copy constructor
+  ~registry_var (void); // destructor
+
+  registry_var &operator= (registry*);
+  registry_var &operator= (const registry_var &);
+  registry* operator-> (void) const;
+
+  operator const registry* () const;
+  operator registry* ();
+  // in, inout, out, _retn
+  registry* in (void) const;
+  registry* &inout (void);
+  registry* &out (void);
+  registry* _retn (void);
+  registry* ptr (void) const;
+
+private:
+  registry* ptr_;
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_REGISTRY___OUT_CH_)
+#define _REGISTRY___OUT_CH_
+
+class  registry_out
+{
+public:
+  registry_out (registry* &);
+  registry_out (registry_var &);
+  registry_out (const registry_out &);
+  registry_out &operator= (const registry_out &);
+  registry_out &operator= (const registry_var &);
+  registry_out &operator= (registry*);
+  operator registry* &();
+  registry* &ptr (void);
+  registry* operator-> (void);
+
+private:
+  registry* &ptr_;
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_REGISTRY___INIT_CH_)
+#define _REGISTRY___INIT_CH_
+
+class  registry_init : public CORBA_ValueFactoryBase
+{
+public:
+  virtual ~registry_init ();
+  virtual const char* tao_repository_id (void);
+
+  // create () goes here
+
+};
+
+#endif /* end #if !defined */
+
+
+#if !defined (_REGISTRY_CH_)
+#define _REGISTRY_CH_
+
+class  registry
+  : public virtual CORBA_ValueBase
+{
+public:
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef registry* _ptr_type;
+  typedef registry_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  static registry* _downcast (CORBA::ValueBase* );
+  // The address of static _downcast is implicit used as type id
+
+  // (TAO extensions or internals)
+  static CORBA::Boolean _tao_unmarshal (
+      TAO_InputCDR &,
+      registry *&
+    );
+  virtual const char* _tao_obv_repository_id () const;
+  static const char* _tao_obv_static_repository_id ();
+
+  virtual void value (CORBA::Long) = 0;    // set
+  virtual CORBA::Long value (void) const = 0;     // get method
+
+
+protected:
+  registry ();
+  virtual ~registry ();
+
+  // TAO internals
+  virtual void *_tao_obv_narrow (ptr_arith_t);
+  virtual CORBA::Boolean _tao_marshal_v (TAO_OutputCDR &);
+  virtual CORBA::Boolean _tao_unmarshal_v (TAO_InputCDR &);
+
+private:
+  registry (const registry &);
+  void operator= (const registry &);
+
+protected:
+  virtual CORBA::Boolean _tao_marshal__registry (TAO_OutputCDR &) = 0;
+  virtual CORBA::Boolean _tao_unmarshal__registry (TAO_InputCDR &) = 0;
+
+};
+
+#endif /* end #if !defined */
+
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_REGISTRIES_CH_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_REGISTRIES_CH_
+
+class TAO_EXPORT_MACRO _TAO_Unbounded_Valuetype_Sequence_registries
+  : public TAO_Unbounded_Base_Sequence
+{
+public:
+  // = Initialization and termination methods.
+  _TAO_Unbounded_Valuetype_Sequence_registries (void);
+  _TAO_Unbounded_Valuetype_Sequence_registries (CORBA::ULong maximum);
+  _TAO_Unbounded_Valuetype_Sequence_registries (
+      CORBA::ULong maximum,
+      CORBA::ULong length,
+      registry_ptr *value,
+      CORBA::Boolean release = 0
+    );
+  _TAO_Unbounded_Valuetype_Sequence_registries (
+      const _TAO_Unbounded_Valuetype_Sequence_registries &rhs
+    );
+  _TAO_Unbounded_Valuetype_Sequence_registries &operator= (
+      const _TAO_Unbounded_Valuetype_Sequence_registries &rhs
+    );
+  virtual ~_TAO_Unbounded_Valuetype_Sequence_registries (void);
+
+  // = Accessors.
+  TAO_Valuetype_Manager<registry,registry_var> operator[] (CORBA::ULong index) const;
+
+  // = Static operations.
+  static  **allocbuf (CORBA::ULong nelems);
+  static void freebuf ( **buffer);
+
+  // Implement the TAO_Base_Sequence methods (see Sequence.h)
+  virtual void _allocate_buffer (CORBA::ULong length);
+  virtual void _deallocate_buffer (void);
+  * *get_buffer (CORBA::Boolean orphan = 0);
+  const * *get_buffer (void) const;
+  virtual void _shrink_buffer (
+      CORBA::ULong nl,
+      CORBA::ULong ol
+    );
+
+  /*
+  virtual void _downcast (
+      void* target,
+      CORBA_ValueBase *src,
+      CORBA_Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    );
+  virtual CORBA_ValueBase* _upcast (void *src) const;
+  */
+};
+
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+
+#if !defined (_REGISTRIES_CH_)
+#define _REGISTRIES_CH_
+
+class registries;
+class registries_var;
+
+// *************************************************************
+// registries
+// *************************************************************
+
+class  registries : public
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+_TAO_Unbounded_Valuetype_Sequence_registries
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+TAO_Unbounded_Valuetype_Sequence<registry,registry_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+{
+public:
+  registries (void); // default ctor
+  registries (CORBA::ULong max); // uses max size
+  registries (
+      CORBA::ULong max,
+      CORBA::ULong length,
+      registry_ptr *buffer,
+      CORBA::Boolean release = 0
+    );
+  registries (const registries &); // copy ctor
+  ~registries (void);
+  static void _tao_any_destructor (void*);
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef registries_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+
+};
+
+#endif /* end #if !defined */
+
+
+#if !defined (_REGISTRIES___VAR_CH_)
+#define _REGISTRIES___VAR_CH_
+
+// *************************************************************
+// class registries_var
+// *************************************************************
+
+class  registries_var
+{
+public:
+  registries_var (void);
+  registries_var (registries *);
+  registries_var (const registries_var &);
+  ~registries_var (void);
+
+  registries_var &operator= (registries *);
+  registries_var &operator= (const registries_var &);
+  registries *operator-> (void);
+  const registries *operator-> (void) const;
+
+  operator const registries &() const;
+  operator registries &();
+  operator registries &() const;
+  operator registries *&(); // variable-size base types only
+
+  TAO_Valuetype_Manager<registry,registry_var> operator[] (CORBA::ULong index);
+
+  // in, inout, out, _retn
+  const registries &in (void) const;
+  registries &inout (void);
+  registries *&out (void);
+  registries *_retn (void);
+  registries *ptr (void) const;
+
+private:
+  registries *ptr_;
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_REGISTRIES___OUT_CH_)
+#define _REGISTRIES___OUT_CH_
+
+class  registries_out
+{
+public:
+  registries_out (registries *&);
+  registries_out (registries_var &);
+  registries_out (const registries_out &);
+  registries_out &operator= (const registries_out &);
+  registries_out &operator= (registries *);
+  operator registries *&();
+  registries *&ptr (void);
+  registries *operator-> (void);
+  TAO_Valuetype_Manager<registry,registry_var> operator[] (CORBA::ULong index);
+
+private:
+  registries *&ptr_;
+  // Assignment from T_var not allowed.
+  void operator= (const registries_var &);
+};
+
+
+#endif /* end #if !defined */
+
+extern  CORBA::TypeCode_ptr  _tc_registries;
+
+
+#if !defined (_SERIES___PTR_CH_)
+#define _SERIES___PTR_CH_
+
+class series;
+typedef series *series_ptr;
+
+#endif /* end #if !defined */
+
+
+#if !defined (_SERIES___VAR_CH_)
+#define _SERIES___VAR_CH_
+
+class  series_var : public TAO_Base_var
+{
+public:
+  series_var (void); // default constructor
+  series_var (series_ptr p) : ptr_ (p) {}
+  series_var (const series_var &); // copy constructor
+  ~series_var (void); // destructor
+
+  series_var &operator= (series_ptr);
+  series_var &operator= (const series_var &);
+  series_ptr operator-> (void) const;
+
+  operator const series_ptr &() const;
+  operator series_ptr &();
+  // in, inout, out, _retn
+  series_ptr in (void) const;
+  series_ptr &inout (void);
+  series_ptr &out (void);
+  series_ptr _retn (void);
+  series_ptr ptr (void) const;
+
+  // Hooks used by template sequence and object manager classes
+  // for non-defined forward declared interfaces.
+  static series_ptr duplicate (series_ptr);
+  static void release (series_ptr);
+  static series_ptr nil (void);
+  static series_ptr narrow (
+      CORBA::Object *,
+      CORBA::Environment &
+    );
+  static CORBA::Object * upcast (void *);
+
+private:
+  series_ptr ptr_;
+  // Unimplemented - prevents widening assignment.
+  series_var (const TAO_Base_var &rhs);
+  series_var &operator= (const TAO_Base_var &rhs);
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_SERIES___OUT_CH_)
+#define _SERIES___OUT_CH_
+
+class  series_out
+{
+public:
+  series_out (series_ptr &);
+  series_out (series_var &);
+  series_out (const series_out &);
+  series_out &operator= (const series_out &);
+  series_out &operator= (const series_var &);
+  series_out &operator= (series_ptr);
+  operator series_ptr &();
+  series_ptr &ptr (void);
+  series_ptr operator-> (void);
+
+private:
+  series_ptr &ptr_;
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_SERIES_CH_)
+#define _SERIES_CH_
+
+// Forward Classes Declaration.
+class _TAO_series_Proxy_Impl;
+class _TAO_series_Remote_Proxy_Impl;
+class _TAO_series_Proxy_Broker;
+class _TAO_series_Remote_Proxy_Broker;
+
+class  series
+  : public virtual CORBA_Object
+{
+public:
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef series_ptr _ptr_type;
+  typedef series_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  static int _tao_class_id;
+
+  // The static operations.
+  static series_ptr _duplicate (series_ptr obj);
+
+  static series_ptr _narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    );
+
+  static series_ptr _unchecked_narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    );
+
+  static series_ptr _nil (void)
+    {
+      return (series_ptr)0;
+    }
+
+  static void _tao_any_destructor (void*);
+
+  virtual registry * cube (
+      registry * v,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual registries * sum (
+      const registries & x,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void shutdown (
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::Boolean _is_a (
+      const CORBA::Char *type_id,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    );
+
+  virtual void *_tao_QueryInterface (ptr_arith_t type);
+
+  virtual const char* _interface_repository_id (void) const;
+
+private:
+  _TAO_series_Proxy_Broker *the_TAO_series_Proxy_Broker_;
+
+protected:
+  series (int collocated = 0);
+
+  // This methods travese the inheritance tree and set the
+  // parents piece of the given class in the right mode
+  virtual void series_setup_collocation (int collocated);
+
+  series (
+      TAO_Stub *objref,
+      CORBA::Boolean _tao_collocated = 0,
+      TAO_Abstract_ServantBase *servant = 0
+    );
+
+  friend class _TAO_series_Remote_Proxy_Impl;
+  friend class _TAO_series_ThruPOA_Proxy_Impl;
+  friend class _TAO_series_Direct_Proxy_Impl;
+
+  virtual ~series (void);
+
+private:
+  series (const series &);
+  void operator= (const series &);
+};
+
+// The Proxy Implementations are used by each interface to
+// perform a call. Each different implementation encapsulate
+// an invocation logics.
+
+
+///////////////////////////////////////////////////////////////////////
+//                    Base Proxy Impl. Declaration
+//
+
+class  _TAO_series_Proxy_Impl
+  : public virtual TAO_Object_Proxy_Impl
+{
+public:
+  virtual ~_TAO_series_Proxy_Impl (void) { }
+  virtual registry * cube (
+      CORBA_Object *_collocated_tao_target_,
+      registry * v,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual registries * sum (
+      CORBA_Object *_collocated_tao_target_,
+      const registries & x,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual void shutdown (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+
+protected:
+  _TAO_series_Proxy_Impl (void);
+};
+
+//
+//               End Base Proxy Impl. Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//                Remote Proxy Impl. Declaration
+//
+
+class  _TAO_series_Remote_Proxy_Impl
+  : public virtual _TAO_series_Proxy_Impl,
+    public virtual TAO_Remote_Object_Proxy_Impl
+{
+public:
+  _TAO_series_Remote_Proxy_Impl (void);
+
+  virtual ~_TAO_series_Remote_Proxy_Impl (void) { }
+  virtual registry * cube (
+      CORBA_Object *_collocated_tao_target_,
+      registry * v,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual registries * sum (
+      CORBA_Object *_collocated_tao_target_,
+      const registries & x,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void shutdown (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+
+};
+
+//
+//             End Remote Proxy Impl. Declaration
+///////////////////////////////////////////////////////////////////////
+
+// The Proxy Brokers are used by each interface to get
+// the right proxy for performing a call. In the new
+// collocation scheme, the proxy to be used can vary on
+// a call by call basis.
+
+
+///////////////////////////////////////////////////////////////////////
+//                 Base Proxy Broker Declaration
+//
+
+class  _TAO_series_Proxy_Broker
+{
+public:
+  virtual ~_TAO_series_Proxy_Broker (void);
+  virtual _TAO_series_Proxy_Impl &select_proxy (
+      series *object,
+      CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
+    ) = 0;
+
+protected:
+  _TAO_series_Proxy_Broker (void);
+
+};
+
+//
+//              End Base Proxy Broker Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//                 Remote Proxy Broker Declaration
+//
+
+class  _TAO_series_Remote_Proxy_Broker
+  : public virtual _TAO_series_Proxy_Broker
+{
+public:
+  _TAO_series_Remote_Proxy_Broker (void);
+
+  virtual ~_TAO_series_Remote_Proxy_Broker (void);
+
+  virtual _TAO_series_Proxy_Impl &select_proxy (
+      series *object,
+      CORBA_Environment &ACE_TRY_ENV
+    );
+
+private:
+  _TAO_series_Remote_Proxy_Impl remote_proxy_impl_;
+
+public:
+  // This member function is used to get an handle to the unique instance
+  // of the Remote Proxy Broker that is available for a given
+  // interface.
+  static _TAO_series_Remote_Proxy_Broker *the_TAO_series_Remote_Proxy_Broker (void);
+};
+
+//
+//              End Remote Proxy Broker Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+#endif /* end #if !defined */
+
+extern  CORBA::TypeCode_ptr  _tc_series;
+
+// Proxy Broker Factory function pointer declarations.
+
+extern
+_TAO_series_Proxy_Broker *
+(*_TAO_series_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  );
+
+
+#if !defined (_REGISTRY___OBV_CH_)
+#define _REGISTRY___OBV_CH_
+
+// OBV_ class
+class OBV_registry
+  : public virtual registry
+{
+public:
+  virtual void value (CORBA::Long);    // set
+  virtual CORBA::Long value (void) const;     // get method
+
+
+protected:
+  virtual CORBA::Boolean _tao_marshal__registry (TAO_OutputCDR &);
+  virtual CORBA::Boolean _tao_unmarshal__registry (TAO_InputCDR &);
+  CORBA::Boolean _tao_marshal_state (TAO_OutputCDR &);
+  CORBA::Boolean _tao_unmarshal_state (TAO_InputCDR &);
+
+private:
+  CORBA::Long _pd_value;
+
+};
+
+#endif /* end #if !defined */
+
+ void operator<<= (CORBA::Any &, const registries &); // copying version
+ void operator<<= (CORBA::Any &, registries*); // noncopying version
+ CORBA::Boolean operator>>= (const CORBA::Any &, registries *&); // deprecated
+ CORBA::Boolean operator>>= (const CORBA::Any &, const registries *&);
+// Any operators for interface series
+ void operator<<= (CORBA::Any &, series_ptr);
+ CORBA::Boolean operator>>= (const CORBA::Any &, series *&);
+
+#ifndef __ACE_INLINE__
+
+ CORBA::Boolean operator<< (TAO_OutputCDR &, const registry *); //
+ CORBA::Boolean operator>> (TAO_InputCDR &, registry *&);
+
+#if !defined _TAO_CDR_OP_registries_H_
+#define _TAO_CDR_OP_registries_H_
+
+ CORBA::Boolean operator<< (
+    TAO_OutputCDR &,
+    const registries &
+  );
+ CORBA::Boolean operator>> (
+    TAO_InputCDR &,
+    registries &
+  );
+
+#endif /* _TAO_CDR_OP_registries_H_ */
+
+ CORBA::Boolean operator<< (TAO_OutputCDR &, const series_ptr );
+ CORBA::Boolean operator>> (TAO_InputCDR &, series_ptr &);
+
+#endif /* __ACE_INLINE__ */
+
+
+#if defined (__ACE_INLINE__)
+#include "seriesC.i"
+#endif /* defined INLINE */
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+#pragma warning(pop)
+#endif /* _MSC_VER */
+
+#if defined (__BORLANDC__)
+#pragma option pop
+#endif /* __BORLANDC__ */
+
+#endif /* ifndef */
diff --git a/TAO/examples/OBV/Sequence/seriesC.i.bak b/TAO/examples/OBV/Sequence/seriesC.i.bak
new file mode 100644
index 00000000000..d210421f66d
--- /dev/null
+++ b/TAO/examples/OBV/Sequence/seriesC.i.bak
@@ -0,0 +1,676 @@
+// -*- C++ -*-
+//
+// $Id$
+
+// ****  Code generated by the The ACE ORB (TAO) IDL Compiler ****
+// TAO and the TAO IDL Compiler have been developed by:
+//       Center for Distributed Object Computing
+//       Washington University
+//       St. Louis, MO
+//       USA
+//       http://www.cs.wustl.edu/~schmidt/doc-center.html
+// and
+//       Distributed Object Computing Laboratory
+//       University of California at Irvine
+//       Irvine, CA
+//       USA
+//       http://doc.ece.uci.edu/
+//
+// Information about TAO is available at:
+//     http://www.cs.wustl.edu/~schmidt/TAO.html
+
+ACE_INLINE
+registry::registry () // default constructor
+{}
+
+ACE_INLINE
+registry::~registry () // destructor
+{}
+
+ACE_INLINE const char*
+registry::_tao_obv_static_repository_id ()
+{
+  return "IDL:registry:1.0";
+}
+
+
+#if !defined (_REGISTRY___VAR_CI_)
+#define _REGISTRY___VAR_CI_
+
+// *************************************************************
+// Inline operations for class registry_var
+// *************************************************************
+
+ACE_INLINE
+registry_var::registry_var (void) // default constructor
+  : ptr_ (0)
+{}
+
+ACE_INLINE
+registry_var::registry_var (registry* p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE
+registry_var::registry_var (const registry* p)
+  : ptr_ (ACE_const_cast(registry*, p))
+{}
+
+ACE_INLINE registry*
+registry_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+registry_var::registry_var (const registry_var &p) // copy constructor
+{
+  CORBA::add_ref (p.ptr ());
+  this->ptr_ = p.ptr ();
+}
+
+ACE_INLINE
+registry_var::~registry_var (void) // destructor
+{
+  CORBA::remove_ref (this->ptr_);
+}
+
+ACE_INLINE registry_var &
+registry_var::operator= (registry* p)
+{
+  CORBA::remove_ref (this->ptr_);
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE registry_var &
+registry_var::operator= (const registry_var &p)
+{
+  if (this != &p)
+  {
+    CORBA::remove_ref (this->ptr_);
+    registry* tmp = p.ptr ();
+    CORBA::add_ref (tmp);
+    this->ptr_ = tmp;
+  }
+  return *this;
+}
+
+ACE_INLINE
+registry_var::operator const registry* () const // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+registry_var::operator registry* () // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE registry*
+registry_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE registry*
+registry_var::in (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE registry* &
+registry_var::inout (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE registry* &
+registry_var::out (void)
+{
+  CORBA::remove_ref (this->ptr_);
+  this->ptr_ = 0;
+  return this->ptr_;
+}
+
+ACE_INLINE registry*
+registry_var::_retn (void)
+{
+  // yield ownership of managed obj reference
+  registry* tmp = this->ptr_;
+  this->ptr_ = 0;
+  return tmp;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_REGISTRY___OUT_CI_)
+#define _REGISTRY___OUT_CI_
+
+// *************************************************************
+// Inline operations for class registry_out
+// *************************************************************
+
+ACE_INLINE
+registry_out::registry_out (registry* &p)
+  : ptr_ (p)
+{
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+registry_out::registry_out (registry_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  CORBA::remove_ref (this->ptr_);
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+registry_out::registry_out (const registry_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (registry_out&,p).ptr_)
+{}
+
+ACE_INLINE registry_out &
+registry_out::operator= (const registry_out &p)
+{
+  this->ptr_ = ACE_const_cast (registry_out&,p).ptr_;
+  return *this;
+}
+
+ACE_INLINE registry_out &
+registry_out::operator= (const registry_var &p)
+{
+  registry* tmp = p.ptr ();
+  CORBA::add_ref (tmp);
+  this->ptr_ = tmp;
+  return *this;
+}
+
+ACE_INLINE registry_out &
+registry_out::operator= (registry* p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE
+registry_out::operator registry* &() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE registry* &
+registry_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE registry*
+registry_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_REGISTRIES_CI_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_REGISTRIES_CI_
+
+ACE_INLINE  **
+_TAO_Unbounded_Valuetype_Sequence_registries::allocbuf (CORBA::ULong nelems)
+{
+   **buf = 0;
+
+  ACE_NEW_RETURN (buf, *[nelems], 0);
+
+  for (CORBA::ULong i = 0; i < nelems; i++)
+    {
+      buf[i] = 0;
+    }
+
+  return buf;
+}
+
+ACE_INLINE void
+_TAO_Unbounded_Valuetype_Sequence_registries::freebuf ( **buffer)
+{
+  if (buffer == 0)
+    return;
+  delete[] buffer;
+}
+
+ACE_INLINE
+_TAO_Unbounded_Valuetype_Sequence_registries::_TAO_Unbounded_Valuetype_Sequence_registries (void)
+{
+}
+
+ACE_INLINE
+_TAO_Unbounded_Valuetype_Sequence_registries::_TAO_Unbounded_Valuetype_Sequence_registries (CORBA::ULong maximum)
+  : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Valuetype_Sequence_registries::allocbuf (maximum))
+{
+}
+
+ACE_INLINE
+_TAO_Unbounded_Valuetype_Sequence_registries::_TAO_Unbounded_Valuetype_Sequence_registries (CORBA::ULong maximum,
+  CORBA::ULong length,
+  registry_ptr *value,
+  CORBA::Boolean release)
+: TAO_Unbounded_Base_Sequence (maximum, length, value, release)
+{
+}
+
+ACE_INLINE
+_TAO_Unbounded_Valuetype_Sequence_registries::_TAO_Unbounded_Valuetype_Sequence_registries(const _TAO_Unbounded_Valuetype_Sequence_registries &rhs)
+  : TAO_Unbounded_Base_Sequence (rhs)
+{
+  if (rhs.buffer_ != 0)
+  {
+     **tmp1 = _TAO_Unbounded_Object_Sequence_registries::allocbuf (this->maximum_);
+     ** const tmp2 = ACE_reinterpret_cast ( ** ACE_CAST_CONST, rhs.buffer_);
+
+    for (CORBA::ULong i = 0; i < rhs.length_; ++i)
+      {
+        tmp2[i]->_add_ref ();
+        tmp1[i] = tmp2[i];
+      }
+
+    this->buffer_ = tmp1;
+  }
+  else
+  {
+    this->buffer_ = 0;
+  }
+}
+
+ACE_INLINE _TAO_Unbounded_Valuetype_Sequence_registries &
+_TAO_Unbounded_Valuetype_Sequence_registries::operator= (const _TAO_Unbounded_Valuetype_Sequence_registries &rhs)
+{
+  if (this == &rhs)
+    return *this;
+
+  if (this->release_)
+  {
+     **tmp = ACE_reinterpret_cast ( **, this->buffer_);
+
+    for (CORBA::ULong i = 0; i < this->length_; ++i)
+    {
+      tmp[i]->_remove_ref ();
+      tmp[i] = 0;
+    }
+    if (this->maximum_ < rhs.maximum_)
+    {
+      _TAO_Unbounded_Valuetype_Sequence_registries::freebuf (tmp);
+      this->buffer_ = _TAO_Unbounded_Valuetype_Sequence_registries::allocbuf (rhs.maximum_);
+    }
+  }
+  else
+    this->buffer_ = _TAO_Unbounded_Valuetype_Sequence_registries::allocbuf (rhs.maximum_);
+
+  TAO_Unbounded_Base_Sequence::operator= (rhs);
+
+   **tmp1 = ACE_reinterpret_cast ( **, this->buffer_);
+   ** const tmp2 = ACE_reinterpret_cast ( ** ACE_CAST_CONST, rhs.buffer_);
+
+  for (CORBA::ULong i = 0; i < rhs.length_; ++i)
+    {
+      tmp2[i]->_add_ref ();
+      tmp1[i] = tmp2[i];
+    }
+
+  return *this;
+}
+
+ACE_INLINE TAO_Valuetype_Manager<registry,registry_var>
+_TAO_Unbounded_Valuetype_Sequence_registries::operator[] (CORBA::ULong index) const
+// read-write accessor
+{
+  ACE_ASSERT (index < this->maximum_);
+   ** const tmp = ACE_reinterpret_cast ( ** ACE_CAST_CONST, this->buffer_);
+  return TAO_Valuetype_Manager<registry,registry_var> (tmp + index, this->release_);
+}
+
+ACE_INLINE * *
+_TAO_Unbounded_Valuetype_Sequence_registries::get_buffer (CORBA::Boolean orphan)
+{
+   **result = 0;
+  if (orphan == 0)
+  {
+    // We retain ownership.
+    if (this->buffer_ == 0)
+    {
+      result = _TAO_Unbounded_Valuetype_Sequence_registries::allocbuf (this->maximum_);
+      this->buffer_ = result;
+      this->release_ = 1;
+    }
+    else
+    {
+      result = ACE_reinterpret_cast (**, this->buffer_);
+    }
+  }
+  else // if (orphan == 1)
+  {
+    if (this->release_ != 0)
+    {
+      // We set the state back to default and relinquish
+      // ownership.
+      result = ACE_reinterpret_cast(**,this->buffer_);
+      this->maximum_ = 0;
+      this->length_ = 0;
+      this->buffer_ = 0;
+      this->release_ = 0;
+    }
+  }
+  return result;
+}
+
+ACE_INLINE const * *
+_TAO_Unbounded_Valuetype_Sequence_registries::get_buffer (void) const
+{
+  return ACE_reinterpret_cast(const  ** ACE_CAST_CONST, this->buffer_);
+}
+
+
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+
+#if !defined (_REGISTRIES_CI_)
+#define _REGISTRIES_CI_
+
+// *************************************************************
+// Inline operations for class registries_var
+// *************************************************************
+
+ACE_INLINE
+registries_var::registries_var (void) // default constructor
+  : ptr_ (0)
+{}
+
+ACE_INLINE
+registries_var::registries_var (registries *p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE
+registries_var::registries_var (const ::registries_var &p) // copy constructor
+{
+  if (p.ptr_)
+    ACE_NEW (this->ptr_, ::registries (*p.ptr_));
+  else
+    this->ptr_ = 0;
+}
+
+ACE_INLINE
+registries_var::~registries_var (void) // destructor
+{
+  delete this->ptr_;
+}
+
+ACE_INLINE registries_var &
+registries_var::operator= (registries *p)
+{
+  delete this->ptr_;
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE ::registries_var &
+registries_var::operator= (const ::registries_var &p)
+{
+  if (this != &p)
+    {
+      if (p.ptr_ == 0)
+        {
+          delete this->ptr_;
+          this->ptr_ = 0;
+        }
+      else
+        {
+          registries *deep_copy =
+            new registries (*p.ptr_);
+
+          if (deep_copy != 0)
+            {
+              registries *tmp = deep_copy;
+              deep_copy = this->ptr_;
+              this->ptr_ = tmp;
+              delete deep_copy;
+            }
+        }
+    }
+
+  return *this;
+}
+
+ACE_INLINE const ::registries *
+registries_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::registries *
+registries_var::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+registries_var::operator const ::registries &() const // cast
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE
+registries_var::operator ::registries &() // cast
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE
+registries_var::operator ::registries &() const // cast
+{
+  return *this->ptr_;
+}
+
+// variable-size types only
+ACE_INLINE
+registries_var::operator ::registries *&() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE TAO_Valuetype_Manager<registry,registry_var>
+registries_var::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+ACE_INLINE const ::registries &
+registries_var::in (void) const
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE ::registries &
+registries_var::inout (void)
+{
+  return *this->ptr_;
+}
+
+// mapping for variable size
+ACE_INLINE ::registries *&
+registries_var::out (void)
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+  return this->ptr_;
+}
+
+ACE_INLINE ::registries *
+registries_var::_retn (void)
+{
+  ::registries *tmp = this->ptr_;
+  this->ptr_ = 0;
+  return tmp;
+}
+
+ACE_INLINE ::registries *
+registries_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+// *************************************************************
+// Inline operations for class registries_out
+// *************************************************************
+
+ACE_INLINE
+registries_out::registries_out (registries *&p)
+  : ptr_ (p)
+{
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+registries_out::registries_out (registries_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+registries_out::registries_out (const ::registries_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (registries_out&, p).ptr_)
+{}
+
+ACE_INLINE ::registries_out &
+registries_out::operator= (const ::registries_out &p)
+{
+  this->ptr_ = ACE_const_cast (registries_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE ::registries_out &
+registries_out::operator= (registries *p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE
+registries_out::operator ::registries *&() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::registries *&
+registries_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::registries *
+registries_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE TAO_Valuetype_Manager<registry,registry_var>
+registries_out::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_SERIES___CI_)
+#define _SERIES___CI_
+
+ACE_INLINE
+series::series (
+    TAO_Stub *objref,
+    CORBA::Boolean _tao_collocated,
+    TAO_Abstract_ServantBase *servant
+  )
+  : CORBA_Object (objref, _tao_collocated, servant)
+{
+  this->series_setup_collocation (_tao_collocated);
+}
+
+
+#endif /* end #if !defined */
+
+ACE_INLINE CORBA::Boolean
+operator<< (TAO_OutputCDR &strm, const registry *_tao_valuetype)
+{
+  return CORBA_ValueBase::_tao_marshal (strm,
+    ACE_const_cast (registry*, _tao_valuetype),
+    (ptr_arith_t) &registry::_downcast);
+}
+
+ACE_INLINE CORBA::Boolean
+operator>> (TAO_InputCDR &strm, registry *&_tao_valuetype)
+{
+  return registry::_tao_unmarshal (strm, _tao_valuetype);
+}
+
+ACE_INLINE CORBA::Boolean
+OBV_registry::_tao_marshal_state (TAO_OutputCDR &strm)
+{
+  if (
+    (strm << _pd_value)
+  )
+    return 1;
+  else
+    return 0;
+
+}
+
+ACE_INLINE CORBA::Boolean
+OBV_registry::_tao_unmarshal_state (TAO_InputCDR &strm)
+{
+  if (
+    (strm >> _pd_value)
+  )
+    return 1;
+  else
+    return 0;
+
+}
+
+
+#if !defined _TAO_CDR_OP_registries_I_
+#define _TAO_CDR_OP_registries_I_
+
+CORBA::Boolean  operator<< (
+    TAO_OutputCDR &,
+    const registries &
+  );
+CORBA::Boolean  operator>> (
+    TAO_InputCDR &,
+    registries &
+  );
+
+#endif /* _TAO_CDR_OP_registries_I_ */
+
+ CORBA::Boolean operator<< (
+    TAO_OutputCDR &,
+    const series_ptr
+  );
+
+ CORBA::Boolean operator>> (
+    TAO_InputCDR &,
+    series_ptr &
+  );
diff --git a/TAO/examples/OBV/Sequence/series_i.cpp b/TAO/examples/OBV/Sequence/series_i.cpp
new file mode 100644
index 00000000000..6bc03a37f45
--- /dev/null
+++ b/TAO/examples/OBV/Sequence/series_i.cpp
@@ -0,0 +1,82 @@
+// $Id$
+
+#include "series_i.h"
+#include "Registry_i.h"
+
+ACE_RCSID(series, series_i, "$Id$")
+
+// Constructor
+series_i::series_i (void)
+{
+  // no-op
+}
+
+// Copy  Constructor
+series_i::series_i (series_i &t)
+  : POA_series (t)
+{
+  // no-op
+}
+
+// Destructor
+
+series_i::~series_i (void)
+{
+  // no-op
+}
+
+// Set the ORB pointer.
+
+void
+series_i::orb (CORBA::ORB_ptr o)
+{
+  this->orb_ = CORBA::ORB::_duplicate (o);
+}
+
+// Return the current date/time on the server.
+
+registry *
+series_i::cube (registry *v, CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  long x = v->value ();
+  x = x * x * x;
+
+  registry_var retv = new registry_impl ();
+  retv->value (x);
+  return retv._retn ();
+}
+
+registries *
+series_i::sum (const registries &v, CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  long r = 0;
+
+  registries_var retv;
+  retv = new registries;
+  retv->length (v.length ());
+
+  for (unsigned int i = 0; i < v.length (); i++)
+    {
+      r += v[i]->value ();
+      retv[i] = new registry_impl;
+      retv[i]->value (r);
+    }
+
+  return retv._retn ();
+}
+
+// Shutdown.
+
+void
+series_i::shutdown (CORBA::Environment & )
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  ACE_DEBUG ((LM_DEBUG,
+              "%s\n",
+              "series_i is shutting down"));
+
+  // Instruct the ORB to shutdown.
+  this->orb_->shutdown ();
+}
diff --git a/TAO/examples/OBV/Sequence/series_i.h b/TAO/examples/OBV/Sequence/series_i.h
new file mode 100644
index 00000000000..c8597a205f2
--- /dev/null
+++ b/TAO/examples/OBV/Sequence/series_i.h
@@ -0,0 +1,68 @@
+// -*- C++ -*-
+// $Id$
+
+// ============================================================================
+//
+// = LIBRARY
+//    TAO/examples/OBV/Sequence
+//
+// = FILENAME
+//    series_i.h
+//
+// = DESCRIPTION
+//    This class implements the "series" IDL interface.
+//
+// = AUTHOR
+//    Nanbor Wang <nanbor@cs.wustl.edu>
+//
+// ============================================================================
+
+#ifndef SERIES_I_H
+#define SERIES_I_H
+
+#include "seriesS.h"
+
+class series_i: public POA_series
+{
+  // = TITLE
+  //    Numerial Series Implementation
+  //
+  // = DESCRIPTION
+  //    Implementation of a simple object that performs various
+  //    arithmatic computation using OBV.
+public:
+  // = Initialization and termination methods.
+  series_i (void);
+  // Constructor
+
+  series_i (series_i &);
+  // Copy Constructor added because g++ generates a
+  // bad one if not defined
+
+  ~series_i (void);
+  // Destructor
+
+  virtual registry* cube (registry *v, CORBA::Environment &env)
+    ACE_THROW_SPEC ((CORBA::SystemException));
+  // Return the current time/date on the server
+
+  virtual registries *sum (const registries &x, CORBA::Environment &env)
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  virtual void shutdown (CORBA::Environment &env)
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  // Shutdown the server.
+
+  void orb (CORBA::ORB_ptr o);
+  // Set the ORB pointer.
+
+private:
+  CORBA::ORB_var orb_;
+  // ORB pointer.
+
+  ACE_UNIMPLEMENTED_FUNC (void operator= (const series_i &))
+  // Keeping g++2.7.2
+};
+
+#endif /* SERIES_I_H */
diff --git a/TAO/examples/OBV/Sequence/server.cpp b/TAO/examples/OBV/Sequence/server.cpp
new file mode 100644
index 00000000000..e95c385e697
--- /dev/null
+++ b/TAO/examples/OBV/Sequence/server.cpp
@@ -0,0 +1,101 @@
+// $Id$
+
+#include "ace/Get_Opt.h"
+#include "series_i.h"
+#include "Registry_i.h"
+#include "tao/PortableServer/ORB_Manager.h"
+
+ACE_RCSID(series, server, "$Id$")
+
+static char *ior_output_file = 0;
+
+int
+parse_args (int argc, char **argv)
+{
+  ACE_Get_Opt get_opts (argc, argv, "f:");
+  int c;
+
+  while ((c = get_opts ()) != -1)
+    switch (c)
+      {
+      case 'f':
+        ior_output_file = ACE_OS::strdup (get_opts.optarg);
+        break;
+      case '?':
+      default:
+        ACE_ERROR_RETURN ((LM_ERROR,
+                           "usage:  %s "
+                           "-f <iorfile>"
+                           "\n",
+                           argv [0]),
+                          -1);
+      }
+  // Indicates sucessful parsing of the command line
+  return 0;
+}
+
+
+int
+main (int argc, char **argv)
+{
+  TAO_ORB_Manager orb_manager;
+
+  ACE_DEBUG ((LM_DEBUG, "\nNumberical series server\n\n"));
+  ACE_DECLARE_NEW_CORBA_ENV;
+  ACE_TRY
+    {
+      orb_manager.init_child_poa (argc,
+                                  argv,
+                                  "child_poa",
+                                  ACE_TRY_ENV);
+      ACE_TRY_CHECK;
+
+      if (parse_args (argc, argv) != 0)
+        return -1;
+
+      series_i servant;
+
+      servant.orb (orb_manager.orb ());
+
+      CORBA::String_var ior =
+        orb_manager.activate_under_child_poa ("my_object",
+                                              &servant,
+                                              ACE_TRY_ENV);
+      ACE_TRY_CHECK;
+
+      ACE_DEBUG ((LM_DEBUG, "%s\n",
+                  ior.in ()));
+
+      // If the ior_output_file exists, output the ior to it
+      if (ior_output_file != 0)
+        {
+          FILE *output_file= ACE_OS::fopen (ior_output_file, "w");
+          if (output_file == 0)
+            ACE_ERROR_RETURN ((LM_ERROR,
+                               "Cannot open output file for writing IOR: %s",
+                               ior_output_file),
+                              -1);
+          ACE_OS::fprintf (output_file, "%s", ior.in ());
+          ACE_OS::fclose (output_file);
+        }
+
+      CORBA_ValueFactory_ptr factory = new registry_factory;
+      CORBA_ValueFactory_ptr prev_factory =
+        orb_manager.orb ()->register_value_factory (factory->tao_repository_id (),
+                                                    factory);
+      if (prev_factory)
+        prev_factory->_remove_ref ();
+      factory->_remove_ref ();
+
+      orb_manager.run (ACE_TRY_ENV);
+      ACE_TRY_CHECK;
+    }
+  ACE_CATCH (CORBA::SystemException, sysex)
+    {
+      ACE_PRINT_EXCEPTION (sysex, "System Exception");
+      return -1;
+    }
+  ACE_ENDTRY;
+
+  return 0;
+}
diff --git a/TAO/examples/OBV/Sequence/server.dsp b/TAO/examples/OBV/Sequence/server.dsp
new file mode 100644
index 00000000000..f1bfbe41c05
--- /dev/null
+++ b/TAO/examples/OBV/Sequence/server.dsp
@@ -0,0 +1,221 @@
+# Microsoft Developer Studio Project File - Name="OBV Sequence server" - Package Owner=<4>

+# Microsoft Developer Studio Generated Build File, Format Version 6.00

+# ** DO NOT EDIT **

+

+# TARGTYPE "Win32 (x86) Console Application" 0x0103

+

+CFG=OBV Sequence server - Win32 Debug

+!MESSAGE This is not a valid makefile. To build this project using NMAKE,

+!MESSAGE use the Export Makefile command and run

+!MESSAGE

+!MESSAGE NMAKE /f "server.mak".

+!MESSAGE

+!MESSAGE You can specify a configuration when running NMAKE

+!MESSAGE by defining the macro CFG on the command line. For example:

+!MESSAGE

+!MESSAGE NMAKE /f "server.mak" CFG="OBV Sequence server - Win32 Debug"

+!MESSAGE

+!MESSAGE Possible choices for configuration are:

+!MESSAGE

+!MESSAGE "OBV Sequence server - Win32 Release" (based on "Win32 (x86) Console Application")

+!MESSAGE "OBV Sequence server - Win32 Debug" (based on "Win32 (x86) Console Application")

+!MESSAGE

+

+# Begin Project

+# PROP AllowPerConfigDependencies 0

+# PROP Scc_ProjName ""

+# PROP Scc_LocalPath ""

+CPP=cl.exe

+RSC=rc.exe

+

+!IF  "$(CFG)" == "OBV Sequence server - Win32 Release"

+

+# PROP BASE Use_MFC 0

+# PROP BASE Use_Debug_Libraries 0

+# PROP BASE Output_Dir "Release"

+# PROP BASE Intermediate_Dir "Release"

+# PROP BASE Target_Dir ""

+# PROP Use_MFC 0

+# PROP Use_Debug_Libraries 0

+# PROP Output_Dir "Release"

+# PROP Intermediate_Dir "Release"

+# PROP Ignore_Export_Lib 0

+# PROP Target_Dir ""

+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c

+# ADD CPP /nologo /MD /W3 /GX /O2 /I "..\..\..\\" /I "..\..\..\..\\" /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c

+# ADD BASE RSC /l 0x409 /d "NDEBUG"

+# ADD RSC /l 0x409 /d "NDEBUG"

+BSC32=bscmake.exe

+# ADD BASE BSC32 /nologo

+# ADD BSC32 /nologo

+LINK32=link.exe

+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386

+# ADD LINK32 ace.lib tao.lib tao_portableserver.lib /nologo /subsystem:console /machine:I386 /libpath:"..\..\..\..\ace" /libpath:"..\..\..\tao" /libpath:"..\..\..\tao\portableserver"

+

+!ELSEIF  "$(CFG)" == "OBV Sequence server - Win32 Debug"

+

+# PROP BASE Use_MFC 0

+# PROP BASE Use_Debug_Libraries 1

+# PROP BASE Output_Dir "Debug"

+# PROP BASE Intermediate_Dir "Debug"

+# PROP BASE Target_Dir ""

+# PROP Use_MFC 0

+# PROP Use_Debug_Libraries 1

+# PROP Output_Dir ""

+# PROP Intermediate_Dir "Debug"

+# PROP Ignore_Export_Lib 0

+# PROP Target_Dir ""

+# ADD BASE CPP /nologo /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD  /c

+# ADD CPP /nologo /MDd /W3 /Gm /GX /Zi /Od /I "..\..\..\\" /I "..\..\..\..\\" /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD  /c

+# ADD BASE RSC /l 0x409 /d "_DEBUG"

+# ADD RSC /l 0x409 /d "_DEBUG"

+BSC32=bscmake.exe

+# ADD BASE BSC32 /nologo

+# ADD BSC32 /nologo

+LINK32=link.exe

+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept

+# ADD LINK32 aced.lib taod.lib tao_portableserverd.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept /libpath:"..\..\..\..\ace" /libpath:"..\..\..\tao" /libpath:"..\..\..\tao\portableserver"

+

+!ENDIF

+

+# Begin Target

+

+# Name "OBV Sequence server - Win32 Release"

+# Name "OBV Sequence server - Win32 Debug"

+# Begin Group "Source Files"

+

+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"

+# Begin Source File

+

+SOURCE=.\registry_i.cpp

+# End Source File

+# Begin Source File

+

+SOURCE=.\series_i.cpp

+# End Source File

+# Begin Source File

+

+SOURCE=.\seriesC.cpp

+# End Source File

+# Begin Source File

+

+SOURCE=.\seriesS.cpp

+# End Source File

+# Begin Source File

+

+SOURCE=.\server.cpp

+# End Source File

+# End Group

+# Begin Group "Header Files"

+

+# PROP Default_Filter "h;hpp;hxx;hm;inl"

+# Begin Source File

+

+SOURCE=.\registry_i.h

+# End Source File

+# Begin Source File

+

+SOURCE=.\series_i.h

+# End Source File

+# Begin Source File

+

+SOURCE=.\seriesC.h

+# End Source File

+# Begin Source File

+

+SOURCE=.\seriesS.h

+# End Source File

+# End Group

+# Begin Group "Resource Files"

+

+# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"

+# End Group

+# Begin Group "IDL Files"

+

+# PROP Default_Filter "idl"

+# Begin Source File

+

+SOURCE=.\series.idl

+

+!IF  "$(CFG)" == "OBV Sequence server - Win32 Release"

+

+# PROP Ignore_Default_Tool 1

+# Begin Custom Build - Invoking TAO_IDL Compiler on $(InputName)

+InputPath=.\series.idl

+InputName=series

+

+BuildCmds= \

+	..\..\.\..\bin\Release\tao_idl -Ge 1 -Gv 1 $(InputName).idl

+

+"$(InputName)C.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"

+   $(BuildCmds)

+

+"$(InputName)C.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"

+   $(BuildCmds)

+

+"$(InputName)C.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"

+   $(BuildCmds)

+

+"$(InputName)S.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"

+   $(BuildCmds)

+

+"$(InputName)S.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"

+   $(BuildCmds)

+

+"$(InputName)S.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"

+   $(BuildCmds)

+

+"$(InputName)S_T.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"

+   $(BuildCmds)

+

+"$(InputName)S_T.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"

+   $(BuildCmds)

+

+"$(InputName)S_T.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"

+   $(BuildCmds)

+# End Custom Build

+

+!ELSEIF  "$(CFG)" == "OBV Sequence server - Win32 Debug"

+

+# PROP Ignore_Default_Tool 1

+# Begin Custom Build - Invoking TAO_IDL Compiler on $(InputName)

+InputPath=.\series.idl

+InputName=series

+

+BuildCmds= \

+	..\..\..\..\bin\tao_idl -Ge 1 -Gv 1 $(InputName).idl

+

+"$(InputName)C.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"

+   $(BuildCmds)

+

+"$(InputName)C.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"

+   $(BuildCmds)

+

+"$(InputName)C.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"

+   $(BuildCmds)

+

+"$(InputName)S.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"

+   $(BuildCmds)

+

+"$(InputName)S.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"

+   $(BuildCmds)

+

+"$(InputName)S.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"

+   $(BuildCmds)

+

+"$(InputName)S_T.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"

+   $(BuildCmds)

+

+"$(InputName)S_T.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"

+   $(BuildCmds)

+

+"$(InputName)S_T.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"

+   $(BuildCmds)

+# End Custom Build

+

+!ENDIF

+

+# End Source File

+# End Group

+# End Target

+# End Project

diff --git a/TAO/tao/Sequence_T.cpp b/TAO/tao/Sequence_T.cpp
index ca69fd4abfe..639bf73ec52 100644
--- a/TAO/tao/Sequence_T.cpp
+++ b/TAO/tao/Sequence_T.cpp
@@ -361,6 +361,71 @@ TAO_Pseudo_Object_Manager<T,T_var>::operator=(const T_var &p)
 }
 
 // *************************************************************
+// class TAO_Valuetype_Manager
+// *************************************************************
+
+template <class T, class T_var> TAO_Valuetype_Manager<T,T_var>&
+TAO_Valuetype_Manager<T,T_var>::
+    operator= (const TAO_Valuetype_Manager<T,T_var> &rhs)
+{
+  if (this == &rhs)
+    return *this;
+
+  if (this->release_)
+    {
+      if (*this->ptr_ != 0)
+        (*this->ptr_)->_remove_ref ();
+      *this->ptr_ = *rhs.ptr_;
+      if (*this->ptr_ != 0)
+        (*this->ptr_)->_add_ref ();
+    }
+  else
+    *this->ptr_ = *rhs.ptr_;
+
+  return *this;
+}
+
+template <class T, class T_var>TAO_Valuetype_Manager<T,T_var> &
+TAO_Valuetype_Manager<T,T_var>::operator=(T* p)
+{
+  if (this->release_)
+    {
+      // The semantics of the elements of a sequence are the same as
+      // that of a var variable.  Therefore we will not duplicate the
+      // user provided pointer before assigning it to the internal
+      // variable.
+      if (*this->ptr_ != 0)
+        (*this->ptr_)->_remove_ref ();
+      *this->ptr_ = p;
+    }
+  else
+    *this->ptr_ = p;
+
+  return *this;
+}
+
+template <class T, class T_var>TAO_Valuetype_Manager<T,T_var> &
+TAO_Valuetype_Manager<T,T_var>::operator=(const T_var &p)
+{
+  if (this->release_)
+    {
+      // The semantics of the elements of a sequence are the same as
+      // that of a var variable.  Therefore we duplicate p's
+      // pointer before assigning it to the internal
+      // variable.
+      if (*this->ptr_ != 0)
+        (*this->ptr_)->_remove_ref ();
+      *this->ptr_ = p.in ();
+      if (p != 0)
+        p->_add_ref ();
+    }
+  else
+    *this->ptr_ = p.in ();
+
+  return *this;
+}
+
+// *************************************************************
 // Operations for class TAO_Unbounded_Object_Sequence
 // *************************************************************
 
@@ -1049,6 +1114,398 @@ TAO_Bounded_Pseudo_Sequence<T, T_var,MAX>::_shrink_buffer (CORBA::ULong nl,
 }
 
 // *************************************************************
+// Operations for class TAO_Unbounded_Valuetype_Sequence
+// *************************************************************
+
+// constructor for unbounded seq
+template <class T, class T_var>
+TAO_Unbounded_Valuetype_Sequence<T,T_var>::
+TAO_Unbounded_Valuetype_Sequence (CORBA::ULong maximum)
+  : TAO_Unbounded_Base_Sequence (maximum,
+                                 TAO_Unbounded_Valuetype_Sequence<T,T_var>::allocbuf (maximum))
+{
+}
+
+template <class T, class T_var>
+TAO_Unbounded_Valuetype_Sequence<T,T_var>::
+TAO_Unbounded_Valuetype_Sequence (const TAO_Unbounded_Valuetype_Sequence<T,T_var> &rhs)
+  : TAO_Unbounded_Base_Sequence (rhs)
+{
+  if (rhs.buffer_ != 0)
+    {
+      T **tmp1 =
+        TAO_Unbounded_Valuetype_Sequence<T,T_var>::allocbuf (this->maximum_);
+      T ** const tmp2 =
+        ACE_reinterpret_cast (T ** ACE_CAST_CONST, rhs.buffer_);
+
+      for (CORBA::ULong i = 0; i < rhs.length_; ++i)
+        {
+          if (tmp2[i] != 0)
+            tmp2[i]->_add_ref ();
+          tmp1[i] = tmp2[i];
+        }
+
+      this->buffer_ = tmp1;
+    }
+  else
+    {
+      this->buffer_ = 0;
+    }
+}
+
+template<class T, class T_var>
+TAO_Unbounded_Valuetype_Sequence<T,T_var>::~TAO_Unbounded_Valuetype_Sequence (void)
+{
+  this->_deallocate_buffer ();
+}
+
+// assignment operator
+template <class T, class T_var>TAO_Unbounded_Valuetype_Sequence<T,T_var>&
+TAO_Unbounded_Valuetype_Sequence<T,T_var>::
+operator= (const TAO_Unbounded_Valuetype_Sequence<T,T_var> &rhs)
+{
+  if (this == &rhs)
+    return *this;
+
+  if (this->release_)
+    {
+      T **tmp = ACE_reinterpret_cast (T **,
+                                      this->buffer_);
+
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+        {
+          if (tmp[i] != 0)
+            tmp[i]->_remove_ref ();
+          tmp[i] = 0;
+        }
+      if (this->maximum_ < rhs.maximum_)
+        {
+          TAO_Unbounded_Valuetype_Sequence<T,T_var>::freebuf (tmp);
+          this->buffer_ =
+            TAO_Unbounded_Valuetype_Sequence<T,T_var>::allocbuf (rhs.maximum_);
+        }
+    }
+  else
+    {
+      if (rhs.maximum_ == 0)
+        {
+          this->buffer_ = 0;
+        }
+      else
+        {
+          this->buffer_ =
+            TAO_Unbounded_Valuetype_Sequence<T,T_var>::allocbuf (rhs.maximum_);
+        }
+    }
+
+  TAO_Unbounded_Base_Sequence::operator= (rhs);
+
+  T **tmp1 = ACE_reinterpret_cast (T **, this->buffer_);
+  T ** const tmp2 = ACE_reinterpret_cast (T ** ACE_CAST_CONST, rhs.buffer_);
+
+  for (CORBA::ULong i = 0; i < rhs.length_; ++i)
+    {
+      if (tmp2[i] != 0)
+        tmp2[i]->_add_ref ();
+      tmp1[i] = tmp2[i];
+    }
+
+  return *this;
+}
+
+template <class T, class T_var> T **
+TAO_Unbounded_Valuetype_Sequence<T,T_var>::allocbuf (CORBA::ULong nelems)
+{
+  T **buf = 0;
+
+  ACE_NEW_RETURN (buf, T*[nelems], 0);
+
+  for (CORBA::ULong i = 0; i < nelems; i++)
+    buf[i] = 0;
+
+  return buf;
+}
+
+template <class T, class T_var> void
+TAO_Unbounded_Valuetype_Sequence<T,T_var>::freebuf (T **buffer)
+{
+  if (buffer == 0)
+    return;
+
+  // {orbos/97-05-15:16.11} The freebuf function ensures that the
+  // destructor for each element is called before the buffer is
+  // destroyed, except for string elements, which are freed using
+  // string_free(), and object reference elements, which are freed
+  // using release(). The freebuf function will ignore null pointers
+  // passed to it.
+
+  // @@ How are we supposed to implement that! We don't know the
+  // length of the buffer here.
+  // Mark the length in the first four bytes? For the moment we let
+  // that be.
+
+  delete[] buffer;
+}
+
+template<class T, class T_var> void
+TAO_Unbounded_Valuetype_Sequence<T,T_var>::_allocate_buffer (CORBA::ULong length)
+{
+  T **tmp = TAO_Unbounded_Valuetype_Sequence<T,T_var>::allocbuf (length);
+
+  if (this->buffer_ != 0)
+    {
+      T **old = ACE_reinterpret_cast (T**, this->buffer_);
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+        // Only call duplicate when we did not own the previous
+        // buffer, since after this method we own it we must also own
+        // the objects.  If we already own the objects there is no
+        // need to copy them, if we did we would also have to remove
+        // the old instances.
+        if (!this->release_)
+          {
+            if (old[i] != 0)
+              old[i]->_add_ref ();
+            tmp[i] = old[i];
+          }
+        else
+          tmp[i] = old[i];
+
+      if (this->release_)
+        delete[] old;
+    }
+  this->buffer_ = tmp;
+}
+
+template<class T, class T_var> void
+TAO_Unbounded_Valuetype_Sequence<T,T_var>::_deallocate_buffer (void)
+{
+  if (this->buffer_ == 0 || this->release_ == 0)
+    return;
+  T **tmp = ACE_reinterpret_cast (T**, this->buffer_);
+  for (CORBA::ULong i = 0; i < this->length_; ++i)
+    {
+      if (tmp[i] != 0)
+        tmp[i]->_remove_ref ();
+      tmp[i] = 0;
+    }
+  TAO_Unbounded_Valuetype_Sequence<T,T_var>::freebuf (tmp);
+  this->buffer_ = 0;
+}
+
+template<class T, class T_var> void
+TAO_Unbounded_Valuetype_Sequence<T,T_var>::_shrink_buffer (CORBA::ULong nl,
+                                                           CORBA::ULong ol)
+{
+  T **tmp = ACE_static_cast (T**, this->buffer_);
+
+  for (CORBA::ULong i = nl; i < ol; ++i)
+    {
+      if (tmp[i] != 0)
+        tmp[i]->_remove_ref ();
+      tmp[i] = 0;
+    }
+}
+
+/*
+template <class T, class T_var> void
+TAO_Unbounded_Valuetype_Sequence<T,T_var>::_downcast (void* target,
+                                                      CORBA_ValueBase* src,
+                                                      CORBA_Environment &ACE_TRY_ENV)
+{
+  T **tmp = ACE_static_cast (T**, target);
+
+  *tmp = T_var::narrow (src, ACE_TRY_ENV);
+
+  ACE_CHECK;
+}
+
+// @@ no upcast available for valuetypes???
+template <class T, class T_var> CORBA_ValueBase*
+TAO_Unbounded_Object_Sequence<T,T_var>::_upcast (void* src) const
+{
+  return T_var::upcast (src);
+}
+*/
+
+// *************************************************************
+// Operations for class TAO_Bounded_Valuetype_Sequence
+// *************************************************************
+
+template <class T, class T_var, size_t MAX>
+TAO_Bounded_Valuetype_Sequence<T, T_var,MAX>::
+TAO_Bounded_Valuetype_Sequence (void)
+  :  TAO_Bounded_Base_Sequence (MAX,
+                                TAO_Bounded_Valuetype_Sequence<T, T_var,MAX>::allocbuf (MAX))
+{
+}
+
+template <class T, class T_var, size_t MAX>
+TAO_Bounded_Valuetype_Sequence<T, T_var,MAX>::
+TAO_Bounded_Valuetype_Sequence (const TAO_Bounded_Valuetype_Sequence<T, T_var,MAX> &rhs)
+  : TAO_Bounded_Base_Sequence (rhs)
+{
+  if (rhs.buffer_ != 0)
+    {
+      T **tmp1 =
+        TAO_Bounded_Valuetype_Sequence<T, T_var,MAX>::allocbuf (MAX);
+
+      T ** const tmp2 =
+        ACE_reinterpret_cast (T** ACE_CAST_CONST, rhs.buffer_);
+
+      for (CORBA::ULong i = 0; i < rhs.length_; i++)
+        {
+          if (tmp2[i] != 0)
+            tmp2[i]->_add_ref ();
+          tmp1[i] = tmp2[i];
+        }
+
+      this->buffer_ = tmp1;
+    }
+  else
+    {
+      this->buffer_ = 0;
+    }
+}
+
+template <class T, class T_var, size_t MAX> TAO_Bounded_Valuetype_Sequence<T, T_var,MAX>&
+TAO_Bounded_Valuetype_Sequence<T, T_var,MAX>::operator=
+(const TAO_Bounded_Valuetype_Sequence<T,T_var, MAX> &rhs)
+{
+  if (this == &rhs)
+    return *this;
+
+  if (this->release_)
+    {
+      T **tmp = ACE_reinterpret_cast (T **, this->buffer_);
+
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+        {
+          if (tmp[i] != 0)
+            tmp[i]->_remove_ref ();
+          tmp[i] = 0;
+        }
+      // No need to reallocate the buffer since it is always of size
+      // MAX
+    }
+  else
+    {
+      if (rhs.maximum_ == 0)
+        {
+          this->buffer_ = 0;
+        }
+      else
+        {
+          this->buffer_ =
+            TAO_Bounded_Valuetype_Sequence<T,T_var,MAX>::allocbuf (rhs.maximum_);
+        }
+    }
+
+  TAO_Bounded_Base_Sequence::operator= (rhs);
+
+  T **tmp1 = ACE_reinterpret_cast (T **, this->buffer_);
+  T ** const tmp2 = ACE_reinterpret_cast (T ** ACE_CAST_CONST, rhs.buffer_);
+
+  for (CORBA::ULong i=0; i < rhs.length_; ++i)
+    {
+      if (tmp2[i] != 0)
+        tmp2[i]->_add_ref ();
+      tmp1[i] = tmp2[i];
+    }
+
+  return *this;
+}
+
+template <class T, class T_var, size_t MAX> T **
+TAO_Bounded_Valuetype_Sequence<T, T_var,MAX>::allocbuf (CORBA::ULong)
+{
+  T **buf = 0;
+
+  ACE_NEW_RETURN (buf, T*[MAX], 0);
+
+  for (CORBA::ULong i = 0; i < MAX; i++)
+    {
+      buf[i] = 0;
+    }
+
+  return buf;
+}
+
+template <class T, class T_var, size_t MAX> void
+TAO_Bounded_Valuetype_Sequence<T, T_var,MAX>::freebuf (T **buffer)
+{
+  // How much do we deallocate? Easy! allocbuf() always creates MAX
+  // elements and initialize them to T::_nil().  So we can be
+  // complaint and call CORBA::release() on each one.
+  for (CORBA::ULong i = 0; i < MAX; ++i)
+    {
+      if (buffer[i] != 0)
+        {
+          if (buffer[i] != 0)
+            buffer[i]->_remove_ref ();
+          buffer[i] = 0;
+        }
+    }
+
+  delete[] buffer;
+}
+
+template<class T, class T_var, size_t MAX> void
+TAO_Bounded_Valuetype_Sequence<T, T_var,MAX>::_allocate_buffer (CORBA::ULong length)
+{
+  // For this class memory is never reallocated so the implementation
+  // is *really* simple.
+  this->buffer_ =
+    TAO_Bounded_Valuetype_Sequence<T, T_var,MAX>::allocbuf (length);
+}
+
+template<class T, class T_var, size_t MAX> void
+TAO_Bounded_Valuetype_Sequence<T,T_var,MAX>::_deallocate_buffer (void)
+{
+  if (this->release_ == 0)
+    {
+      return;
+    }
+
+  T **tmp = ACE_reinterpret_cast (T **, this->buffer_);
+  TAO_Bounded_Valuetype_Sequence<T,T_var,MAX>::freebuf (tmp);
+  this->buffer_ = 0;
+}
+
+template<class T, class T_var, size_t MAX> void
+TAO_Bounded_Valuetype_Sequence<T,T_var, MAX>::_shrink_buffer (CORBA::ULong nl,
+                                                              CORBA::ULong ol)
+{
+  T **tmp = ACE_reinterpret_cast (T **, this->buffer_);
+
+  for (CORBA::ULong i = nl; i < ol; ++i)
+    {
+      if (tmp[i] != 0)
+        tmp[i]->_remove_ref ();
+      tmp[i] = 0;
+    }
+}
+
+/*
+template <class T, class T_var, size_t MAX> void
+TAO_Bounded_Valuetype_Sequence<T, T_var,MAX>::_downcast (void* target,
+                                                         CORBA_ValueBase* src,
+                                                         CORBA_Environment &ACE_TRY_ENV)
+{
+  T **tmp = ACE_static_cast (T**, target);
+
+  *tmp = T_var::narrow (src, ACE_TRY_ENV);
+
+  ACE_CHECK;
+}
+
+template <class T, class T_var, size_t MAX> CORBA_ValueBase*
+TAO_Bounded_Valuetype_Sequence<T, T_var,MAX>::_upcast (void* src) const
+{
+  return T_var::upcast (src);
+}
+*/
+
+// *************************************************************
 // Operations for class TAO_Unbounded_Array_Sequence
 // *************************************************************
 
@@ -1057,8 +1514,8 @@ TAO_Unbounded_Array_Sequence<T, T_var>::allocbuf (CORBA::ULong nelems)
 {
   T *buf = 0;
 
-  ACE_NEW_RETURN (buf, 
-                  T[nelems], 
+  ACE_NEW_RETURN (buf,
+                  T[nelems],
                   0);
 
   return buf;
@@ -1223,8 +1680,8 @@ TAO_Bounded_Array_Sequence<T, T_var, MAX>::allocbuf (CORBA::ULong)
 {
   T *buf = 0;
 
-  ACE_NEW_RETURN (buf, 
-                  T[MAX], 
+  ACE_NEW_RETURN (buf,
+                  T[MAX],
                   0);
 
   return buf;
diff --git a/TAO/tao/Sequence_T.h b/TAO/tao/Sequence_T.h
index 2fefbe2ec3a..8ce5fab6042 100644
--- a/TAO/tao/Sequence_T.h
+++ b/TAO/tao/Sequence_T.h
@@ -126,6 +126,8 @@ public:
                 CORBA::Boolean release = 0);
 };
 
+// *************************************************************
+
 /**
  * @class TAO_Bounded_Sequence
  *
@@ -234,7 +236,9 @@ public:
 
 template<class T,class T_var> class TAO_Unbounded_Object_Sequence;
 template<class T,class T_var> class TAO_Unbounded_Pseudo_Sequence;
+template<class T,class T_var> class TAO_Unbounded_Valuetype_Sequence;
 template<class T, class T_var, size_t MAX> class TAO_Bounded_Object_Sequence;
+template<class T, class T_var, size_t MAX> class TAO_Bounded_Valuetype_Sequence;
 template<size_t MAX> class TAO_Bounded_String_Sequence;
 
 // *************************************************************
@@ -340,6 +344,8 @@ private:
   CORBA::Boolean release_;
 };
 
+// *************************************************************
+
   /**
    * @class TAO_Pseudo_Object_Manager
    *
@@ -421,6 +427,95 @@ private:
 
 // *************************************************************
 
+  /**
+   * @class TAO_Valuetype_Manager
+   *
+   * @brief Manager for valuetypes.
+   *
+   * According to the spec., valuetypes are handled similarly to object
+   * references, so a manager class is needed.
+   *
+   * @see TAO_Object_Manager
+   */
+template<class T, class T_var>
+class TAO_Valuetype_Manager
+{
+  friend class TAO_Unbounded_Valuetype_Sequence<T,T_var>;
+public:
+  // @@ Use partial template specialization here to give access only
+  // to the right kind of sequence.
+  // friend template<CORBA::ULong MAX>
+  //    class TAO_Bounded_Valuetype_Sequence<T,MAX>;
+
+  // = Initialization and termination methods.
+  /**
+   * Copy constructor, the semantics are non-trivial:
+   *   + The referenced element is duplicated or not according to the
+   *   release value on the <rhs>.
+   *   + In any case a new reference to the same object is created.
+   */
+  TAO_Valuetype_Manager (const TAO_Valuetype_Manager<T,T_var> &rhs);
+
+  /**
+   * Constructor from address of an element, it should be private and
+   * only TAO_*_Object_Sequence would use it, but we have some
+   * problems with friendship and templates.
+   */
+  TAO_Valuetype_Manager (T **, CORBA::Boolean release);
+
+  /// Destructor, only releases the object if <release_> is true.
+  ~TAO_Valuetype_Manager (void);
+
+  /**
+   * Assignment from another managed type, only release if
+   * <this->release_> is true.
+   * @@ TODO what happens if rhs.release_ is true an this->relase_ is
+   * false?
+   */
+  TAO_Valuetype_Manager<T,T_var> &operator= (const TAO_Valuetype_Manager<T,T_var> &rhs);
+
+  /// Assignment from T *.
+  TAO_Valuetype_Manager<T,T_var> &operator= (T *);
+
+  /// Assignment from T_var.
+  TAO_Valuetype_Manager<T,T_var> &operator= (const T_var &);
+
+  /// Return pointer.
+  T * operator-> (void) const;
+
+  /// Cast (read-only).
+  operator const T *() const;
+
+  /// Cast.
+  operator T *&();
+
+  /// Cast (read-only) so that assignment from a structured
+  /// type to a T_var will make a copy.
+  operator const T_var() const;
+
+  /// for in parameter.
+  T *in (void) const;
+
+  /// for inout parameter.
+  T *&inout (void);
+
+  /// for out parameter.
+  T *&out (void);
+
+  /// for return type
+  T *_retn (void);
+
+private:
+  /// data member, notice that it is a pointer, to implement the
+  /// reference behavior for assignment.
+  T **ptr_;
+
+  /// release flag based on parent's flag
+  CORBA::Boolean release_;
+};
+
+// *************************************************************
+
 /**
  * @class TAO_Unbounded_Object_Sequence
  *
@@ -428,7 +523,7 @@ private:
  *
  * Some IDL types require that sequences on them have a "manager"
  * class, in charge of handling the object lifetime, examples are
- * pseudo objects, object references and strings.
+ * pseudo objects, object references, valuetypes, and strings.
  */
 template<class T,class T_var>
 class TAO_Unbounded_Object_Sequence : public TAO_Unbounded_Base_Sequence
@@ -737,6 +832,131 @@ public:
 // *************************************************************
 
 /**
+ * @class TAO_Unbounded_Valuetype_Sequence
+ *
+ * @brief Parametric sequence for valuetypes
+ *
+ * @see TAO_Unbounded_Object_Sequence
+ */
+template<class T,class T_var>
+class TAO_Unbounded_Valuetype_Sequence : public TAO_Unbounded_Base_Sequence
+{
+public:
+  // = Initialization and termination methods.
+
+  // Default ctor.
+  TAO_Unbounded_Valuetype_Sequence (void);
+
+  /// Constructor with a "hint" for the maximum capacity.
+  TAO_Unbounded_Valuetype_Sequence (CORBA::ULong max);
+
+  /// Constructor with a given buffer.
+  TAO_Unbounded_Valuetype_Sequence (CORBA::ULong maximum,
+                                    CORBA::ULong length,
+                                    T* *data,
+                                    CORBA::Boolean release=0);
+
+  /// Copy ctor, deep copies.
+  TAO_Unbounded_Valuetype_Sequence(const TAO_Unbounded_Valuetype_Sequence<T,T_var> &);
+
+  /// The destructor releases all object reference memebrs and frees
+  /// all string members.
+  ~TAO_Unbounded_Valuetype_Sequence (void);
+
+  /**
+   * The assignment operator first releases all object reference
+   * members and frees all string members, and then performs a
+   * deepcopy to create a new structure.
+   */
+  TAO_Unbounded_Valuetype_Sequence<T,T_var> &operator= (const TAO_Unbounded_Valuetype_Sequence <T,T_var> &);
+
+  /// read-write accessor
+  TAO_Valuetype_Manager<T,T_var> operator[] (CORBA::ULong slot) const;
+
+  /// The allocbuf function allocates a vector of T elements that can
+  /// be passed to the T *data constructor.
+  static T **allocbuf (CORBA::ULong);
+
+  /// Release all the elements.
+  static void freebuf (T **);
+
+  // The Base_Sequence functions, please see "tao/Sequence.h"
+  /// No default to workaround egcs problem with templates and
+  /// namespaces
+  virtual void _allocate_buffer (CORBA::ULong length);
+  virtual void _deallocate_buffer (void);
+  virtual void _shrink_buffer (CORBA::ULong new_length,
+                               CORBA::ULong old_length);
+  /*
+  virtual void _downcast (void* target,
+                          CORBA_ValueBase* src,
+                          CORBA_Environment &ACE_TRY_ENV =
+                              TAO_default_environment ());
+  virtual CORBA_ValueBase* _upcast (void* src) const;
+  */
+};
+
+// *************************************************************
+
+/**
+ * @class TAO_Bounded_Valuetype_Sequence
+ *
+ * @brief Parametric sequence for types that require managers.
+ *
+ * Please see the documentation for the unbounded case.
+ */
+template<class T, class T_var, size_t MAX>
+class TAO_Bounded_Valuetype_Sequence : public TAO_Bounded_Base_Sequence
+{
+public:
+  // = Initialization and termination methods.
+
+  // Default ctor.
+  TAO_Bounded_Valuetype_Sequence (void);
+
+  /// Constructor from data.
+  TAO_Bounded_Valuetype_Sequence (CORBA::ULong length,
+                                  T* *value,
+                                  CORBA::Boolean release=0);
+
+  /// Copy constructor.
+  TAO_Bounded_Valuetype_Sequence (const TAO_Bounded_Valuetype_Sequence<T,T_var,MAX> &);
+
+  /// destructor
+  ~TAO_Bounded_Valuetype_Sequence (void);
+
+  /// Assignment from another Bounded sequence.
+  TAO_Bounded_Valuetype_Sequence &operator= (const TAO_Bounded_Valuetype_Sequence<T,T_var,MAX> &);
+
+  /// Read-write accessor.
+  TAO_Valuetype_Manager<T,T_var> operator[] (CORBA::ULong slot) const;
+
+  /// Allocate storage for a sequence..
+  static T **allocbuf (CORBA::ULong length);
+
+  /// Free a buffer allocated by allocbuf() and release each element on
+  /// it.
+  static void freebuf (T **buffer);
+
+  // The Base_Sequence functions, please see "tao/sequence.h"
+  /// No default to workaround egcs problem with templates and
+  /// namespaces
+  virtual void _allocate_buffer (CORBA::ULong length);
+  virtual void _deallocate_buffer (void);
+  virtual void _shrink_buffer (CORBA::ULong new_length,
+                               CORBA::ULong old_length);
+  /*
+  virtual void _downcast (void* target,
+                          CORBA_ValueBase* src,
+                          CORBA_Environment &ACE_TRY_ENV =
+                              TAO_default_environment ());
+  virtual CORBA_ValueBase* _upcast (void* src) const;
+  */
+};
+
+// *************************************************************
+
+/**
  * @class TAO_Unbounded_Array_Sequence
  *
  * @brief Parametric sequence for arrays.
diff --git a/TAO/tao/Sequence_T.i b/TAO/tao/Sequence_T.i
index c747c35ab7d..881f6584d96 100644
--- a/TAO/tao/Sequence_T.i
+++ b/TAO/tao/Sequence_T.i
@@ -51,20 +51,20 @@ TAO_Unbounded_Sequence<T>::get_buffer (CORBA::Boolean orphan)
             {
               result = TAO_Unbounded_Sequence<T>::allocbuf (this->length_);
               this->buffer_ = result;
-	      this->release_ = 1;
+              this->release_ = 1;
             }
         }
       else
         {
           result =
-            ACE_reinterpret_cast (T*, 
-	                          this->buffer_);
+            ACE_reinterpret_cast (T*,
+                                  this->buffer_);
         }
     }
   else // if (orphan == 1)
     {
       result = ACE_reinterpret_cast (T*,
-	                             this->buffer_);
+                                     this->buffer_);
 
       if (this->release_ != 0)
         {
@@ -145,7 +145,7 @@ TAO_Bounded_Sequence<T, MAX>::get_buffer (CORBA::Boolean orphan)
         {
           result = TAO_Bounded_Sequence<T,MAX>::allocbuf (this->maximum_);
           this->buffer_ = result;
-	  this->release_ = 1;
+          this->release_ = 1;
         }
       else
         {
@@ -339,6 +339,84 @@ TAO_Pseudo_Object_Manager<T,T_var>::_retn (void)
 }
 
 // *************************************************************
+// Inline operations for class TAO_Valuetype_Manager
+// *************************************************************
+
+template <class T, class T_var> ACE_INLINE
+TAO_Valuetype_Manager<T,T_var>::~TAO_Valuetype_Manager (void)
+{
+}
+
+template <class T, class T_var> ACE_INLINE
+TAO_Valuetype_Manager<T,T_var>::TAO_Valuetype_Manager (const TAO_Valuetype_Manager<T,T_var> &rhs)
+  : ptr_ (rhs.ptr_),
+    release_ (rhs.release_)
+{
+}
+
+template <class T, class T_var> ACE_INLINE
+TAO_Valuetype_Manager<T,T_var>::TAO_Valuetype_Manager(T** buffer, CORBA::Boolean release)
+  : ptr_ (buffer),
+    release_ (release)
+{
+}
+
+template <class T, class T_var> ACE_INLINE T *
+TAO_Valuetype_Manager<T,T_var>::operator-> (void) const
+{
+  return *this->ptr_;
+}
+
+template <class T, class T_var> ACE_INLINE
+TAO_Valuetype_Manager<T,T_var>::operator const T_var () const
+{
+  if (*this->ptr_ != 0)
+    (*this->ptr_)->_add_ref ();
+  return *this->ptr_;
+}
+
+template <class T, class T_var> ACE_INLINE
+TAO_Valuetype_Manager<T,T_var>::operator const T* () const // cast
+{
+  return *this->ptr_;
+}
+
+template <class T, class T_var> ACE_INLINE
+TAO_Valuetype_Manager<T,T_var>::operator T* &() // cast
+{
+  return *this->ptr_;
+}
+
+template <class T, class T_var> ACE_INLINE T *
+TAO_Valuetype_Manager<T,T_var>::in (void) const
+{
+  return *this->ptr_;
+}
+
+template <class T, class T_var> ACE_INLINE T *&
+TAO_Valuetype_Manager<T,T_var>::inout (void)
+{
+  return *this->ptr_;
+}
+
+template <class T, class T_var> ACE_INLINE T *&
+TAO_Valuetype_Manager<T,T_var>::out (void)
+{
+  if (*this->ptr_ != 0)
+    (*this->ptr_)->_remove_ref ();
+  *this->ptr_ = 0;
+  return *this->ptr_;
+}
+
+template <class T, class T_var> ACE_INLINE T *
+TAO_Valuetype_Manager<T,T_var>::_retn (void)
+{
+  T *temp = *this->ptr_;
+  *this->ptr_ = 0;
+  return temp;
+}
+
+// *************************************************************
 // class TAO_Unbounded_Object_Sequence
 // *************************************************************
 
@@ -451,6 +529,61 @@ TAO_Bounded_Pseudo_Sequence<T, T_var,MAX>::operator[] (CORBA::ULong slot) const
 }
 
 // *************************************************************
+// class TAO_Unbounded_Valuetype_Sequence
+// *************************************************************
+
+//default constructor
+template <class T, class T_var> ACE_INLINE
+TAO_Unbounded_Valuetype_Sequence<T,T_var>::TAO_Unbounded_Valuetype_Sequence (void)
+{
+}
+
+template <class T, class T_var> ACE_INLINE
+TAO_Unbounded_Valuetype_Sequence<T,T_var>::
+TAO_Unbounded_Valuetype_Sequence (CORBA::ULong maximum,
+                                  CORBA::ULong length,
+                                  T* *value,
+                                  CORBA::Boolean release)
+  : TAO_Unbounded_Base_Sequence (maximum, length, value, release)
+{
+}
+
+template <class T, class T_var> ACE_INLINE TAO_Valuetype_Manager<T,T_var>
+TAO_Unbounded_Valuetype_Sequence<T,T_var>::operator[] (CORBA::ULong slot) const
+{
+  ACE_ASSERT (slot < this->maximum_);
+  T ** const tmp = ACE_reinterpret_cast (T ** ACE_CAST_CONST, this->buffer_);
+  return TAO_Valuetype_Manager<T,T_var> (tmp + slot, this->release_);
+}
+
+// *************************************************************
+// class TAO_Bounded_Valuetype_Sequence
+// *************************************************************
+
+template<class T, class T_var, size_t MAX> ACE_INLINE
+TAO_Bounded_Valuetype_Sequence<T,T_var,MAX>::~TAO_Bounded_Valuetype_Sequence (void)
+{
+  this->_deallocate_buffer ();
+}
+
+template <class T, class T_var, size_t MAX> ACE_INLINE
+TAO_Bounded_Valuetype_Sequence<T,T_var,MAX>::
+TAO_Bounded_Valuetype_Sequence (CORBA::ULong length,
+                                T **value,
+                                CORBA::Boolean release)
+  : TAO_Bounded_Base_Sequence (MAX, length, value, release)
+{
+}
+
+template <class T, class T_var, size_t MAX> ACE_INLINE TAO_Valuetype_Manager<T,T_var>
+TAO_Bounded_Valuetype_Sequence<T, T_var,MAX>::operator[] (CORBA::ULong slot) const
+{
+  ACE_ASSERT (slot < this->maximum_);
+  T **const tmp = ACE_reinterpret_cast (T ** ACE_CAST_CONST, this->buffer_);
+  return TAO_Valuetype_Manager<T,T_var> (tmp + slot, this->release_);
+}
+
+// *************************************************************
 // class TAO_Unbounded_Array_Sequence
 // *************************************************************
 
@@ -523,19 +656,19 @@ TAO_Unbounded_Array_Sequence<T, T_var>::get_buffer (CORBA::Boolean orphan)
         {
           if (this->length_ > 0)
             {
-              result = 
-	        TAO_Unbounded_Array_Sequence<T, T_var>::allocbuf (
+              result =
+                TAO_Unbounded_Array_Sequence<T, T_var>::allocbuf (
                     this->length_
                   );
               this->buffer_ = result;
-	      this->release_ = 1;
+              this->release_ = 1;
             }
         }
       else
         {
           result =
-            ACE_reinterpret_cast (T*, 
-	                          this->buffer_);
+            ACE_reinterpret_cast (T*,
+                                  this->buffer_);
         }
     }
   else // if (orphan == 1)
@@ -545,7 +678,7 @@ TAO_Unbounded_Array_Sequence<T, T_var>::get_buffer (CORBA::Boolean orphan)
           // We set the state back to default and relinquish
           // ownership.
           result = ACE_reinterpret_cast (T*,
-	                                 this->buffer_);
+                                         this->buffer_);
           this->maximum_ = 0;
           this->length_ = 0;
           this->buffer_ = 0;
@@ -558,13 +691,13 @@ TAO_Unbounded_Array_Sequence<T, T_var>::get_buffer (CORBA::Boolean orphan)
 template <class T, class T_var> ACE_INLINE const T *
 TAO_Unbounded_Array_Sequence<T, T_var>::get_buffer (void) const
 {
-  return ACE_reinterpret_cast (const T * ACE_CAST_CONST, 
+  return ACE_reinterpret_cast (const T * ACE_CAST_CONST,
                                this->buffer_);
 }
 
 template <class T, class T_var> ACE_INLINE void
 TAO_Unbounded_Array_Sequence<T, T_var>::replace (CORBA::ULong max,
-				                   CORBA::ULong length,
+                                                   CORBA::ULong length,
                                                    T *data,
                                                    CORBA::Boolean release)
 {
@@ -643,10 +776,10 @@ TAO_Bounded_Array_Sequence<T, T_var, MAX>::get_buffer (CORBA::Boolean orphan)
 
       if (this->buffer_ == 0)
         {
-          result = 
-	    TAO_Bounded_Array_Sequence<T, T_var, MAX>::allocbuf (this->maximum_);
+          result =
+            TAO_Bounded_Array_Sequence<T, T_var, MAX>::allocbuf (this->maximum_);
           this->buffer_ = result;
-	  this->release_ = 1;
+          this->release_ = 1;
         }
       else
         {
@@ -673,7 +806,7 @@ TAO_Bounded_Array_Sequence<T, T_var, MAX>::get_buffer (CORBA::Boolean orphan)
 template <class T, class T_var, size_t MAX> ACE_INLINE const T *
 TAO_Bounded_Array_Sequence<T, T_var, MAX>::get_buffer (void) const
 {
-  return ACE_reinterpret_cast (const T * ACE_CAST_CONST, 
+  return ACE_reinterpret_cast (const T * ACE_CAST_CONST,
                                this->buffer_);
 }
 
@@ -687,7 +820,7 @@ TAO_Bounded_Array_Sequence<T, T_var, MAX>::replace (CORBA::ULong max,
   this->length_ = length;
   if (this->buffer_ && this->release_ == 1)
     {
-      T* tmp = ACE_reinterpret_cast (T*, 
+      T* tmp = ACE_reinterpret_cast (T*,
                                      this->buffer_);
       TAO_Bounded_Array_Sequence<T, T_var, MAX>::freebuf (tmp);
     }