AbstractBase.*

1 files changed, 42 insertions, 42 deletions

diff --git a/TAO/tao/CORBA_String.inl b/TAO/tao/CORBA_String.inl
index e087707c6de..79c40246dcd 100644
--- a/TAO/tao/CORBA_String.inl
+++ b/TAO/tao/CORBA_String.inl
@@ -1,5 +1,5 @@
 // -*- C++ -*-
-
+//
 // $Id$
 
 // ----------------------------------------------------------------------
@@ -7,57 +7,57 @@
 // ----------------------------------------------------------------------
 
 ACE_INLINE
-CORBA_String_var::CORBA_String_var (void)
+CORBA::String_var::String_var (void)
   : ptr_ (0)
 {
 }
 
 ACE_INLINE
-CORBA_String_var::CORBA_String_var (const char *p)
+CORBA::String_var::String_var (const char *p)
   : ptr_ (CORBA::string_dup (p))
 {
 }
 
 ACE_INLINE CORBA::Char &
-CORBA_String_var::operator[] (CORBA::ULong slot)
+CORBA::String_var::operator[] (CORBA::ULong slot)
 {
   // We need to verify bounds else raise some exception.
   return this->ptr_[slot];
 }
 
 ACE_INLINE CORBA::Char
-CORBA_String_var::operator[] (CORBA::ULong slot) const
+CORBA::String_var::operator[] (CORBA::ULong slot) const
 {
   // We need to verify bounds else raise some exception.
   return this->ptr_[slot];
 }
 
 ACE_INLINE
-CORBA_String_var::operator char *&()
+CORBA::String_var::operator char *&()
 {
   return this->ptr_;
 }
 
 ACE_INLINE
-CORBA_String_var::operator const char *() const
+CORBA::String_var::operator const char *() const
 {
   return this->ptr_;
 }
 
 ACE_INLINE const char *
-CORBA_String_var::in (void) const
+CORBA::String_var::in (void) const
 {
   return this->ptr_;
 }
 
 ACE_INLINE char *&
-CORBA_String_var::inout (void)
+CORBA::String_var::inout (void)
 {
   return this->ptr_;
 }
 
 ACE_INLINE char *&
-CORBA_String_var::out (void)
+CORBA::String_var::out (void)
 {
   CORBA::string_free (this->ptr_);
   this->ptr_ = 0;
@@ -65,7 +65,7 @@ CORBA_String_var::out (void)
 }
 
 ACE_INLINE char *
-CORBA_String_var::_retn (void)
+CORBA::String_var::_retn (void)
 {
   char *temp = this->ptr_;
   this->ptr_ = 0;
@@ -77,59 +77,59 @@ CORBA_String_var::_retn (void)
 // ----------------------------------------------------
 
 ACE_INLINE
-CORBA_String_out::CORBA_String_out (char *&s)
+CORBA::String_out::String_out (char *&s)
   : ptr_ (s)
 {
   this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_String_out::CORBA_String_out (CORBA_String_var &s)
+CORBA::String_out::String_out (CORBA::String_var &s)
   : ptr_ (s.out ())
 {
 }
 
 ACE_INLINE
-CORBA_String_out::CORBA_String_out (TAO_String_Manager &s)
+CORBA::String_out::String_out (TAO_String_Manager &s)
   : ptr_ (s.out ())
 {
 }
 
 ACE_INLINE
-CORBA_String_out::CORBA_String_out (const CORBA_String_out &s)
+CORBA::String_out::String_out (const CORBA::String_out &s)
   : ptr_ (s.ptr_)
 {
 }
 
-ACE_INLINE CORBA_String_out &
-CORBA_String_out::operator= (const CORBA_String_out &s)
+ACE_INLINE CORBA::String_out &
+CORBA::String_out::operator= (const CORBA::String_out &s)
 {
   this->ptr_ = s.ptr_;
   return *this;
 }
 
-ACE_INLINE CORBA_String_out &
-CORBA_String_out::operator= (char *s)
+ACE_INLINE CORBA::String_out &
+CORBA::String_out::operator= (char *s)
 {
   this->ptr_ = s;
   return *this;
 }
 
-ACE_INLINE CORBA_String_out &
-CORBA_String_out::operator= (const char *s)
+ACE_INLINE CORBA::String_out &
+CORBA::String_out::operator= (const char *s)
 {
   this->ptr_ = CORBA::string_dup (s);
   return *this;
 }
 
 ACE_INLINE
-CORBA_String_out::operator char *&()
+CORBA::String_out::operator char *&()
 {
   return this->ptr_;
 }
 
 ACE_INLINE char *&
-CORBA_String_out::ptr (void)
+CORBA::String_out::ptr (void)
 {
   return this->ptr_;
 }
@@ -141,57 +141,57 @@ CORBA_String_out::ptr (void)
 // ----------------------------------------------------------------------
 
 ACE_INLINE
-CORBA_WString_var::CORBA_WString_var (void)
+CORBA::WString_var::WString_var (void)
   : ptr_ (0)
 {
 }
 
 ACE_INLINE
-CORBA_WString_var::CORBA_WString_var (const CORBA::WChar *p)
+CORBA::WString_var::WString_var (const CORBA::WChar *p)
   : ptr_ (CORBA::wstring_dup (p))
 {
 }
 
 ACE_INLINE CORBA::WChar &
-CORBA_WString_var::operator[] (CORBA::ULong slot)
+CORBA::WString_var::operator[] (CORBA::ULong slot)
 {
   // @@ We need to verify bounds else raise some exception.
   return this->ptr_[slot];
 }
 
 ACE_INLINE CORBA::WChar
-CORBA_WString_var::operator[] (CORBA::ULong slot) const
+CORBA::WString_var::operator[] (CORBA::ULong slot) const
 {
   // @@ We need to verify bounds else raise some exception.
   return this->ptr_[slot];
 }
 
 ACE_INLINE
-CORBA_WString_var::operator CORBA::WChar *()
+CORBA::WString_var::operator CORBA::WChar *()
 {
   return this->ptr_;
 }
 
 ACE_INLINE
-CORBA_WString_var::operator const CORBA::WChar *() const
+CORBA::WString_var::operator const CORBA::WChar *() const
 {
   return this->ptr_;
 }
 
 ACE_INLINE const CORBA::WChar *
-CORBA_WString_var::in (void) const
+CORBA::WString_var::in (void) const
 {
   return this->ptr_;
 }
 
 ACE_INLINE CORBA::WChar *&
-CORBA_WString_var::inout (void)
+CORBA::WString_var::inout (void)
 {
   return this->ptr_;
 }
 
 ACE_INLINE CORBA::WChar *&
-CORBA_WString_var::out (void)
+CORBA::WString_var::out (void)
 {
   CORBA::wstring_free (this->ptr_);
   this->ptr_ = 0;
@@ -199,7 +199,7 @@ CORBA_WString_var::out (void)
 }
 
 ACE_INLINE CORBA::WChar *
-CORBA_WString_var::_retn (void)
+CORBA::WString_var::_retn (void)
 {
   CORBA::WChar *temp = this->ptr_;
   this->ptr_ = 0;
@@ -211,46 +211,46 @@ CORBA_WString_var::_retn (void)
 // ----------------------------------------------------
 
 ACE_INLINE
-CORBA_WString_out::CORBA_WString_out (CORBA::WChar *&s)
+CORBA::WString_out::WString_out (CORBA::WChar *&s)
   : ptr_ (s)
 {
   this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_WString_out::CORBA_WString_out (CORBA_WString_var &s)
+CORBA::WString_out::WString_out (CORBA::WString_var &s)
   : ptr_ (s.out ())
 {
 }
 
 ACE_INLINE
-CORBA_WString_out::CORBA_WString_out (const CORBA_WString_out &s)
+CORBA::WString_out::WString_out (const CORBA::WString_out &s)
   : ptr_ (s.ptr_)
 {
 }
 
-ACE_INLINE CORBA_WString_out &
-CORBA_WString_out::operator= (const CORBA_WString_out &s)
+ACE_INLINE CORBA::WString_out &
+CORBA::WString_out::operator= (const CORBA::WString_out &s)
 {
   this->ptr_ = s.ptr_;
   return *this;
 }
 
-ACE_INLINE CORBA_WString_out &
-CORBA_WString_out::operator= (CORBA::WChar *s)
+ACE_INLINE CORBA::WString_out &
+CORBA::WString_out::operator= (CORBA::WChar *s)
 {
   this->ptr_ = s;
   return *this;
 }
 
 ACE_INLINE
-CORBA_WString_out::operator CORBA::WChar *&()
+CORBA::WString_out::operator CORBA::WChar *&()
 {
   return this->ptr_;
 }
 
 ACE_INLINE CORBA::WChar *&
-CORBA_WString_out::ptr (void)
+CORBA::WString_out::ptr (void)
 {
   return this->ptr_;
 }