--- StringSeqC.h.old	Sun Oct 22 22:31:13 2000
+++ StringSeqC.h	Sun Oct 22 22:31:52 2000
@@ -23,13 +23,14 @@
 #define _TAO_IDL_STRINGSEQC_H_
 
 #include "ace/pre.h"
-#include "tao/corba.h"
+
+#include "tao/corbafwd.h"
 
 #if !defined (ACE_LACKS_PRAGMA_ONCE)
 # pragma once
 #endif /* ACE_LACKS_PRAGMA_ONCE */
 
-#include "tao/corbafwd.h"
+#include "tao/Sequence.h"
 
 #if defined (TAO_EXPORT_MACRO)
 #undef TAO_EXPORT_MACRO
@@ -54,14 +55,14 @@
 #if !defined (_STRINGSEQ_CH_)
 #define _STRINGSEQ_CH_
 
-class StringSeq;
-class StringSeq_var;
+class CORBA_StringSeq;
+class CORBA_StringSeq_var;
 
 // *************************************************************
-// StringSeq
+// CORBA_StringSeq
 // *************************************************************
 
-class TAO_Export StringSeq : public 
+class TAO_Export CORBA_StringSeq : public 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
   TAO_Unbounded_String_Sequence
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
@@ -69,20 +70,20 @@
 #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
 {
 public:
-  StringSeq (void); // default ctor
-  StringSeq (CORBA::ULong max); // uses max size
-  StringSeq (
+  CORBA_StringSeq (void); // default ctor
+  CORBA_StringSeq (CORBA::ULong max); // uses max size
+  CORBA_StringSeq (
     CORBA::ULong max, 
     CORBA::ULong length, 
     char * *buffer, 
     CORBA::Boolean release = 0
   );
-  StringSeq (const StringSeq &); // copy ctor
-  ~StringSeq (void);
+  CORBA_StringSeq (const CORBA_StringSeq &); // copy ctor
+  ~CORBA_StringSeq (void);
   static void _tao_any_destructor (void*);
 
 #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
-  typedef StringSeq_var _var_type;
+  typedef CORBA_StringSeq_var _var_type;
 #endif /* ! __GNUC__ || g++ >= 2.8 */
 
 };
@@ -94,38 +95,38 @@
 #define _STRINGSEQ___VAR_CH_
 
 // *************************************************************
-// class StringSeq_var
+// class CORBA_StringSeq_var
 // *************************************************************
 
-class TAO_Export StringSeq_var
+class TAO_Export CORBA_StringSeq_var
 {
 public:
-  StringSeq_var (void); // default constructor
-  StringSeq_var (StringSeq *);
-  StringSeq_var (const StringSeq_var &); // copy constructor
-  ~StringSeq_var (void); // destructor
+  CORBA_StringSeq_var (void); // default constructor
+  CORBA_StringSeq_var (CORBA_StringSeq *);
+  CORBA_StringSeq_var (const CORBA_StringSeq_var &); // copy constructor
+  ~CORBA_StringSeq_var (void); // destructor
   
-  StringSeq_var &operator= (StringSeq *);
-  StringSeq_var &operator= (const StringSeq_var &);
-  StringSeq *operator-> (void);
-  const StringSeq *operator-> (void) const;
+  CORBA_StringSeq_var &operator= (CORBA_StringSeq *);
+  CORBA_StringSeq_var &operator= (const CORBA_StringSeq_var &);
+  CORBA_StringSeq *operator-> (void);
+  const CORBA_StringSeq *operator-> (void) const;
   
-  operator const StringSeq &() const;
-  operator StringSeq &();
-  operator StringSeq &() const;
-  operator StringSeq *&(); // variable-size base types only
+  operator const CORBA_StringSeq &() const;
+  operator CORBA_StringSeq &();
+  operator CORBA_StringSeq &() const;
+  operator CORBA_StringSeq *&(); // variable-size base types only
   
   TAO_SeqElem_String_Manager operator[] (CORBA::ULong index);
   
   // in, inout, out, _retn 
-  const StringSeq &in (void) const;
-  StringSeq &inout (void);
-  StringSeq *&out (void);
-  StringSeq *_retn (void);
-  StringSeq *ptr (void) const;
+  const CORBA_StringSeq &in (void) const;
+  CORBA_StringSeq &inout (void);
+  CORBA_StringSeq *&out (void);
+  CORBA_StringSeq *_retn (void);
+  CORBA_StringSeq *ptr (void) const;
 
 private:
-  StringSeq *ptr_;
+  CORBA_StringSeq *ptr_;
 };
 
 
@@ -135,42 +136,42 @@
 #if !defined (_STRINGSEQ___OUT_CH_)
 #define _STRINGSEQ___OUT_CH_
 
-class TAO_Export StringSeq_out
+class TAO_Export CORBA_StringSeq_out
 {
 public:
-  StringSeq_out (StringSeq *&);
-  StringSeq_out (StringSeq_var &);
-  StringSeq_out (const StringSeq_out &);
-  StringSeq_out &operator= (const StringSeq_out &);
-  StringSeq_out &operator= (StringSeq *);
-  operator StringSeq *&();
-  StringSeq *&ptr (void);
-  StringSeq *operator-> (void);
+  CORBA_StringSeq_out (CORBA_StringSeq *&);
+  CORBA_StringSeq_out (CORBA_StringSeq_var &);
+  CORBA_StringSeq_out (const CORBA_StringSeq_out &);
+  CORBA_StringSeq_out &operator= (const CORBA_StringSeq_out &);
+  CORBA_StringSeq_out &operator= (CORBA_StringSeq *);
+  operator CORBA_StringSeq *&();
+  CORBA_StringSeq *&ptr (void);
+  CORBA_StringSeq *operator-> (void);
   TAO_SeqElem_String_Manager operator[] (CORBA::ULong index);
   
 private:
-  StringSeq *&ptr_;
+  CORBA_StringSeq *&ptr_;
   // assignment from T_var not allowed
-  void operator= (const StringSeq_var &);
+  void operator= (const CORBA_StringSeq_var &);
 };
 
 
 #endif /* end #if !defined */
 
-extern TAO_Export CORBA::TypeCode_ptr  _tc_StringSeq;
+extern TAO_Export CORBA::TypeCode_ptr  _tc_CORBA_StringSeq;
 
 
 #if !defined (_WSTRINGSEQ_CH_)
 #define _WSTRINGSEQ_CH_
 
-class WStringSeq;
-class WStringSeq_var;
+class CORBA_WStringSeq;
+class CORBA_WStringSeq_var;
 
 // *************************************************************
-// WStringSeq
+// CORBA_WStringSeq
 // *************************************************************
 
-class TAO_Export WStringSeq : public 
+class TAO_Export CORBA_WStringSeq : public 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
   TAO_Unbounded_WString_Sequence
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
@@ -178,20 +179,20 @@
 #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
 {
 public:
-  WStringSeq (void); // default ctor
-  WStringSeq (CORBA::ULong max); // uses max size
-  WStringSeq (
+  CORBA_WStringSeq (void); // default ctor
+  CORBA_WStringSeq (CORBA::ULong max); // uses max size
+  CORBA_WStringSeq (
     CORBA::ULong max, 
     CORBA::ULong length, 
     CORBA::WChar * *buffer, 
     CORBA::Boolean release = 0
   );
-  WStringSeq (const WStringSeq &); // copy ctor
-  ~WStringSeq (void);
+  CORBA_WStringSeq (const CORBA_WStringSeq &); // copy ctor
+  ~CORBA_WStringSeq (void);
   static void _tao_any_destructor (void*);
 
 #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
-  typedef WStringSeq_var _var_type;
+  typedef CORBA_WStringSeq_var _var_type;
 #endif /* ! __GNUC__ || g++ >= 2.8 */
 
 };
@@ -203,38 +204,38 @@
 #define _WSTRINGSEQ___VAR_CH_
 
 // *************************************************************
-// class WStringSeq_var
+// class CORBA_WStringSeq_var
 // *************************************************************
 
-class TAO_Export WStringSeq_var
+class TAO_Export CORBA_WStringSeq_var
 {
 public:
-  WStringSeq_var (void); // default constructor
-  WStringSeq_var (WStringSeq *);
-  WStringSeq_var (const WStringSeq_var &); // copy constructor
-  ~WStringSeq_var (void); // destructor
+  CORBA_WStringSeq_var (void); // default constructor
+  CORBA_WStringSeq_var (CORBA_WStringSeq *);
+  CORBA_WStringSeq_var (const CORBA_WStringSeq_var &); // copy constructor
+  ~CORBA_WStringSeq_var (void); // destructor
   
-  WStringSeq_var &operator= (WStringSeq *);
-  WStringSeq_var &operator= (const WStringSeq_var &);
-  WStringSeq *operator-> (void);
-  const WStringSeq *operator-> (void) const;
+  CORBA_WStringSeq_var &operator= (CORBA_WStringSeq *);
+  CORBA_WStringSeq_var &operator= (const CORBA_WStringSeq_var &);
+  CORBA_WStringSeq *operator-> (void);
+  const CORBA_WStringSeq *operator-> (void) const;
   
-  operator const WStringSeq &() const;
-  operator WStringSeq &();
-  operator WStringSeq &() const;
-  operator WStringSeq *&(); // variable-size base types only
+  operator const CORBA_WStringSeq &() const;
+  operator CORBA_WStringSeq &();
+  operator CORBA_WStringSeq &() const;
+  operator CORBA_WStringSeq *&(); // variable-size base types only
   
   TAO_SeqElem_WString_Manager operator[] (CORBA::ULong index);
   
   // in, inout, out, _retn 
-  const WStringSeq &in (void) const;
-  WStringSeq &inout (void);
-  WStringSeq *&out (void);
-  WStringSeq *_retn (void);
-  WStringSeq *ptr (void) const;
+  const CORBA_WStringSeq &in (void) const;
+  CORBA_WStringSeq &inout (void);
+  CORBA_WStringSeq *&out (void);
+  CORBA_WStringSeq *_retn (void);
+  CORBA_WStringSeq *ptr (void) const;
 
 private:
-  WStringSeq *ptr_;
+  CORBA_WStringSeq *ptr_;
 };
 
 
@@ -244,70 +245,70 @@
 #if !defined (_WSTRINGSEQ___OUT_CH_)
 #define _WSTRINGSEQ___OUT_CH_
 
-class TAO_Export WStringSeq_out
+class TAO_Export CORBA_WStringSeq_out
 {
 public:
-  WStringSeq_out (WStringSeq *&);
-  WStringSeq_out (WStringSeq_var &);
-  WStringSeq_out (const WStringSeq_out &);
-  WStringSeq_out &operator= (const WStringSeq_out &);
-  WStringSeq_out &operator= (WStringSeq *);
-  operator WStringSeq *&();
-  WStringSeq *&ptr (void);
-  WStringSeq *operator-> (void);
+  CORBA_WStringSeq_out (CORBA_WStringSeq *&);
+  CORBA_WStringSeq_out (CORBA_WStringSeq_var &);
+  CORBA_WStringSeq_out (const CORBA_WStringSeq_out &);
+  CORBA_WStringSeq_out &operator= (const CORBA_WStringSeq_out &);
+  CORBA_WStringSeq_out &operator= (CORBA_WStringSeq *);
+  operator CORBA_WStringSeq *&();
+  CORBA_WStringSeq *&ptr (void);
+  CORBA_WStringSeq *operator-> (void);
   TAO_SeqElem_WString_Manager operator[] (CORBA::ULong index);
   
 private:
-  WStringSeq *&ptr_;
+  CORBA_WStringSeq *&ptr_;
   // assignment from T_var not allowed
-  void operator= (const WStringSeq_var &);
+  void operator= (const CORBA_WStringSeq_var &);
 };
 
 
 #endif /* end #if !defined */
 
-extern TAO_Export CORBA::TypeCode_ptr  _tc_WStringSeq;
+extern TAO_Export CORBA::TypeCode_ptr  _tc_CORBA_WStringSeq;
 
-TAO_Export void operator<<= (CORBA::Any &, const StringSeq &); // copying version
-TAO_Export void operator<<= (CORBA::Any &, StringSeq*); // noncopying version
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, StringSeq *&); // deprecated
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const StringSeq *&);
-TAO_Export void operator<<= (CORBA::Any &, const WStringSeq &); // copying version
-TAO_Export void operator<<= (CORBA::Any &, WStringSeq*); // noncopying version
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, WStringSeq *&); // deprecated
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const WStringSeq *&);
+TAO_Export void operator<<= (CORBA::Any &, const CORBA_StringSeq &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, CORBA_StringSeq*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA_StringSeq *&); // deprecated
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA_StringSeq *&);
+TAO_Export void operator<<= (CORBA::Any &, const CORBA_WStringSeq &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, CORBA_WStringSeq*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA_WStringSeq *&); // deprecated
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA_WStringSeq *&);
 
 #ifndef __ACE_INLINE__
 
 
-#if !defined _TAO_CDR_OP_StringSeq_H_
-#define _TAO_CDR_OP_StringSeq_H_
+#if !defined _TAO_CDR_OP_CORBA_StringSeq_H_
+#define _TAO_CDR_OP_CORBA_StringSeq_H_
 
 TAO_Export CORBA::Boolean operator<< (
     TAO_OutputCDR &,
-    const StringSeq &
+    const CORBA_StringSeq &
   );
 TAO_Export CORBA::Boolean operator>> (
     TAO_InputCDR &,
-    StringSeq &
+    CORBA_StringSeq &
   );
 
-#endif /* _TAO_CDR_OP_StringSeq_H_ */
+#endif /* _TAO_CDR_OP_CORBA_StringSeq_H_ */
 
 
-#if !defined _TAO_CDR_OP_WStringSeq_H_
-#define _TAO_CDR_OP_WStringSeq_H_
+#if !defined _TAO_CDR_OP_CORBA_WStringSeq_H_
+#define _TAO_CDR_OP_CORBA_WStringSeq_H_
 
 TAO_Export CORBA::Boolean operator<< (
     TAO_OutputCDR &,
-    const WStringSeq &
+    const CORBA_WStringSeq &
   );
 TAO_Export CORBA::Boolean operator>> (
     TAO_InputCDR &,
-    WStringSeq &
+    CORBA_WStringSeq &
   );
 
-#endif /* _TAO_CDR_OP_WStringSeq_H_ */
+#endif /* _TAO_CDR_OP_CORBA_WStringSeq_H_ */
 
 
 #endif /* __ACE_INLINE__ */
--- StringSeqC.i.old	Sun Oct 22 22:31:13 2000
+++ StringSeqC.i	Sun Oct 22 22:31:52 2000
@@ -24,144 +24,144 @@
 #define _STRINGSEQ_CI_
 
 // *************************************************************
-// Inline operations for class StringSeq_var
+// Inline operations for class CORBA_StringSeq_var
 // *************************************************************
 
 ACE_INLINE
-StringSeq_var::StringSeq_var (void) // default constructor
+CORBA_StringSeq_var::CORBA_StringSeq_var (void) // default constructor
   : ptr_ (0)
 {}
 
 ACE_INLINE
-StringSeq_var::StringSeq_var (StringSeq *p)
+CORBA_StringSeq_var::CORBA_StringSeq_var (CORBA_StringSeq *p)
   : ptr_ (p)
 {}
 
 ACE_INLINE
-StringSeq_var::StringSeq_var (const ::StringSeq_var &p) // copy constructor
+CORBA_StringSeq_var::CORBA_StringSeq_var (const ::CORBA_StringSeq_var &p) // copy constructor
 {
   if (p.ptr_)
-    ACE_NEW (this->ptr_, ::StringSeq (*p.ptr_));
+    ACE_NEW (this->ptr_, ::CORBA_StringSeq (*p.ptr_));
   else
     this->ptr_ = 0;
 }
 
 ACE_INLINE
-StringSeq_var::~StringSeq_var (void) // destructor
+CORBA_StringSeq_var::~CORBA_StringSeq_var (void) // destructor
 {
   delete this->ptr_;
 }
 
-ACE_INLINE StringSeq_var &
-StringSeq_var::operator= (StringSeq *p)
+ACE_INLINE CORBA_StringSeq_var &
+CORBA_StringSeq_var::operator= (CORBA_StringSeq *p)
 {
   delete this->ptr_;
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE StringSeq_var &
-StringSeq_var::operator= (const ::StringSeq_var &p) // deep copy
+ACE_INLINE CORBA_StringSeq_var &
+CORBA_StringSeq_var::operator= (const ::CORBA_StringSeq_var &p) // deep copy
 {
   if (this != &p)
   {
     delete this->ptr_;
-    ACE_NEW_RETURN (this->ptr_, ::StringSeq (*p.ptr_), *this);
+    ACE_NEW_RETURN (this->ptr_, ::CORBA_StringSeq (*p.ptr_), *this);
   }
   return *this;
 }
 
-ACE_INLINE const ::StringSeq *
-StringSeq_var::operator-> (void) const
+ACE_INLINE const ::CORBA_StringSeq *
+CORBA_StringSeq_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE ::StringSeq *
-StringSeq_var::operator-> (void)
+ACE_INLINE ::CORBA_StringSeq *
+CORBA_StringSeq_var::operator-> (void)
 {
   return this->ptr_;
 }
 
 ACE_INLINE 
-StringSeq_var::operator const ::StringSeq &() const // cast
+CORBA_StringSeq_var::operator const ::CORBA_StringSeq &() const // cast
 {
   return *this->ptr_;
 }
 
 ACE_INLINE 
-StringSeq_var::operator ::StringSeq &() // cast 
+CORBA_StringSeq_var::operator ::CORBA_StringSeq &() // cast 
 {
   return *this->ptr_;
 }
 
 ACE_INLINE 
-StringSeq_var::operator ::StringSeq &() const // cast 
+CORBA_StringSeq_var::operator ::CORBA_StringSeq &() const // cast 
 {
   return *this->ptr_;
 }
 
 // variable-size types only
 ACE_INLINE
-StringSeq_var::operator ::StringSeq *&() // cast 
+CORBA_StringSeq_var::operator ::CORBA_StringSeq *&() // cast 
 {
   return this->ptr_;
 }
 
 ACE_INLINE TAO_SeqElem_String_Manager
-StringSeq_var::operator[] (CORBA::ULong index)
+CORBA_StringSeq_var::operator[] (CORBA::ULong index)
 {
   return this->ptr_->operator[] (index);
 }
 
-ACE_INLINE const ::StringSeq &
-StringSeq_var::in (void) const
+ACE_INLINE const ::CORBA_StringSeq &
+CORBA_StringSeq_var::in (void) const
 {
   return *this->ptr_;
 }
 
-ACE_INLINE ::StringSeq &
-StringSeq_var::inout (void)
+ACE_INLINE ::CORBA_StringSeq &
+CORBA_StringSeq_var::inout (void)
 {
   return *this->ptr_;
 }
 
 // mapping for variable size 
-ACE_INLINE ::StringSeq *&
-StringSeq_var::out (void)
+ACE_INLINE ::CORBA_StringSeq *&
+CORBA_StringSeq_var::out (void)
 {
   delete this->ptr_;
   this->ptr_ = 0;
   return this->ptr_;
 }
 
-ACE_INLINE ::StringSeq *
-StringSeq_var::_retn (void)
+ACE_INLINE ::CORBA_StringSeq *
+CORBA_StringSeq_var::_retn (void)
 {
-  ::StringSeq *tmp = this->ptr_;
+  ::CORBA_StringSeq *tmp = this->ptr_;
   this->ptr_ = 0;
   return tmp;
 }
 
-ACE_INLINE ::StringSeq *
-StringSeq_var::ptr (void) const
+ACE_INLINE ::CORBA_StringSeq *
+CORBA_StringSeq_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 // *************************************************************
-// Inline operations for class StringSeq_out
+// Inline operations for class CORBA_StringSeq_out
 // *************************************************************
 
 ACE_INLINE
-StringSeq_out::StringSeq_out (StringSeq *&p)
+CORBA_StringSeq_out::CORBA_StringSeq_out (CORBA_StringSeq *&p)
   : ptr_ (p)
 {
   this->ptr_ = 0;
 }
 
 ACE_INLINE
-StringSeq_out::StringSeq_out (StringSeq_var &p) // constructor from _var
+CORBA_StringSeq_out::CORBA_StringSeq_out (CORBA_StringSeq_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   delete this->ptr_;
@@ -169,44 +169,44 @@
 }
 
 ACE_INLINE
-StringSeq_out::StringSeq_out (const ::StringSeq_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (StringSeq_out&, p).ptr_)
+CORBA_StringSeq_out::CORBA_StringSeq_out (const ::CORBA_StringSeq_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (CORBA_StringSeq_out&, p).ptr_)
 {}
 
-ACE_INLINE ::StringSeq_out &
-StringSeq_out::operator= (const ::StringSeq_out &p)
+ACE_INLINE ::CORBA_StringSeq_out &
+CORBA_StringSeq_out::operator= (const ::CORBA_StringSeq_out &p)
 {
-  this->ptr_ = ACE_const_cast (StringSeq_out&, p).ptr_;
+  this->ptr_ = ACE_const_cast (CORBA_StringSeq_out&, p).ptr_;
   return *this;
 }
 
-ACE_INLINE ::StringSeq_out &
-StringSeq_out::operator= (StringSeq *p)
+ACE_INLINE ::CORBA_StringSeq_out &
+CORBA_StringSeq_out::operator= (CORBA_StringSeq *p)
 {
   this->ptr_ = p;
   return *this;
 }
 
 ACE_INLINE 
-StringSeq_out::operator ::StringSeq *&() // cast
+CORBA_StringSeq_out::operator ::CORBA_StringSeq *&() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE ::StringSeq *&
-StringSeq_out::ptr (void) // ptr
+ACE_INLINE ::CORBA_StringSeq *&
+CORBA_StringSeq_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE ::StringSeq *
-StringSeq_out::operator-> (void)
+ACE_INLINE ::CORBA_StringSeq *
+CORBA_StringSeq_out::operator-> (void)
 {
   return this->ptr_;
 }
 
 ACE_INLINE TAO_SeqElem_String_Manager
-StringSeq_out::operator[] (CORBA::ULong index)
+CORBA_StringSeq_out::operator[] (CORBA::ULong index)
 {
   return this->ptr_->operator[] (index);
 }
@@ -219,144 +219,144 @@
 #define _WSTRINGSEQ_CI_
 
 // *************************************************************
-// Inline operations for class WStringSeq_var
+// Inline operations for class CORBA_WStringSeq_var
 // *************************************************************
 
 ACE_INLINE
-WStringSeq_var::WStringSeq_var (void) // default constructor
+CORBA_WStringSeq_var::CORBA_WStringSeq_var (void) // default constructor
   : ptr_ (0)
 {}
 
 ACE_INLINE
-WStringSeq_var::WStringSeq_var (WStringSeq *p)
+CORBA_WStringSeq_var::CORBA_WStringSeq_var (CORBA_WStringSeq *p)
   : ptr_ (p)
 {}
 
 ACE_INLINE
-WStringSeq_var::WStringSeq_var (const ::WStringSeq_var &p) // copy constructor
+CORBA_WStringSeq_var::CORBA_WStringSeq_var (const ::CORBA_WStringSeq_var &p) // copy constructor
 {
   if (p.ptr_)
-    ACE_NEW (this->ptr_, ::WStringSeq (*p.ptr_));
+    ACE_NEW (this->ptr_, ::CORBA_WStringSeq (*p.ptr_));
   else
     this->ptr_ = 0;
 }
 
 ACE_INLINE
-WStringSeq_var::~WStringSeq_var (void) // destructor
+CORBA_WStringSeq_var::~CORBA_WStringSeq_var (void) // destructor
 {
   delete this->ptr_;
 }
 
-ACE_INLINE WStringSeq_var &
-WStringSeq_var::operator= (WStringSeq *p)
+ACE_INLINE CORBA_WStringSeq_var &
+CORBA_WStringSeq_var::operator= (CORBA_WStringSeq *p)
 {
   delete this->ptr_;
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE WStringSeq_var &
-WStringSeq_var::operator= (const ::WStringSeq_var &p) // deep copy
+ACE_INLINE CORBA_WStringSeq_var &
+CORBA_WStringSeq_var::operator= (const ::CORBA_WStringSeq_var &p) // deep copy
 {
   if (this != &p)
   {
     delete this->ptr_;
-    ACE_NEW_RETURN (this->ptr_, ::WStringSeq (*p.ptr_), *this);
+    ACE_NEW_RETURN (this->ptr_, ::CORBA_WStringSeq (*p.ptr_), *this);
   }
   return *this;
 }
 
-ACE_INLINE const ::WStringSeq *
-WStringSeq_var::operator-> (void) const
+ACE_INLINE const ::CORBA_WStringSeq *
+CORBA_WStringSeq_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE ::WStringSeq *
-WStringSeq_var::operator-> (void)
+ACE_INLINE ::CORBA_WStringSeq *
+CORBA_WStringSeq_var::operator-> (void)
 {
   return this->ptr_;
 }
 
 ACE_INLINE 
-WStringSeq_var::operator const ::WStringSeq &() const // cast
+CORBA_WStringSeq_var::operator const ::CORBA_WStringSeq &() const // cast
 {
   return *this->ptr_;
 }
 
 ACE_INLINE 
-WStringSeq_var::operator ::WStringSeq &() // cast 
+CORBA_WStringSeq_var::operator ::CORBA_WStringSeq &() // cast 
 {
   return *this->ptr_;
 }
 
 ACE_INLINE 
-WStringSeq_var::operator ::WStringSeq &() const // cast 
+CORBA_WStringSeq_var::operator ::CORBA_WStringSeq &() const // cast 
 {
   return *this->ptr_;
 }
 
 // variable-size types only
 ACE_INLINE
-WStringSeq_var::operator ::WStringSeq *&() // cast 
+CORBA_WStringSeq_var::operator ::CORBA_WStringSeq *&() // cast 
 {
   return this->ptr_;
 }
 
 ACE_INLINE TAO_SeqElem_WString_Manager
-WStringSeq_var::operator[] (CORBA::ULong index)
+CORBA_WStringSeq_var::operator[] (CORBA::ULong index)
 {
   return this->ptr_->operator[] (index);
 }
 
-ACE_INLINE const ::WStringSeq &
-WStringSeq_var::in (void) const
+ACE_INLINE const ::CORBA_WStringSeq &
+CORBA_WStringSeq_var::in (void) const
 {
   return *this->ptr_;
 }
 
-ACE_INLINE ::WStringSeq &
-WStringSeq_var::inout (void)
+ACE_INLINE ::CORBA_WStringSeq &
+CORBA_WStringSeq_var::inout (void)
 {
   return *this->ptr_;
 }
 
 // mapping for variable size 
-ACE_INLINE ::WStringSeq *&
-WStringSeq_var::out (void)
+ACE_INLINE ::CORBA_WStringSeq *&
+CORBA_WStringSeq_var::out (void)
 {
   delete this->ptr_;
   this->ptr_ = 0;
   return this->ptr_;
 }
 
-ACE_INLINE ::WStringSeq *
-WStringSeq_var::_retn (void)
+ACE_INLINE ::CORBA_WStringSeq *
+CORBA_WStringSeq_var::_retn (void)
 {
-  ::WStringSeq *tmp = this->ptr_;
+  ::CORBA_WStringSeq *tmp = this->ptr_;
   this->ptr_ = 0;
   return tmp;
 }
 
-ACE_INLINE ::WStringSeq *
-WStringSeq_var::ptr (void) const
+ACE_INLINE ::CORBA_WStringSeq *
+CORBA_WStringSeq_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 // *************************************************************
-// Inline operations for class WStringSeq_out
+// Inline operations for class CORBA_WStringSeq_out
 // *************************************************************
 
 ACE_INLINE
-WStringSeq_out::WStringSeq_out (WStringSeq *&p)
+CORBA_WStringSeq_out::CORBA_WStringSeq_out (CORBA_WStringSeq *&p)
   : ptr_ (p)
 {
   this->ptr_ = 0;
 }
 
 ACE_INLINE
-WStringSeq_out::WStringSeq_out (WStringSeq_var &p) // constructor from _var
+CORBA_WStringSeq_out::CORBA_WStringSeq_out (CORBA_WStringSeq_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   delete this->ptr_;
@@ -364,44 +364,44 @@
 }
 
 ACE_INLINE
-WStringSeq_out::WStringSeq_out (const ::WStringSeq_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (WStringSeq_out&, p).ptr_)
+CORBA_WStringSeq_out::CORBA_WStringSeq_out (const ::CORBA_WStringSeq_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (CORBA_WStringSeq_out&, p).ptr_)
 {}
 
-ACE_INLINE ::WStringSeq_out &
-WStringSeq_out::operator= (const ::WStringSeq_out &p)
+ACE_INLINE ::CORBA_WStringSeq_out &
+CORBA_WStringSeq_out::operator= (const ::CORBA_WStringSeq_out &p)
 {
-  this->ptr_ = ACE_const_cast (WStringSeq_out&, p).ptr_;
+  this->ptr_ = ACE_const_cast (CORBA_WStringSeq_out&, p).ptr_;
   return *this;
 }
 
-ACE_INLINE ::WStringSeq_out &
-WStringSeq_out::operator= (WStringSeq *p)
+ACE_INLINE ::CORBA_WStringSeq_out &
+CORBA_WStringSeq_out::operator= (CORBA_WStringSeq *p)
 {
   this->ptr_ = p;
   return *this;
 }
 
 ACE_INLINE 
-WStringSeq_out::operator ::WStringSeq *&() // cast
+CORBA_WStringSeq_out::operator ::CORBA_WStringSeq *&() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE ::WStringSeq *&
-WStringSeq_out::ptr (void) // ptr
+ACE_INLINE ::CORBA_WStringSeq *&
+CORBA_WStringSeq_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE ::WStringSeq *
-WStringSeq_out::operator-> (void)
+ACE_INLINE ::CORBA_WStringSeq *
+CORBA_WStringSeq_out::operator-> (void)
 {
   return this->ptr_;
 }
 
 ACE_INLINE TAO_SeqElem_WString_Manager
-WStringSeq_out::operator[] (CORBA::ULong index)
+CORBA_WStringSeq_out::operator[] (CORBA::ULong index)
 {
   return this->ptr_->operator[] (index);
 }
@@ -410,32 +410,32 @@
 #endif /* end #if !defined */
 
 
-#if !defined _TAO_CDR_OP_StringSeq_I_
-#define _TAO_CDR_OP_StringSeq_I_
+#if !defined _TAO_CDR_OP_CORBA_StringSeq_I_
+#define _TAO_CDR_OP_CORBA_StringSeq_I_
 
 CORBA::Boolean TAO_Export operator<< (
     TAO_OutputCDR &,
-    const StringSeq &
+    const CORBA_StringSeq &
   );
 CORBA::Boolean TAO_Export operator>> (
     TAO_InputCDR &,
-    StringSeq &
+    CORBA_StringSeq &
   );
 
-#endif /* _TAO_CDR_OP_StringSeq_I_ */
+#endif /* _TAO_CDR_OP_CORBA_StringSeq_I_ */
 
 
-#if !defined _TAO_CDR_OP_WStringSeq_I_
-#define _TAO_CDR_OP_WStringSeq_I_
+#if !defined _TAO_CDR_OP_CORBA_WStringSeq_I_
+#define _TAO_CDR_OP_CORBA_WStringSeq_I_
 
 CORBA::Boolean TAO_Export operator<< (
     TAO_OutputCDR &,
-    const WStringSeq &
+    const CORBA_WStringSeq &
   );
 CORBA::Boolean TAO_Export operator>> (
     TAO_InputCDR &,
-    WStringSeq &
+    CORBA_WStringSeq &
   );
 
-#endif /* _TAO_CDR_OP_WStringSeq_I_ */
+#endif /* _TAO_CDR_OP_CORBA_WStringSeq_I_ */
 
--- StringSeqC.cpp.old	Sun Oct 22 22:31:13 2000
+++ StringSeqC.cpp	Sun Oct 22 22:31:52 2000
@@ -25,17 +25,18 @@
 #include "StringSeqC.i"
 #endif /* !defined INLINE */
 
+#include "tao/Any.h"
 
 #if !defined (_STRINGSEQ_CS_)
 #define _STRINGSEQ_CS_
 
 // *************************************************************
-// StringSeq
+// CORBA_StringSeq
 // *************************************************************
 
-StringSeq::StringSeq (void)
+CORBA_StringSeq::CORBA_StringSeq (void)
 {}
-StringSeq::StringSeq (CORBA::ULong max) // uses max size
+CORBA_StringSeq::CORBA_StringSeq (CORBA::ULong max) // uses max size
   : 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
   TAO_Unbounded_String_Sequence
@@ -44,7 +45,7 @@
 #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
  (max)
 {}
-StringSeq::StringSeq (CORBA::ULong max, CORBA::ULong length, char * *buffer, CORBA::Boolean release)
+CORBA_StringSeq::CORBA_StringSeq (CORBA::ULong max, CORBA::ULong length, char * *buffer, CORBA::Boolean release)
   : 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
   TAO_Unbounded_String_Sequence
@@ -53,7 +54,7 @@
 #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
  (max, length, buffer, release)
 {}
-StringSeq::StringSeq (const StringSeq &seq) // copy ctor
+CORBA_StringSeq::CORBA_StringSeq (const CORBA_StringSeq &seq) // copy ctor
   : 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
   TAO_Unbounded_String_Sequence
@@ -62,22 +63,22 @@
 #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
  (seq)
 {}
-StringSeq::~StringSeq (void) // dtor
+CORBA_StringSeq::~CORBA_StringSeq (void) // dtor
 {}
-void StringSeq::_tao_any_destructor (void *x)
+void CORBA_StringSeq::_tao_any_destructor (void *x)
 {
-  StringSeq *tmp = ACE_static_cast (StringSeq*,x);
+  CORBA_StringSeq *tmp = ACE_static_cast (CORBA_StringSeq*,x);
   delete tmp;
 }
 
 
 #endif /* end #if !defined */
 
-static const CORBA::Long _oc_StringSeq[] =
+static const CORBA::Long _oc_CORBA_StringSeq[] =
 {
   TAO_ENCAP_BYTE_ORDER, // byte order
-  18, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x53747269), ACE_NTOHL (0x6e675365), ACE_NTOHL (0x713a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:StringSeq:1.0
-  10, ACE_NTOHL (0x53747269), ACE_NTOHL (0x6e675365), ACE_NTOHL (0x71000000),  // name = StringSeq
+  18, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x53747269), ACE_NTOHL (0x6e675365), ACE_NTOHL (0x713a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:CORBA_StringSeq:1.0
+  10, ACE_NTOHL (0x53747269), ACE_NTOHL (0x6e675365), ACE_NTOHL (0x71000000),  // name = CORBA_StringSeq
   CORBA::tk_sequence, // typecode kind
   16, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
@@ -86,20 +87,20 @@
     0U,
 
 };
-static CORBA::TypeCode _tc_TAO_tc_StringSeq (CORBA::tk_alias, sizeof (_oc_StringSeq), (char *) &_oc_StringSeq, 0, sizeof (StringSeq));
-CORBA::TypeCode_ptr _tc_StringSeq = &_tc_TAO_tc_StringSeq;
+static CORBA::TypeCode _tc_TAO_tc_CORBA_StringSeq (CORBA::tk_alias, sizeof (_oc_CORBA_StringSeq), (char *) &_oc_CORBA_StringSeq, 0, sizeof (CORBA_StringSeq));
+CORBA::TypeCode_ptr _tc_CORBA_StringSeq = &_tc_TAO_tc_CORBA_StringSeq;
 
 
 #if !defined (_WSTRINGSEQ_CS_)
 #define _WSTRINGSEQ_CS_
 
 // *************************************************************
-// WStringSeq
+// CORBA_WStringSeq
 // *************************************************************
 
-WStringSeq::WStringSeq (void)
+CORBA_WStringSeq::CORBA_WStringSeq (void)
 {}
-WStringSeq::WStringSeq (CORBA::ULong max) // uses max size
+CORBA_WStringSeq::CORBA_WStringSeq (CORBA::ULong max) // uses max size
   : 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
   TAO_Unbounded_WString_Sequence
@@ -108,7 +109,7 @@
 #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
  (max)
 {}
-WStringSeq::WStringSeq (CORBA::ULong max, CORBA::ULong length, CORBA::WChar * *buffer, CORBA::Boolean release)
+CORBA_WStringSeq::CORBA_WStringSeq (CORBA::ULong max, CORBA::ULong length, CORBA::WChar * *buffer, CORBA::Boolean release)
   : 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
   TAO_Unbounded_WString_Sequence
@@ -117,7 +118,7 @@
 #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
  (max, length, buffer, release)
 {}
-WStringSeq::WStringSeq (const WStringSeq &seq) // copy ctor
+CORBA_WStringSeq::CORBA_WStringSeq (const CORBA_WStringSeq &seq) // copy ctor
   : 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
   TAO_Unbounded_WString_Sequence
@@ -126,22 +127,22 @@
 #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
  (seq)
 {}
-WStringSeq::~WStringSeq (void) // dtor
+CORBA_WStringSeq::~CORBA_WStringSeq (void) // dtor
 {}
-void WStringSeq::_tao_any_destructor (void *x)
+void CORBA_WStringSeq::_tao_any_destructor (void *x)
 {
-  WStringSeq *tmp = ACE_static_cast (WStringSeq*,x);
+  CORBA_WStringSeq *tmp = ACE_static_cast (CORBA_WStringSeq*,x);
   delete tmp;
 }
 
 
 #endif /* end #if !defined */
 
-static const CORBA::Long _oc_WStringSeq[] =
+static const CORBA::Long _oc_CORBA_WStringSeq[] =
 {
   TAO_ENCAP_BYTE_ORDER, // byte order
-  19, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x57537472), ACE_NTOHL (0x696e6753), ACE_NTOHL (0x65713a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:WStringSeq:1.0
-  11, ACE_NTOHL (0x57537472), ACE_NTOHL (0x696e6753), ACE_NTOHL (0x65710000),  // name = WStringSeq
+  19, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x57537472), ACE_NTOHL (0x696e6753), ACE_NTOHL (0x65713a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:CORBA_WStringSeq:1.0
+  11, ACE_NTOHL (0x57537472), ACE_NTOHL (0x696e6753), ACE_NTOHL (0x65710000),  // name = CORBA_WStringSeq
   CORBA::tk_sequence, // typecode kind
   16, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
@@ -150,54 +151,54 @@
     0U,
 
 };
-static CORBA::TypeCode _tc_TAO_tc_WStringSeq (CORBA::tk_alias, sizeof (_oc_WStringSeq), (char *) &_oc_WStringSeq, 0, sizeof (WStringSeq));
-CORBA::TypeCode_ptr _tc_WStringSeq = &_tc_TAO_tc_WStringSeq;
+static CORBA::TypeCode _tc_TAO_tc_CORBA_WStringSeq (CORBA::tk_alias, sizeof (_oc_CORBA_WStringSeq), (char *) &_oc_CORBA_WStringSeq, 0, sizeof (CORBA_WStringSeq));
+CORBA::TypeCode_ptr _tc_CORBA_WStringSeq = &_tc_TAO_tc_CORBA_WStringSeq;
 
 void operator<<= (
     CORBA::Any &_tao_any,
-    const StringSeq &_tao_elem
+    const CORBA_StringSeq &_tao_elem
   ) // copying
 {
   TAO_OutputCDR stream;
   if (stream << _tao_elem)
   {
     _tao_any._tao_replace (
-        _tc_StringSeq,
+        _tc_CORBA_StringSeq,
         TAO_ENCAP_BYTE_ORDER,
         stream.begin ()
       );
   }
 }
 
-void operator<<= (CORBA::Any &_tao_any, StringSeq *_tao_elem) // non copying
+void operator<<= (CORBA::Any &_tao_any, CORBA_StringSeq *_tao_elem) // non copying
 {
   TAO_OutputCDR stream;
   stream << *_tao_elem;
   _tao_any._tao_replace (
-      _tc_StringSeq,
+      _tc_CORBA_StringSeq,
       TAO_ENCAP_BYTE_ORDER,
       stream.begin (),
       1,
       _tao_elem,
-      StringSeq::_tao_any_destructor
+      CORBA_StringSeq::_tao_any_destructor
     );
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, StringSeq *&_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_StringSeq *&_tao_elem)
 {
   return _tao_any >>= ACE_const_cast(
-      const StringSeq*&,
+      const CORBA_StringSeq*&,
       _tao_elem
     );
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const StringSeq *&_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA_StringSeq *&_tao_elem)
 {
   _tao_elem = 0;
   ACE_TRY_NEW_ENV
   {
     CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (_tc_StringSeq, ACE_TRY_ENV)) // not equal
+    if (!type->equivalent (_tc_CORBA_StringSeq, ACE_TRY_ENV)) // not equal
       {
         return 0;
       }
@@ -205,15 +206,15 @@
     if (_tao_any.any_owns_data ())
     {
       _tao_elem = ACE_static_cast(
-          const StringSeq*,
+          const CORBA_StringSeq*,
           _tao_any.value ()
         );
       return 1;
     }
     else
     {
-      StringSeq *tmp;
-      ACE_NEW_RETURN (tmp, StringSeq, 0);
+      CORBA_StringSeq *tmp;
+      ACE_NEW_RETURN (tmp, CORBA_StringSeq, 0);
       TAO_InputCDR stream (
           _tao_any._tao_get_cdr (),
           _tao_any._tao_byte_order ()
@@ -221,10 +222,10 @@
       if (stream >> *tmp)
       {
         ((CORBA::Any *)&_tao_any)->_tao_replace (
-            _tc_StringSeq,
+            _tc_CORBA_StringSeq,
             1,
             ACE_static_cast (void *, tmp),
-            StringSeq::_tao_any_destructor
+            CORBA_StringSeq::_tao_any_destructor
           );
         _tao_elem = tmp;
         return 1;
@@ -244,49 +245,49 @@
 
 void operator<<= (
     CORBA::Any &_tao_any,
-    const WStringSeq &_tao_elem
+    const CORBA_WStringSeq &_tao_elem
   ) // copying
 {
   TAO_OutputCDR stream;
   if (stream << _tao_elem)
   {
     _tao_any._tao_replace (
-        _tc_WStringSeq,
+        _tc_CORBA_WStringSeq,
         TAO_ENCAP_BYTE_ORDER,
         stream.begin ()
       );
   }
 }
 
-void operator<<= (CORBA::Any &_tao_any, WStringSeq *_tao_elem) // non copying
+void operator<<= (CORBA::Any &_tao_any, CORBA_WStringSeq *_tao_elem) // non copying
 {
   TAO_OutputCDR stream;
   stream << *_tao_elem;
   _tao_any._tao_replace (
-      _tc_WStringSeq,
+      _tc_CORBA_WStringSeq,
       TAO_ENCAP_BYTE_ORDER,
       stream.begin (),
       1,
       _tao_elem,
-      WStringSeq::_tao_any_destructor
+      CORBA_WStringSeq::_tao_any_destructor
     );
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, WStringSeq *&_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_WStringSeq *&_tao_elem)
 {
   return _tao_any >>= ACE_const_cast(
-      const WStringSeq*&,
+      const CORBA_WStringSeq*&,
       _tao_elem
     );
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const WStringSeq *&_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA_WStringSeq *&_tao_elem)
 {
   _tao_elem = 0;
   ACE_TRY_NEW_ENV
   {
     CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (_tc_WStringSeq, ACE_TRY_ENV)) // not equal
+    if (!type->equivalent (_tc_CORBA_WStringSeq, ACE_TRY_ENV)) // not equal
       {
         return 0;
       }
@@ -294,15 +295,15 @@
     if (_tao_any.any_owns_data ())
     {
       _tao_elem = ACE_static_cast(
-          const WStringSeq*,
+          const CORBA_WStringSeq*,
           _tao_any.value ()
         );
       return 1;
     }
     else
     {
-      WStringSeq *tmp;
-      ACE_NEW_RETURN (tmp, WStringSeq, 0);
+      CORBA_WStringSeq *tmp;
+      ACE_NEW_RETURN (tmp, CORBA_WStringSeq, 0);
       TAO_InputCDR stream (
           _tao_any._tao_get_cdr (),
           _tao_any._tao_byte_order ()
@@ -310,10 +311,10 @@
       if (stream >> *tmp)
       {
         ((CORBA::Any *)&_tao_any)->_tao_replace (
-            _tc_WStringSeq,
+            _tc_CORBA_WStringSeq,
             1,
             ACE_static_cast (void *, tmp),
-            WStringSeq::_tao_any_destructor
+            CORBA_WStringSeq::_tao_any_destructor
           );
         _tao_elem = tmp;
         return 1;
@@ -333,7 +334,7 @@
 
 CORBA::Boolean operator<< (
     TAO_OutputCDR &strm,
-    const StringSeq &_tao_sequence
+    const CORBA_StringSeq &_tao_sequence
   )
 {
   if (strm << _tao_sequence.length ())
@@ -351,7 +352,7 @@
 
 CORBA::Boolean operator>> (
     TAO_InputCDR &strm,
-    StringSeq &_tao_sequence
+    CORBA_StringSeq &_tao_sequence
   )
 {
   CORBA::ULong _tao_seq_len;
@@ -375,7 +376,7 @@
 
 CORBA::Boolean operator<< (
     TAO_OutputCDR &strm,
-    const WStringSeq &_tao_sequence
+    const CORBA_WStringSeq &_tao_sequence
   )
 {
   if (strm << _tao_sequence.length ())
@@ -393,7 +394,7 @@
 
 CORBA::Boolean operator>> (
     TAO_InputCDR &strm,
-    WStringSeq &_tao_sequence
+    CORBA_WStringSeq &_tao_sequence
   )
 {
   CORBA::ULong _tao_seq_len;