TAO/tao/RTCORBA/RT_Policy_i.cpp

   1 #include "tao/RTCORBA/RT_Policy_i.h"
   2
   3 #if defined (TAO_HAS_CORBA_MESSAGING) && TAO_HAS_CORBA_MESSAGING != 0
   4
   5 #include "tao/ORB_Core.h"
   6 #include "tao/Policy_Manager.h"
   7 #include "tao/debug.h"
   8 #include "tao/CDR.h"
   9 #include "tao/AnyTypeCode/Any.h"
  10 #include "tao/SystemException.h"
  11
  12 #include "ace/OS_NS_string.h"
  13
  14 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
  15
  16 TAO_PriorityModelPolicy::TAO_PriorityModelPolicy (
  17   RTCORBA::PriorityModel priority_model,
  18   RTCORBA::Priority server_priority)
  19   : ::CORBA::Object ()
  20   , ::CORBA::Policy ()
  21   , RTCORBA::PriorityModelPolicy ()
  22   , ::CORBA::LocalObject ()
  23   , priority_model_ (priority_model)
  24   , server_priority_ (server_priority)
  25 {
  26 }
  27
  28 TAO_PriorityModelPolicy::TAO_PriorityModelPolicy (const TAO_PriorityModelPolicy &rhs)
  29   : ::CORBA::Object ()
  30   , ::CORBA::Policy ()
  31   , RTCORBA::PriorityModelPolicy ()
  32   , ::CORBA::LocalObject ()
  33   , priority_model_ (rhs.priority_model_)
  34   , server_priority_ (rhs.server_priority_)
  35 {
  36 }
  37
  38 TAO_PriorityModelPolicy::TAO_PriorityModelPolicy ()
  39   : priority_model_ (RTCORBA::SERVER_DECLARED),
  40     server_priority_ (0)
  41 {
  42 }
  43
  44 TAO_PriorityModelPolicy::~TAO_PriorityModelPolicy ()
  45 {
  46 }
  47
  48 CORBA::Policy_ptr
  49 TAO_PriorityModelPolicy::create (const CORBA::Any &)
  50 {
  51   /*
  52    * @@ The following code should be changed once the OMG spec has
  53    * been fixed such that a RTCORBA::PriorityModelPolicy can be
  54    * created by using the ORB::create_policy interface.
  55    */
  56   throw ::CORBA::PolicyError (CORBA::BAD_POLICY_VALUE);
  57 }
  58
  59 RTCORBA::PriorityModel
  60 TAO_PriorityModelPolicy::get_priority_model ()
  61 {
  62   return this->priority_model_;
  63 }
  64
  65 RTCORBA::PriorityModel
  66 TAO_PriorityModelPolicy::priority_model ()
  67 {
  68   return this->priority_model_;
  69 }
  70
  71 RTCORBA::Priority
  72 TAO_PriorityModelPolicy::server_priority ()
  73 {
  74   return this->server_priority_;
  75 }
  76
  77 CORBA::PolicyType
  78 TAO_PriorityModelPolicy::policy_type ()
  79 {
  80   return RTCORBA::PRIORITY_MODEL_POLICY_TYPE;
  81 }
  82
  83 CORBA::Policy_ptr
  84 TAO_PriorityModelPolicy::copy ()
  85 {
  86   TAO_PriorityModelPolicy* tmp = 0;
  87   ACE_NEW_THROW_EX (tmp,
  88                     TAO_PriorityModelPolicy (*this),
  89                     CORBA::NO_MEMORY (TAO::VMCID,
  90                                       CORBA::COMPLETED_NO));
  91
  92   return tmp;
  93 }
  94
  95 void
  96 TAO_PriorityModelPolicy::destroy ()
  97 {
  98 }
  99
 100 CORBA::Boolean
 101 TAO_PriorityModelPolicy::_tao_encode (TAO_OutputCDR &out_cdr)
 102 {
 103   // Note: the fields are encoded according to
 104   // the order specified in the RTCORBA 1.0 spec (ptc/99-05-03)
 105   // section 4.7.3.
 106
 107   return ((out_cdr << priority_model_) && (out_cdr << server_priority_));
 108 }
 109
 110 CORBA::Boolean
 111 TAO_PriorityModelPolicy::_tao_decode (TAO_InputCDR &in_cdr)
 112 {
 113   return ((in_cdr >> priority_model_) && (in_cdr >> server_priority_));
 114 }
 115
 116 TAO_Cached_Policy_Type
 117 TAO_PriorityModelPolicy::_tao_cached_type () const
 118 {
 119   return TAO_CACHED_POLICY_PRIORITY_MODEL;
 120 }
 121
 122 TAO_Policy_Scope
 123 TAO_PriorityModelPolicy::_tao_scope () const
 124 {
 125   // Note that this policy is propagated to the client even though
 126   // it is not specified here.  The reason for this is that the
 127   // server priority field is set dynamically depending on the model
 128   // and the servant's priority.  Therefore, it can't be simply
 129   // copied to the list of client exposed policies.
 130   return static_cast<TAO_Policy_Scope> (TAO_POLICY_ORB_SCOPE |
 131                           TAO_POLICY_POA_SCOPE);
 132 }
 133
 134 // ****************************************************************
 135
 136 TAO_ThreadpoolPolicy::TAO_ThreadpoolPolicy (RTCORBA::ThreadpoolId id)
 137   : ::CORBA::Object ()
 138   , ::CORBA::Policy ()
 139   , RTCORBA::ThreadpoolPolicy ()
 140   , ::CORBA::LocalObject ()
 141   , id_ (id)
 142 {
 143 }
 144
 145 TAO_ThreadpoolPolicy::TAO_ThreadpoolPolicy (const TAO_ThreadpoolPolicy &rhs)
 146   : ::CORBA::Object ()
 147   , ::CORBA::Policy ()
 148   , RTCORBA::ThreadpoolPolicy ()
 149   , ::CORBA::LocalObject ()
 150   , id_ (rhs.id_)
 151 {
 152 }
 153
 154 TAO_ThreadpoolPolicy::~TAO_ThreadpoolPolicy ()
 155 {
 156 }
 157
 158 CORBA::Policy_ptr
 159 TAO_ThreadpoolPolicy::create (const CORBA::Any &val)
 160 {
 161   RTCORBA::ThreadpoolId value;
 162   if (!(val >>= value))
 163     throw ::CORBA::PolicyError (CORBA::BAD_POLICY_VALUE);
 164
 165   TAO_ThreadpoolPolicy *tmp = 0;
 166   ACE_NEW_THROW_EX (tmp,
 167                     TAO_ThreadpoolPolicy (value),
 168                     CORBA::NO_MEMORY (TAO::VMCID,
 169                                       CORBA::COMPLETED_NO));
 170
 171   return tmp;
 172 }
 173
 174 RTCORBA::ThreadpoolId
 175 TAO_ThreadpoolPolicy::threadpool ()
 176 {
 177   return this->id_;
 178 }
 179
 180 CORBA::PolicyType
 181 TAO_ThreadpoolPolicy::policy_type ()
 182 {
 183   return RTCORBA::THREADPOOL_POLICY_TYPE;
 184 }
 185
 186 CORBA::Policy_ptr
 187 TAO_ThreadpoolPolicy::copy ()
 188 {
 189   TAO_ThreadpoolPolicy* tmp = 0;
 190   ACE_NEW_THROW_EX (tmp,
 191                     TAO_ThreadpoolPolicy (*this),
 192                     CORBA::NO_MEMORY (TAO::VMCID,
 193                                       CORBA::COMPLETED_NO));
 194
 195   return tmp;
 196 }
 197
 198 void
 199 TAO_ThreadpoolPolicy::destroy ()
 200 {
 201 }
 202
 203 TAO_Cached_Policy_Type
 204 TAO_ThreadpoolPolicy::_tao_cached_type () const
 205 {
 206   return TAO_CACHED_POLICY_THREADPOOL;
 207 }
 208
 209 TAO_Policy_Scope
 210 TAO_ThreadpoolPolicy::_tao_scope () const
 211 {
 212   return static_cast<TAO_Policy_Scope> (TAO_POLICY_ORB_SCOPE |
 213                           TAO_POLICY_POA_SCOPE);
 214 }
 215
 216 // ****************************************************************
 217
 218 TAO_PrivateConnectionPolicy::TAO_PrivateConnectionPolicy ()
 219   : ::CORBA::Object ()
 220   , ::CORBA::Policy ()
 221   , RTCORBA::PrivateConnectionPolicy ()
 222   , ::CORBA::LocalObject ()
 223 {
 224 }
 225
 226 TAO_PrivateConnectionPolicy::TAO_PrivateConnectionPolicy (const TAO_PrivateConnectionPolicy &)
 227   : ::CORBA::Object ()
 228   , ::CORBA::Policy ()
 229   , RTCORBA::PrivateConnectionPolicy ()
 230   , ::CORBA::LocalObject ()
 231 {
 232 }
 233
 234 TAO_PrivateConnectionPolicy::~TAO_PrivateConnectionPolicy ()
 235 {
 236 }
 237
 238 CORBA::Policy_ptr
 239 TAO_PrivateConnectionPolicy::create (const CORBA::Any &)
 240 {
 241   TAO_PrivateConnectionPolicy *tmp = 0;
 242   ACE_NEW_THROW_EX (tmp,
 243                     TAO_PrivateConnectionPolicy (),
 244                     CORBA::NO_MEMORY (TAO::VMCID,
 245                                       CORBA::COMPLETED_NO));
 246
 247   return tmp;
 248 }
 249
 250 CORBA::PolicyType
 251 TAO_PrivateConnectionPolicy::policy_type ()
 252 {
 253   return RTCORBA::PRIVATE_CONNECTION_POLICY_TYPE;
 254 }
 255
 256 CORBA::Policy_ptr
 257 TAO_PrivateConnectionPolicy::copy ()
 258 {
 259   TAO_PrivateConnectionPolicy* tmp = 0;
 260   ACE_NEW_THROW_EX (tmp,
 261                     TAO_PrivateConnectionPolicy (*this),
 262                     CORBA::NO_MEMORY (TAO::VMCID,
 263                                       CORBA::COMPLETED_NO));
 264
 265   return tmp;
 266 }
 267
 268 void
 269 TAO_PrivateConnectionPolicy::destroy ()
 270 {
 271 }
 272
 273 TAO_Cached_Policy_Type
 274 TAO_PrivateConnectionPolicy::_tao_cached_type () const
 275 {
 276   return TAO_CACHED_POLICY_RT_PRIVATE_CONNECTION;
 277 }
 278
 279 TAO_Policy_Scope
 280 TAO_PrivateConnectionPolicy::_tao_scope () const
 281 {
 282   return static_cast<TAO_Policy_Scope> (TAO_POLICY_OBJECT_SCOPE |
 283                           TAO_POLICY_THREAD_SCOPE |
 284                           TAO_POLICY_ORB_SCOPE);
 285 }
 286
 287 // ****************************************************************
 288
 289 TAO_PriorityBandedConnectionPolicy::TAO_PriorityBandedConnectionPolicy (const RTCORBA::PriorityBands &bands)
 290   : ::CORBA::Object ()
 291   , ::CORBA::Policy ()
 292   , RTCORBA::PriorityBandedConnectionPolicy ()
 293   , ::CORBA::LocalObject ()
 294   , priority_bands_ (bands)
 295 {
 296 }
 297
 298 TAO_PriorityBandedConnectionPolicy::TAO_PriorityBandedConnectionPolicy (const TAO_PriorityBandedConnectionPolicy &rhs)
 299   : ::CORBA::Object ()
 300   , ::CORBA::Policy ()
 301   , RTCORBA::PriorityBandedConnectionPolicy ()
 302   , ::CORBA::LocalObject ()
 303   , priority_bands_ (rhs.priority_bands_)
 304 {
 305 }
 306
 307 TAO_PriorityBandedConnectionPolicy::TAO_PriorityBandedConnectionPolicy ()
 308 {
 309 }
 310
 311 TAO_PriorityBandedConnectionPolicy::~TAO_PriorityBandedConnectionPolicy ()
 312 {
 313 }
 314
 315 CORBA::Policy_ptr
 316 TAO_PriorityBandedConnectionPolicy::create (const CORBA::Any &val)
 317 {
 318   const RTCORBA::PriorityBands *value = 0;
 319   if (!(val >>= value))
 320     throw ::CORBA::PolicyError (CORBA::BAD_POLICY_VALUE);
 321
 322   TAO_PriorityBandedConnectionPolicy *tmp = 0;
 323   ACE_NEW_THROW_EX (tmp,
 324                     TAO_PriorityBandedConnectionPolicy (*value),
 325                     CORBA::NO_MEMORY (TAO::VMCID,
 326                                       CORBA::COMPLETED_NO));
 327
 328   return tmp;
 329 }
 330
 331 RTCORBA::PriorityBands *
 332 TAO_PriorityBandedConnectionPolicy::priority_bands ()
 333 {
 334   RTCORBA::PriorityBands *tmp = 0;
 335   ACE_NEW_THROW_EX (tmp,
 336                     RTCORBA::PriorityBands (this->priority_bands_),
 337                     CORBA::NO_MEMORY (TAO::VMCID,
 338                                       CORBA::COMPLETED_NO));
 339
 340   return tmp;
 341 }
 342
 343 CORBA::PolicyType
 344 TAO_PriorityBandedConnectionPolicy::policy_type ()
 345 {
 346   return RTCORBA::PRIORITY_BANDED_CONNECTION_POLICY_TYPE;
 347 }
 348
 349 CORBA::Policy_ptr
 350 TAO_PriorityBandedConnectionPolicy::copy ()
 351 {
 352   TAO_PriorityBandedConnectionPolicy *tmp = 0;
 353   ACE_NEW_THROW_EX (tmp,
 354                     TAO_PriorityBandedConnectionPolicy (*this),
 355                     CORBA::NO_MEMORY (TAO::VMCID,
 356                                       CORBA::COMPLETED_NO));
 357
 358   return tmp;
 359 }
 360
 361 void
 362 TAO_PriorityBandedConnectionPolicy::destroy ()
 363 {
 364 }
 365
 366 CORBA::Boolean
 367 TAO_PriorityBandedConnectionPolicy::_tao_encode (TAO_OutputCDR &out_cdr)
 368 {
 369   return out_cdr << this->priority_bands_;
 370 }
 371
 372 CORBA::Boolean
 373 TAO_PriorityBandedConnectionPolicy::_tao_decode (TAO_InputCDR &in_cdr)
 374 {
 375   return in_cdr >> this->priority_bands_;
 376 }
 377
 378 TAO_Cached_Policy_Type
 379 TAO_PriorityBandedConnectionPolicy::_tao_cached_type () const
 380 {
 381   return TAO_CACHED_POLICY_RT_PRIORITY_BANDED_CONNECTION;
 382 }
 383
 384 TAO_Policy_Scope
 385 TAO_PriorityBandedConnectionPolicy::_tao_scope () const
 386 {
 387   return static_cast<TAO_Policy_Scope> (TAO_POLICY_DEFAULT_SCOPE |
 388                           TAO_POLICY_CLIENT_EXPOSED);
 389 }
 390
 391 RTCORBA::PriorityBands &
 392 TAO_PriorityBandedConnectionPolicy::priority_bands_rep ()
 393 {
 394   return this->priority_bands_;
 395 }
 396
 397 // ****************************************************************
 398
 399 TAO_ServerProtocolPolicy::TAO_ServerProtocolPolicy (const RTCORBA::ProtocolList &protocols)
 400   : ::CORBA::Object ()
 401   , ::CORBA::Policy ()
 402   , RTCORBA::ServerProtocolPolicy ()
 403   , ::CORBA::LocalObject ()
 404   , protocols_ (protocols)
 405 {
 406 }
 407
 408 TAO_ServerProtocolPolicy::TAO_ServerProtocolPolicy (const TAO_ServerProtocolPolicy &rhs)
 409   : ::CORBA::Object ()
 410   , ::CORBA::Policy ()
 411   , RTCORBA::ServerProtocolPolicy ()
 412   , ::CORBA::LocalObject ()
 413   , protocols_ (rhs.protocols_)
 414 {
 415 }
 416
 417 TAO_ServerProtocolPolicy::~TAO_ServerProtocolPolicy ()
 418 {
 419 }
 420
 421 CORBA::Policy_ptr
 422 TAO_ServerProtocolPolicy::create (const CORBA::Any &val)
 423 {
 424   const RTCORBA::ProtocolList *value = 0;
 425   if (!(val >>= value))
 426     throw ::CORBA::PolicyError (CORBA::BAD_POLICY_VALUE);
 427
 428   TAO_ServerProtocolPolicy *tmp = 0;
 429   ACE_NEW_THROW_EX (tmp,
 430                     TAO_ServerProtocolPolicy (*value),
 431                     CORBA::NO_MEMORY (TAO::VMCID,
 432                                       CORBA::COMPLETED_NO));
 433
 434   return tmp;
 435 }
 436
 437 RTCORBA::ProtocolList *
 438 TAO_ServerProtocolPolicy::protocols ()
 439 {
 440   RTCORBA::ProtocolList *tmp = 0;
 441   ACE_NEW_THROW_EX (tmp,
 442                     RTCORBA::ProtocolList (this->protocols_),
 443                     CORBA::NO_MEMORY (TAO::VMCID,
 444                                       CORBA::COMPLETED_NO));
 445
 446   return tmp;
 447 }
 448
 449 CORBA::PolicyType
 450 TAO_ServerProtocolPolicy::policy_type ()
 451 {
 452   return RTCORBA::SERVER_PROTOCOL_POLICY_TYPE;
 453 }
 454
 455 CORBA::Policy_ptr
 456 TAO_ServerProtocolPolicy::copy ()
 457 {
 458   TAO_ServerProtocolPolicy* tmp = 0;
 459   ACE_NEW_THROW_EX (tmp,
 460                     TAO_ServerProtocolPolicy (*this),
 461                     CORBA::NO_MEMORY (TAO::VMCID,
 462                                       CORBA::COMPLETED_NO));
 463
 464   return tmp;
 465 }
 466
 467 void
 468 TAO_ServerProtocolPolicy::destroy ()
 469 {
 470 }
 471
 472 TAO_Cached_Policy_Type
 473 TAO_ServerProtocolPolicy::_tao_cached_type () const
 474 {
 475   return TAO_CACHED_POLICY_RT_SERVER_PROTOCOL;
 476 }
 477
 478 TAO_Policy_Scope
 479 TAO_ServerProtocolPolicy::_tao_scope () const
 480 {
 481   return static_cast<TAO_Policy_Scope> (TAO_POLICY_ORB_SCOPE |
 482                           TAO_POLICY_POA_SCOPE);
 483 }
 484
 485 RTCORBA::ProtocolList &
 486 TAO_ServerProtocolPolicy::protocols_rep ()
 487 {
 488   return protocols_;
 489 }
 490
 491 // ****************************************************************
 492
 493 TAO_ClientProtocolPolicy::TAO_ClientProtocolPolicy ()
 494 {
 495 }
 496
 497
 498 TAO_ClientProtocolPolicy::TAO_ClientProtocolPolicy (const RTCORBA::ProtocolList &protocols)
 499   : ::CORBA::Object ()
 500   , ::CORBA::Policy ()
 501   , RTCORBA::ClientProtocolPolicy ()
 502   , ::CORBA::LocalObject ()
 503   , protocols_ (protocols)
 504 {
 505 }
 506
 507 TAO_ClientProtocolPolicy::TAO_ClientProtocolPolicy (const TAO_ClientProtocolPolicy &rhs)
 508   : ::CORBA::Object ()
 509   , ::CORBA::Policy ()
 510   , RTCORBA::ClientProtocolPolicy ()
 511   , ::CORBA::LocalObject ()
 512   , protocols_ (rhs.protocols_)
 513 {
 514 }
 515
 516 TAO_ClientProtocolPolicy::~TAO_ClientProtocolPolicy ()
 517 {
 518 }
 519
 520 CORBA::Policy_ptr
 521 TAO_ClientProtocolPolicy::create (const CORBA::Any &val)
 522 {
 523   const RTCORBA::ProtocolList *value = 0;
 524   if (!(val >>= value))
 525     throw ::CORBA::PolicyError (CORBA::BAD_POLICY_VALUE);
 526
 527   TAO_ClientProtocolPolicy *tmp = 0;
 528   ACE_NEW_THROW_EX (tmp,
 529                     TAO_ClientProtocolPolicy (*value),
 530                     CORBA::NO_MEMORY (TAO::VMCID,
 531                                       CORBA::COMPLETED_NO));
 532
 533   return tmp;
 534 }
 535
 536 RTCORBA::ProtocolList *
 537 TAO_ClientProtocolPolicy::protocols ()
 538 {
 539   RTCORBA::ProtocolList *tmp = 0;
 540   ACE_NEW_THROW_EX (tmp,
 541                     RTCORBA::ProtocolList (this->protocols_),
 542                     CORBA::NO_MEMORY (TAO::VMCID,
 543                                       CORBA::COMPLETED_NO));
 544
 545   return tmp;
 546 }
 547
 548 CORBA::PolicyType
 549 TAO_ClientProtocolPolicy::policy_type ()
 550 {
 551   return RTCORBA::CLIENT_PROTOCOL_POLICY_TYPE;
 552 }
 553
 554 CORBA::Policy_ptr
 555 TAO_ClientProtocolPolicy::copy ()
 556 {
 557   TAO_ClientProtocolPolicy* tmp = 0;
 558   ACE_NEW_THROW_EX (tmp,
 559                     TAO_ClientProtocolPolicy (*this),
 560                     CORBA::NO_MEMORY (TAO::VMCID,
 561                                       CORBA::COMPLETED_NO));
 562
 563   return tmp;
 564 }
 565
 566 void
 567 TAO_ClientProtocolPolicy::destroy ()
 568 {
 569 }
 570
 571 TAO_Cached_Policy_Type
 572 TAO_ClientProtocolPolicy::_tao_cached_type () const
 573 {
 574   return TAO_CACHED_POLICY_RT_CLIENT_PROTOCOL;
 575 }
 576
 577 TAO_Policy_Scope
 578 TAO_ClientProtocolPolicy::_tao_scope () const
 579 {
 580   return static_cast<TAO_Policy_Scope> (TAO_POLICY_DEFAULT_SCOPE |
 581                           TAO_POLICY_CLIENT_EXPOSED);
 582 }
 583
 584 CORBA::Boolean
 585 TAO_ClientProtocolPolicy::_tao_encode (TAO_OutputCDR &out_cdr)
 586 {
 587   CORBA::Boolean is_write_ok = out_cdr << this->protocols_.length ();
 588
 589   for (CORBA::ULong i = 0;
 590        (i < this->protocols_.length ()) && is_write_ok;
 591        i++)
 592     {
 593       is_write_ok =
 594         (out_cdr << this->protocols_[i].protocol_type)
 595         &&
 596         this->protocols_[i].orb_protocol_properties->_tao_encode (out_cdr)
 597         &&
 598         this->protocols_[i].transport_protocol_properties->_tao_encode (out_cdr);
 599     }
 600
 601   return is_write_ok;
 602 }
 603
 604 CORBA::Boolean
 605 TAO_ClientProtocolPolicy::_tao_decode (TAO_InputCDR &in_cdr)
 606 {
 607   CORBA::ULong length;
 608   CORBA::Boolean is_read_ok = in_cdr >> length;
 609
 610   this->protocols_.length (length);
 611
 612   for (CORBA::ULong i = 0; (i < length) && is_read_ok; i++)
 613     {
 614       is_read_ok = in_cdr >> this->protocols_[i].protocol_type;
 615
 616       this->protocols_[i].orb_protocol_properties =
 617         TAO_Protocol_Properties_Factory::create_orb_protocol_property
 618         (this->protocols_[i].protocol_type);
 619
 620       this->protocols_[i].transport_protocol_properties =
 621         TAO_Protocol_Properties_Factory::create_transport_protocol_property
 622         (this->protocols_[i].protocol_type, in_cdr.orb_core ());
 623
 624       if (is_read_ok
 625           && (this->protocols_[i].orb_protocol_properties.ptr () != 0))
 626         is_read_ok =
 627           this->protocols_[i].orb_protocol_properties->_tao_decode (in_cdr);
 628
 629       if (is_read_ok
 630           && (this->protocols_[i].transport_protocol_properties.ptr () != 0))
 631         is_read_ok =
 632           this->protocols_[i].transport_protocol_properties->_tao_decode (in_cdr);
 633     }
 634
 635   return is_read_ok;
 636 }
 637
 638 RTCORBA::ProtocolList &
 639 TAO_ClientProtocolPolicy::protocols_rep ()
 640 {
 641   return protocols_;
 642 }
 643
 644 // ****************************************************************
 645
 646 TAO_TCP_Protocol_Properties::TAO_TCP_Protocol_Properties (CORBA::Long send_buffer_size,
 647                                                           CORBA::Long recv_buffer_size,
 648                                                           CORBA::Boolean keep_alive,
 649                                                           CORBA::Boolean dont_route,
 650                                                           CORBA::Boolean no_delay,
 651                                                           CORBA::Boolean enable_network_priority)
 652   : send_buffer_size_ (send_buffer_size),
 653     recv_buffer_size_ (recv_buffer_size),
 654     keep_alive_ (keep_alive),
 655     dont_route_ (dont_route),
 656     no_delay_ (no_delay),
 657     enable_network_priority_ (enable_network_priority)
 658 {
 659 }
 660
 661 TAO_TCP_Protocol_Properties::~TAO_TCP_Protocol_Properties ()
 662 {
 663 }
 664
 665 CORBA::Long
 666 TAO_TCP_Protocol_Properties::send_buffer_size ()
 667 {
 668   return this->send_buffer_size_;
 669 }
 670
 671 void
 672 TAO_TCP_Protocol_Properties::send_buffer_size (CORBA::Long send_buffer_size)
 673 {
 674   this->send_buffer_size_ = send_buffer_size;
 675 }
 676
 677 CORBA::Long
 678 TAO_TCP_Protocol_Properties::recv_buffer_size ()
 679 {
 680   return this->recv_buffer_size_;
 681 }
 682
 683 void
 684 TAO_TCP_Protocol_Properties::recv_buffer_size (CORBA::Long recv_buffer_size)
 685 {
 686   this->recv_buffer_size_ = recv_buffer_size;
 687 }
 688
 689 CORBA::Boolean
 690 TAO_TCP_Protocol_Properties::keep_alive ()
 691 {
 692   return this->keep_alive_;
 693 }
 694
 695 void
 696 TAO_TCP_Protocol_Properties::keep_alive (CORBA::Boolean keep_alive)
 697 {
 698   this->keep_alive_ = keep_alive;
 699 }
 700
 701 CORBA::Boolean
 702 TAO_TCP_Protocol_Properties::dont_route ()
 703 {
 704   return this->dont_route_;
 705 }
 706
 707 void
 708 TAO_TCP_Protocol_Properties::dont_route (CORBA::Boolean dont_route)
 709 {
 710   this->dont_route_ = dont_route;
 711 }
 712
 713 CORBA::Boolean TAO_TCP_Protocol_Properties::no_delay ()
 714 {
 715   return this->no_delay_;
 716 }
 717
 718 void
 719 TAO_TCP_Protocol_Properties::no_delay (CORBA::Boolean no_delay)
 720 {
 721   this->no_delay_ = no_delay;
 722 }
 723
 724 CORBA::Boolean
 725 TAO_TCP_Protocol_Properties::enable_network_priority ()
 726 {
 727   return this->enable_network_priority_;
 728 }
 729
 730 void
 731 TAO_TCP_Protocol_Properties::enable_network_priority (CORBA::Boolean enable)
 732 {
 733   this->enable_network_priority_ = enable;
 734 }
 735
 736 CORBA::Boolean
 737 TAO_TCP_Protocol_Properties::_tao_encode (TAO_OutputCDR & out_cdr)
 738 {
 739   return ((out_cdr << this->send_buffer_size_)
 740           &&
 741           (out_cdr << this->recv_buffer_size_)
 742           &&
 743           (out_cdr.write_boolean (this->keep_alive_))
 744           &&
 745           (out_cdr.write_boolean (this->dont_route_))
 746           &&
 747           (out_cdr.write_boolean (this->no_delay_)));
 748 }
 749
 750 CORBA::Boolean
 751 TAO_TCP_Protocol_Properties::_tao_decode (TAO_InputCDR &in_cdr)
 752 {
 753   return ((in_cdr >> this->send_buffer_size_)
 754           &&
 755           (in_cdr >> this->recv_buffer_size_)
 756           &&
 757           (in_cdr.read_boolean (this->keep_alive_))
 758           &&
 759           (in_cdr.read_boolean (this->dont_route_))
 760           &&
 761           (in_cdr.read_boolean (this->no_delay_)));
 762 }
 763
 764 // ****************************************************************
 765
 766 TAO_UnixDomain_Protocol_Properties::TAO_UnixDomain_Protocol_Properties
 767 (CORBA::Long send_buffer_size,
 768  CORBA::Long recv_buffer_size)
 769   : send_buffer_size_ (send_buffer_size),
 770     recv_buffer_size_ (recv_buffer_size)
 771 {
 772 }
 773
 774 TAO_UnixDomain_Protocol_Properties::~TAO_UnixDomain_Protocol_Properties ()
 775 {
 776 }
 777
 778 CORBA::Long
 779 TAO_UnixDomain_Protocol_Properties::send_buffer_size ()
 780 {
 781   return this->send_buffer_size_;
 782 }
 783
 784 void
 785 TAO_UnixDomain_Protocol_Properties::send_buffer_size (CORBA::Long send_buffer_size)
 786 {
 787   this->send_buffer_size_ = send_buffer_size;
 788 }
 789
 790 CORBA::Long
 791 TAO_UnixDomain_Protocol_Properties::recv_buffer_size ()
 792 {
 793   return this->recv_buffer_size_;
 794 }
 795
 796 void
 797 TAO_UnixDomain_Protocol_Properties::recv_buffer_size (CORBA::Long recv_buffer_size)
 798 {
 799   this->recv_buffer_size_ = recv_buffer_size;
 800 }
 801
 802 CORBA::Boolean
 803 TAO_UnixDomain_Protocol_Properties::_tao_encode (TAO_OutputCDR &out_cdr)
 804 {
 805   return ((out_cdr << this->send_buffer_size_)
 806           && (out_cdr << this->recv_buffer_size_));
 807 }
 808
 809 CORBA::Boolean
 810 TAO_UnixDomain_Protocol_Properties::_tao_decode (TAO_InputCDR &in_cdr)
 811 {
 812   return ((in_cdr >> this->send_buffer_size_)
 813           && (in_cdr >> this->recv_buffer_size_));
 814 }
 815
 816 // ****************************************************************
 817
 818 TAO_SharedMemory_Protocol_Properties::TAO_SharedMemory_Protocol_Properties (CORBA::Long send_buffer_size,
 819                                                                             CORBA::Long recv_buffer_size,
 820                                                                             CORBA::Boolean keep_alive,
 821                                                                             CORBA::Boolean dont_route,
 822                                                                             CORBA::Boolean no_delay,
 823                                                                             CORBA::Long preallocate_buffer_size,
 824                                                                             const char *mmap_filename,
 825                                                                             const char *mmap_lockname)
 826   : send_buffer_size_ (send_buffer_size),
 827     recv_buffer_size_ (recv_buffer_size),
 828     keep_alive_ (keep_alive),
 829     dont_route_ (dont_route),
 830     no_delay_ (no_delay),
 831     preallocate_buffer_size_ (preallocate_buffer_size),
 832     mmap_filename_ (mmap_filename),
 833     mmap_lockname_ (mmap_lockname)
 834 {
 835 }
 836
 837 TAO_SharedMemory_Protocol_Properties::~TAO_SharedMemory_Protocol_Properties ()
 838 {
 839 }
 840
 841
 842 CORBA::Long
 843 TAO_SharedMemory_Protocol_Properties::send_buffer_size ()
 844 {
 845   return this->send_buffer_size_;
 846 }
 847
 848 void
 849 TAO_SharedMemory_Protocol_Properties::send_buffer_size (CORBA::Long send_buffer_size)
 850 {
 851   this->send_buffer_size_ = send_buffer_size;
 852 }
 853
 854 CORBA::Long
 855 TAO_SharedMemory_Protocol_Properties::recv_buffer_size ()
 856 {
 857   return this->recv_buffer_size_;
 858 }
 859
 860 void
 861 TAO_SharedMemory_Protocol_Properties::recv_buffer_size (CORBA::Long recv_buffer_size)
 862 {
 863   this->recv_buffer_size_ = recv_buffer_size;
 864 }
 865
 866 CORBA::Boolean
 867 TAO_SharedMemory_Protocol_Properties::keep_alive ()
 868 {
 869   return this->keep_alive_;
 870 }
 871
 872 void
 873 TAO_SharedMemory_Protocol_Properties::keep_alive (CORBA::Boolean keep_alive)
 874 {
 875   this->keep_alive_ = keep_alive;
 876 }
 877
 878 CORBA::Boolean
 879 TAO_SharedMemory_Protocol_Properties::dont_route ()
 880 {
 881   return this->dont_route_;
 882 }
 883
 884 void
 885 TAO_SharedMemory_Protocol_Properties::dont_route (CORBA::Boolean dont_route)
 886 {
 887   this->dont_route_ = dont_route;
 888 }
 889
 890 CORBA::Boolean
 891 TAO_SharedMemory_Protocol_Properties::no_delay ()
 892 {
 893   return this->no_delay_;
 894 }
 895
 896 void
 897 TAO_SharedMemory_Protocol_Properties::no_delay (CORBA::Boolean no_delay)
 898 {
 899   this->no_delay_ = no_delay;
 900 }
 901
 902 CORBA::Long
 903 TAO_SharedMemory_Protocol_Properties::preallocate_buffer_size ()
 904 {
 905   return this->preallocate_buffer_size_;
 906 }
 907
 908 void
 909 TAO_SharedMemory_Protocol_Properties::preallocate_buffer_size (CORBA::Long preallocate_buffer_size)
 910 {
 911   this->preallocate_buffer_size_ = preallocate_buffer_size;
 912 }
 913
 914 char *
 915 TAO_SharedMemory_Protocol_Properties::mmap_filename ()
 916 {
 917   return this->mmap_filename_.rep ();
 918 }
 919
 920 void
 921 TAO_SharedMemory_Protocol_Properties::mmap_filename (const char * mmap_filename)
 922 {
 923   this->mmap_filename_.set (mmap_filename);
 924 }
 925
 926 char *
 927 TAO_SharedMemory_Protocol_Properties::mmap_lockname ()
 928 {
 929   return this->mmap_lockname_.rep ();
 930 }
 931
 932 void
 933 TAO_SharedMemory_Protocol_Properties::mmap_lockname (const char * mmap_lockname)
 934 {
 935   this->mmap_lockname_.set (mmap_lockname);
 936 }
 937
 938 CORBA::Boolean
 939 TAO_SharedMemory_Protocol_Properties::_tao_encode (TAO_OutputCDR &out_cdr)
 940 {
 941   return ((out_cdr << this->send_buffer_size_)
 942           &&
 943           (out_cdr << this->recv_buffer_size_)
 944           &&
 945           (out_cdr.write_boolean (this->keep_alive_))
 946           &&
 947           (out_cdr.write_boolean (this->dont_route_))
 948           &&
 949           (out_cdr.write_boolean (this->no_delay_))
 950           &&
 951           (out_cdr << this->preallocate_buffer_size_)
 952           &&
 953           (out_cdr << this->mmap_filename_)
 954           &&
 955           (out_cdr << this->mmap_lockname_));
 956 }
 957
 958 CORBA::Boolean
 959 TAO_SharedMemory_Protocol_Properties::_tao_decode (TAO_InputCDR &in_cdr)
 960 {
 961   return ((in_cdr >> this->send_buffer_size_)
 962           &&
 963           (in_cdr >> this->recv_buffer_size_)
 964           &&
 965           (in_cdr.read_boolean (this->keep_alive_))
 966           &&
 967           (in_cdr.read_boolean (this->dont_route_))
 968           &&
 969           (in_cdr.read_boolean (this->no_delay_))
 970           &&
 971           (in_cdr >> this->preallocate_buffer_size_)
 972           &&
 973           (in_cdr >> this->mmap_filename_)
 974           &&
 975           (in_cdr >> this->mmap_lockname_));
 976 }
 977
 978 // ****************************************************************
 979
 980 TAO_UserDatagram_Protocol_Properties::TAO_UserDatagram_Protocol_Properties (
 981   CORBA::Long send_buffer_size,
 982   CORBA::Long recv_buffer_size,
 983   CORBA::Boolean enable_network_priority)
 984   : send_buffer_size_ (send_buffer_size),
 985     recv_buffer_size_ (recv_buffer_size),
 986     enable_network_priority_ (enable_network_priority)
 987 {
 988 }
 989
 990 TAO_UserDatagram_Protocol_Properties::~TAO_UserDatagram_Protocol_Properties ()
 991 {
 992 }
 993
 994 CORBA::Boolean
 995 TAO_UserDatagram_Protocol_Properties::enable_network_priority ()
 996 {
 997   return this->enable_network_priority_;
 998 }
 999
1000 void
1001 TAO_UserDatagram_Protocol_Properties::enable_network_priority (CORBA::Boolean enable)
1002 {
1003   this->enable_network_priority_ = enable;
1004 }
1005
1006 CORBA::Long
1007 TAO_UserDatagram_Protocol_Properties::send_buffer_size ()
1008 {
1009   return this->send_buffer_size_;
1010 }
1011
1012 void
1013 TAO_UserDatagram_Protocol_Properties::send_buffer_size (CORBA::Long send_buffer_size)
1014 {
1015   this->send_buffer_size_ = send_buffer_size;
1016 }
1017
1018 CORBA::Long
1019 TAO_UserDatagram_Protocol_Properties::recv_buffer_size ()
1020 {
1021   return this->recv_buffer_size_;
1022 }
1023
1024 void
1025 TAO_UserDatagram_Protocol_Properties::recv_buffer_size (CORBA::Long recv_buffer_size)
1026 {
1027   this->recv_buffer_size_ = recv_buffer_size;
1028 }
1029
1030 CORBA::Boolean
1031 TAO_UserDatagram_Protocol_Properties::_tao_encode (TAO_OutputCDR &)
1032 {
1033   return true;
1034 }
1035
1036 CORBA::Boolean
1037 TAO_UserDatagram_Protocol_Properties::_tao_decode (TAO_InputCDR &)
1038 {
1039   return true;
1040 }
1041
1042 // ****************************************************************
1043
1044 TAO_StreamControl_Protocol_Properties::TAO_StreamControl_Protocol_Properties (CORBA::Long send_buffer_size,
1045                                                                               CORBA::Long recv_buffer_size,
1046                                                                               CORBA::Boolean keep_alive,
1047                                                                               CORBA::Boolean dont_route,
1048                                                                               CORBA::Boolean no_delay,
1049                                                                               CORBA::Boolean enable_network_priority)
1050   : send_buffer_size_ (send_buffer_size),
1051     recv_buffer_size_ (recv_buffer_size),
1052     keep_alive_ (keep_alive),
1053     dont_route_ (dont_route),
1054     no_delay_ (no_delay),
1055     enable_network_priority_ (enable_network_priority)
1056 {
1057 }
1058
1059 TAO_StreamControl_Protocol_Properties::~TAO_StreamControl_Protocol_Properties ()
1060 {
1061 }
1062
1063 CORBA::Long
1064 TAO_StreamControl_Protocol_Properties::send_buffer_size ()
1065 {
1066   return this->send_buffer_size_;
1067 }
1068
1069 void
1070 TAO_StreamControl_Protocol_Properties::send_buffer_size (CORBA::Long send_buffer_size)
1071 {
1072   this->send_buffer_size_ = send_buffer_size;
1073 }
1074
1075 CORBA::Long
1076 TAO_StreamControl_Protocol_Properties::recv_buffer_size ()
1077 {
1078   return this->recv_buffer_size_;
1079 }
1080
1081 void
1082 TAO_StreamControl_Protocol_Properties::recv_buffer_size (CORBA::Long recv_buffer_size)
1083 {
1084   this->recv_buffer_size_ = recv_buffer_size;
1085 }
1086
1087 CORBA::Boolean
1088 TAO_StreamControl_Protocol_Properties::keep_alive ()
1089 {
1090   return this->keep_alive_;
1091 }
1092
1093 void
1094 TAO_StreamControl_Protocol_Properties::keep_alive (CORBA::Boolean keep_alive)
1095 {
1096   this->keep_alive_ = keep_alive;
1097 }
1098
1099 CORBA::Boolean
1100 TAO_StreamControl_Protocol_Properties::dont_route ()
1101 {
1102   return this->dont_route_;
1103 }
1104
1105 void
1106 TAO_StreamControl_Protocol_Properties::dont_route (CORBA::Boolean dont_route)
1107 {
1108   this->dont_route_ = dont_route;
1109 }
1110
1111 CORBA::Boolean TAO_StreamControl_Protocol_Properties::no_delay ()
1112 {
1113   return this->no_delay_;
1114 }
1115
1116 void
1117 TAO_StreamControl_Protocol_Properties::no_delay (CORBA::Boolean no_delay)
1118 {
1119   this->no_delay_ = no_delay;
1120 }
1121
1122 CORBA::Boolean
1123 TAO_StreamControl_Protocol_Properties::enable_network_priority ()
1124 {
1125   return this->enable_network_priority_;
1126 }
1127
1128 void
1129 TAO_StreamControl_Protocol_Properties::enable_network_priority (CORBA::Boolean enable)
1130 {
1131   this->enable_network_priority_ = enable;
1132 }
1133
1134 CORBA::Boolean
1135 TAO_StreamControl_Protocol_Properties::_tao_encode (TAO_OutputCDR & out_cdr)
1136 {
1137   return ((out_cdr << this->send_buffer_size_)
1138           &&
1139           (out_cdr << this->recv_buffer_size_)
1140           &&
1141           (out_cdr.write_boolean (this->keep_alive_))
1142           &&
1143           (out_cdr.write_boolean (this->dont_route_))
1144           &&
1145           (out_cdr.write_boolean (this->no_delay_)));
1146 }
1147
1148 CORBA::Boolean
1149 TAO_StreamControl_Protocol_Properties::_tao_decode (TAO_InputCDR &in_cdr)
1150 {
1151   return ((in_cdr >> this->send_buffer_size_)
1152           &&
1153           (in_cdr >> this->recv_buffer_size_)
1154           &&
1155           (in_cdr.read_boolean (this->keep_alive_))
1156           &&
1157           (in_cdr.read_boolean (this->dont_route_))
1158           &&
1159           (in_cdr.read_boolean (this->no_delay_)));
1160 }
1161
1162 // ****************************************************************
1163
1164 TAO_GIOP_Protocol_Properties::TAO_GIOP_Protocol_Properties ()
1165 {
1166 }
1167
1168 TAO_GIOP_Protocol_Properties::~TAO_GIOP_Protocol_Properties ()
1169 {
1170 }
1171
1172 CORBA::Boolean
1173 TAO_GIOP_Protocol_Properties::_tao_encode (TAO_OutputCDR &)
1174 {
1175   return true;
1176 }
1177
1178 CORBA::Boolean
1179 TAO_GIOP_Protocol_Properties::_tao_decode (TAO_InputCDR &)
1180 {
1181   return true;
1182 }
1183
1184 // ****************************************************************
1185
1186 RTCORBA::ProtocolProperties *
1187 TAO_Protocol_Properties_Factory::create_transport_protocol_property (IOP::ProfileId id,
1188                                                                      TAO_ORB_Core *orb_core)
1189 {
1190   RTCORBA::ProtocolProperties* property = 0;
1191
1192   if (id == IOP::TAG_INTERNET_IOP)
1193     {
1194       int send_buffer_size = orb_core ? orb_core->orb_params ()->sock_sndbuf_size () : 0;
1195       int recv_buffer_size = orb_core ? orb_core->orb_params ()->sock_rcvbuf_size () : 0;
1196       int no_delay = orb_core ? orb_core->orb_params ()->nodelay () : 0;
1197       CORBA::Boolean keep_alive = orb_core ? orb_core->orb_params ()->sock_keepalive () : true;
1198       CORBA::Boolean dont_route = orb_core ? orb_core->orb_params ()->sock_dontroute () : false;
1199       CORBA::Boolean enable_network_priority = false;
1200
1201       ACE_NEW_RETURN (property,
1202                       TAO_TCP_Protocol_Properties (send_buffer_size,
1203                                                    recv_buffer_size,
1204                                                    keep_alive,
1205                                                    dont_route,
1206                                                    no_delay,
1207                                                    enable_network_priority),
1208                       0);
1209     }
1210
1211   else if (id == TAO_TAG_SHMEM_PROFILE)
1212     {
1213       int send_buffer_size = orb_core ? orb_core->orb_params ()->sock_sndbuf_size () : 0;
1214       int recv_buffer_size = orb_core ? orb_core->orb_params ()->sock_rcvbuf_size () : 0;
1215       int no_delay = orb_core ? orb_core->orb_params ()->nodelay () : 0;
1216       CORBA::Boolean keep_alive = true;
1217       CORBA::Boolean dont_route = false;
1218       CORBA::Long preallocate_buffer_size = false;
1219       const char *mmap_filename = "";
1220       const char *mmap_lockname = "";
1221
1222       ACE_NEW_RETURN (property,
1223                       TAO_SharedMemory_Protocol_Properties (send_buffer_size,
1224                                                             recv_buffer_size,
1225                                                             keep_alive,
1226                                                             dont_route,
1227                                                             no_delay,
1228                                                             preallocate_buffer_size,
1229                                                             mmap_filename,
1230                                                             mmap_lockname),
1231                       0);
1232     }
1233
1234   else if (id == TAO_TAG_UIOP_PROFILE)
1235     {
1236       int const send_buffer_size = orb_core ? orb_core->orb_params ()->sock_sndbuf_size () : 0;
1237       int const recv_buffer_size = orb_core ? orb_core->orb_params ()->sock_rcvbuf_size () : 0;
1238
1239       ACE_NEW_RETURN (property,
1240                       TAO_UnixDomain_Protocol_Properties (send_buffer_size,
1241                                                           recv_buffer_size),
1242                       0);
1243     }
1244
1245   else if (id == TAO_TAG_DIOP_PROFILE)
1246     {
1247       int const send_buffer_size = orb_core ? orb_core->orb_params ()->sock_sndbuf_size () : 0;
1248       int const recv_buffer_size = orb_core ? orb_core->orb_params ()->sock_rcvbuf_size () : 0;
1249       CORBA::Boolean enable_network_priority = false;
1250
1251       ACE_NEW_RETURN (property,
1252                       TAO_UserDatagram_Protocol_Properties (send_buffer_size,
1253                                                             recv_buffer_size,
1254                                                             enable_network_priority),
1255                       0);
1256     }
1257
1258   else if (id == TAO_TAG_SCIOP_PROFILE)
1259     {
1260       int send_buffer_size = orb_core ? orb_core->orb_params ()->sock_sndbuf_size () : 0;
1261       int recv_buffer_size = orb_core ? orb_core->orb_params ()->sock_rcvbuf_size () : 0;
1262       int no_delay = orb_core ? orb_core->orb_params ()->nodelay () : 0;
1263       CORBA::Boolean keep_alive = true;
1264       CORBA::Boolean dont_route = false;
1265       CORBA::Boolean enable_network_priority = false;
1266
1267       ACE_NEW_RETURN (property,
1268                       TAO_StreamControl_Protocol_Properties (send_buffer_size,
1269                                                              recv_buffer_size,
1270                                                              keep_alive,
1271                                                              dont_route,
1272                                                              no_delay,
1273                                                              enable_network_priority),
1274                       0);
1275     }
1276
1277   return property;
1278 }
1279
1280 RTCORBA::ProtocolProperties*
1281 TAO_Protocol_Properties_Factory::create_orb_protocol_property (IOP::ProfileId id)
1282 {
1283   RTCORBA::ProtocolProperties* property = 0;
1284
1285   if (id == IOP::TAG_INTERNET_IOP)
1286     ACE_NEW_RETURN (property,
1287                     TAO_GIOP_Protocol_Properties,
1288                     0);
1289
1290   // Right now the only supported ORB protocol is GIOP
1291   // so we couple this with every protocol property.
1292   // The else statement is not necessary, but it
1293   // is here just to make clear that as soon as
1294   // new ORB protocol are supported other case
1295   // should be considered.
1296   else
1297     ACE_NEW_RETURN (property,
1298                     TAO_GIOP_Protocol_Properties,
1299                     0);
1300   return property;
1301 }
1302
1303 TAO_END_VERSIONED_NAMESPACE_DECL
1304
1305 #endif /* TAO_HAS_CORBA_MESSAGING && TAO_HAS_CORBA_MESSAGING != 0 */