stringseq.diff

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

   return *this;
 }
 
-ACE_INLINE ::CORBA::StringSeq_var &
-CORBA::StringSeq_var::operator= (const ::CORBA::StringSeq_var &p)
+ACE_INLINE ::CORBA_StringSeq_var &
+CORBA_StringSeq_var::operator= (const ::CORBA_StringSeq_var &p)
 {
   if (this != &p)
     {
@@ -72,12 +72,12 @@
         }
       else
         {
-          StringSeq *deep_copy =
-            new StringSeq (*p.ptr_);
+          CORBA_StringSeq *deep_copy =
+            new CORBA_StringSeq (*p.ptr_);
           
           if (deep_copy != 0)
             {
-              StringSeq *tmp = deep_copy;
+              CORBA_StringSeq *tmp = deep_copy;
               deep_copy = this->ptr_;
               this->ptr_ = tmp;
               delete deep_copy;
@@ -88,80 +88,80 @@
   return *this;
 }
 
-ACE_INLINE const ::CORBA::StringSeq *
-CORBA::StringSeq_var::operator-> (void) const
+ACE_INLINE const ::CORBA_StringSeq *
+CORBA_StringSeq_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE ::CORBA::StringSeq *
-CORBA::StringSeq_var::operator-> (void)
+ACE_INLINE ::CORBA_StringSeq *
+CORBA_StringSeq_var::operator-> (void)
 {
   return this->ptr_;
 }
 
 ACE_INLINE 
-CORBA::StringSeq_var::operator const ::CORBA::StringSeq &() const // cast
+CORBA_StringSeq_var::operator const ::CORBA_StringSeq &() const // cast
 {
   return *this->ptr_;
 }
 
 ACE_INLINE 
-CORBA::StringSeq_var::operator ::CORBA::StringSeq &() // cast 
+CORBA_StringSeq_var::operator ::CORBA_StringSeq &() // cast 
 {
   return *this->ptr_;
 }
 
 ACE_INLINE 
-CORBA::StringSeq_var::operator ::CORBA::StringSeq &() const // cast 
+CORBA_StringSeq_var::operator ::CORBA_StringSeq &() const // cast 
 {
   return *this->ptr_;
 }
 
 // variable-size types only
 ACE_INLINE
-CORBA::StringSeq_var::operator ::CORBA::StringSeq *&() // cast 
+CORBA_StringSeq_var::operator ::CORBA_StringSeq *&() // cast 
 {
   return this->ptr_;
 }
 
 ACE_INLINE TAO_SeqElem_String_Manager
-CORBA::StringSeq_var::operator[] (CORBA::ULong index)
+CORBA_StringSeq_var::operator[] (CORBA::ULong index)
 {
   return this->ptr_->operator[] (index);
 }
 
-ACE_INLINE const ::CORBA::StringSeq &
-CORBA::StringSeq_var::in (void) const
+ACE_INLINE const ::CORBA_StringSeq &
+CORBA_StringSeq_var::in (void) const
 {
   return *this->ptr_;
 }
 
-ACE_INLINE ::CORBA::StringSeq &
-CORBA::StringSeq_var::inout (void)
+ACE_INLINE ::CORBA_StringSeq &
+CORBA_StringSeq_var::inout (void)
 {
   return *this->ptr_;
 }
 
 // mapping for variable size 
-ACE_INLINE ::CORBA::StringSeq *&
-CORBA::StringSeq_var::out (void)
+ACE_INLINE ::CORBA_StringSeq *&
+CORBA_StringSeq_var::out (void)
 {
   delete this->ptr_;
   this->ptr_ = 0;
   return this->ptr_;
 }
 
-ACE_INLINE ::CORBA::StringSeq *
-CORBA::StringSeq_var::_retn (void)
+ACE_INLINE ::CORBA_StringSeq *
+CORBA_StringSeq_var::_retn (void)
 {
-  ::CORBA::StringSeq *tmp = this->ptr_;
+  ::CORBA_StringSeq *tmp = this->ptr_;
   this->ptr_ = 0;
   return tmp;
 }
 
-ACE_INLINE ::CORBA::StringSeq *
-CORBA::StringSeq_var::ptr (void) const
+ACE_INLINE ::CORBA_StringSeq *
+CORBA_StringSeq_var::ptr (void) const
 {
   return this->ptr_;
 }
@@ -171,14 +171,14 @@
 // *************************************************************
 
 ACE_INLINE
-CORBA::StringSeq_out::StringSeq_out (StringSeq *&p)
+CORBA_StringSeq_out::CORBA_StringSeq_out (CORBA_StringSeq *&p)
   : ptr_ (p)
 {
   this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA::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_;
@@ -186,44 +186,44 @@
 }
 
 ACE_INLINE
-CORBA::StringSeq_out::StringSeq_out (const ::CORBA::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 ::CORBA::StringSeq_out &
-CORBA::StringSeq_out::operator= (const ::CORBA::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 ::CORBA::StringSeq_out &
-CORBA::StringSeq_out::operator= (StringSeq *p)
+ACE_INLINE ::CORBA_StringSeq_out &
+CORBA_StringSeq_out::operator= (CORBA_StringSeq *p)
 {
   this->ptr_ = p;
   return *this;
 }
 
 ACE_INLINE 
-CORBA::StringSeq_out::operator ::CORBA::StringSeq *&() // cast
+CORBA_StringSeq_out::operator ::CORBA_StringSeq *&() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE ::CORBA::StringSeq *&
-CORBA::StringSeq_out::ptr (void) // ptr
+ACE_INLINE ::CORBA_StringSeq *&
+CORBA_StringSeq_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE ::CORBA::StringSeq *
-CORBA::StringSeq_out::operator-> (void)
+ACE_INLINE ::CORBA_StringSeq *
+CORBA_StringSeq_out::operator-> (void)
 {
   return this->ptr_;
 }
 
 ACE_INLINE TAO_SeqElem_String_Manager
-CORBA::StringSeq_out::operator[] (CORBA::ULong index)
+CORBA_StringSeq_out::operator[] (CORBA::ULong index)
 {
   return this->ptr_->operator[] (index);
 }
@@ -240,40 +240,40 @@
 // *************************************************************
 
 ACE_INLINE
-CORBA::WStringSeq_var::WStringSeq_var (void) // default constructor
+CORBA_WStringSeq_var::CORBA_WStringSeq_var (void) // default constructor
   : ptr_ (0)
 {}
 
 ACE_INLINE
-CORBA::WStringSeq_var::WStringSeq_var (WStringSeq *p)
+CORBA_WStringSeq_var::CORBA_WStringSeq_var (CORBA_WStringSeq *p)
   : ptr_ (p)
 {}
 
 ACE_INLINE
-CORBA::WStringSeq_var::WStringSeq_var (const ::CORBA::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_, ::CORBA::WStringSeq (*p.ptr_));
+    ACE_NEW (this->ptr_, ::CORBA_WStringSeq (*p.ptr_));
   else
     this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA::WStringSeq_var::~WStringSeq_var (void) // destructor
+CORBA_WStringSeq_var::~CORBA_WStringSeq_var (void) // destructor
 {
   delete this->ptr_;
 }
 
-ACE_INLINE CORBA::WStringSeq_var &
-CORBA::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 ::CORBA::WStringSeq_var &
-CORBA::WStringSeq_var::operator= (const ::CORBA::WStringSeq_var &p)
+ACE_INLINE ::CORBA_WStringSeq_var &
+CORBA_WStringSeq_var::operator= (const ::CORBA_WStringSeq_var &p)
 {
   if (this != &p)
     {
@@ -284,12 +284,12 @@
         }
       else
         {
-          WStringSeq *deep_copy =
-            new WStringSeq (*p.ptr_);
+          CORBA_WStringSeq *deep_copy =
+            new CORBA_WStringSeq (*p.ptr_);
           
           if (deep_copy != 0)
             {
-              WStringSeq *tmp = deep_copy;
+              CORBA_WStringSeq *tmp = deep_copy;
               deep_copy = this->ptr_;
               this->ptr_ = tmp;
               delete deep_copy;
@@ -300,80 +300,80 @@
   return *this;
 }
 
-ACE_INLINE const ::CORBA::WStringSeq *
-CORBA::WStringSeq_var::operator-> (void) const
+ACE_INLINE const ::CORBA_WStringSeq *
+CORBA_WStringSeq_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE ::CORBA::WStringSeq *
-CORBA::WStringSeq_var::operator-> (void)
+ACE_INLINE ::CORBA_WStringSeq *
+CORBA_WStringSeq_var::operator-> (void)
 {
   return this->ptr_;
 }
 
 ACE_INLINE 
-CORBA::WStringSeq_var::operator const ::CORBA::WStringSeq &() const // cast
+CORBA_WStringSeq_var::operator const ::CORBA_WStringSeq &() const // cast
 {
   return *this->ptr_;
 }
 
 ACE_INLINE 
-CORBA::WStringSeq_var::operator ::CORBA::WStringSeq &() // cast 
+CORBA_WStringSeq_var::operator ::CORBA_WStringSeq &() // cast 
 {
   return *this->ptr_;
 }
 
 ACE_INLINE 
-CORBA::WStringSeq_var::operator ::CORBA::WStringSeq &() const // cast 
+CORBA_WStringSeq_var::operator ::CORBA_WStringSeq &() const // cast 
 {
   return *this->ptr_;
 }
 
 // variable-size types only
 ACE_INLINE
-CORBA::WStringSeq_var::operator ::CORBA::WStringSeq *&() // cast 
+CORBA_WStringSeq_var::operator ::CORBA_WStringSeq *&() // cast 
 {
   return this->ptr_;
 }
 
 ACE_INLINE TAO_SeqElem_WString_Manager
-CORBA::WStringSeq_var::operator[] (CORBA::ULong index)
+CORBA_WStringSeq_var::operator[] (CORBA::ULong index)
 {
   return this->ptr_->operator[] (index);
 }
 
-ACE_INLINE const ::CORBA::WStringSeq &
-CORBA::WStringSeq_var::in (void) const
+ACE_INLINE const ::CORBA_WStringSeq &
+CORBA_WStringSeq_var::in (void) const
 {
   return *this->ptr_;
 }
 
-ACE_INLINE ::CORBA::WStringSeq &
-CORBA::WStringSeq_var::inout (void)
+ACE_INLINE ::CORBA_WStringSeq &
+CORBA_WStringSeq_var::inout (void)
 {
   return *this->ptr_;
 }
 
 // mapping for variable size 
-ACE_INLINE ::CORBA::WStringSeq *&
-CORBA::WStringSeq_var::out (void)
+ACE_INLINE ::CORBA_WStringSeq *&
+CORBA_WStringSeq_var::out (void)
 {
   delete this->ptr_;
   this->ptr_ = 0;
   return this->ptr_;
 }
 
-ACE_INLINE ::CORBA::WStringSeq *
-CORBA::WStringSeq_var::_retn (void)
+ACE_INLINE ::CORBA_WStringSeq *
+CORBA_WStringSeq_var::_retn (void)
 {
-  ::CORBA::WStringSeq *tmp = this->ptr_;
+  ::CORBA_WStringSeq *tmp = this->ptr_;
   this->ptr_ = 0;
   return tmp;
 }
 
-ACE_INLINE ::CORBA::WStringSeq *
-CORBA::WStringSeq_var::ptr (void) const
+ACE_INLINE ::CORBA_WStringSeq *
+CORBA_WStringSeq_var::ptr (void) const
 {
   return this->ptr_;
 }
@@ -383,14 +383,14 @@
 // *************************************************************
 
 ACE_INLINE
-CORBA::WStringSeq_out::WStringSeq_out (WStringSeq *&p)
+CORBA_WStringSeq_out::CORBA_WStringSeq_out (CORBA_WStringSeq *&p)
   : ptr_ (p)
 {
   this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA::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_;
@@ -398,44 +398,44 @@
 }
 
 ACE_INLINE
-CORBA::WStringSeq_out::WStringSeq_out (const ::CORBA::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 ::CORBA::WStringSeq_out &
-CORBA::WStringSeq_out::operator= (const ::CORBA::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 ::CORBA::WStringSeq_out &
-CORBA::WStringSeq_out::operator= (WStringSeq *p)
+ACE_INLINE ::CORBA_WStringSeq_out &
+CORBA_WStringSeq_out::operator= (CORBA_WStringSeq *p)