stringseq.diff

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

 {
   this->ptr_ = p;
   return *this;
 }
 
 ACE_INLINE 
-CORBA::WStringSeq_out::operator ::CORBA::WStringSeq *&() // cast
+CORBA_WStringSeq_out::operator ::CORBA_WStringSeq *&() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE ::CORBA::WStringSeq *&
-CORBA::WStringSeq_out::ptr (void) // ptr
+ACE_INLINE ::CORBA_WStringSeq *&
+CORBA_WStringSeq_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE ::CORBA::WStringSeq *
-CORBA::WStringSeq_out::operator-> (void)
+ACE_INLINE ::CORBA_WStringSeq *
+CORBA_WStringSeq_out::operator-> (void)
 {
   return this->ptr_;
 }
 
 ACE_INLINE TAO_SeqElem_WString_Manager
-CORBA::WStringSeq_out::operator[] (CORBA::ULong index)
+CORBA_WStringSeq_out::operator[] (CORBA::ULong index)
 {
   return this->ptr_->operator[] (index);
 }
@@ -464,11 +464,11 @@
 
 CORBA::Boolean TAO_Export operator<< (
     TAO_OutputCDR &,
-    const CORBA::WStringSeq &
+    const CORBA_WStringSeq &
   );
 CORBA::Boolean TAO_Export operator>> (
     TAO_InputCDR &,
-    CORBA::WStringSeq &
+    CORBA_WStringSeq &
   );
 
 #endif /* _TAO_CDR_OP_CORBA_WStringSeq_I_ */
--- StringSeqC.cpp.old	Fri Mar  2 23:51:36 2001
+++ StringSeqC.cpp	Sat Mar  3 11:28:29 2001
@@ -21,10 +21,6 @@
 
 #include "StringSeqC.h"
 
-#if TAO_HAS_INTERCEPTORS == 1
-#include "tao/RequestInfo_Util.h"
-#endif  /* TAO_HAS_INTERCEPTORS == 1 */
-
 #if defined (__BORLANDC__)
 #pragma option -w-rvl -w-rch -w-ccc -w-aus
 #endif /* __BORLANDC__ */
@@ -33,6 +29,9 @@
 #include "StringSeqC.i"
 #endif /* !defined INLINE */
 
+#include "Any.h"
+#include "CDR.h"
+#include "Typecode.h"
 
 #if !defined (_CORBA_STRINGSEQ_CS_)
 #define _CORBA_STRINGSEQ_CS_
@@ -41,40 +40,40 @@
 // CORBA::StringSeq
 // *************************************************************
 
-CORBA::StringSeq::StringSeq (void)
+CORBA_StringSeq::CORBA_StringSeq (void)
 {}
-CORBA::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
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
   TAO_Unbounded_String_Sequence
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
  (max)
 {}
-CORBA::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
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
   TAO_Unbounded_String_Sequence
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
  (max, length, buffer, release)
 {}
-CORBA::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
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
   TAO_Unbounded_String_Sequence
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
  (seq)
 {}
-CORBA::StringSeq::~StringSeq (void) // dtor
+CORBA_StringSeq::~CORBA_StringSeq (void) // dtor
 {}
-void CORBA::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;
 }
 
@@ -89,12 +88,12 @@
   CORBA::tk_sequence, // typecode kind
   16, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
-    CORBA::tk_string, 
+    CORBA::tk_string,
     0U, // string length
     0U,
 
 };
-static CORBA::TypeCode _tc_TAO_tc_CORBA_StringSeq (CORBA::tk_alias, sizeof (_oc_CORBA_StringSeq), (char *) &_oc_CORBA_StringSeq, 0, sizeof (CORBA::StringSeq));
+static CORBA::TypeCode _tc_TAO_tc_CORBA_StringSeq (CORBA::tk_alias, sizeof (_oc_CORBA_StringSeq), (char *) &_oc_CORBA_StringSeq, 0, sizeof (CORBA_StringSeq));
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
 TAO_NAMESPACE_BEGIN (CORBA)
 TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_StringSeq, &_tc_TAO_tc_CORBA_StringSeq)
@@ -107,40 +106,40 @@
 // CORBA::WStringSeq
 // *************************************************************
 
-CORBA::WStringSeq::WStringSeq (void)
+CORBA_WStringSeq::CORBA_WStringSeq (void)
 {}
-CORBA::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
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
   TAO_Unbounded_WString_Sequence
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
  (max)
 {}
-CORBA::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
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
   TAO_Unbounded_WString_Sequence
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
  (max, length, buffer, release)
 {}
-CORBA::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
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
   TAO_Unbounded_WString_Sequence
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
  (seq)
 {}
-CORBA::WStringSeq::~WStringSeq (void) // dtor
+CORBA_WStringSeq::~CORBA_WStringSeq (void) // dtor
 {}
-void CORBA::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;
 }
 
@@ -155,19 +154,20 @@
   CORBA::tk_sequence, // typecode kind
   16, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
-    CORBA::tk_wstring, 
+    CORBA::tk_wstring,
     0U, // string length
     0U,
 
 };
-static CORBA::TypeCode _tc_TAO_tc_CORBA_WStringSeq (CORBA::tk_alias, sizeof (_oc_CORBA_WStringSeq), (char *) &_oc_CORBA_WStringSeq, 0, sizeof (CORBA::WStringSeq));
+static CORBA::TypeCode _tc_TAO_tc_CORBA_WStringSeq (CORBA::tk_alias, sizeof (_oc_CORBA_WStringSeq), (char *) &_oc_CORBA_WStringSeq, 0, sizeof (CORBA_WStringSeq));
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
 TAO_NAMESPACE_BEGIN (CORBA)
 TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_WStringSeq, &_tc_TAO_tc_CORBA_WStringSeq)
 TAO_NAMESPACE_END
+
 void operator<<= (
     CORBA::Any &_tao_any,
-    const CORBA::StringSeq &_tao_elem
+    const CORBA_StringSeq &_tao_elem
   ) // copying
 {
   TAO_OutputCDR stream;
@@ -181,7 +181,7 @@
   }
 }
 
-void operator<<= (CORBA::Any &_tao_any, CORBA::StringSeq *_tao_elem) // non copying
+void operator<<= (CORBA::Any &_tao_any, CORBA_StringSeq *_tao_elem) // non copying
 {
   TAO_OutputCDR stream;
   stream << *_tao_elem;
@@ -191,19 +191,19 @@
       stream.begin (),
       1,
       _tao_elem,
-      CORBA::StringSeq::_tao_any_destructor
+      CORBA_StringSeq::_tao_any_destructor
     );
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::StringSeq *&_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_StringSeq *&_tao_elem)
 {
   return _tao_any >>= ACE_const_cast(
-      const CORBA::StringSeq*&,
+      const CORBA_StringSeq*&,
       _tao_elem
     );
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::StringSeq *&_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA_StringSeq *&_tao_elem)
 {
   _tao_elem = 0;
   ACE_TRY_NEW_ENV
@@ -217,15 +217,15 @@
     if (_tao_any.any_owns_data ())
     {
       _tao_elem = ACE_static_cast(
-          const CORBA::StringSeq*,
+          const CORBA_StringSeq*,
           _tao_any.value ()
         );
       return 1;
     }
     else
     {
-      CORBA::StringSeq *tmp;
-      ACE_NEW_RETURN (tmp, CORBA::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 ()
@@ -236,7 +236,7 @@
             CORBA::_tc_StringSeq,
             1,
             ACE_static_cast (void *, tmp),
-            CORBA::StringSeq::_tao_any_destructor
+            CORBA_StringSeq::_tao_any_destructor
           );
         _tao_elem = tmp;
         return 1;
@@ -256,7 +256,7 @@
 
 void operator<<= (
     CORBA::Any &_tao_any,
-    const CORBA::WStringSeq &_tao_elem
+    const CORBA_WStringSeq &_tao_elem
   ) // copying
 {
   TAO_OutputCDR stream;
@@ -270,7 +270,7 @@
   }
 }
 
-void operator<<= (CORBA::Any &_tao_any, CORBA::WStringSeq *_tao_elem) // non copying
+void operator<<= (CORBA::Any &_tao_any, CORBA_WStringSeq *_tao_elem) // non copying
 {
   TAO_OutputCDR stream;
   stream << *_tao_elem;
@@ -280,19 +280,19 @@
       stream.begin (),
       1,
       _tao_elem,
-      CORBA::WStringSeq::_tao_any_destructor
+      CORBA_WStringSeq::_tao_any_destructor
     );
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::WStringSeq *&_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_WStringSeq *&_tao_elem)
 {
   return _tao_any >>= ACE_const_cast(
-      const CORBA::WStringSeq*&,
+      const CORBA_WStringSeq*&,
       _tao_elem
     );
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::WStringSeq *&_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA_WStringSeq *&_tao_elem)
 {
   _tao_elem = 0;
   ACE_TRY_NEW_ENV
@@ -306,15 +306,15 @@
     if (_tao_any.any_owns_data ())
     {
       _tao_elem = ACE_static_cast(
-          const CORBA::WStringSeq*,
+          const CORBA_WStringSeq*,
           _tao_any.value ()
         );
       return 1;
     }
     else
     {
-      CORBA::WStringSeq *tmp;
-      ACE_NEW_RETURN (tmp, CORBA::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 ()
@@ -325,7 +325,7 @@
             CORBA::_tc_WStringSeq,
             1,
             ACE_static_cast (void *, tmp),
-            CORBA::WStringSeq::_tao_any_destructor
+            CORBA_WStringSeq::_tao_any_destructor
           );
         _tao_elem = tmp;
         return 1;
@@ -345,7 +345,7 @@
 
 CORBA::Boolean operator<< (
     TAO_OutputCDR &strm,
-    const CORBA::StringSeq &_tao_sequence
+    const CORBA_StringSeq &_tao_sequence
   )
 {
   if (strm << _tao_sequence.length ())
@@ -363,7 +363,7 @@
 
 CORBA::Boolean operator>> (
     TAO_InputCDR &strm,
-    CORBA::StringSeq &_tao_sequence
+    CORBA_StringSeq &_tao_sequence
   )
 {
   CORBA::ULong _tao_seq_len;
@@ -372,7 +372,7 @@
     // set the length of the sequence
     _tao_sequence.length (_tao_seq_len);
     // If length is 0 we return true.
-    if (0 >= _tao_seq_len) 
+    if (0 >= _tao_seq_len)
       return 1;
     // retrieve all the elements
     CORBA::Boolean _tao_marshal_flag = 1;
@@ -387,7 +387,7 @@
 
 CORBA::Boolean operator<< (
     TAO_OutputCDR &strm,
-    const CORBA::WStringSeq &_tao_sequence
+    const CORBA_WStringSeq &_tao_sequence
   )
 {
   if (strm << _tao_sequence.length ())
@@ -405,7 +405,7 @@
 
 CORBA::Boolean operator>> (
     TAO_InputCDR &strm,
-    CORBA::WStringSeq &_tao_sequence
+    CORBA_WStringSeq &_tao_sequence
   )
 {
   CORBA::ULong _tao_seq_len;
@@ -414,7 +414,7 @@
     // set the length of the sequence
     _tao_sequence.length (_tao_seq_len);
     // If length is 0 we return true.
-    if (0 >= _tao_seq_len) 
+    if (0 >= _tao_seq_len)
       return 1;
     // retrieve all the elements
     CORBA::Boolean _tao_marshal_flag = 1;
@@ -426,4 +426,3 @@
   }
   return 0; // error
 }
-