dep/ACE_wrappers/ace/CDR_Size.inl

   1 // -*- C++ -*-
   2 //
   3 // $Id: CDR_Size.inl 80826 2008-03-04 14:51:23Z wotte $
   4
   5 #include "ace/OS_NS_string.h"
   6
   7 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
   8
   9 ACE_INLINE
  10 ACE_SizeCDR::ACE_SizeCDR (ACE_CDR::Octet major_version,
  11                           ACE_CDR::Octet minor_version)
  12     : good_bit_ (true),
  13       size_ (0),
  14       major_version_ (major_version),
  15       minor_version_ (minor_version)
  16 {
  17 }
  18
  19 ACE_INLINE bool
  20 ACE_SizeCDR::good_bit (void) const
  21 {
  22   return this->good_bit_;
  23 }
  24
  25 ACE_INLINE void
  26 ACE_SizeCDR::reset (void)
  27 {
  28   this->size_ = 0;
  29 }
  30
  31 ACE_INLINE size_t
  32 ACE_SizeCDR::total_length (void) const
  33 {
  34   return this->size_;
  35 }
  36
  37
  38 // Encode the CDR stream.
  39
  40 ACE_INLINE ACE_CDR::Boolean
  41 ACE_SizeCDR::write_octet (ACE_CDR::Octet x)
  42 {
  43   return this->write_1 (reinterpret_cast<const ACE_CDR::Octet *> (&x));
  44 }
  45
  46 ACE_INLINE ACE_CDR::Boolean
  47 ACE_SizeCDR::write_boolean (ACE_CDR::Boolean x)
  48 {
  49   return (ACE_CDR::Boolean) this->write_octet (x ? (ACE_CDR::Octet) 1 : (ACE_CDR::Octet) 0);
  50 }
  51
  52 ACE_INLINE ACE_CDR::Boolean
  53 ACE_SizeCDR::write_char (ACE_CDR::Char x)
  54 {
  55   // Note: translator framework is not supported.
  56   //
  57   return this->write_1 (reinterpret_cast<const ACE_CDR::Octet*> (&x));
  58 }
  59
  60 ACE_INLINE ACE_CDR::Boolean
  61 ACE_SizeCDR::write_short (ACE_CDR::Short x)
  62 {
  63   return this->write_2 (reinterpret_cast<const ACE_CDR::UShort*> (&x));
  64 }
  65
  66 ACE_INLINE ACE_CDR::Boolean
  67 ACE_SizeCDR::write_ushort (ACE_CDR::UShort x)
  68 {
  69   return this->write_2 (reinterpret_cast<const ACE_CDR::UShort*> (&x));
  70 }
  71
  72 ACE_INLINE ACE_CDR::Boolean
  73 ACE_SizeCDR::write_long (ACE_CDR::Long x)
  74 {
  75   return this->write_4 (reinterpret_cast<const ACE_CDR::ULong*> (&x));
  76 }
  77
  78 ACE_INLINE ACE_CDR::Boolean
  79 ACE_SizeCDR::write_ulong (ACE_CDR::ULong x)
  80 {
  81   return this->write_4 (reinterpret_cast<const ACE_CDR::ULong*> (&x));
  82 }
  83
  84 ACE_INLINE ACE_CDR::Boolean
  85 ACE_SizeCDR::write_longlong (const ACE_CDR::LongLong &x)
  86 {
  87   return this->write_8 (reinterpret_cast<const ACE_CDR::ULongLong*> (&x));
  88 }
  89
  90 ACE_INLINE ACE_CDR::Boolean
  91 ACE_SizeCDR::write_ulonglong (const ACE_CDR::ULongLong &x)
  92 {
  93   const void *temp = &x;
  94   return this->write_8 (reinterpret_cast<const ACE_CDR::ULongLong *> (temp));
  95 }
  96
  97 ACE_INLINE ACE_CDR::Boolean
  98 ACE_SizeCDR::write_float (ACE_CDR::Float x)
  99 {
 100   const void *temp = &x;
 101   return this->write_4 (reinterpret_cast<const ACE_CDR::ULong *> (temp));
 102 }
 103
 104 ACE_INLINE ACE_CDR::Boolean
 105 ACE_SizeCDR::write_double (const ACE_CDR::Double &x)
 106 {
 107   const void *temp = &x;
 108   return this->write_8 (reinterpret_cast<const ACE_CDR::ULongLong*> (temp));
 109 }
 110
 111 ACE_INLINE ACE_CDR::Boolean
 112 ACE_SizeCDR::write_longdouble (const ACE_CDR::LongDouble &x)
 113 {
 114   const void *temp = &x;
 115   return this->write_16 (reinterpret_cast<const ACE_CDR::LongDouble*> (temp));
 116 }
 117
 118 ACE_INLINE ACE_CDR::Boolean
 119 ACE_SizeCDR::write_string (const ACE_CDR::Char *x)
 120 {
 121   if (x != 0)
 122     {
 123       const ACE_CDR::ULong len =
 124         static_cast<ACE_CDR::ULong> (ACE_OS::strlen (x));
 125       return this->write_string (len, x);
 126     }
 127   return this->write_string (0, 0);
 128 }
 129
 130 ACE_INLINE ACE_CDR::Boolean
 131 ACE_SizeCDR::write_wstring (const ACE_CDR::WChar *x)
 132 {
 133   if (x != 0)
 134     {
 135       ACE_CDR::ULong len =
 136         static_cast<ACE_CDR::ULong> (ACE_OS::strlen (x));
 137       return this->write_wstring (len, x);
 138     }
 139   return this->write_wstring (0, 0);
 140 }
 141
 142 ACE_INLINE ACE_CDR::Boolean
 143 ACE_SizeCDR::write_char_array (const ACE_CDR::Char *x,
 144                                  ACE_CDR::ULong length)
 145 {
 146   // Note: translator framework is not supported.
 147   //
 148   return this->write_array (x,
 149                             ACE_CDR::OCTET_SIZE,
 150                             ACE_CDR::OCTET_ALIGN,
 151                             length);
 152 }
 153
 154 ACE_INLINE ACE_CDR::Boolean
 155 ACE_SizeCDR::write_wchar_array (const ACE_CDR::WChar* x,
 156                                   ACE_CDR::ULong length)
 157 {
 158   // Note: translator framework is not supported.
 159   //
 160   if (ACE_OutputCDR::wchar_maxbytes () == 0)
 161     {
 162       errno = EACCES;
 163       return (ACE_CDR::Boolean) (this->good_bit_ = false);
 164     }
 165   if (ACE_OutputCDR::wchar_maxbytes () == sizeof (ACE_CDR::WChar))
 166     return this->write_array (x,
 167                               sizeof (ACE_CDR::WChar),
 168                               sizeof (ACE_CDR::WChar) == 2
 169                               ? ACE_CDR::SHORT_ALIGN
 170                               : ACE_CDR::LONG_ALIGN,
 171                               length);
 172   return this->write_wchar_array_i (x,length);
 173 }
 174
 175 ACE_INLINE ACE_CDR::Boolean
 176 ACE_SizeCDR::write_octet_array (const ACE_CDR::Octet* x,
 177                                   ACE_CDR::ULong length)
 178 {
 179   return this->write_array (x,
 180                             ACE_CDR::OCTET_SIZE,
 181                             ACE_CDR::OCTET_ALIGN,
 182                             length);
 183 }
 184
 185 ACE_INLINE ACE_CDR::Boolean
 186 ACE_SizeCDR::write_short_array (const ACE_CDR::Short *x,
 187                                   ACE_CDR::ULong length)
 188 {
 189   return this->write_array (x,
 190                             ACE_CDR::SHORT_SIZE,
 191                             ACE_CDR::SHORT_ALIGN,
 192                             length);
 193 }
 194
 195 ACE_INLINE ACE_CDR::Boolean
 196 ACE_SizeCDR::write_ushort_array (const ACE_CDR::UShort *x,
 197                                  ACE_CDR::ULong length)
 198 {
 199   return this->write_array (x,
 200                             ACE_CDR::SHORT_SIZE,
 201                             ACE_CDR::SHORT_ALIGN,
 202                             length);
 203 }
 204
 205 ACE_INLINE ACE_CDR::Boolean
 206 ACE_SizeCDR::write_long_array (const ACE_CDR::Long *x,
 207                                ACE_CDR::ULong length)
 208 {
 209   return this->write_array (x,
 210                             ACE_CDR::LONG_SIZE,
 211                             ACE_CDR::LONG_ALIGN,
 212                             length);
 213 }
 214
 215 ACE_INLINE ACE_CDR::Boolean
 216 ACE_SizeCDR::write_ulong_array (const ACE_CDR::ULong *x,
 217                                 ACE_CDR::ULong length)
 218 {
 219   return this->write_array (x,
 220                             ACE_CDR::LONG_SIZE,
 221                             ACE_CDR::LONG_ALIGN,
 222                             length);
 223 }
 224
 225 ACE_INLINE ACE_CDR::Boolean
 226 ACE_SizeCDR::write_longlong_array (const ACE_CDR::LongLong *x,
 227                                      ACE_CDR::ULong length)
 228 {
 229   return this->write_array (x,
 230                             ACE_CDR::LONGLONG_SIZE,
 231                             ACE_CDR::LONGLONG_ALIGN,
 232                             length);
 233 }
 234
 235 ACE_INLINE ACE_CDR::Boolean
 236 ACE_SizeCDR::write_ulonglong_array (const ACE_CDR::ULongLong *x,
 237                                       ACE_CDR::ULong length)
 238 {
 239   return this->write_array (x,
 240                             ACE_CDR::LONGLONG_SIZE,
 241                             ACE_CDR::LONGLONG_ALIGN,
 242                             length);
 243 }
 244
 245 ACE_INLINE ACE_CDR::Boolean
 246 ACE_SizeCDR::write_float_array (const ACE_CDR::Float *x,
 247                                   ACE_CDR::ULong length)
 248 {
 249   return this->write_array (x,
 250                             ACE_CDR::LONG_SIZE,
 251                             ACE_CDR::LONG_ALIGN,
 252                             length);
 253 }
 254
 255
 256 ACE_INLINE ACE_CDR::Boolean
 257 ACE_SizeCDR::write_double_array (const ACE_CDR::Double *x,
 258                                    ACE_CDR::ULong length)
 259 {
 260   return this->write_array (x,
 261                             ACE_CDR::LONGLONG_SIZE,
 262                             ACE_CDR::LONGLONG_ALIGN,
 263                             length);
 264 }
 265
 266 ACE_INLINE ACE_CDR::Boolean
 267 ACE_SizeCDR::write_longdouble_array (const ACE_CDR::LongDouble* x,
 268                                        ACE_CDR::ULong length)
 269 {
 270   return this->write_array (x,
 271                             ACE_CDR::LONGDOUBLE_SIZE,
 272                             ACE_CDR::LONGDOUBLE_ALIGN,
 273                             length);
 274 }
 275
 276
 277 // ****************************************************************
 278
 279
 280 ACE_INLINE ACE_CDR::Boolean
 281 operator<< (ACE_SizeCDR &ss, ACE_CDR::Char x)
 282 {
 283   ss.write_char (x);
 284   return (ACE_CDR::Boolean) ss.good_bit ();
 285 }
 286
 287 ACE_INLINE ACE_CDR::Boolean
 288 operator<< (ACE_SizeCDR &ss, ACE_CDR::Short x)
 289 {
 290   ss.write_short (x);
 291   return (ACE_CDR::Boolean) ss.good_bit ();
 292 }
 293
 294 ACE_INLINE ACE_CDR::Boolean
 295 operator<< (ACE_SizeCDR &ss, ACE_CDR::UShort x)
 296 {
 297   ss.write_ushort (x);
 298   return (ACE_CDR::Boolean) ss.good_bit ();
 299 }
 300
 301 ACE_INLINE ACE_CDR::Boolean
 302 operator<< (ACE_SizeCDR &ss, ACE_CDR::Long x)
 303 {
 304   ss.write_long (x);
 305   return (ACE_CDR::Boolean) ss.good_bit ();
 306 }
 307
 308 ACE_INLINE ACE_CDR::Boolean
 309 operator<< (ACE_SizeCDR &ss, ACE_CDR::ULong x)
 310 {
 311   ss.write_ulong (x);
 312   return (ACE_CDR::Boolean) ss.good_bit ();
 313 }
 314
 315 ACE_INLINE ACE_CDR::Boolean
 316 operator<< (ACE_SizeCDR &ss, ACE_CDR::LongLong x)
 317 {
 318   ss.write_longlong (x);
 319   return (ACE_CDR::Boolean) ss.good_bit ();
 320 }
 321
 322 ACE_INLINE ACE_CDR::Boolean
 323 operator<< (ACE_SizeCDR &ss, ACE_CDR::ULongLong x)
 324 {
 325   ss.write_ulonglong (x);
 326   return (ACE_CDR::Boolean) ss.good_bit ();
 327 }
 328
 329 ACE_INLINE ACE_CDR::Boolean
 330 operator<< (ACE_SizeCDR &ss, ACE_CDR::LongDouble x)
 331 {
 332   ss.write_longdouble (x);
 333   return (ACE_CDR::Boolean) ss.good_bit ();
 334 }
 335
 336 ACE_INLINE ACE_CDR::Boolean
 337 operator<< (ACE_SizeCDR &ss, ACE_CDR::Float x)
 338 {
 339   ss.write_float (x);
 340   return (ACE_CDR::Boolean) ss.good_bit ();
 341 }
 342
 343 ACE_INLINE ACE_CDR::Boolean
 344 operator<< (ACE_SizeCDR &ss, ACE_CDR::Double x)
 345 {
 346   ss.write_double (x);
 347   return (ACE_CDR::Boolean) ss.good_bit ();
 348 }
 349
 350 ACE_INLINE ACE_CDR::Boolean
 351 operator<< (ACE_SizeCDR &ss, const ACE_CDR::Char *x)
 352 {
 353   ss.write_string (x);
 354   return (ACE_CDR::Boolean) ss.good_bit ();
 355 }
 356
 357 ACE_INLINE ACE_CDR::Boolean
 358 operator<< (ACE_SizeCDR &ss, const ACE_CDR::WChar *x)
 359 {
 360   ss.write_wstring (x);
 361   return (ACE_CDR::Boolean) ss.good_bit ();
 362 }
 363
 364 // The following use the helper classes
 365 ACE_INLINE ACE_CDR::Boolean
 366 operator<< (ACE_SizeCDR &ss, ACE_OutputCDR::from_boolean x)
 367 {
 368   ss.write_boolean (x.val_);
 369   return (ACE_CDR::Boolean) ss.good_bit ();
 370 }
 371
 372 ACE_INLINE ACE_CDR::Boolean
 373 operator<< (ACE_SizeCDR &ss, ACE_OutputCDR::from_char x)
 374 {
 375   ss.write_char (x.val_);
 376   return (ACE_CDR::Boolean) ss.good_bit ();
 377 }
 378
 379 ACE_INLINE ACE_CDR::Boolean
 380 operator<< (ACE_SizeCDR &ss, ACE_OutputCDR::from_wchar x)
 381 {
 382   ss.write_wchar (x.val_);
 383   return (ACE_CDR::Boolean) ss.good_bit ();
 384 }
 385
 386 ACE_INLINE ACE_CDR::Boolean
 387 operator<< (ACE_SizeCDR &ss, ACE_OutputCDR::from_octet x)
 388 {
 389   ss.write_octet (x.val_);
 390   return (ACE_CDR::Boolean) ss.good_bit ();
 391 }
 392
 393 ACE_INLINE ACE_CDR::Boolean
 394 operator<< (ACE_SizeCDR &ss, ACE_OutputCDR::from_string x)
 395 {
 396   ACE_CDR::ULong len = 0;
 397
 398   if (x.val_ != 0)
 399     {
 400       len = static_cast<ACE_CDR::ULong> (ACE_OS::strlen (x.val_));
 401     }
 402
 403   ss.write_string (len, x.val_);
 404   return
 405     (ACE_CDR::Boolean) (ss.good_bit () && (!x.bound_ || len <= x.bound_));
 406 }
 407
 408 ACE_INLINE ACE_CDR::Boolean
 409 operator<< (ACE_SizeCDR &ss, ACE_OutputCDR::from_wstring x)
 410 {
 411   ACE_CDR::ULong len = 0;
 412
 413   if (x.val_ != 0)
 414     {
 415         len = static_cast<ACE_CDR::ULong> (ACE_OS::strlen (x.val_));
 416     }
 417
 418   ss.write_wstring (len, x.val_);
 419   return
 420     (ACE_CDR::Boolean) (ss.good_bit () && (!x.bound_ || len <= x.bound_));
 421 }
 422
 423
 424 ACE_END_VERSIONED_NAMESPACE_DECL