TAO: RT_Policy_i.cpp Source File

Go to the documentation of this file.
00001 // $Id: RT_Policy_i.cpp 83337 2008-10-21 09:10:54Z johnnyw $
00002 
00003 #include "tao/RTCORBA/RT_Policy_i.h"
00004 
00005 #if defined (TAO_HAS_CORBA_MESSAGING) && TAO_HAS_CORBA_MESSAGING != 0
00006 
00007 #include "tao/ORB_Core.h"
00008 #include "tao/Policy_Manager.h"
00009 #include "tao/debug.h"
00010 #include "tao/CDR.h"
00011 #include "tao/AnyTypeCode/Any.h"
00012 #include "tao/SystemException.h"
00013 
00014 #include "ace/OS_NS_string.h"
00015 
00016 ACE_RCSID (RTCORBA,
00017            RT_Policy_i,
00018            "$Id: RT_Policy_i.cpp 83337 2008-10-21 09:10:54Z johnnyw $")
00019 
00020 // ****************************************************************
00021 
00022 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
00023 
00024 TAO_PriorityModelPolicy::TAO_PriorityModelPolicy (
00025   RTCORBA::PriorityModel priority_model,
00026   RTCORBA::Priority server_priority)
00027   : ::CORBA::Object ()
00028   , ::CORBA::Policy ()
00029   , RTCORBA::PriorityModelPolicy ()
00030   , ::CORBA::LocalObject ()
00031   , priority_model_ (priority_model)
00032   , server_priority_ (server_priority)
00033 {
00034 }
00035 
00036 TAO_PriorityModelPolicy::TAO_PriorityModelPolicy (const TAO_PriorityModelPolicy &rhs)
00037   : ::CORBA::Object ()
00038   , ::CORBA::Policy ()
00039   , RTCORBA::PriorityModelPolicy ()
00040   , ::CORBA::LocalObject ()
00041   , priority_model_ (rhs.priority_model_)
00042   , server_priority_ (rhs.server_priority_)
00043 {
00044 }
00045 
00046 TAO_PriorityModelPolicy::TAO_PriorityModelPolicy (void)
00047   : priority_model_ (RTCORBA::SERVER_DECLARED),
00048     server_priority_ (0)
00049 {
00050 }
00051 
00052 TAO_PriorityModelPolicy::~TAO_PriorityModelPolicy (void)
00053 {
00054 }
00055 
00056 CORBA::Policy_ptr
00057 TAO_PriorityModelPolicy::create (const CORBA::Any &)
00058 {
00059   /*
00060    * @@ The following code should be changed once the OMG spec has
00061    * been fixed such that a RTCORBA::PriorityModelPolicy can be
00062    * created by using the ORB::create_policy interface.
00063    */
00064   throw ::CORBA::PolicyError (CORBA::BAD_POLICY_VALUE);
00065 }
00066 
00067 RTCORBA::PriorityModel
00068 TAO_PriorityModelPolicy::get_priority_model (void)
00069 {
00070   return this->priority_model_;
00071 }
00072 
00073 RTCORBA::PriorityModel
00074 TAO_PriorityModelPolicy::priority_model (void)
00075 {
00076   return this->priority_model_;
00077 }
00078 
00079 RTCORBA::Priority
00080 TAO_PriorityModelPolicy::server_priority (void)
00081 {
00082   return this->server_priority_;
00083 }
00084 
00085 CORBA::PolicyType
00086 TAO_PriorityModelPolicy::policy_type (void)
00087 {
00088   return RTCORBA::PRIORITY_MODEL_POLICY_TYPE;
00089 }
00090 
00091 CORBA::Policy_ptr
00092 TAO_PriorityModelPolicy::copy (void)
00093 {
00094   TAO_PriorityModelPolicy* tmp = 0;
00095   ACE_NEW_THROW_EX (tmp,
00096                     TAO_PriorityModelPolicy (*this),
00097                     CORBA::NO_MEMORY (TAO::VMCID,
00098                                       CORBA::COMPLETED_NO));
00099 
00100   return tmp;
00101 }
00102 
00103 void
00104 TAO_PriorityModelPolicy::destroy (void)
00105 {
00106 }
00107 
00108 CORBA::Boolean
00109 TAO_PriorityModelPolicy::_tao_encode (TAO_OutputCDR &out_cdr)
00110 {
00111   // Note: the fields are encoded according to
00112   // the order specified in the RTCORBA 1.0 spec (ptc/99-05-03)
00113   // section 4.7.3.
00114 
00115   return ((out_cdr << priority_model_) && (out_cdr << server_priority_));
00116 }
00117 
00118 CORBA::Boolean
00119 TAO_PriorityModelPolicy::_tao_decode (TAO_InputCDR &in_cdr)
00120 {
00121   return ((in_cdr >> priority_model_) && (in_cdr >> server_priority_));
00122 }
00123 
00124 TAO_Cached_Policy_Type
00125 TAO_PriorityModelPolicy::_tao_cached_type (void) const
00126 {
00127   return TAO_CACHED_POLICY_PRIORITY_MODEL;
00128 }
00129 
00130 TAO_Policy_Scope
00131 TAO_PriorityModelPolicy::_tao_scope (void) const
00132 {
00133   // Note that this policy is propogated to the client even though
00134   // it is not specified here.  The reason for this is that the
00135   // server priority field is set dynamically depending on the model
00136   // and the servant's priority.  Therefore, it can't be simply
00137   // copied to the list of client exposed policies.
00138   return static_cast<TAO_Policy_Scope> (TAO_POLICY_ORB_SCOPE |
00139                           TAO_POLICY_POA_SCOPE);
00140 }
00141 
00142 // ****************************************************************
00143 
00144 TAO_ThreadpoolPolicy::TAO_ThreadpoolPolicy (RTCORBA::ThreadpoolId id)
00145   : ::CORBA::Object ()
00146   , ::CORBA::Policy ()
00147   , RTCORBA::ThreadpoolPolicy ()
00148   , ::CORBA::LocalObject ()
00149   , id_ (id)
00150 {
00151 }
00152 
00153 TAO_ThreadpoolPolicy::TAO_ThreadpoolPolicy (const TAO_ThreadpoolPolicy &rhs)
00154   : ::CORBA::Object ()
00155   , ::CORBA::Policy ()
00156   , RTCORBA::ThreadpoolPolicy ()
00157   , ::CORBA::LocalObject ()
00158   , id_ (rhs.id_)
00159 {
00160 }
00161 
00162 TAO_ThreadpoolPolicy::~TAO_ThreadpoolPolicy (void)
00163 {
00164 }
00165 
00166 CORBA::Policy_ptr
00167 TAO_ThreadpoolPolicy::create (const CORBA::Any &val)
00168 {
00169   RTCORBA::ThreadpoolId value;
00170   if (!(val >>= value))
00171     throw ::CORBA::PolicyError (CORBA::BAD_POLICY_VALUE);
00172 
00173   TAO_ThreadpoolPolicy *tmp = 0;
00174   ACE_NEW_THROW_EX (tmp,
00175                     TAO_ThreadpoolPolicy (value),
00176                     CORBA::NO_MEMORY (TAO::VMCID,
00177                                       CORBA::COMPLETED_NO));
00178 
00179   return tmp;
00180 }
00181 
00182 RTCORBA::ThreadpoolId
00183 TAO_ThreadpoolPolicy::threadpool (void)
00184 {
00185   return this->id_;
00186 }
00187 
00188 CORBA::PolicyType
00189 TAO_ThreadpoolPolicy::policy_type (void)
00190 {
00191   return RTCORBA::THREADPOOL_POLICY_TYPE;
00192 }
00193 
00194 CORBA::Policy_ptr
00195 TAO_ThreadpoolPolicy::copy (void)
00196 {
00197   TAO_ThreadpoolPolicy* tmp = 0;
00198   ACE_NEW_THROW_EX (tmp,
00199                     TAO_ThreadpoolPolicy (*this),
00200                     CORBA::NO_MEMORY (TAO::VMCID,
00201                                       CORBA::COMPLETED_NO));
00202 
00203   return tmp;
00204 }
00205 
00206 void
00207 TAO_ThreadpoolPolicy::destroy (void)
00208 {
00209 }
00210 
00211 TAO_Cached_Policy_Type
00212 TAO_ThreadpoolPolicy::_tao_cached_type (void) const
00213 {
00214   return TAO_CACHED_POLICY_THREADPOOL;
00215 }
00216 
00217 TAO_Policy_Scope
00218 TAO_ThreadpoolPolicy::_tao_scope (void) const
00219 {
00220   return static_cast<TAO_Policy_Scope> (TAO_POLICY_ORB_SCOPE |
00221                           TAO_POLICY_POA_SCOPE);
00222 }
00223 
00224 // ****************************************************************
00225 
00226 TAO_PrivateConnectionPolicy::TAO_PrivateConnectionPolicy (void)
00227   : ::CORBA::Object ()
00228   , ::CORBA::Policy ()
00229   , RTCORBA::PrivateConnectionPolicy ()
00230   , ::CORBA::LocalObject ()
00231 {
00232 }
00233 
00234 TAO_PrivateConnectionPolicy::TAO_PrivateConnectionPolicy (const TAO_PrivateConnectionPolicy &)
00235   : ::CORBA::Object ()
00236   , ::CORBA::Policy ()
00237   , RTCORBA::PrivateConnectionPolicy ()
00238   , ::CORBA::LocalObject ()
00239 {
00240 }
00241 
00242 TAO_PrivateConnectionPolicy::~TAO_PrivateConnectionPolicy (void)
00243 {
00244 }
00245 
00246 CORBA::Policy_ptr
00247 TAO_PrivateConnectionPolicy::create (const CORBA::Any &)
00248 {
00249   TAO_PrivateConnectionPolicy *tmp = 0;
00250   ACE_NEW_THROW_EX (tmp,
00251                     TAO_PrivateConnectionPolicy (),
00252                     CORBA::NO_MEMORY (TAO::VMCID,
00253                                       CORBA::COMPLETED_NO));
00254 
00255   return tmp;
00256 }
00257 
00258 CORBA::PolicyType
00259 TAO_PrivateConnectionPolicy::policy_type (void)
00260 {
00261   return RTCORBA::PRIVATE_CONNECTION_POLICY_TYPE;
00262 }
00263 
00264 CORBA::Policy_ptr
00265 TAO_PrivateConnectionPolicy::copy (void)
00266 {
00267   TAO_PrivateConnectionPolicy* tmp = 0;
00268   ACE_NEW_THROW_EX (tmp,
00269                     TAO_PrivateConnectionPolicy (*this),
00270                     CORBA::NO_MEMORY (TAO::VMCID,
00271                                       CORBA::COMPLETED_NO));
00272 
00273   return tmp;
00274 }
00275 
00276 void
00277 TAO_PrivateConnectionPolicy::destroy (void)
00278 {
00279 }
00280 
00281 TAO_Cached_Policy_Type
00282 TAO_PrivateConnectionPolicy::_tao_cached_type (void) const
00283 {
00284   return TAO_CACHED_POLICY_RT_PRIVATE_CONNECTION;
00285 }
00286 
00287 TAO_Policy_Scope
00288 TAO_PrivateConnectionPolicy::_tao_scope (void) const
00289 {
00290   return static_cast<TAO_Policy_Scope> (TAO_POLICY_OBJECT_SCOPE |
00291                           TAO_POLICY_THREAD_SCOPE |
00292                           TAO_POLICY_ORB_SCOPE);
00293 }
00294 
00295 // ****************************************************************
00296 
00297 TAO_PriorityBandedConnectionPolicy::TAO_PriorityBandedConnectionPolicy (const RTCORBA::PriorityBands &bands)
00298   : ::CORBA::Object ()
00299   , ::CORBA::Policy ()
00300   , RTCORBA::PriorityBandedConnectionPolicy ()
00301   , ::CORBA::LocalObject ()
00302   , priority_bands_ (bands)
00303 {
00304 }
00305 
00306 TAO_PriorityBandedConnectionPolicy::TAO_PriorityBandedConnectionPolicy (const TAO_PriorityBandedConnectionPolicy &rhs)
00307   : ::CORBA::Object ()
00308   , ::CORBA::Policy ()
00309   , RTCORBA::PriorityBandedConnectionPolicy ()
00310   , ::CORBA::LocalObject ()
00311   , priority_bands_ (rhs.priority_bands_)
00312 {
00313 }
00314 
00315 TAO_PriorityBandedConnectionPolicy::TAO_PriorityBandedConnectionPolicy (void)
00316 {
00317 }
00318 
00319 TAO_PriorityBandedConnectionPolicy::~TAO_PriorityBandedConnectionPolicy (void)
00320 {
00321 }
00322 
00323 CORBA::Policy_ptr
00324 TAO_PriorityBandedConnectionPolicy::create (const CORBA::Any &val)
00325 {
00326   RTCORBA::PriorityBands *value = 0;
00327   if (!(val >>= value))
00328     throw ::CORBA::PolicyError (CORBA::BAD_POLICY_VALUE);
00329 
00330   TAO_PriorityBandedConnectionPolicy *tmp = 0;
00331   ACE_NEW_THROW_EX (tmp,
00332                     TAO_PriorityBandedConnectionPolicy (*value),
00333                     CORBA::NO_MEMORY (TAO::VMCID,
00334                                       CORBA::COMPLETED_NO));
00335 
00336   return tmp;
00337 }
00338 
00339 RTCORBA::PriorityBands *
00340 TAO_PriorityBandedConnectionPolicy::priority_bands (void)
00341 {
00342   RTCORBA::PriorityBands *tmp = 0;
00343   ACE_NEW_THROW_EX (tmp,
00344                     RTCORBA::PriorityBands (this->priority_bands_),
00345                     CORBA::NO_MEMORY (TAO::VMCID,
00346                                       CORBA::COMPLETED_NO));
00347 
00348   return tmp;
00349 }
00350 
00351 CORBA::PolicyType
00352 TAO_PriorityBandedConnectionPolicy::policy_type (void)
00353 {
00354   return RTCORBA::PRIORITY_BANDED_CONNECTION_POLICY_TYPE;
00355 }
00356 
00357 CORBA::Policy_ptr
00358 TAO_PriorityBandedConnectionPolicy::copy (void)
00359 {
00360   TAO_PriorityBandedConnectionPolicy *tmp = 0;
00361   ACE_NEW_THROW_EX (tmp,
00362                     TAO_PriorityBandedConnectionPolicy (*this),
00363                     CORBA::NO_MEMORY (TAO::VMCID,
00364                                       CORBA::COMPLETED_NO));
00365 
00366   return tmp;
00367 }
00368 
00369 void
00370 TAO_PriorityBandedConnectionPolicy::destroy (void)
00371 {
00372 }
00373 
00374 CORBA::Boolean
00375 TAO_PriorityBandedConnectionPolicy::_tao_encode (TAO_OutputCDR &out_cdr)
00376 {
00377   return out_cdr << this->priority_bands_;
00378 }
00379 
00380 CORBA::Boolean
00381 TAO_PriorityBandedConnectionPolicy::_tao_decode (TAO_InputCDR &in_cdr)
00382 {
00383   return in_cdr >> this->priority_bands_;
00384 }
00385 
00386 TAO_Cached_Policy_Type
00387 TAO_PriorityBandedConnectionPolicy::_tao_cached_type (void) const
00388 {
00389   return TAO_CACHED_POLICY_RT_PRIORITY_BANDED_CONNECTION;
00390 }
00391 
00392 TAO_Policy_Scope
00393 TAO_PriorityBandedConnectionPolicy::_tao_scope (void) const
00394 {
00395   return static_cast<TAO_Policy_Scope> (TAO_POLICY_DEFAULT_SCOPE |
00396                           TAO_POLICY_CLIENT_EXPOSED);
00397 }
00398 
00399 RTCORBA::PriorityBands &
00400 TAO_PriorityBandedConnectionPolicy::priority_bands_rep (void)
00401 {
00402   return this->priority_bands_;
00403 }
00404 
00405 // ****************************************************************
00406 
00407 TAO_ServerProtocolPolicy::TAO_ServerProtocolPolicy (const RTCORBA::ProtocolList &protocols)
00408   : ::CORBA::Object ()
00409   , ::CORBA::Policy ()
00410   , RTCORBA::ServerProtocolPolicy ()
00411   , ::CORBA::LocalObject ()
00412   , protocols_ (protocols)
00413 {
00414 }
00415 
00416 TAO_ServerProtocolPolicy::TAO_ServerProtocolPolicy (const TAO_ServerProtocolPolicy &rhs)
00417   : ::CORBA::Object ()
00418   , ::CORBA::Policy ()
00419   , RTCORBA::ServerProtocolPolicy ()
00420   , ::CORBA::LocalObject ()
00421   , protocols_ (rhs.protocols_)
00422 {
00423 }
00424 
00425 TAO_ServerProtocolPolicy::~TAO_ServerProtocolPolicy (void)
00426 {
00427 }
00428 
00429 CORBA::Policy_ptr
00430 TAO_ServerProtocolPolicy::create (const CORBA::Any &val)
00431 {
00432   RTCORBA::ProtocolList *value = 0;
00433   if (!(val >>= value))
00434     throw ::CORBA::PolicyError (CORBA::BAD_POLICY_VALUE);
00435 
00436   TAO_ServerProtocolPolicy *tmp = 0;
00437   ACE_NEW_THROW_EX (tmp,
00438                     TAO_ServerProtocolPolicy (*value),
00439                     CORBA::NO_MEMORY (TAO::VMCID,
00440                                       CORBA::COMPLETED_NO));
00441 
00442   return tmp;
00443 }
00444 
00445 RTCORBA::ProtocolList *
00446 TAO_ServerProtocolPolicy::protocols (void)
00447 {
00448   RTCORBA::ProtocolList *tmp = 0;
00449   ACE_NEW_THROW_EX (tmp,
00450                     RTCORBA::ProtocolList (this->protocols_),
00451                     CORBA::NO_MEMORY (TAO::VMCID,
00452                                       CORBA::COMPLETED_NO));
00453 
00454   return tmp;
00455 }
00456 
00457 CORBA::PolicyType
00458 TAO_ServerProtocolPolicy::policy_type (void)
00459 {
00460   return RTCORBA::SERVER_PROTOCOL_POLICY_TYPE;
00461 }
00462 
00463 CORBA::Policy_ptr
00464 TAO_ServerProtocolPolicy::copy (void)
00465 {
00466   TAO_ServerProtocolPolicy* tmp = 0;
00467   ACE_NEW_THROW_EX (tmp,
00468                     TAO_ServerProtocolPolicy (*this),
00469                     CORBA::NO_MEMORY (TAO::VMCID,
00470                                       CORBA::COMPLETED_NO));
00471 
00472   return tmp;
00473 }
00474 
00475 void
00476 TAO_ServerProtocolPolicy::destroy (void)
00477 {
00478 }
00479 
00480 TAO_Cached_Policy_Type
00481 TAO_ServerProtocolPolicy::_tao_cached_type (void) const
00482 {
00483   return TAO_CACHED_POLICY_RT_SERVER_PROTOCOL;
00484 }
00485 
00486 TAO_Policy_Scope
00487 TAO_ServerProtocolPolicy::_tao_scope (void) const
00488 {
00489   return static_cast<TAO_Policy_Scope> (TAO_POLICY_ORB_SCOPE |
00490                           TAO_POLICY_POA_SCOPE);
00491 }
00492 
00493 RTCORBA::ProtocolList &
00494 TAO_ServerProtocolPolicy::protocols_rep (void)
00495 {
00496   return protocols_;
00497 }
00498 
00499 // ****************************************************************
00500 
00501 TAO_ClientProtocolPolicy::TAO_ClientProtocolPolicy (void)
00502 {
00503 }
00504 
00505 
00506 TAO_ClientProtocolPolicy::TAO_ClientProtocolPolicy (const RTCORBA::ProtocolList &protocols)
00507   : ::CORBA::Object ()
00508   , ::CORBA::Policy ()
00509   , RTCORBA::ClientProtocolPolicy ()
00510   , ::CORBA::LocalObject ()
00511   , protocols_ (protocols)
00512 {
00513 }
00514 
00515 TAO_ClientProtocolPolicy::TAO_ClientProtocolPolicy (const TAO_ClientProtocolPolicy &rhs)
00516   : ::CORBA::Object ()
00517   , ::CORBA::Policy ()
00518   , RTCORBA::ClientProtocolPolicy ()
00519   , ::CORBA::LocalObject ()
00520   , protocols_ (rhs.protocols_)
00521 {
00522 }
00523 
00524 TAO_ClientProtocolPolicy::~TAO_ClientProtocolPolicy ()
00525 {
00526 }
00527 
00528 CORBA::Policy_ptr
00529 TAO_ClientProtocolPolicy::create (const CORBA::Any &val)
00530 {
00531   RTCORBA::ProtocolList *value = 0;
00532   if (!(val >>= value))
00533     throw ::CORBA::PolicyError (CORBA::BAD_POLICY_VALUE);
00534 
00535   TAO_ClientProtocolPolicy *tmp = 0;
00536   ACE_NEW_THROW_EX (tmp,
00537                     TAO_ClientProtocolPolicy (*value),
00538                     CORBA::NO_MEMORY (TAO::VMCID,
00539                                       CORBA::COMPLETED_NO));
00540 
00541   return tmp;
00542 }
00543 
00544 RTCORBA::ProtocolList *
00545 TAO_ClientProtocolPolicy::protocols (void)
00546 {
00547   RTCORBA::ProtocolList *tmp = 0;
00548   ACE_NEW_THROW_EX (tmp,
00549                     RTCORBA::ProtocolList (this->protocols_),
00550                     CORBA::NO_MEMORY (TAO::VMCID,
00551                                       CORBA::COMPLETED_NO));
00552 
00553   return tmp;
00554 }
00555 
00556 CORBA::PolicyType
00557 TAO_ClientProtocolPolicy::policy_type (void)
00558 {
00559   return RTCORBA::CLIENT_PROTOCOL_POLICY_TYPE;
00560 }
00561 
00562 CORBA::Policy_ptr
00563 TAO_ClientProtocolPolicy::copy (void)
00564 {
00565   TAO_ClientProtocolPolicy* tmp = 0;
00566   ACE_NEW_THROW_EX (tmp,
00567                     TAO_ClientProtocolPolicy (*this),
00568                     CORBA::NO_MEMORY (TAO::VMCID,
00569                                       CORBA::COMPLETED_NO));
00570 
00571   return tmp;
00572 }
00573 
00574 void
00575 TAO_ClientProtocolPolicy::destroy (void)
00576 {
00577 }
00578 
00579 TAO_Cached_Policy_Type
00580 TAO_ClientProtocolPolicy::_tao_cached_type (void) const
00581 {
00582   return TAO_CACHED_POLICY_RT_CLIENT_PROTOCOL;
00583 }
00584 
00585 TAO_Policy_Scope
00586 TAO_ClientProtocolPolicy::_tao_scope (void) const
00587 {
00588   return static_cast<TAO_Policy_Scope> (TAO_POLICY_DEFAULT_SCOPE |
00589                           TAO_POLICY_CLIENT_EXPOSED);
00590 }
00591 
00592 CORBA::Boolean
00593 TAO_ClientProtocolPolicy::_tao_encode (TAO_OutputCDR &out_cdr)
00594 {
00595   CORBA::Boolean is_write_ok = out_cdr << this->protocols_.length ();
00596 
00597   for (CORBA::ULong i = 0;
00598        (i < this->protocols_.length ()) && is_write_ok;
00599        i++)
00600     {
00601       is_write_ok =
00602         (out_cdr << this->protocols_[i].protocol_type)
00603         &&
00604         this->protocols_[i].orb_protocol_properties->_tao_encode (out_cdr)
00605         &&
00606         this->protocols_[i].transport_protocol_properties->_tao_encode (out_cdr);
00607     }
00608 
00609   return is_write_ok;
00610 }
00611 
00612 CORBA::Boolean
00613 TAO_ClientProtocolPolicy::_tao_decode (TAO_InputCDR &in_cdr)
00614 {
00615   CORBA::ULong length;
00616   CORBA::Boolean is_read_ok = in_cdr >> length;
00617 
00618   this->protocols_.length (length);
00619 
00620   for (CORBA::ULong i = 0; (i < length) && is_read_ok; i++)
00621     {
00622       is_read_ok = in_cdr >> this->protocols_[i].protocol_type;
00623 
00624       this->protocols_[i].orb_protocol_properties =
00625         TAO_Protocol_Properties_Factory::create_orb_protocol_property
00626         (this->protocols_[i].protocol_type);
00627 
00628       this->protocols_[i].transport_protocol_properties =
00629         TAO_Protocol_Properties_Factory::create_transport_protocol_property
00630         (this->protocols_[i].protocol_type, in_cdr.orb_core ());
00631 
00632       if (is_read_ok
00633           && (this->protocols_[i].orb_protocol_properties.ptr () != 0))
00634         is_read_ok =
00635           this->protocols_[i].orb_protocol_properties->_tao_decode (in_cdr);
00636 
00637       if (is_read_ok
00638           && (this->protocols_[i].transport_protocol_properties.ptr () != 0))
00639         is_read_ok =
00640           this->protocols_[i].transport_protocol_properties->_tao_decode (in_cdr);
00641 
00642     }
00643 
00644   return is_read_ok;
00645 }
00646 
00647 RTCORBA::ProtocolList &
00648 TAO_ClientProtocolPolicy::protocols_rep (void)
00649 {
00650   return protocols_;
00651 }
00652 
00653 // ****************************************************************
00654 
00655 TAO_TCP_Protocol_Properties::TAO_TCP_Protocol_Properties (CORBA::Long send_buffer_size,
00656                                                           CORBA::Long recv_buffer_size,
00657                                                           CORBA::Boolean keep_alive,
00658                                                           CORBA::Boolean dont_route,
00659                                                           CORBA::Boolean no_delay,
00660                                                           CORBA::Boolean enable_network_priority)
00661   : send_buffer_size_ (send_buffer_size),
00662     recv_buffer_size_ (recv_buffer_size),
00663     keep_alive_ (keep_alive),
00664     dont_route_ (dont_route),
00665     no_delay_ (no_delay),
00666     enable_network_priority_ (enable_network_priority)
00667 {
00668 }
00669 
00670 TAO_TCP_Protocol_Properties::~TAO_TCP_Protocol_Properties (void)
00671 {
00672 }
00673 
00674 CORBA::Long
00675 TAO_TCP_Protocol_Properties::send_buffer_size (void)
00676 {
00677   return this->send_buffer_size_;
00678 }
00679 
00680 void
00681 TAO_TCP_Protocol_Properties::send_buffer_size (CORBA::Long send_buffer_size)
00682 {
00683   this->send_buffer_size_ = send_buffer_size;
00684 }
00685 
00686 CORBA::Long
00687 TAO_TCP_Protocol_Properties::recv_buffer_size (void)
00688 {
00689   return this->recv_buffer_size_;
00690 }
00691 
00692 void
00693 TAO_TCP_Protocol_Properties::recv_buffer_size (CORBA::Long recv_buffer_size)
00694 {
00695   this->recv_buffer_size_ = recv_buffer_size;
00696 }
00697 
00698 CORBA::Boolean
00699 TAO_TCP_Protocol_Properties::keep_alive (void)
00700 {
00701   return this->keep_alive_;
00702 }
00703 
00704 void
00705 TAO_TCP_Protocol_Properties::keep_alive (CORBA::Boolean keep_alive)
00706 {
00707   this->keep_alive_ = keep_alive;
00708 }
00709 
00710 CORBA::Boolean
00711 TAO_TCP_Protocol_Properties::dont_route (void)
00712 {
00713   return this->dont_route_;
00714 }
00715 
00716 void
00717 TAO_TCP_Protocol_Properties::dont_route (CORBA::Boolean dont_route)
00718 {
00719   this->dont_route_ = dont_route;
00720 }
00721 
00722 CORBA::Boolean TAO_TCP_Protocol_Properties::no_delay (void)
00723 {
00724   return this->no_delay_;
00725 }
00726 
00727 void
00728 TAO_TCP_Protocol_Properties::no_delay (CORBA::Boolean no_delay)
00729 {
00730   this->no_delay_ = no_delay;
00731 }
00732 
00733 CORBA::Boolean
00734 TAO_TCP_Protocol_Properties::enable_network_priority (void)
00735 {
00736   return this->enable_network_priority_;
00737 }
00738 
00739 void
00740 TAO_TCP_Protocol_Properties::enable_network_priority (CORBA::Boolean enable)
00741 {
00742   this->enable_network_priority_ = enable;
00743 }
00744 
00745 CORBA::Boolean
00746 TAO_TCP_Protocol_Properties::_tao_encode (TAO_OutputCDR & out_cdr)
00747 {
00748   return ((out_cdr << this->send_buffer_size_)
00749           &&
00750           (out_cdr << this->recv_buffer_size_)
00751           &&
00752           (out_cdr.write_boolean (this->keep_alive_))
00753           &&
00754           (out_cdr.write_boolean (this->dont_route_))
00755           &&
00756           (out_cdr.write_boolean (this->no_delay_)));
00757 }
00758 
00759 CORBA::Boolean
00760 TAO_TCP_Protocol_Properties::_tao_decode (TAO_InputCDR &in_cdr)
00761 {
00762   return ((in_cdr >> this->send_buffer_size_)
00763           &&
00764           (in_cdr >> this->recv_buffer_size_)
00765           &&
00766           (in_cdr.read_boolean (this->keep_alive_))
00767           &&
00768           (in_cdr.read_boolean (this->dont_route_))
00769           &&
00770           (in_cdr.read_boolean (this->no_delay_)));
00771 }
00772 
00773 // ****************************************************************
00774 
00775 TAO_UnixDomain_Protocol_Properties::TAO_UnixDomain_Protocol_Properties
00776 (CORBA::Long send_buffer_size,
00777  CORBA::Long recv_buffer_size)
00778   : send_buffer_size_ (send_buffer_size),
00779     recv_buffer_size_ (recv_buffer_size)
00780 {
00781 }
00782 
00783 TAO_UnixDomain_Protocol_Properties::~TAO_UnixDomain_Protocol_Properties (void)
00784 {
00785 }
00786 
00787 CORBA::Long
00788 TAO_UnixDomain_Protocol_Properties::send_buffer_size (void)
00789 {
00790   return this->send_buffer_size_;
00791 }
00792 
00793 void
00794 TAO_UnixDomain_Protocol_Properties::send_buffer_size (CORBA::Long send_buffer_size)
00795 {
00796   this->send_buffer_size_ = send_buffer_size;
00797 }
00798 
00799 CORBA::Long
00800 TAO_UnixDomain_Protocol_Properties::recv_buffer_size (void)
00801 {
00802   return this->recv_buffer_size_;
00803 }
00804 
00805 void
00806 TAO_UnixDomain_Protocol_Properties::recv_buffer_size (CORBA::Long recv_buffer_size)
00807 {
00808   this->recv_buffer_size_ = recv_buffer_size;
00809 }
00810 
00811 CORBA::Boolean
00812 TAO_UnixDomain_Protocol_Properties::_tao_encode (TAO_OutputCDR &out_cdr)
00813 {
00814   return ((out_cdr << this->send_buffer_size_)
00815           && (out_cdr << this->recv_buffer_size_));
00816 }
00817 
00818 CORBA::Boolean
00819 TAO_UnixDomain_Protocol_Properties::_tao_decode (TAO_InputCDR &in_cdr)
00820 {
00821   return ((in_cdr >> this->send_buffer_size_)
00822           && (in_cdr >> this->recv_buffer_size_));
00823 }
00824 
00825 // ****************************************************************
00826 
00827 TAO_SharedMemory_Protocol_Properties::TAO_SharedMemory_Protocol_Properties (CORBA::Long send_buffer_size,
00828                                                                             CORBA::Long recv_buffer_size,
00829                                                                             CORBA::Boolean keep_alive,
00830                                                                             CORBA::Boolean dont_route,
00831                                                                             CORBA::Boolean no_delay,
00832                                                                             CORBA::Long preallocate_buffer_size,
00833                                                                             const char *mmap_filename,
00834                                                                             const char *mmap_lockname)
00835   : send_buffer_size_ (send_buffer_size),
00836     recv_buffer_size_ (recv_buffer_size),
00837     keep_alive_ (keep_alive),
00838     dont_route_ (dont_route),
00839     no_delay_ (no_delay),
00840     preallocate_buffer_size_ (preallocate_buffer_size),
00841     mmap_filename_ (mmap_filename),
00842     mmap_lockname_ (mmap_lockname)
00843 {
00844 }
00845 
00846 TAO_SharedMemory_Protocol_Properties::~TAO_SharedMemory_Protocol_Properties (void)
00847 {
00848 }
00849 
00850 
00851 CORBA::Long
00852 TAO_SharedMemory_Protocol_Properties::send_buffer_size (void)
00853 {
00854   return this->send_buffer_size_;
00855 }
00856 
00857 void
00858 TAO_SharedMemory_Protocol_Properties::send_buffer_size (CORBA::Long send_buffer_size)
00859 {
00860   this->send_buffer_size_ = send_buffer_size;
00861 }
00862 
00863 CORBA::Long
00864 TAO_SharedMemory_Protocol_Properties::recv_buffer_size (void)
00865 {
00866   return this->recv_buffer_size_;
00867 }
00868 
00869 void
00870 TAO_SharedMemory_Protocol_Properties::recv_buffer_size (CORBA::Long recv_buffer_size)
00871 {
00872   this->recv_buffer_size_ = recv_buffer_size;
00873 }
00874 
00875 CORBA::Boolean
00876 TAO_SharedMemory_Protocol_Properties::keep_alive (void)
00877 {
00878   return this->keep_alive_;
00879 }
00880 
00881 void
00882 TAO_SharedMemory_Protocol_Properties::keep_alive (CORBA::Boolean keep_alive)
00883 {
00884   this->keep_alive_ = keep_alive;
00885 }
00886 
00887 CORBA::Boolean
00888 TAO_SharedMemory_Protocol_Properties::dont_route (void)
00889 {
00890   return this->dont_route_;
00891 }
00892 
00893 void
00894 TAO_SharedMemory_Protocol_Properties::dont_route (CORBA::Boolean dont_route)
00895 {
00896   this->dont_route_ = dont_route;
00897 }
00898 
00899 CORBA::Boolean
00900 TAO_SharedMemory_Protocol_Properties::no_delay (void)
00901 {
00902   return this->no_delay_;
00903 }
00904 
00905 void
00906 TAO_SharedMemory_Protocol_Properties::no_delay (CORBA::Boolean no_delay)
00907 {
00908   this->no_delay_ = no_delay;
00909 }
00910 
00911 CORBA::Long
00912 TAO_SharedMemory_Protocol_Properties::preallocate_buffer_size (void)
00913 {
00914   return this->preallocate_buffer_size_;
00915 }
00916 
00917 void
00918 TAO_SharedMemory_Protocol_Properties::preallocate_buffer_size (CORBA::Long preallocate_buffer_size)
00919 {
00920   this->preallocate_buffer_size_ = preallocate_buffer_size;
00921 }
00922 
00923 char *
00924 TAO_SharedMemory_Protocol_Properties::mmap_filename (void)
00925 {
00926   return this->mmap_filename_.rep ();
00927 }
00928 
00929 void
00930 TAO_SharedMemory_Protocol_Properties::mmap_filename (const char * mmap_filename)
00931 {
00932   this->mmap_filename_.set (mmap_filename);
00933 }
00934 
00935 char *
00936 TAO_SharedMemory_Protocol_Properties::mmap_lockname (void)
00937 {
00938   return this->mmap_lockname_.rep ();
00939 }
00940 
00941 void
00942 TAO_SharedMemory_Protocol_Properties::mmap_lockname (const char * mmap_lockname)
00943 {
00944   this->mmap_lockname_.set (mmap_lockname);
00945 }
00946 
00947 CORBA::Boolean
00948 TAO_SharedMemory_Protocol_Properties::_tao_encode (TAO_OutputCDR &out_cdr)
00949 {
00950   return ((out_cdr << this->send_buffer_size_)
00951           &&
00952           (out_cdr << this->recv_buffer_size_)
00953           &&
00954           (out_cdr.write_boolean (this->keep_alive_))
00955           &&
00956           (out_cdr.write_boolean (this->dont_route_))
00957           &&
00958           (out_cdr.write_boolean (this->no_delay_))
00959           &&
00960           (out_cdr << this->preallocate_buffer_size_)
00961           &&
00962           (out_cdr << this->mmap_filename_)
00963           &&
00964           (out_cdr << this->mmap_lockname_));
00965 }
00966 
00967 CORBA::Boolean
00968 TAO_SharedMemory_Protocol_Properties::_tao_decode (TAO_InputCDR &in_cdr)
00969 {
00970   return ((in_cdr >> this->send_buffer_size_)
00971           &&
00972           (in_cdr >> this->recv_buffer_size_)
00973           &&
00974           (in_cdr.read_boolean (this->keep_alive_))
00975           &&
00976           (in_cdr.read_boolean (this->dont_route_))
00977           &&
00978           (in_cdr.read_boolean (this->no_delay_))
00979           &&
00980           (in_cdr >> this->preallocate_buffer_size_)
00981           &&
00982           (in_cdr >> this->mmap_filename_)
00983           &&
00984           (in_cdr >> this->mmap_lockname_));
00985 }
00986 
00987 // ****************************************************************
00988 
00989 TAO_UserDatagram_Protocol_Properties::TAO_UserDatagram_Protocol_Properties (
00990   CORBA::Long send_buffer_size,
00991   CORBA::Long recv_buffer_size,
00992   CORBA::Boolean enable_network_priority)
00993   : send_buffer_size_ (send_buffer_size),
00994     recv_buffer_size_ (recv_buffer_size),
00995     enable_network_priority_ (enable_network_priority)
00996 {
00997 }
00998 
00999 TAO_UserDatagram_Protocol_Properties::~TAO_UserDatagram_Protocol_Properties (void)
01000 {
01001 }
01002 
01003 CORBA::Boolean
01004 TAO_UserDatagram_Protocol_Properties::enable_network_priority (void)
01005 {
01006   return this->enable_network_priority_;
01007 }
01008 
01009 void
01010 TAO_UserDatagram_Protocol_Properties::enable_network_priority (CORBA::Boolean enable)
01011 {
01012   this->enable_network_priority_ = enable;
01013 }
01014 
01015 CORBA::Long
01016 TAO_UserDatagram_Protocol_Properties::send_buffer_size (void)
01017 {
01018   return this->send_buffer_size_;
01019 }
01020 
01021 void
01022 TAO_UserDatagram_Protocol_Properties::send_buffer_size (CORBA::Long send_buffer_size)
01023 {
01024   this->send_buffer_size_ = send_buffer_size;
01025 }
01026 
01027 CORBA::Long
01028 TAO_UserDatagram_Protocol_Properties::recv_buffer_size (void)
01029 {
01030   return this->recv_buffer_size_;
01031 }
01032 
01033 void
01034 TAO_UserDatagram_Protocol_Properties::recv_buffer_size (CORBA::Long recv_buffer_size)
01035 {
01036   this->recv_buffer_size_ = recv_buffer_size;
01037 }
01038 
01039 CORBA::Boolean
01040 TAO_UserDatagram_Protocol_Properties::_tao_encode (TAO_OutputCDR &)
01041 {
01042   return true;
01043 }
01044 
01045 CORBA::Boolean
01046 TAO_UserDatagram_Protocol_Properties::_tao_decode (TAO_InputCDR &)
01047 {
01048   return true;
01049 }
01050 
01051 // ****************************************************************
01052 
01053 TAO_StreamControl_Protocol_Properties::TAO_StreamControl_Protocol_Properties (CORBA::Long send_buffer_size,
01054                                                                               CORBA::Long recv_buffer_size,
01055                                                                               CORBA::Boolean keep_alive,
01056                                                                               CORBA::Boolean dont_route,
01057                                                                               CORBA::Boolean no_delay,
01058                                                                               CORBA::Boolean enable_network_priority)
01059   : send_buffer_size_ (send_buffer_size),
01060     recv_buffer_size_ (recv_buffer_size),
01061     keep_alive_ (keep_alive),
01062     dont_route_ (dont_route),
01063     no_delay_ (no_delay),
01064     enable_network_priority_ (enable_network_priority)
01065 {
01066 }
01067 
01068 TAO_StreamControl_Protocol_Properties::~TAO_StreamControl_Protocol_Properties (void)
01069 {
01070 }
01071 
01072 CORBA::Long
01073 TAO_StreamControl_Protocol_Properties::send_buffer_size (void)
01074 {
01075   return this->send_buffer_size_;
01076 }
01077 
01078 void
01079 TAO_StreamControl_Protocol_Properties::send_buffer_size (CORBA::Long send_buffer_size)
01080 {
01081   this->send_buffer_size_ = send_buffer_size;
01082 }
01083 
01084 CORBA::Long
01085 TAO_StreamControl_Protocol_Properties::recv_buffer_size (void)
01086 {
01087   return this->recv_buffer_size_;
01088 }
01089 
01090 void
01091 TAO_StreamControl_Protocol_Properties::recv_buffer_size (CORBA::Long recv_buffer_size)
01092 {
01093   this->recv_buffer_size_ = recv_buffer_size;
01094 }
01095 
01096 CORBA::Boolean
01097 TAO_StreamControl_Protocol_Properties::keep_alive (void)
01098 {
01099   return this->keep_alive_;
01100 }
01101 
01102 void
01103 TAO_StreamControl_Protocol_Properties::keep_alive (CORBA::Boolean keep_alive)
01104 {
01105   this->keep_alive_ = keep_alive;
01106 }
01107 
01108 CORBA::Boolean
01109 TAO_StreamControl_Protocol_Properties::dont_route (void)
01110 {
01111   return this->dont_route_;
01112 }
01113 
01114 void
01115 TAO_StreamControl_Protocol_Properties::dont_route (CORBA::Boolean dont_route)
01116 {
01117   this->dont_route_ = dont_route;
01118 }
01119 
01120 CORBA::Boolean TAO_StreamControl_Protocol_Properties::no_delay (void)
01121 {
01122   return this->no_delay_;
01123 }
01124 
01125 void
01126 TAO_StreamControl_Protocol_Properties::no_delay (CORBA::Boolean no_delay)
01127 {
01128   this->no_delay_ = no_delay;
01129 }
01130 
01131 CORBA::Boolean
01132 TAO_StreamControl_Protocol_Properties::enable_network_priority (void)
01133 {
01134   return this->enable_network_priority_;
01135 }
01136 
01137 void
01138 TAO_StreamControl_Protocol_Properties::enable_network_priority (CORBA::Boolean enable)
01139 {
01140   this->enable_network_priority_ = enable;
01141 }
01142 
01143 CORBA::Boolean
01144 TAO_StreamControl_Protocol_Properties::_tao_encode (TAO_OutputCDR & out_cdr)
01145 {
01146   return ((out_cdr << this->send_buffer_size_)
01147           &&
01148           (out_cdr << this->recv_buffer_size_)
01149           &&
01150           (out_cdr.write_boolean (this->keep_alive_))
01151           &&
01152           (out_cdr.write_boolean (this->dont_route_))
01153           &&
01154           (out_cdr.write_boolean (this->no_delay_)));
01155 }
01156 
01157 CORBA::Boolean
01158 TAO_StreamControl_Protocol_Properties::_tao_decode (TAO_InputCDR &in_cdr)
01159 {
01160   return ((in_cdr >> this->send_buffer_size_)
01161           &&
01162           (in_cdr >> this->recv_buffer_size_)
01163           &&
01164           (in_cdr.read_boolean (this->keep_alive_))
01165           &&
01166           (in_cdr.read_boolean (this->dont_route_))
01167           &&
01168           (in_cdr.read_boolean (this->no_delay_)));
01169 }
01170 
01171 // ****************************************************************
01172 
01173 TAO_GIOP_Protocol_Properties::TAO_GIOP_Protocol_Properties (void)
01174 {
01175 }
01176 
01177 TAO_GIOP_Protocol_Properties::~TAO_GIOP_Protocol_Properties (void)
01178 {
01179 }
01180 
01181 CORBA::Boolean
01182 TAO_GIOP_Protocol_Properties::_tao_encode (TAO_OutputCDR &)
01183 {
01184   return true;
01185 }
01186 
01187 CORBA::Boolean
01188 TAO_GIOP_Protocol_Properties::_tao_decode (TAO_InputCDR &)
01189 {
01190   return true;
01191 }
01192 
01193 // ****************************************************************
01194 
01195 RTCORBA::ProtocolProperties *
01196 TAO_Protocol_Properties_Factory::create_transport_protocol_property (IOP::ProfileId id,
01197                                                                      TAO_ORB_Core *orb_core)
01198 {
01199   RTCORBA::ProtocolProperties* property = 0;
01200 
01201   if (id == IOP::TAG_INTERNET_IOP)
01202     {
01203       int send_buffer_size = orb_core ? orb_core->orb_params ()->sock_sndbuf_size () : 0;
01204       int recv_buffer_size = orb_core ? orb_core->orb_params ()->sock_rcvbuf_size () : 0;
01205       int no_delay = orb_core ? orb_core->orb_params ()->nodelay () : 0;
01206       CORBA::Boolean keep_alive = orb_core ? orb_core->orb_params ()->sock_keepalive () : true;
01207       CORBA::Boolean dont_route = orb_core ? orb_core->orb_params ()->sock_dontroute () : false;
01208       CORBA::Boolean enable_network_priority = false;
01209 
01210       ACE_NEW_RETURN (property,
01211                       TAO_TCP_Protocol_Properties (send_buffer_size,
01212                                                    recv_buffer_size,
01213                                                    keep_alive,
01214                                                    dont_route,
01215                                                    no_delay,
01216                                                    enable_network_priority),
01217                       0);
01218     }
01219 
01220   else if (id == TAO_TAG_SHMEM_PROFILE)
01221     {
01222       int send_buffer_size = orb_core ? orb_core->orb_params ()->sock_sndbuf_size () : 0;
01223       int recv_buffer_size = orb_core ? orb_core->orb_params ()->sock_rcvbuf_size () : 0;
01224       int no_delay = orb_core ? orb_core->orb_params ()->nodelay () : 0;
01225       CORBA::Boolean keep_alive = true;
01226       CORBA::Boolean dont_route = false;
01227       CORBA::Long preallocate_buffer_size = false;
01228       const char *mmap_filename = "";
01229       const char *mmap_lockname = "";
01230 
01231       ACE_NEW_RETURN (property,
01232                       TAO_SharedMemory_Protocol_Properties (send_buffer_size,
01233                                                             recv_buffer_size,
01234                                                             keep_alive,
01235                                                             dont_route,
01236                                                             no_delay,
01237                                                             preallocate_buffer_size,
01238                                                             mmap_filename,
01239                                                             mmap_lockname),
01240                       0);
01241     }
01242 
01243   else if (id == TAO_TAG_UIOP_PROFILE)
01244     {
01245       int const send_buffer_size = orb_core ? orb_core->orb_params ()->sock_sndbuf_size () : 0;
01246       int const recv_buffer_size = orb_core ? orb_core->orb_params ()->sock_rcvbuf_size () : 0;
01247 
01248       ACE_NEW_RETURN (property,
01249                       TAO_UnixDomain_Protocol_Properties (send_buffer_size,
01250                                                           recv_buffer_size),
01251                       0);
01252     }
01253 
01254   else if (id == TAO_TAG_DIOP_PROFILE)
01255     {
01256       int const send_buffer_size = orb_core ? orb_core->orb_params ()->sock_sndbuf_size () : 0;
01257       int const recv_buffer_size = orb_core ? orb_core->orb_params ()->sock_rcvbuf_size () : 0;
01258       CORBA::Boolean enable_network_priority = false;
01259 
01260       ACE_NEW_RETURN (property,
01261                       TAO_UserDatagram_Protocol_Properties (send_buffer_size,
01262                                                             recv_buffer_size,
01263                                                             enable_network_priority),
01264                       0);
01265     }
01266 
01267   else if (id == TAO_TAG_SCIOP_PROFILE)
01268     {
01269       int send_buffer_size = orb_core ? orb_core->orb_params ()->sock_sndbuf_size () : 0;
01270       int recv_buffer_size = orb_core ? orb_core->orb_params ()->sock_rcvbuf_size () : 0;
01271       int no_delay = orb_core ? orb_core->orb_params ()->nodelay () : 0;
01272       CORBA::Boolean keep_alive = true;
01273       CORBA::Boolean dont_route = false;
01274       CORBA::Boolean enable_network_priority = false;
01275 
01276       ACE_NEW_RETURN (property,
01277                       TAO_StreamControl_Protocol_Properties (send_buffer_size,
01278                                                              recv_buffer_size,
01279                                                              keep_alive,
01280                                                              dont_route,
01281                                                              no_delay,
01282                                                              enable_network_priority),
01283                       0);
01284     }
01285 
01286   return property;
01287 }
01288 
01289 RTCORBA::ProtocolProperties*
01290 TAO_Protocol_Properties_Factory::create_orb_protocol_property (IOP::ProfileId id)
01291 {
01292   RTCORBA::ProtocolProperties* property = 0;
01293 
01294   if (id == IOP::TAG_INTERNET_IOP)
01295     ACE_NEW_RETURN (property,
01296                     TAO_GIOP_Protocol_Properties,
01297                     0);
01298 
01299   // Right now the only supported ORB protocol is GIOP
01300   // so we couple this with every protocol property.
01301   // The else statement is not necessary, but it
01302   // is here just to make clear that as soon as
01303   // new ORB protocol are supported other case
01304   // should be considered.
01305   else
01306     ACE_NEW_RETURN (property,
01307                     TAO_GIOP_Protocol_Properties,
01308                     0);
01309   return property;
01310 }
01311 
01312 TAO_END_VERSIONED_NAMESPACE_DECL
01313 
01314 #endif /* TAO_HAS_CORBA_MESSAGING && TAO_HAS_CORBA_MESSAGING != 0 */