stringseq.diff

来自「这是广泛使用的通信开源项目,对于大容量,高并发的通讯要求完全能够胜任,他广泛可用」· DIFF 代码 · 共 1,229 行 · 第 1/3 页

--- StringSeqC.h.old	Fri Mar  2 23:51:36 2001
+++ StringSeqC.h	Sat Mar  3 11:28:11 2001
@@ -19,17 +19,18 @@
 // Information about TAO is available at:
 //     http://www.cs.wustl.edu/~schmidt/TAO.html
 
-#ifndef _TAO_IDL_STRINGSEQC_H_
-#define _TAO_IDL_STRINGSEQC_H_
+#ifndef _TAO_IDL_CORBA_STRINGSEQC_H_
+#define _TAO_IDL_CORBA_STRINGSEQC_H_
 
 #include "ace/pre.h"
-#include "tao/corba.h"
+
+#include "corbafwd.h"
 
 #if !defined (ACE_LACKS_PRAGMA_ONCE)
 # pragma once
 #endif /* ACE_LACKS_PRAGMA_ONCE */
 
-#include "corbafwd.h"
+#include "Sequence.h"
 
 #if defined (TAO_EXPORT_MACRO)
 #undef TAO_EXPORT_MACRO
@@ -54,20 +55,17 @@
 #pragma option push -w-rvl -w-rch -w-ccc -w-inl
 #endif /* __BORLANDC__ */
 
-TAO_NAMESPACE  CORBA
-{
-
 #if !defined (_CORBA_STRINGSEQ_CH_)
 #define _CORBA_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 */
@@ -75,20 +73,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 */
 
   };
@@ -103,35 +101,35 @@
   // 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_;
   };
 
 
@@ -141,42 +139,39 @@
 #if !defined (_CORBA_STRINGSEQ___OUT_CH_)
 #define _CORBA_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 */
 
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_StringSeq;
-
-
 #if !defined (_CORBA_WSTRINGSEQ_CH_)
 #define _CORBA_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 */
@@ -184,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 */
 
   };
@@ -209,38 +204,38 @@
 #define _CORBA_WSTRINGSEQ___VAR_CH_
 
   // *************************************************************
-  // class CORBA::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_;
   };
 
 
@@ -250,44 +245,38 @@
 #if !defined (_CORBA_WSTRINGSEQ___OUT_CH_)
 #define _CORBA_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 */
 
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_WStringSeq;
-
-
-}
-TAO_NAMESPACE_CLOSE // module CORBA
-
 // Proxy Broker Factory function pointer declarations.
 
-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 *&);
+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__
 
@@ -297,11 +286,11 @@
 
 TAO_Export CORBA::Boolean operator<< (
     TAO_OutputCDR &,
-    const CORBA::StringSeq &
+    const CORBA_StringSeq &
   );
 TAO_Export CORBA::Boolean operator>> (
     TAO_InputCDR &,
-    CORBA::StringSeq &
+    CORBA_StringSeq &
   );
 
 #endif /* _TAO_CDR_OP_CORBA_StringSeq_H_ */
@@ -312,11 +301,11 @@
 
 TAO_Export CORBA::Boolean operator<< (
     TAO_OutputCDR &,
-    const CORBA::WStringSeq &
+    const CORBA_WStringSeq &
   );
 TAO_Export CORBA::Boolean operator>> (
     TAO_InputCDR &,
-    CORBA::WStringSeq &
+    CORBA_WStringSeq &
   );
 
 #endif /* _TAO_CDR_OP_CORBA_WStringSeq_H_ */
--- StringSeqC.i.old	Fri Mar  2 23:51:36 2001
+++ StringSeqC.i	Sat Mar  3 11:28:19 2001
@@ -28,40 +28,40 @@
 // *************************************************************
 
 ACE_INLINE
-CORBA::StringSeq_var::StringSeq_var (void) // default constructor
+CORBA_StringSeq_var::CORBA_StringSeq_var (void) // default constructor
   : ptr_ (0)
 {}
 
 ACE_INLINE
-CORBA::StringSeq_var::StringSeq_var (StringSeq *p)
+CORBA_StringSeq_var::CORBA_StringSeq_var (CORBA_StringSeq *p)
   : ptr_ (p)
 {}
 
 ACE_INLINE
-CORBA::StringSeq_var::StringSeq_var (const ::CORBA::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_, ::CORBA::StringSeq (*p.ptr_));
+    ACE_NEW (this->ptr_, ::CORBA_StringSeq (*p.ptr_));
   else
     this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA::StringSeq_var::~StringSeq_var (void) // destructor
+CORBA_StringSeq_var::~CORBA_StringSeq_var (void) // destructor
 {
   delete this->ptr_;
 }
 
-ACE_INLINE CORBA::StringSeq_var &
-CORBA::StringSeq_var::operator= (StringSeq *p)
+ACE_INLINE CORBA_StringSeq_var &
+CORBA_StringSeq_var::operator= (CORBA_StringSeq *p)
 {
   delete this->ptr_;
   this->ptr_ = p;