ChangeLogTag:Fri Aug 14 20:13:28 1998 Carlos O'Ryan <coryan@cs.wustl.edu>

8 files changed, 154 insertions, 181 deletions

diff --git a/TAO/tao/CDR.h b/TAO/tao/CDR.h
index cc8ef49015c..c3488e2f91f 100644
--- a/TAO/tao/CDR.h
+++ b/TAO/tao/CDR.h
@@ -587,58 +587,58 @@ private:
 #if defined(__ACE_INLINE__)
 # include "tao/CDR.i"
 #else
-extern TAO_Export TAO_OutputCDR& operator<< (TAO_OutputCDR& cdr,
-					     CORBA::Boolean x);
-extern TAO_Export TAO_OutputCDR& operator<< (TAO_OutputCDR& cdr,
-					     CORBA::Octet x);
-extern TAO_Export TAO_OutputCDR& operator<< (TAO_OutputCDR& cdr,
-					     CORBA::Short x);
-extern TAO_Export TAO_OutputCDR& operator<< (TAO_OutputCDR& cdr,
-					     CORBA::UShort x);
-extern TAO_Export TAO_OutputCDR& operator<< (TAO_OutputCDR& cdr,
-					     CORBA::Long x);
-extern TAO_Export TAO_OutputCDR& operator<< (TAO_OutputCDR& cdr,
-					     CORBA::ULong x);
-extern TAO_Export TAO_OutputCDR& operator<< (TAO_OutputCDR& cdr,
-					     CORBA::LongLong x);
-extern TAO_Export TAO_OutputCDR& operator<< (TAO_OutputCDR& cdr,
-					     CORBA::ULongLong x);
-extern TAO_Export TAO_OutputCDR& operator<< (TAO_OutputCDR& cdr,
-					     CORBA::Float x);
-extern TAO_Export TAO_OutputCDR& operator<< (TAO_OutputCDR& cdr,
-					     CORBA::Double x);
-extern TAO_Export TAO_OutputCDR& operator<< (TAO_OutputCDR& cdr,
-					     CORBA::Char x);
-extern TAO_Export TAO_OutputCDR& operator<< (TAO_OutputCDR& cdr,
-					     CORBA::WChar x);
-extern TAO_Export TAO_OutputCDR& operator<< (TAO_OutputCDR& cdr,
-					     const CORBA::Char* x);
-
-extern TAO_Export TAO_InputCDR& operator>> (TAO_InputCDR& cdr,
+extern TAO_Export CORBA_Boolean operator<< (TAO_OutputCDR& cdr,
+					    CORBA::Boolean x);
+extern TAO_Export CORBA_Boolean operator<< (TAO_OutputCDR& cdr,
+					    CORBA::Octet x);
+extern TAO_Export CORBA_Boolean operator<< (TAO_OutputCDR& cdr,
+					    CORBA::Short x);
+extern TAO_Export CORBA_Boolean operator<< (TAO_OutputCDR& cdr,
+					    CORBA::UShort x);
+extern TAO_Export CORBA_Boolean operator<< (TAO_OutputCDR& cdr,
+					    CORBA::Long x);
+extern TAO_Export CORBA_Boolean operator<< (TAO_OutputCDR& cdr,
+					    CORBA::ULong x);
+extern TAO_Export CORBA_Boolean operator<< (TAO_OutputCDR& cdr,
+					    CORBA::LongLong x);
+extern TAO_Export CORBA_Boolean operator<< (TAO_OutputCDR& cdr,
+					    CORBA::ULongLong x);
+extern TAO_Export CORBA_Boolean operator<< (TAO_OutputCDR& cdr,
+					    CORBA::Float x);
+extern TAO_Export CORBA_Boolean operator<< (TAO_OutputCDR& cdr,
+					    CORBA::Double x);
+extern TAO_Export CORBA_Boolean operator<< (TAO_OutputCDR& cdr,
+					    CORBA::Char x);
+extern TAO_Export CORBA_Boolean operator<< (TAO_OutputCDR& cdr,
+					    CORBA::WChar x);
+extern TAO_Export CORBA_Boolean operator<< (TAO_OutputCDR& cdr,
+					    const CORBA::Char* x);
+
+extern TAO_Export CORBA_Boolean operator>> (TAO_InputCDR& cdr,
 					    CORBA::Boolean &x);
-extern TAO_Export TAO_InputCDR& operator>> (TAO_InputCDR& cdr,
+extern TAO_Export CORBA_Boolean operator>> (TAO_InputCDR& cdr,
 					    CORBA::Octet &x);
-extern TAO_Export TAO_InputCDR& operator>> (TAO_InputCDR& cdr,
+extern TAO_Export CORBA_Boolean operator>> (TAO_InputCDR& cdr,
 					    CORBA::Short &x);
-extern TAO_Export TAO_InputCDR& operator>> (TAO_InputCDR& cdr,
+extern TAO_Export CORBA_Boolean operator>> (TAO_InputCDR& cdr,
 					    CORBA::UShort &x);
-extern TAO_Export TAO_InputCDR& operator>> (TAO_InputCDR& cdr,
+extern TAO_Export CORBA_Boolean operator>> (TAO_InputCDR& cdr,
 					    CORBA::Long &x);
-extern TAO_Export TAO_InputCDR& operator>> (TAO_InputCDR& cdr,
+extern TAO_Export CORBA_Boolean operator>> (TAO_InputCDR& cdr,
 					    CORBA::ULong &x);
-extern TAO_Export TAO_InputCDR& operator>> (TAO_InputCDR& cdr,
+extern TAO_Export CORBA_Boolean operator>> (TAO_InputCDR& cdr,
 					    CORBA::LongLong &x);
-extern TAO_Export TAO_InputCDR& operator>> (TAO_InputCDR& cdr,
+extern TAO_Export CORBA_Boolean operator>> (TAO_InputCDR& cdr,
 					    CORBA::ULongLong &x);
-extern TAO_Export TAO_InputCDR& operator>> (TAO_InputCDR& cdr,
+extern TAO_Export CORBA_Boolean operator>> (TAO_InputCDR& cdr,
 					    CORBA::Float &x);
-extern TAO_Export TAO_InputCDR& operator>> (TAO_InputCDR& cdr,
+extern TAO_Export CORBA_Boolean operator>> (TAO_InputCDR& cdr,
 					    CORBA::Double &x);
-extern TAO_Export TAO_InputCDR& operator>> (TAO_InputCDR& cdr,
+extern TAO_Export CORBA_Boolean operator>> (TAO_InputCDR& cdr,
 					    CORBA::Char &x);
-extern TAO_Export TAO_InputCDR& operator>> (TAO_InputCDR& cdr,
+extern TAO_Export CORBA_Boolean operator>> (TAO_InputCDR& cdr,
 					    CORBA::WChar &x);
-extern TAO_Export TAO_InputCDR& operator>> (TAO_InputCDR& cdr,
+extern TAO_Export CORBA_Boolean operator>> (TAO_InputCDR& cdr,
 					    CORBA::Char*& x);
 #endif /* __ACE_INLINE */
 
diff --git a/TAO/tao/CDR.i b/TAO/tao/CDR.i
index 40376bf3612..ab1afeb948c 100644
--- a/TAO/tao/CDR.i
+++ b/TAO/tao/CDR.i
@@ -705,202 +705,178 @@ TAO_InputCDR::rd_ptr (void)
 }
 
 // ****************************************************************
-// TODO: Use the CORBA_* types when they become available.
+// @@ TODO: Use the CORBA_* types when they become available.
 
 #if defined (ACE_HAS_BOOL)
-ACE_INLINE TAO_OutputCDR&
+ACE_INLINE CORBA_Boolean
 operator<< (TAO_OutputCDR& cdr, CORBA::Boolean x)
 {
-  if (cdr.good_bit ())
-    cdr.write_boolean (x);
-  return cdr;
+  cdr.write_boolean (x);
+  return cdr.good_bit ();
 }
 #endif /* ACE_HAS_BOOL */
 
-ACE_INLINE TAO_OutputCDR&
+ACE_INLINE CORBA_Boolean
 operator<< (TAO_OutputCDR& cdr, CORBA::Octet x)
 {
-  if (cdr.good_bit ())
-    cdr.write_octet (x);
-  return cdr;
+  cdr.write_octet (x);
+  return cdr.good_bit ();
 }
 
-ACE_INLINE TAO_OutputCDR&
+ACE_INLINE CORBA_Boolean
 operator<< (TAO_OutputCDR& cdr, CORBA::Short x)
 {
-  if (cdr.good_bit ())
-    cdr.write_short (x);
-  return cdr;
+  cdr.write_short (x);
+  return cdr.good_bit ();
 }
 
-ACE_INLINE TAO_OutputCDR&
+ACE_INLINE CORBA_Boolean
 operator<< (TAO_OutputCDR& cdr, CORBA::UShort x)
 {
-  if (cdr.good_bit ())
-    cdr.write_short (x);
-  return cdr;
+  cdr.write_short (x);
+  return cdr.good_bit ();
 }
 
-ACE_INLINE TAO_OutputCDR&
+ACE_INLINE CORBA_Boolean
 operator<< (TAO_OutputCDR& cdr, CORBA::Long x)
 {
-  if (cdr.good_bit ())
-    cdr.write_long (x);
-  return cdr;
+  cdr.write_long (x);
+  return cdr.good_bit ();
 }
 
-ACE_INLINE TAO_OutputCDR&
+ACE_INLINE CORBA_Boolean
 operator<< (TAO_OutputCDR& cdr, CORBA::ULong x)
 {
-  if (cdr.good_bit ())
-    cdr.write_long (x);
-  return cdr;
+  cdr.write_long (x);
+  return cdr.good_bit ();
 }
 
-ACE_INLINE TAO_OutputCDR&
+ACE_INLINE CORBA_Boolean
 operator<< (TAO_OutputCDR& cdr, CORBA::LongLong x)
 {
-  if (cdr.good_bit ())
-    cdr.write_longlong (x);
-  return cdr;
+  cdr.write_longlong (x);
+  return cdr.good_bit ();
 }
 
-ACE_INLINE TAO_OutputCDR&
+ACE_INLINE CORBA_Boolean
 operator<< (TAO_OutputCDR& cdr, CORBA::ULongLong x)
 {
-  if (cdr.good_bit ())
-    cdr.write_ulonglong (x);
-  return cdr;
+  cdr.write_ulonglong (x);
+  return cdr.good_bit ();
 }
 
-ACE_INLINE TAO_OutputCDR&
+ACE_INLINE CORBA_Boolean
 operator<< (TAO_OutputCDR& cdr, CORBA::Float x)
 {
-  if (cdr.good_bit ())
-    cdr.write_float (x);
-  return cdr;
+  cdr.write_float (x);
+  return cdr.good_bit ();
 }
 
-ACE_INLINE TAO_OutputCDR&
+ACE_INLINE CORBA_Boolean
 operator<< (TAO_OutputCDR& cdr, CORBA::Double x)
 {
-  if (cdr.good_bit ())
-    cdr.write_double (x);
-  return cdr;
+  cdr.write_double (x);
+  return cdr.good_bit ();
 }
 
-ACE_INLINE TAO_OutputCDR&
+ACE_INLINE CORBA_Boolean
 operator<< (TAO_OutputCDR& cdr, CORBA::Char x)
 {
-  if (cdr.good_bit ())
-    cdr.write_char (x);
-  return cdr;
+  cdr.write_char (x);
+  return cdr.good_bit ();
 }
 
-ACE_INLINE TAO_OutputCDR&
+ACE_INLINE CORBA_Boolean
 operator<< (TAO_OutputCDR& cdr, const CORBA::Char* x)
 {
-  if (cdr.good_bit ())
-    cdr.write_string (x);
-  return cdr;
+  cdr.write_string (x);
+  return cdr.good_bit ();
 }
 
 #if defined (ACE_HAS_BOOL)
-ACE_INLINE TAO_InputCDR&
+ACE_INLINE CORBA_Boolean
 operator>> (TAO_InputCDR& cdr, CORBA::Boolean &x)
 {
-  if (cdr.good_bit ())
-    cdr.read_boolean (x);
-  return cdr;
+  cdr.read_boolean (x);
+  return cdr.good_bit ();
 }
 #endif /* ACE_HAS_BOOL */
 
-ACE_INLINE TAO_InputCDR&
+ACE_INLINE CORBA_Boolean
 operator>> (TAO_InputCDR& cdr, CORBA::Octet &x)
 {
-  if (cdr.good_bit ())
-    cdr.read_octet (x);
-  return cdr;
+  cdr.read_octet (x);
+  return cdr.good_bit ();
 }
 
-ACE_INLINE TAO_InputCDR&
+ACE_INLINE CORBA_Boolean
 operator>> (TAO_InputCDR& cdr, CORBA::Short &x)
 {
-  if (cdr.good_bit ())
-    cdr.read_short (x);
-  return cdr;
+  cdr.read_short (x);
+  return cdr.good_bit ();
 }
 
-ACE_INLINE TAO_InputCDR&
+ACE_INLINE CORBA_Boolean
 operator>> (TAO_InputCDR& cdr, CORBA::UShort &x)
 {
-  if (cdr.good_bit ())
-    cdr.read_ushort (x);
-  return cdr;
+  cdr.read_ushort (x);
+  return cdr.good_bit ();
 }
 
-ACE_INLINE TAO_InputCDR&
+ACE_INLINE CORBA_Boolean
 operator>> (TAO_InputCDR& cdr, CORBA::Long &x)
 {
-  if (cdr.good_bit ())
-    cdr.read_long (x);
-  return cdr;
+  cdr.read_long (x);
+  return cdr.good_bit ();
 }
 
-ACE_INLINE TAO_InputCDR&
+ACE_INLINE CORBA_Boolean
 operator>> (TAO_InputCDR& cdr, CORBA::ULong &x)
 {
-  if (cdr.good_bit ())
-    cdr.read_ulong (x);
-  return cdr;
+  cdr.read_ulong (x);
+  return cdr.good_bit ();
 }
 
-ACE_INLINE TAO_InputCDR&
+ACE_INLINE CORBA_Boolean
 operator>> (TAO_InputCDR& cdr, CORBA::LongLong &x)
 {
-  if (cdr.good_bit ())
-    cdr.read_longlong (x);
-  return cdr;
+  cdr.read_longlong (x);
+  return cdr.good_bit ();
 }
 
-ACE_INLINE TAO_InputCDR&
+ACE_INLINE CORBA_Boolean
 operator>> (TAO_InputCDR& cdr, CORBA::ULongLong &x)
 {
-  if (cdr.good_bit ())
-    cdr.read_ulonglong (x);
-  return cdr;
+  cdr.read_ulonglong (x);
+  return cdr.good_bit ();
 }
 
-ACE_INLINE TAO_InputCDR&
+ACE_INLINE CORBA_Boolean
 operator>> (TAO_InputCDR& cdr, CORBA::Float &x)
 {
-  if (cdr.good_bit ())
-    cdr.read_float (x);
-  return cdr;
+  cdr.read_float (x);
+  return cdr.good_bit ();
 }
 
-ACE_INLINE TAO_InputCDR&
+ACE_INLINE CORBA_Boolean
 operator>> (TAO_InputCDR& cdr, CORBA::Double &x)
 {
-  if (cdr.good_bit ())
-    cdr.read_double (x);
-  return cdr;
+  cdr.read_double (x);
+  return cdr.good_bit ();
 }
 
-ACE_INLINE TAO_InputCDR&
+ACE_INLINE CORBA_Boolean
 operator>> (TAO_InputCDR& cdr, CORBA::Char &x)
 {
-  if (cdr.good_bit ())
-    cdr.read_char (x);
-  return cdr;
+  cdr.read_char (x);
+  return cdr.good_bit ();
 }
 
-ACE_INLINE TAO_InputCDR&
+ACE_INLINE CORBA_Boolean
 operator>> (TAO_InputCDR& cdr, CORBA::Char*&x)
 {
-  if (cdr.good_bit ())
-    cdr.read_string (x);
-  return cdr;
+  cdr.read_string (x);
+  return cdr.good_bit ();
 }
 
 // ***************************************************************************
diff --git a/TAO/tao/GIOP.cpp b/TAO/tao/GIOP.cpp
index 3ae8c7cefa3..42385677b17 100644
--- a/TAO/tao/GIOP.cpp
+++ b/TAO/tao/GIOP.cpp
@@ -123,39 +123,36 @@ TAO_GIOP::dump_msg (const char *label,
     }
 }
 
-TAO_OutputCDR&
+CORBA_Boolean
 operator<<(TAO_OutputCDR& cdr, const TAO_GIOP_ServiceContext& x)
 {
-  if (cdr.good_bit ())
-    {
-      cdr << x.context_id
-          << x.context_data;
-    }
-  return cdr;
+  if ( (cdr << x.context_id)
+       && (cdr << x.context_data) )
+    return CORBA::B_TRUE;
+  return CORBA::B_FALSE;
 }
 
-TAO_InputCDR&
+CORBA_Boolean
+
 operator>>(TAO_InputCDR& cdr, TAO_GIOP_ServiceContext& x)
 {
-  if (cdr.good_bit ())
-    {
-      cdr >> x.context_id
-          >> x.context_data;
-    }
-  return cdr;
+  if ( (cdr >> x.context_id)
+       && (cdr >> x.context_data) )
+    return CORBA::B_TRUE;
+  return CORBA::B_FALSE;
 }
 
-TAO_OutputCDR&
+CORBA_Boolean
 operator<<(TAO_OutputCDR& cdr, const TAO_GIOP_ServiceContextList& x)
 {
   CORBA::ULong length = x.length ();
   cdr.write_ulong (length);
   for (CORBA::ULong i = 0; i < length && cdr.good_bit (); ++i)
     cdr << x[i];
-  return cdr;
+  return cdr.good_bit ();
 }
 
-TAO_InputCDR&
+CORBA_Boolean
 operator>>(TAO_InputCDR& cdr, TAO_GIOP_ServiceContextList& x)
 {
   CORBA::ULong length;
@@ -166,7 +163,7 @@ operator>>(TAO_InputCDR& cdr, TAO_GIOP_ServiceContextList& x)
       for (CORBA::ULong i = 0; i < length && cdr.good_bit (); ++i)
         cdr >> x[i];
     }
-  return cdr;
+  return cdr.good_bit ();
 }
 
 // @@ TODO: this is a good candidate for an ACE routine, even more,
diff --git a/TAO/tao/GIOP.h b/TAO/tao/GIOP.h
index 47fa24eae5e..575f4397dd5 100644
--- a/TAO/tao/GIOP.h
+++ b/TAO/tao/GIOP.h
@@ -189,17 +189,17 @@ typedef TAO_Unbounded_Sequence<TAO_GIOP_ServiceContext>
 
 extern CORBA::TypeCode_ptr TC_ServiceContextList;
 
-extern TAO_Export TAO_OutputCDR&
-operator<<(TAO_OutputCDR&, const TAO_GIOP_ServiceContext&);
+extern TAO_Export CORBA_Boolean
+operator<< (TAO_OutputCDR&, const TAO_GIOP_ServiceContext&);
 
-extern TAO_Export TAO_InputCDR&
-operator>>(TAO_InputCDR&, TAO_GIOP_ServiceContext&);
+extern TAO_Export CORBA_Boolean
+operator>> (TAO_InputCDR&, TAO_GIOP_ServiceContext&);
 
-extern TAO_Export TAO_OutputCDR&
-operator<<(TAO_OutputCDR&, const TAO_GIOP_ServiceContextList&);
+extern TAO_Export CORBA_Boolean
+operator<< (TAO_OutputCDR&, const TAO_GIOP_ServiceContextList&);
 
-extern TAO_Export TAO_InputCDR&
-operator>>(TAO_InputCDR&, TAO_GIOP_ServiceContextList&);
+extern TAO_Export CORBA_Boolean
+operator>> (TAO_InputCDR&, TAO_GIOP_ServiceContextList&);
 
 // = Reply headers
 
diff --git a/TAO/tao/ORB.cpp b/TAO/tao/ORB.cpp
index 8f126ad675a..c2f3b74cfec 100644
--- a/TAO/tao/ORB.cpp
+++ b/TAO/tao/ORB.cpp
@@ -829,8 +829,8 @@ CORBA::ORB_init (int &argc,
 // Inline operators for TAO_opaque encoding and decoding
 // *************************************************************
 
-TAO_OutputCDR&
-operator<<(TAO_OutputCDR& cdr, const TAO_opaque& x)
+CORBA_Boolean
+operator<< (TAO_OutputCDR& cdr, const TAO_opaque& x)
 {
   CORBA::ULong length = x.length ();
   cdr.write_ulong (length);
@@ -842,10 +842,10 @@ operator<<(TAO_OutputCDR& cdr, const TAO_opaque& x)
   else
     cdr.write_octet_array_mb (x.mb ());
 #endif /* TAO_NO_COPY_OCTET_SEQUENCES */
-  return cdr;
+  return cdr.good_bit ();
 }
 
-TAO_InputCDR&
+CORBA_Boolean
 operator>>(TAO_InputCDR& cdr, TAO_opaque& x)
 {
   CORBA::ULong length;
@@ -857,7 +857,7 @@ operator>>(TAO_InputCDR& cdr, TAO_opaque& x)
   x.replace (length, cdr.start ());
   cdr.skip_bytes (length);
 #endif /* TAO_NO_COPY_OCTET_SEQUENCES */
-  return cdr;
+  return cdr.good_bit ();
 }
 
 // ****************************************************************
diff --git a/TAO/tao/Principal.cpp b/TAO/tao/Principal.cpp
index 4751d0bf8e8..b453b4d6eff 100644
--- a/TAO/tao/Principal.cpp
+++ b/TAO/tao/Principal.cpp
@@ -39,7 +39,7 @@ CORBA_Principal::~CORBA_Principal (void)
 {
 }
 
-TAO_OutputCDR&
+CORBA_Boolean
 operator<< (TAO_OutputCDR& cdr, CORBA_Principal* x)
 {
   if (x != 0)
@@ -52,10 +52,10 @@ operator<< (TAO_OutputCDR& cdr, CORBA_Principal* x)
     {
       cdr.write_ulong (0);
     }
-  return cdr;
+  return cdr.good_bit ();
 }
 
-TAO_InputCDR&
+CORBA_Boolean
 operator>> (TAO_InputCDR& cdr, CORBA_Principal*& x)
 {
   CORBA::ULong length;
@@ -66,9 +66,9 @@ operator>> (TAO_InputCDR& cdr, CORBA_Principal*& x)
     }
   else
     {
-      ACE_NEW_RETURN (x, CORBA::Principal, cdr);
+      ACE_NEW_RETURN (x, CORBA::Principal, CORBA::B_FALSE);
       x->id.length (length);
       cdr.read_octet_array (x->id.get_buffer (), length);
     }
-  return cdr;
+  return cdr.good_bit ();
 }
diff --git a/TAO/tao/Principal.h b/TAO/tao/Principal.h
index 655c2f1f1f5..48ecf23ce28 100644
--- a/TAO/tao/Principal.h
+++ b/TAO/tao/Principal.h
@@ -67,11 +67,11 @@ private:
 #endif /* __GNUG__ */
 };
 
-extern TAO_Export TAO_OutputCDR&
-operator<<(TAO_OutputCDR&, CORBA_Principal*);
+extern TAO_Export CORBA_Boolean
+operator<< (TAO_OutputCDR&, CORBA_Principal*);
 
-extern TAO_Export TAO_InputCDR&
-operator>>(TAO_InputCDR&, CORBA_Principal*&);
+extern TAO_Export CORBA_Boolean
+operator>> (TAO_InputCDR&, CORBA_Principal*&);
 
 #if defined (__ACE_INLINE__)
 # include "tao/Principal.i"
diff --git a/TAO/tao/corba.h b/TAO/tao/corba.h
index 665110dfd2b..466bdf1b4fd 100644
--- a/TAO/tao/corba.h
+++ b/TAO/tao/corba.h
@@ -161,11 +161,11 @@ typedef void (*TAO_Skeleton)(CORBA_ServerRequest &,
 typedef TAO_Unbounded_Sequence<CORBA::Octet> TAO_opaque;
 extern CORBA::TypeCode_ptr TC_opaque;
 
-extern TAO_Export TAO_OutputCDR&
-operator<<(TAO_OutputCDR&, const TAO_opaque&);
+extern TAO_Export CORBA_Boolean
+operator<< (TAO_OutputCDR&, const TAO_opaque&);
 
-extern TAO_Export TAO_InputCDR&
-operator>>(TAO_InputCDR&, TAO_opaque&);
+extern TAO_Export CORBA_Boolean
+operator>> (TAO_InputCDR&, TAO_opaque&);
 
 #include "tao/Exception.h"
 #include "tao/Any.h"