TAO/tao/CDR.inl

   1 // -*- C++ -*-
   2 #include "tao/SystemException.h"
   3 #include <cstring>
   4
   5 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
   6
   7 ACE_INLINE
   8 TAO_OutputCDR::~TAO_OutputCDR ()
   9 {
  10 }
  11
  12 ACE_INLINE bool
  13 TAO_OutputCDR::more_fragments () const
  14 {
  15   return this->more_fragments_;
  16 }
  17
  18 ACE_INLINE void
  19 TAO_OutputCDR::more_fragments (bool more)
  20 {
  21   this->more_fragments_ = more;
  22 }
  23
  24 ACE_INLINE void
  25 TAO_OutputCDR::message_attributes (CORBA::ULong request_id,
  26                                    TAO_Stub * stub,
  27                                    TAO_Message_Semantics message_semantics,
  28                                    ACE_Time_Value * timeout)
  29 {
  30   this->request_id_        = request_id;
  31   this->stub_              = stub;
  32   this->message_semantics_ = message_semantics;
  33   this->timeout_           = timeout;
  34 }
  35
  36 ACE_INLINE CORBA::ULong
  37 TAO_OutputCDR::request_id () const
  38 {
  39   return this->request_id_;
  40 }
  41
  42 ACE_INLINE TAO_Stub *
  43 TAO_OutputCDR::stub () const
  44 {
  45   return this->stub_;
  46 }
  47
  48 ACE_INLINE TAO_Message_Semantics
  49 TAO_OutputCDR::message_semantics () const
  50 {
  51   return this->message_semantics_;
  52 }
  53
  54 ACE_INLINE ACE_Time_Value *
  55 TAO_OutputCDR::timeout () const
  56 {
  57   return this->timeout_;
  58 }
  59
  60 ACE_INLINE void
  61 TAO_OutputCDR::get_version (TAO_GIOP_Message_Version& giop_version)
  62 {
  63   giop_version.set_version (this->major_version_, this->minor_version_);
  64 }
  65
  66 ACE_INLINE TAO_OutputCDR::Repo_Id_Map_Handle&
  67 TAO_OutputCDR::get_repo_id_map ()
  68 {
  69   return this->repo_id_map_;
  70 }
  71
  72 #ifdef TAO_HAS_VALUETYPE_CODEBASE
  73 ACE_INLINE TAO_OutputCDR::Codebase_URL_Map_Handle&
  74 TAO_OutputCDR::get_codebase_url_map ()
  75 {
  76   return this->codebase_map_;
  77 }
  78 #endif
  79
  80 ACE_INLINE TAO_OutputCDR::Value_Map_Handle&
  81 TAO_OutputCDR::get_value_map ()
  82 {
  83   return this->value_map_;
  84 }
  85
  86 ACE_INLINE void
  87 TAO_OutputCDR::set_repo_id_map (TAO_OutputCDR::Repo_Id_Map_Handle& map)
  88 {
  89   this->repo_id_map_ = map;
  90 }
  91
  92 #ifdef TAO_HAS_VALUETYPE_CODEBASE
  93 ACE_INLINE void
  94 TAO_OutputCDR::set_codebase_url_map (TAO_OutputCDR::Codebase_URL_Map_Handle& map)
  95 {
  96   this->codebase_map_ = map;
  97 }
  98 #endif
  99
 100 ACE_INLINE void
 101 TAO_OutputCDR::set_value_map (TAO_OutputCDR::Value_Map_Handle& map)
 102 {
 103   this->value_map_ = map;
 104 }
 105
 106 ACE_INLINE void
 107 TAO_OutputCDR::reset_vt_indirect_maps ()
 108 {
 109   if (! this->repo_id_map_.is_nil () && this->repo_id_map_->get()->current_size () != 0)
 110   {
 111     this->repo_id_map_->get()->unbind_all ();
 112   }
 113 #ifdef TAO_HAS_VALUETYPE_CODEBASE
 114   if (! this->codebase_map_.is_nil () && this->codebase_map_->get()->current_size () != 0)
 115   {
 116     this->codebase_map_->get()->unbind_all ();
 117   }
 118 #endif
 119   if (! this->value_map_.is_nil () && this->value_map_->get()->current_size () != 0)
 120   {
 121     this->value_map_->get()->unbind_all ();
 122   }
 123 }
 124
 125 // -------------------------------------------------------------------
 126
 127 ACE_INLINE
 128 TAO_InputCDR::TAO_InputCDR (const char *buf,
 129                             size_t bufsiz,
 130                             int byte_order,
 131                             ACE_CDR::Octet major_version,
 132                             ACE_CDR::Octet minor_version,
 133                             TAO_ORB_Core* orb_core)
 134   : ACE_InputCDR (buf,
 135                   bufsiz,
 136                   byte_order,
 137                   major_version,
 138                   minor_version),
 139     orb_core_ (orb_core)
 140 {
 141 }
 142
 143 ACE_INLINE
 144 TAO_InputCDR::TAO_InputCDR (size_t bufsiz,
 145                             int byte_order,
 146                             ACE_CDR::Octet major_version,
 147                             ACE_CDR::Octet minor_version,
 148                             TAO_ORB_Core* orb_core)
 149   : ACE_InputCDR (bufsiz,
 150                   byte_order,
 151                   major_version,
 152                   minor_version),
 153     orb_core_ (orb_core)
 154 {
 155 }
 156
 157 ACE_INLINE
 158 TAO_InputCDR::TAO_InputCDR (const ACE_Message_Block *data,
 159                             int byte_order,
 160                             ACE_CDR::Octet major_version,
 161                             ACE_CDR::Octet minor_version,
 162                             TAO_ORB_Core* orb_core)
 163   : ACE_InputCDR (data,
 164                   byte_order,
 165                   major_version,
 166                   minor_version),
 167     orb_core_ (orb_core)
 168 {
 169 }
 170
 171 ACE_INLINE
 172 TAO_InputCDR::TAO_InputCDR (const ACE_Message_Block *data,
 173                             ACE_Lock* lock,
 174                             int byte_order,
 175                             ACE_CDR::Octet major_version,
 176                             ACE_CDR::Octet minor_version,
 177                             TAO_ORB_Core* orb_core)
 178   : ACE_InputCDR (data,
 179                   byte_order,
 180                   major_version,
 181                   minor_version,
 182                   lock),
 183     orb_core_ (orb_core)
 184 {
 185 }
 186
 187 ACE_INLINE
 188 TAO_InputCDR::TAO_InputCDR (ACE_Data_Block *data,
 189                             ACE_Message_Block::Message_Flags flag,
 190                             int byte_order,
 191                             ACE_CDR::Octet major_version,
 192                             ACE_CDR::Octet minor_version,
 193                             TAO_ORB_Core* orb_core)
 194   : ACE_InputCDR (data,
 195                   flag,
 196                   byte_order,
 197                   major_version,
 198                   minor_version),
 199     orb_core_ (orb_core)
 200 {
 201 }
 202
 203
 204 ACE_INLINE
 205 TAO_InputCDR::TAO_InputCDR (ACE_Data_Block *data,
 206                             ACE_Message_Block::Message_Flags flag,
 207                             size_t rd_pos,
 208                             size_t wr_pos,
 209                             int byte_order,
 210                             ACE_CDR::Octet major_version,
 211                             ACE_CDR::Octet minor_version,
 212                             TAO_ORB_Core* orb_core)
 213   : ACE_InputCDR (data,
 214                   flag,
 215                   rd_pos,
 216                   wr_pos,
 217                   byte_order,
 218                   major_version,
 219                   minor_version),
 220     orb_core_ (orb_core)
 221 {
 222 }
 223
 224
 225 ACE_INLINE
 226 TAO_InputCDR::TAO_InputCDR (const TAO_InputCDR& rhs,
 227                             size_t size,
 228                             ACE_CDR::Long offset)
 229   : ACE_InputCDR (rhs,
 230                   size,
 231                   offset),
 232     orb_core_ (rhs.orb_core_)
 233 {
 234 }
 235
 236 ACE_INLINE
 237 TAO_InputCDR::TAO_InputCDR (const TAO_InputCDR& rhs,
 238                             size_t size)
 239   : ACE_InputCDR (rhs,
 240                   size),
 241     orb_core_ (rhs.orb_core_)
 242 {
 243 }
 244
 245 ACE_INLINE
 246 TAO_InputCDR::TAO_InputCDR (const TAO_InputCDR& rhs)
 247   : ACE_InputCDR (rhs),
 248     orb_core_ (rhs.orb_core_),
 249     repo_id_map_ (rhs.repo_id_map_),
 250     codebase_map_ (rhs.codebase_map_),
 251     value_map_ (rhs.value_map_)
 252 {
 253 }
 254
 255 ACE_INLINE
 256 TAO_InputCDR::TAO_InputCDR (ACE_InputCDR::Transfer_Contents rhs,
 257                             TAO_ORB_Core* orb_core)
 258   : ACE_InputCDR (rhs),
 259     orb_core_ (orb_core)
 260 {
 261 }
 262
 263
 264 ACE_INLINE
 265 TAO_InputCDR::~TAO_InputCDR ()
 266 {
 267 }
 268
 269 ACE_INLINE TAO_ORB_Core*
 270 TAO_InputCDR::orb_core () const
 271 {
 272   return this->orb_core_;
 273 }
 274
 275
 276 ACE_INLINE TAO_InputCDR::Repo_Id_Map_Handle&
 277 TAO_InputCDR::get_repo_id_map ()
 278 {
 279   return this->repo_id_map_;
 280 }
 281
 282 ACE_INLINE TAO_InputCDR::Codebase_URL_Map_Handle&
 283 TAO_InputCDR::get_codebase_url_map ()
 284 {
 285   return this->codebase_map_;
 286 }
 287
 288 ACE_INLINE TAO_InputCDR::Value_Map_Handle&
 289 TAO_InputCDR::get_value_map ()
 290 {
 291   return this->value_map_;
 292 }
 293
 294 ACE_INLINE void
 295 TAO_InputCDR::set_repo_id_map (TAO_InputCDR::Repo_Id_Map_Handle& map)
 296 {
 297   this->repo_id_map_ = map;
 298 }
 299
 300 ACE_INLINE void
 301 TAO_InputCDR::set_codebase_url_map (TAO_InputCDR::Codebase_URL_Map_Handle& map)
 302 {
 303   this->codebase_map_ = map;
 304 }
 305
 306 ACE_INLINE void
 307 TAO_InputCDR::set_value_map (TAO_InputCDR::Value_Map_Handle& map)
 308 {
 309   this->value_map_ = map;
 310 }
 311
 312 ACE_INLINE void
 313 TAO_InputCDR::reset_vt_indirect_maps ()
 314 {
 315   if (! this->repo_id_map_.is_nil () && this->repo_id_map_->get()->current_size () != 0)
 316   {
 317     this->repo_id_map_->get()->unbind_all ();
 318   }
 319   if (! this->codebase_map_.is_nil () && this->codebase_map_->get()->current_size () != 0)
 320   {
 321     this->codebase_map_->get()->unbind_all ();
 322   }
 323   if (! this->value_map_.is_nil () && this->value_map_->get()->current_size () != 0)
 324   {
 325     this->value_map_->get()->unbind_all ();
 326   }
 327 }
 328
 329 // ****************************************************************
 330
 331 ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &os,
 332                                       CORBA::Short x)
 333 {
 334   return
 335     os.fragment_stream (ACE_CDR::SHORT_ALIGN,
 336                         sizeof (CORBA::Short))
 337     && static_cast<ACE_OutputCDR &> (os) << x;
 338 }
 339
 340 ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &os,
 341                                       CORBA::UShort x)
 342 {
 343   return
 344     os.fragment_stream (ACE_CDR::SHORT_ALIGN,
 345                         sizeof (CORBA::UShort))
 346     && static_cast<ACE_OutputCDR &> (os) << x;
 347 }
 348
 349 ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &os,
 350                                       CORBA::Long x)
 351 {
 352   return
 353     os.fragment_stream (ACE_CDR::LONG_ALIGN,
 354                         sizeof (CORBA::Long))
 355     && static_cast<ACE_OutputCDR &> (os) << x;
 356 }
 357
 358 ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &os,
 359                                       CORBA::ULong x)
 360 {
 361   return
 362     os.fragment_stream (ACE_CDR::LONG_ALIGN,
 363                         sizeof (CORBA::ULong))
 364     && static_cast<ACE_OutputCDR &> (os) << x;
 365 }
 366
 367 ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &os,
 368                                       CORBA::LongLong x)
 369 {
 370   return
 371     os.fragment_stream (ACE_CDR::LONGLONG_ALIGN,
 372                         sizeof (CORBA::LongLong))
 373     && static_cast<ACE_OutputCDR &> (os) << x;
 374 }
 375
 376 ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &os,
 377                                       CORBA::ULongLong x)
 378 {
 379   return
 380     os.fragment_stream (ACE_CDR::LONGLONG_ALIGN,
 381                         sizeof (CORBA::ULongLong))
 382     && static_cast<ACE_OutputCDR &> (os) << x;
 383 }
 384
 385 ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR& os,
 386                                       CORBA::LongDouble x)
 387 {
 388   return
 389     os.fragment_stream (ACE_CDR::LONGDOUBLE_ALIGN,
 390                         sizeof (CORBA::LongDouble))
 391     && static_cast<ACE_OutputCDR &> (os) << x;
 392 }
 393
 394 ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &os,
 395                                       CORBA::Float x)
 396 {
 397   return
 398     os.fragment_stream (ACE_CDR::LONG_ALIGN,
 399                         sizeof (CORBA::Float))
 400     && static_cast<ACE_OutputCDR &> (os) << x;
 401 }
 402
 403 ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &os,
 404                                       CORBA::Double x)
 405 {
 406   return
 407     os.fragment_stream (ACE_CDR::LONGLONG_ALIGN,
 408                         sizeof (CORBA::Double))
 409     && static_cast<ACE_OutputCDR &> (os) << x;
 410 }
 411
 412 ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &os,
 413                                       const char * x)
 414 {
 415   return
 416     os.fragment_stream (ACE_CDR::OCTET_ALIGN,
 417                         sizeof (char))
 418     && static_cast<ACE_OutputCDR &> (os) << x;
 419 }
 420
 421 ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &os,
 422                                       const CORBA::WChar * x)
 423 {
 424   return
 425     os.fragment_stream ((sizeof (CORBA::WChar) == 2
 426                          ? ACE_CDR::SHORT_ALIGN
 427                          : ACE_CDR::LONG_ALIGN),
 428                         sizeof (CORBA::WChar))
 429     && static_cast<ACE_OutputCDR &> (os) << x;
 430 }
 431
 432 ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &os,
 433                                       ACE_OutputCDR::from_string x)
 434 {
 435   if (x.bound_ != 0 && x.val_ != 0 &&
 436       std::strlen (x.val_) > x.bound_)
 437     {
 438       throw CORBA::BAD_PARAM ();
 439     }
 440   return os << x.val_;
 441 }
 442
 443 ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &os,
 444                                       ACE_OutputCDR::from_wstring x)
 445 {
 446   if (x.bound_ != 0 && x.val_ != 0 &&
 447       ACE_OS::strlen (x.val_) > x.bound_)
 448     {
 449       throw CORBA::BAD_PARAM ();
 450     }
 451   return os << x.val_;
 452 }
 453
 454 ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &os,
 455                                       const std::string &x)
 456 {
 457   return
 458     os.fragment_stream (ACE_CDR::OCTET_ALIGN,
 459                         sizeof (char))
 460     && static_cast<ACE_OutputCDR &> (os) << x;
 461 }
 462
 463 ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &os,
 464                                       const std::string_view &x)
 465 {
 466   return
 467     os.fragment_stream (ACE_CDR::OCTET_ALIGN,
 468                         sizeof (char))
 469     && static_cast<ACE_OutputCDR &> (os) << x;
 470 }
 471
 472 ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &os,
 473                                       ACE_OutputCDR::from_std_string x)
 474 {
 475   if (x.bound_ != 0 &&
 476       static_cast<ACE_CDR::ULong> (x.val_.size ()) > x.bound_)
 477     {
 478       throw CORBA::BAD_PARAM ();
 479     }
 480   return os << x.val_;
 481 }
 482
 483 #if !defined(ACE_LACKS_STD_WSTRING)
 484 ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &os,
 485                                       const std::wstring &x)
 486 {
 487   return
 488     os.fragment_stream ((sizeof (CORBA::WChar) == 2
 489                          ? ACE_CDR::SHORT_ALIGN
 490                          : ACE_CDR::LONG_ALIGN),
 491                         sizeof (CORBA::WChar))
 492     && static_cast<ACE_OutputCDR &> (os) << x;
 493 }
 494
 495 ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &os,
 496                                       ACE_OutputCDR::from_std_wstring x)
 497 {
 498   if (x.bound_ != 0 &&
 499       static_cast<ACE_CDR::ULong> (x.val_.size ()) > x.bound_)
 500     {
 501       throw CORBA::BAD_PARAM ();
 502     }
 503   return os << x.val_;
 504 }
 505 #endif /* ACE_LACKS_STD_WSTRING */
 506
 507 // ****************************************************************
 508
 509 ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &is,
 510                                       CORBA::Short &x)
 511 {
 512   return static_cast<ACE_InputCDR &> (is) >> x;
 513 }
 514
 515 ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &is,
 516                                       CORBA::UShort &x)
 517 {
 518   return static_cast<ACE_InputCDR &> (is) >> x;
 519 }
 520
 521 ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &is,
 522                                       CORBA::Long &x)
 523 {
 524   return static_cast<ACE_InputCDR&> (is) >> x;
 525 }
 526
 527 ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &is,
 528                                       CORBA::ULong &x)
 529 {
 530   return static_cast<ACE_InputCDR &> (is) >> x;
 531 }
 532
 533 ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &is,
 534                                       CORBA::LongLong &x)
 535 {
 536   return static_cast<ACE_InputCDR &> (is) >> x;
 537 }
 538
 539 ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &is,
 540                                       CORBA::ULongLong &x)
 541 {
 542   return static_cast<ACE_InputCDR &> (is) >> x;
 543 }
 544
 545 ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &is,
 546                                       CORBA::LongDouble &x)
 547 {
 548   return static_cast<ACE_InputCDR &> (is) >> x;
 549 }
 550
 551 ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &is,
 552                                       CORBA::Float &x)
 553 {
 554   return static_cast<ACE_InputCDR &> (is) >> x;
 555 }
 556
 557 ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &is,
 558                                       CORBA::Double &x)
 559 {
 560   return static_cast<ACE_InputCDR &> (is) >> x;
 561 }
 562
 563 ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &is,
 564                                       CORBA::Char* &x)
 565 {
 566   return static_cast<ACE_InputCDR &> (is) >> x;
 567 }
 568
 569 ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &is,
 570                                       CORBA::WChar* &x)
 571 {
 572   return static_cast<ACE_InputCDR &> (is) >> x;
 573 }
 574
 575 ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &is,
 576                                       ACE_InputCDR::to_string x)
 577 {
 578   CORBA::Boolean const marshal_flag =
 579     is >> const_cast<ACE_CDR::Char *&> (x.val_);
 580   if (marshal_flag && x.bound_ != 0 && x.val_ != 0 &&
 581       std::strlen (x.val_) > x.bound_)
 582     {
 583       throw CORBA::BAD_PARAM ();
 584     }
 585   return marshal_flag;
 586 }
 587
 588 ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &is,
 589                                       ACE_InputCDR::to_wstring x)
 590 {
 591   CORBA::Boolean const marshal_flag =
 592     is >> const_cast<ACE_CDR::WChar *&> (x.val_);
 593   if (marshal_flag && x.bound_ != 0 && x.val_ != 0 &&
 594       ACE_OS::strlen (x.val_) > x.bound_)
 595     {
 596       throw CORBA::BAD_PARAM ();
 597     }
 598   return marshal_flag;
 599 }
 600
 601 ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &is,
 602                                       std::string &x)
 603 {
 604   return static_cast<ACE_InputCDR &> (is) >> x;
 605 }
 606
 607 ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &is,
 608                                       ACE_InputCDR::to_std_string x)
 609 {
 610   CORBA::Boolean const marshal_flag = is >> x.val_;
 611   if (marshal_flag && x.bound_ != 0 && x.val_.size () > x.bound_)
 612     {
 613       throw CORBA::BAD_PARAM ();
 614     }
 615   return marshal_flag;
 616 }
 617
 618 #if !defined(ACE_LACKS_STD_WSTRING)
 619 ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &is,
 620                                       std::wstring &x)
 621 {
 622   return static_cast<ACE_InputCDR &> (is) >> x;
 623 }
 624
 625 ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &is,
 626                                       ACE_InputCDR::to_std_wstring x)
 627 {
 628   CORBA::Boolean const marshal_flag = is >> x.val_;
 629   if (marshal_flag && x.bound_ != 0 && x.val_.size () > x.bound_)
 630     {
 631       throw CORBA::BAD_PARAM ();
 632     }
 633   return marshal_flag;
 634 }
 635 #endif /* ACE_LACKS_STD_WSTRING */
 636
 637 TAO_END_VERSIONED_NAMESPACE_DECL