TAO_RTCORBA: RT_Policy_i.cpp Source File

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