ChangeLogTag:Sun Feb 14 12:47:03 1999 Carlos O'Ryan <coryan@cs.wustl.edu>

4 files changed, 118 insertions, 112 deletions

diff --git a/ChangeLog-99b b/ChangeLog-99b
index 36a594e6733..6acf4f33134 100644
--- a/ChangeLog-99b
+++ b/ChangeLog-99b
@@ -1,3 +1,10 @@
+Sun Feb 14 12:47:03 1999  Carlos O'Ryan  <coryan@cs.wustl.edu>
+
+	* ace/CDR_Stream.h: 
+	* ace/CDR_Stream.i: 
+	* ace/CDR_Stream.cpp: 
+	  Minor cosmetic changes, mostly trailing spaces.
+
 Sat Feb 13 22:06:17 1999  Nanbor Wang  <nanbor@cs.wustl.edu>
 
 	The following changes are based on the patch Eric Covington
@@ -248,7 +255,7 @@ Sun Feb  7 00:43:32 1999  Jeff Parsons  <parsons@cs.wustl.edu>
 Sat Feb  6 22:38:40 1999  Jeff Parsons <parsons@cs.wustl.edu>
 
         * ACE_wrappers/tests/CDR_Test.cpp:
-          Changed #include file name to ace/CDR_STream.h (the new
+          Changed #include file name to ace/CDR_Stream.h (the new
           source file name).
 
 Sat Feb  6 22:21:14 1999  Carlos O'Ryan  <coryan@cs.wustl.edu>
diff --git a/ace/CDR_Stream.cpp b/ace/CDR_Stream.cpp
index 3dd90812ed9..0f4ed8875fc 100644
--- a/ace/CDR_Stream.cpp
+++ b/ace/CDR_Stream.cpp
@@ -110,7 +110,7 @@ ACE_OutputCDR::ACE_OutputCDR (size_t size,
                               size_t memcpy_tradeoff)
   :  start_ (size ? size : CDR::DEFAULT_BUFSIZE + CDR::MAX_ALIGNMENT,
              ACE_Message_Block::MB_DATA,
-             0, 
+             0,
              0,
              buffer_allocator,
              0,
@@ -157,7 +157,7 @@ ACE_OutputCDR::ACE_OutputCDR (ACE_Message_Block *data,
      do_byte_swap_ (byte_order != ACE_CDR_BYTE_ORDER),
      good_bit_ (1),
      memcpy_tradeoff_ (memcpy_tradeoff)
-{ 
+{
   // We cannot trust the buffer to be properly aligned
   CDR::mb_align (&this->start_);
   this->current_ = &this->start_;
@@ -193,8 +193,8 @@ ACE_OutputCDR::total_length (void) const
 }
 
 int
-ACE_OutputCDR::grow_and_adjust (size_t size, 
-                                size_t align, 
+ACE_OutputCDR::grow_and_adjust (size_t size,
+                                size_t align,
                                 char*& buf)
 {
   if (this->current_->cont () == 0
@@ -214,7 +214,7 @@ ACE_OutputCDR::grow_and_adjust (size_t size,
       ACE_NEW_RETURN (tmp,
                       ACE_Message_Block (block_size,
                                          ACE_Message_Block::MB_DATA,
-                                         0, 
+                                         0,
                                          0,
                                          this->current_->data_block ()->allocator_strategy (),
                                          0,
@@ -251,7 +251,7 @@ ACE_OutputCDR::grow_and_adjust (size_t size,
 }
 
 CDR::Boolean
-ACE_OutputCDR::write_string (CDR::ULong len, 
+ACE_OutputCDR::write_string (CDR::ULong len,
                              const char *x)
 {
   if (len != 0)
@@ -272,7 +272,7 @@ ACE_OutputCDR::write_string (CDR::ULong len,
           return this->write_char (0);
         }
     }
-  
+
   return 0;
 }
 
@@ -441,13 +441,13 @@ ACE_OutputCDR::write_8 (const CDR::ULongLong *x)
 
   return 0;
 }
-      
+
 CDR::Boolean
 ACE_OutputCDR::write_16 (const CDR::LongDouble *x)
 {
   char* buf;
-  if (this->adjust (CDR::LONGDOUBLE_SIZE, 
-                    CDR::LONGDOUBLE_ALIGN, 
+  if (this->adjust (CDR::LONGDOUBLE_SIZE,
+                    CDR::LONGDOUBLE_ALIGN,
                     buf) == 0)
     {
 #if !defined (ACE_ENABLE_SWAP_ON_WRITE)
@@ -512,7 +512,7 @@ ACE_OutputCDR::write_array (const void *x,
               this->good_bit_ = 0;
               return 0;
             }
-	  
+
           const char *source = ACE_reinterpret_cast (const char *, x);
           const char *end = source + size*length;
 
@@ -548,7 +548,7 @@ ACE_OutputCDR::write_boolean_array (const CDR::Boolean* x,
 
 // ****************************************************************
 
-ACE_InputCDR::ACE_InputCDR (const char *buf, 
+ACE_InputCDR::ACE_InputCDR (const char *buf,
                             size_t bufsiz,
                             int byte_order)
   : start_ (buf, bufsiz),
@@ -769,7 +769,7 @@ ACE_InputCDR::read_array (void* x,
                 {
                   CDR::swap_8 (buf, target);
                 }
-              break;	      
+              break;
             case 16:
               for (; target != end; target += size, buf += size)
                 {
@@ -893,8 +893,8 @@ CDR::Boolean
 ACE_InputCDR::read_16 (CDR::LongDouble *x)
 {
   char *buf;
-  if (this->adjust (CDR::LONGLONG_SIZE, 
-                    CDR::LONGLONG_ALIGN, 
+  if (this->adjust (CDR::LONGLONG_SIZE,
+                    CDR::LONGLONG_ALIGN,
                     buf) == 0)
     {
 #if !defined (ACE_DISABLE_SWAP_ON_READ)
diff --git a/ace/CDR_Stream.h b/ace/CDR_Stream.h
index 89a51513b8d..f68f5c56bdc 100644
--- a/ace/CDR_Stream.h
+++ b/ace/CDR_Stream.h
@@ -126,7 +126,7 @@ public:
   // classes. The cleanest way to avoid complaints from all compilers
   // is to define them all.
   #if defined (ghs) && defined (CHORUS)
-    // This is non-compliant, but a nasty bout with 
+    // This is non-compliant, but a nasty bout with
     // Green Hills C++68000 1.8.8 forces us into it.
     typedef unsigned long Boolean;
   #else  /* ! (ghs && CHORUS) */
@@ -242,28 +242,28 @@ public:
   friend class ACE_InputCDR;
   // For reading from an output CDR stream.
 
-  ACE_OutputCDR (size_t size = 0, 
+  ACE_OutputCDR (size_t size = 0,
                  int byte_order = ACE_CDR_BYTE_ORDER,
                  ACE_Allocator* buffer_allocator = 0,
                  ACE_Allocator* data_block_allocator = 0,
-                 size_t memcpy_tradeoff = 
+                 size_t memcpy_tradeoff =
                    ACE_DEFAULT_CDR_MEMCPY_TRADEOFF);
   // Default constructor, allocates <size> bytes in the internal
   // buffer, if <size> == 0 it allocates the default size.
 
-  ACE_OutputCDR (char *data, 
+  ACE_OutputCDR (char *data,
                  size_t size,
                  int byte_order = ACE_CDR_BYTE_ORDER,
                  ACE_Allocator* buffer_allocator = 0,
                  ACE_Allocator* data_block_allocator = 0,
-                 size_t memcpy_tradeoff= 
+                 size_t memcpy_tradeoff=
                    ACE_DEFAULT_CDR_MEMCPY_TRADEOFF);
   // Build a CDR stream with an initial buffer, it will *not* remove
   // <data>, since it did not allocated it.
 
   ACE_OutputCDR (ACE_Message_Block *data,
                  int byte_order = ACE_CDR_BYTE_ORDER,
-                 size_t memcpy_tradeoff= 
+                 size_t memcpy_tradeoff=
                    ACE_DEFAULT_CDR_MEMCPY_TRADEOFF);
   // Build a CDR stream with an initial Message_Block chain, it will
   // *not* remove <data>, since it did not allocate it.
@@ -330,7 +330,7 @@ public:
   CDR::Boolean write_string (CDR::ULong len, const CDR::Char *x);
   CDR::Boolean write_string (const ACE_CString &x);
   CDR::Boolean write_wstring (const CDR::WChar *x);
-  CDR::Boolean write_wstring (CDR::ULong length, 
+  CDR::Boolean write_wstring (CDR::ULong length,
                               const CDR::WChar *x);
 
   // = We add one method to write arrays of basic IDL types.
@@ -338,25 +338,25 @@ public:
   // The length is *NOT* stored into the CDR stream.
   CDR::Boolean write_boolean_array (const CDR::Boolean *x,
                                     CDR::ULong length);
-  CDR::Boolean write_char_array (const CDR::Char *x, 
+  CDR::Boolean write_char_array (const CDR::Char *x,
                                  CDR::ULong length);
   CDR::Boolean write_wchar_array (const CDR::WChar* x,
                                   CDR::ULong length);
   CDR::Boolean write_octet_array (const CDR::Octet* x,
                                   CDR::ULong length);
-  CDR::Boolean write_short_array (const CDR::Short *x, 
+  CDR::Boolean write_short_array (const CDR::Short *x,
                                   CDR::ULong length);
-  CDR::Boolean write_ushort_array (const CDR::UShort *x, 
+  CDR::Boolean write_ushort_array (const CDR::UShort *x,
                                    CDR::ULong length);
-  CDR::Boolean write_long_array (const CDR::Long *x, 
+  CDR::Boolean write_long_array (const CDR::Long *x,
                                  CDR::ULong length);
-  CDR::Boolean write_ulong_array (const CDR::ULong *x, 
+  CDR::Boolean write_ulong_array (const CDR::ULong *x,
                                   CDR::ULong length);
   CDR::Boolean write_longlong_array (const CDR::LongLong* x,
                                      CDR::ULong length);
   CDR::Boolean write_ulonglong_array (const CDR::ULongLong *x,
                                       CDR::ULong length);
-  CDR::Boolean write_float_array (const CDR::Float *x, 
+  CDR::Boolean write_float_array (const CDR::Float *x,
                                   CDR::ULong length);
   CDR::Boolean write_double_array (const CDR::Double *x,
                                    CDR::ULong length);
@@ -422,8 +422,8 @@ private:
   CDR::Boolean write_8 (const CDR::ULongLong *x);
   CDR::Boolean write_16 (const CDR::LongDouble *x);
 
-  CDR::Boolean write_array (const void *x, 
-                            size_t size, 
+  CDR::Boolean write_array (const void *x,
+                            size_t size,
                             size_t align,
                             CDR::ULong length);
   // write an array of <length> elements, each of <size> bytes and the
@@ -437,21 +437,21 @@ private:
   // could be interesting to find the break even point and optimize
   // for that case, but that would be too platform dependent.
 
-  int adjust (size_t size, 
+  int adjust (size_t size,
               char *&buf);
   // Returns (in <buf>) the next position in the buffer aligned to
   // <size>, it advances the Message_Block wr_ptr past the data
   // (i.e. <buf> + <size>). If necessary it grows the Message_Block
   // buffer.  Sets the good_bit to 0 and returns a -1 on failure.
 
-  int adjust (size_t size, 
-              size_t align, 
+  int adjust (size_t size,
+              size_t align,
               char *&buf);
   // As above, but now the size and alignment requirements may be
   // different.
-  
-  int grow_and_adjust (size_t size, 
-                       size_t align, 
+
+  int grow_and_adjust (size_t size,
+                       size_t align,
                        char *&buf);
   // Grow the CDR stream. When it returns <buf> contains a pointer to
   // memory in the CDR stream, with at least <size> bytes ahead of it
@@ -616,27 +616,27 @@ public:
   // They return -1 on failure and 0 on success.
   CDR::Boolean read_boolean_array (CDR::Boolean* x,
                                    CDR::ULong length);
-  CDR::Boolean read_char_array (CDR::Char *x, 
+  CDR::Boolean read_char_array (CDR::Char *x,
                                 CDR::ULong length);
   CDR::Boolean read_wchar_array (CDR::WChar* x,
                                  CDR::ULong length);
   CDR::Boolean read_octet_array (CDR::Octet* x,
                                  CDR::ULong length);
-  CDR::Boolean read_short_array (CDR::Short *x, 
+  CDR::Boolean read_short_array (CDR::Short *x,
                                  CDR::ULong length);
-  CDR::Boolean read_ushort_array (CDR::UShort *x, 
+  CDR::Boolean read_ushort_array (CDR::UShort *x,
                                   CDR::ULong length);
-  CDR::Boolean read_long_array (CDR::Long *x, 
+  CDR::Boolean read_long_array (CDR::Long *x,
                                 CDR::ULong length);
-  CDR::Boolean read_ulong_array (CDR::ULong *x, 
+  CDR::Boolean read_ulong_array (CDR::ULong *x,
                                  CDR::ULong length);
   CDR::Boolean read_longlong_array (CDR::LongLong* x,
                                     CDR::ULong length);
   CDR::Boolean read_ulonglong_array (CDR::ULongLong* x,
                                      CDR::ULong length);
-  CDR::Boolean read_float_array (CDR::Float *x, 
+  CDR::Boolean read_float_array (CDR::Float *x,
                                  CDR::ULong length);
-  CDR::Boolean read_double_array (CDR::Double *x, 
+  CDR::Boolean read_double_array (CDR::Double *x,
                                   CDR::ULong length);
   CDR::Boolean read_longdouble_array (CDR::LongDouble* x,
                                       CDR::ULong length);
@@ -695,8 +695,8 @@ private:
   // alignment requirements of CDR streams and implement the
   // operations using asignment.
 
-  CDR::Boolean read_array (void* x, 
-                           size_t size, 
+  CDR::Boolean read_array (void* x,
+                           size_t size,
                            size_t align,
                            CDR::ULong length);
   // Read an array of <length> elements, each of <size> bytes and the
@@ -714,19 +714,19 @@ private:
   char* end (void);
   // Short cuts for the underlying message block.
 
-  int adjust (size_t size, 
+  int adjust (size_t size,
               char *&buf);
   // Returns (in <buf>) the next position in the buffer aligned to
   // <size>, it advances the Message_Block rd_ptr past the data
   // (i.e. <buf> + <size>).  Sets the good_bit to 0 and returns a -1
   // on failure.
 
-  int adjust (size_t size, 
-              size_t align, 
+  int adjust (size_t size,
+              size_t align,
               char *&buf);
   // As above, but now the size and alignment requirements may be
   // different.
-  
+
 protected:
   ACE_Message_Block start_;
   // The start of the chain of message blocks, even though in the
@@ -745,13 +745,13 @@ protected:
 #else
 
 // CDR output operators for primitive types
-extern ACE_Export CDR::Boolean operator<< (ACE_OutputCDR &os, 
+extern ACE_Export CDR::Boolean operator<< (ACE_OutputCDR &os,
                                            CDR::Short x);
-extern ACE_Export CDR::Boolean operator<< (ACE_OutputCDR &os, 
+extern ACE_Export CDR::Boolean operator<< (ACE_OutputCDR &os,
                                            CDR::UShort x);
-extern ACE_Export CDR::Boolean operator<< (ACE_OutputCDR &os, 
+extern ACE_Export CDR::Boolean operator<< (ACE_OutputCDR &os,
                                            CDR::Long x);
-extern ACE_Export CDR::Boolean operator<< (ACE_OutputCDR &os, 
+extern ACE_Export CDR::Boolean operator<< (ACE_OutputCDR &os,
                                            CDR::ULong x);
 extern ACE_Export CDR::Boolean operator<< (ACE_OutputCDR &os,
                                            CDR::LongLong x);
@@ -759,11 +759,11 @@ extern ACE_Export CDR::Boolean operator<< (ACE_OutputCDR &os,
                                            CDR::ULongLong x);
 extern ACE_Export CDR::Boolean operator<< (ACE_OutputCDR& os,
                                            CDR::LongDouble x);
-extern ACE_Export CDR::Boolean operator<< (ACE_OutputCDR &os, 
+extern ACE_Export CDR::Boolean operator<< (ACE_OutputCDR &os,
                                            CDR::Float x);
-extern ACE_Export CDR::Boolean operator<< (ACE_OutputCDR &os, 
+extern ACE_Export CDR::Boolean operator<< (ACE_OutputCDR &os,
                                            CDR::Double x);
-extern ACE_Export CDR::Boolean operator<< (ACE_OutputCDR &os, 
+extern ACE_Export CDR::Boolean operator<< (ACE_OutputCDR &os,
                                            const ACE_CString &x);
 
 // CDR output operator from helper classes
@@ -780,13 +780,13 @@ extern ACE_Export CDR::Boolean operator<< (ACE_OutputCDR &os,
 extern ACE_Export CDR::Boolean operator<< (ACE_OutputCDR &os,
                                            const CDR::Char* x);
 // CDR input operators for primitive types
-extern ACE_Export CDR::Boolean operator>> (ACE_InputCDR &is, 
+extern ACE_Export CDR::Boolean operator>> (ACE_InputCDR &is,
                                            CDR::Short &x);
-extern ACE_Export CDR::Boolean operator>> (ACE_InputCDR &is, 
+extern ACE_Export CDR::Boolean operator>> (ACE_InputCDR &is,
                                            CDR::UShort &x);
-extern ACE_Export CDR::Boolean operator>> (ACE_InputCDR &is, 
+extern ACE_Export CDR::Boolean operator>> (ACE_InputCDR &is,
                                            CDR::Long &x);
-extern ACE_Export CDR::Boolean operator>> (ACE_InputCDR &is, 
+extern ACE_Export CDR::Boolean operator>> (ACE_InputCDR &is,
                                            CDR::ULong &x);
 extern ACE_Export CDR::Boolean operator>> (ACE_InputCDR &is,
                                            CDR::LongLong &x);
@@ -794,11 +794,11 @@ extern ACE_Export CDR::Boolean operator>> (ACE_InputCDR &is,
                                            CDR::ULongLong &x);
 extern ACE_Export CDR::Boolean operator>> (ACE_InputCDR &is,
                                            CDR::LongDouble &x);
-extern ACE_Export CDR::Boolean operator>> (ACE_InputCDR &is, 
+extern ACE_Export CDR::Boolean operator>> (ACE_InputCDR &is,
                                            CDR::Float &x);
-extern ACE_Export CDR::Boolean operator>> (ACE_InputCDR &is, 
+extern ACE_Export CDR::Boolean operator>> (ACE_InputCDR &is,
                                            CDR::Double &x);
-extern ACE_Export CDR::Boolean operator>> (ACE_InputCDR &is, 
+extern ACE_Export CDR::Boolean operator>> (ACE_InputCDR &is,
                                            ACE_CString &x);
 
 // CDR input operator from helper classes
diff --git a/ace/CDR_Stream.i b/ace/CDR_Stream.i
index 4c6a2f2c8ad..2a11af1605b 100644
--- a/ace/CDR_Stream.i
+++ b/ace/CDR_Stream.i
@@ -3,14 +3,14 @@
 
 // ****************************************************************
 
-ACE_INLINE void 
+ACE_INLINE void
 CDR::swap_2 (const char *orig, char* target)
 {
   target[1] = *orig++;
   target[0] = *orig++;
 }
- 
-ACE_INLINE void 
+
+ACE_INLINE void
 CDR::swap_4 (const char *orig, char* target)
 {
   target [3] = *orig++;
@@ -19,7 +19,7 @@ CDR::swap_4 (const char *orig, char* target)
   target [0] = *orig++;
 }
 
-ACE_INLINE void 
+ACE_INLINE void
 CDR::swap_8 (const char *orig, char* target)
 {
   target [7] = *orig++;
@@ -32,7 +32,7 @@ CDR::swap_8 (const char *orig, char* target)
   target [0] = *orig++;
 }
 
-ACE_INLINE void 
+ACE_INLINE void
 CDR::swap_16 (const char *orig, char* target)
 {
   target [15] = *orig++;
@@ -53,7 +53,7 @@ CDR::swap_16 (const char *orig, char* target)
   target [0] = *orig++;
 }
 
-ACE_INLINE void 
+ACE_INLINE void
 CDR::mb_align (ACE_Message_Block *mb)
 {
   char *start = ptr_align_binary (mb->base (),
@@ -156,7 +156,7 @@ ACE_OutputCDR::write_boolean (CDR::Boolean x)
   return this->write_octet (x ? 1 : 0);
 }
 
-ACE_INLINE CDR::Boolean 
+ACE_INLINE CDR::Boolean
 ACE_OutputCDR::write_char (CDR::Char x)
 {
   return this->write_1 (ACE_reinterpret_cast (const CDR::Octet*, &x));
@@ -168,25 +168,25 @@ ACE_OutputCDR::write_wchar (CDR::WChar x)
   return this->write_2 (ACE_reinterpret_cast (const CDR::UShort*,&x));
 }
 
-ACE_INLINE CDR::Boolean 
+ACE_INLINE CDR::Boolean
 ACE_OutputCDR::write_short (CDR::Short x)
 {
   return this->write_2 (ACE_reinterpret_cast (const CDR::UShort*, &x));
 }
 
-ACE_INLINE CDR::Boolean 
+ACE_INLINE CDR::Boolean
 ACE_OutputCDR::write_ushort (CDR::UShort x)
 {
   return this->write_2 (ACE_reinterpret_cast (const CDR::UShort*, &x));
 }
 
-ACE_INLINE CDR::Boolean 
+ACE_INLINE CDR::Boolean
 ACE_OutputCDR::write_long (CDR::Long x)
 {
   return this->write_4 (ACE_reinterpret_cast (const CDR::ULong*, &x));
 }
 
-ACE_INLINE CDR::Boolean 
+ACE_INLINE CDR::Boolean
 ACE_OutputCDR::write_ulong (CDR::ULong x)
 {
   return this->write_4 (ACE_reinterpret_cast (const CDR::ULong*, &x));
@@ -204,13 +204,13 @@ ACE_OutputCDR::write_ulonglong (const CDR::ULongLong &x)
   return this->write_8 (ACE_reinterpret_cast (const CDR::ULongLong*,&x));
 }
 
-ACE_INLINE CDR::Boolean 
+ACE_INLINE CDR::Boolean
 ACE_OutputCDR::write_float (CDR::Float x)
 {
   return this->write_4 (ACE_reinterpret_cast (const CDR::ULong*, &x));
 }
 
-ACE_INLINE CDR::Boolean 
+ACE_INLINE CDR::Boolean
 ACE_OutputCDR::write_double (const CDR::Double &x)
 {
   return this->write_8 (ACE_reinterpret_cast (const CDR::ULongLong*, &x));
@@ -222,7 +222,7 @@ ACE_OutputCDR::write_longdouble (const CDR::LongDouble &x)
   return this->write_16 (ACE_reinterpret_cast (const CDR::LongDouble*,&x));
 }
 
-ACE_INLINE CDR::Boolean 
+ACE_INLINE CDR::Boolean
 ACE_OutputCDR::write_string (const CDR::Char *x)
 {
   if (x != 0)
@@ -230,7 +230,7 @@ ACE_OutputCDR::write_string (const CDR::Char *x)
   return this->write_string (0, 0);
 }
 
-ACE_INLINE CDR::Boolean 
+ACE_INLINE CDR::Boolean
 ACE_OutputCDR::write_string (const ACE_CString &x)
 {
   return this->write_string (x.length(), x.c_str());
@@ -244,11 +244,11 @@ ACE_OutputCDR::write_wstring (const CDR::WChar *x)
   return this->write_wstring (0, 0);
 }
 
-ACE_INLINE CDR::Boolean 
-ACE_OutputCDR::write_char_array (const CDR::Char *x, 
+ACE_INLINE CDR::Boolean
+ACE_OutputCDR::write_char_array (const CDR::Char *x,
                                  CDR::ULong length)
 {
-  return this->write_array (x, 
+  return this->write_array (x,
                             CDR::OCTET_SIZE,
                             CDR::OCTET_ALIGN,
                             length);
@@ -274,8 +274,8 @@ ACE_OutputCDR::write_octet_array (const CDR::Octet* x,
                             length);
 }
 
-ACE_INLINE CDR::Boolean 
-ACE_OutputCDR::write_short_array (const CDR::Short *x, 
+ACE_INLINE CDR::Boolean
+ACE_OutputCDR::write_short_array (const CDR::Short *x,
                                   CDR::ULong length)
 {
   return this->write_array (x,
@@ -284,8 +284,8 @@ ACE_OutputCDR::write_short_array (const CDR::Short *x,
                             length);
 }
 
-ACE_INLINE CDR::Boolean 
-ACE_OutputCDR::write_ushort_array (const CDR::UShort *x, 
+ACE_INLINE CDR::Boolean
+ACE_OutputCDR::write_ushort_array (const CDR::UShort *x,
                                    CDR::ULong length)
 {
   return this->write_array (x,
@@ -294,8 +294,8 @@ ACE_OutputCDR::write_ushort_array (const CDR::UShort *x,
                             length);
 }
 
-ACE_INLINE CDR::Boolean 
-ACE_OutputCDR::write_long_array (const CDR::Long *x, 
+ACE_INLINE CDR::Boolean
+ACE_OutputCDR::write_long_array (const CDR::Long *x,
                                  CDR::ULong length)
 {
   return this->write_array (x,
@@ -303,11 +303,11 @@ ACE_OutputCDR::write_long_array (const CDR::Long *x,
                             CDR::LONG_ALIGN,
                             length);
 }
-  
-ACE_INLINE CDR::Boolean 
-ACE_OutputCDR::write_ulong_array (const CDR::ULong *x, 
+
+ACE_INLINE CDR::Boolean
+ACE_OutputCDR::write_ulong_array (const CDR::ULong *x,
                                   CDR::ULong length)
-{   
+{
   return this->write_array (x,
                             CDR::LONG_SIZE,
                             CDR::LONG_ALIGN,
@@ -334,8 +334,8 @@ ACE_OutputCDR::write_ulonglong_array (const CDR::ULongLong *x,
                             length);
 }
 
-ACE_INLINE CDR::Boolean 
-ACE_OutputCDR::write_float_array (const CDR::Float *x, 
+ACE_INLINE CDR::Boolean
+ACE_OutputCDR::write_float_array (const CDR::Float *x,
                                   CDR::ULong length)
 {
   return this->write_array (x,
@@ -345,8 +345,8 @@ ACE_OutputCDR::write_float_array (const CDR::Float *x,
 }
 
 
-ACE_INLINE CDR::Boolean 
-ACE_OutputCDR::write_double_array (const CDR::Double *x, 
+ACE_INLINE CDR::Boolean
+ACE_OutputCDR::write_double_array (const CDR::Double *x,
                                    CDR::ULong length)
 {
   return this->write_array (x,
@@ -372,11 +372,11 @@ ACE_OutputCDR::good_bit (void) const
 }
 
 ACE_INLINE int
-ACE_OutputCDR::adjust (size_t size, 
-                       size_t align, 
+ACE_OutputCDR::adjust (size_t size,
+                       size_t align,
                        char*& buf)
 {
-  buf = ptr_align_binary (this->current_->wr_ptr(), 
+  buf = ptr_align_binary (this->current_->wr_ptr(),
                           align);
   char *end = buf + size;
 
@@ -389,7 +389,7 @@ ACE_OutputCDR::adjust (size_t size,
   return this->grow_and_adjust (size, align, buf);
 }
 
-ACE_INLINE int 
+ACE_INLINE int
 ACE_OutputCDR::adjust (size_t size, char*& buf)
 {
   return this->adjust (size, size, buf);
@@ -442,7 +442,7 @@ ACE_InputCDR::read_boolean (CDR::Boolean& x)
   return this->good_bit_;
 }
 
-ACE_INLINE CDR::Boolean 
+ACE_INLINE CDR::Boolean
 ACE_InputCDR::read_char (CDR::Char &x)
 {
   return this->read_1 (ACE_reinterpret_cast (CDR::Octet*, &x));
@@ -514,7 +514,7 @@ ACE_InputCDR::read_longdouble (CDR::LongDouble &x)
 }
 
 ACE_INLINE CDR::Boolean
-ACE_InputCDR::read_char_array (CDR::Char* x, 
+ACE_InputCDR::read_char_array (CDR::Char* x,
                                CDR::ULong length)
 {
   return this->read_array (x,
@@ -544,7 +544,7 @@ ACE_InputCDR::read_octet_array (CDR::Octet* x,
 }
 
 ACE_INLINE CDR::Boolean
-ACE_InputCDR::read_short_array (CDR::Short *x, 
+ACE_InputCDR::read_short_array (CDR::Short *x,
                                 CDR::ULong length)
 {
   return this->read_array (x,
@@ -554,7 +554,7 @@ ACE_InputCDR::read_short_array (CDR::Short *x,
 }
 
 ACE_INLINE CDR::Boolean
-ACE_InputCDR::read_ushort_array (CDR::UShort *x, 
+ACE_InputCDR::read_ushort_array (CDR::UShort *x,
                                  CDR::ULong length)
 {
   return this->read_array (x,
@@ -564,7 +564,7 @@ ACE_InputCDR::read_ushort_array (CDR::UShort *x,
 }
 
 ACE_INLINE CDR::Boolean
-ACE_InputCDR::read_long_array (CDR::Long *x, 
+ACE_InputCDR::read_long_array (CDR::Long *x,
                                CDR::ULong length)
 {
   return this->read_array (x,
@@ -574,7 +574,7 @@ ACE_InputCDR::read_long_array (CDR::Long *x,
 }
 
 ACE_INLINE CDR::Boolean
-ACE_InputCDR::read_ulong_array (CDR::ULong *x, 
+ACE_InputCDR::read_ulong_array (CDR::ULong *x,
                                 CDR::ULong length)
 {
   return this->read_array (x,
@@ -604,7 +604,7 @@ ACE_InputCDR::read_ulonglong_array (CDR::ULongLong *x,
 }
 
 ACE_INLINE CDR::Boolean
-ACE_InputCDR::read_float_array (CDR::Float *x, 
+ACE_InputCDR::read_float_array (CDR::Float *x,
                                 CDR::ULong length)
 {
   return this->read_array (x,
@@ -615,7 +615,7 @@ ACE_InputCDR::read_float_array (CDR::Float *x,
 
 
 ACE_INLINE CDR::Boolean
-ACE_InputCDR::read_double_array (CDR::Double *x, 
+ACE_InputCDR::read_double_array (CDR::Double *x,
                                  CDR::ULong length)
 {
   return this->read_array (x,
@@ -926,7 +926,7 @@ operator>>(ACE_InputCDR &is, CDR::Long &x)
 
 ACE_INLINE CDR::Boolean
 operator>> (ACE_InputCDR &is, CDR::ULong &x)
-{ 
+{
   is.read_ulong (x);
   return is.good_bit ();
 }
@@ -1118,7 +1118,7 @@ ACE_INLINE CDR::Boolean
 ACE_OutputCDR::append_string (ACE_InputCDR &stream)
 {
   CDR::Char *x;
-  CDR::Boolean flag = 
+  CDR::Boolean flag =
     (stream.read_string (x) ? this->write_string (x) : 0);
   delete [] x;
   return flag;
@@ -1128,9 +1128,8 @@ ACE_INLINE CDR::Boolean
 ACE_OutputCDR::append_wstring (ACE_InputCDR &stream)
 {
   CDR::WChar *x;
-  CDR::Boolean flag = 
+  CDR::Boolean flag =
     (stream.read_wstring (x) ? this->write_wstring (x) : 0);
   delete [] x;
   return flag;
 }
-