TAO/tao/Messaging/Messaging_Policy_i.cpp

   1 #include "tao/Messaging/Messaging_Policy_i.h"
   2 #include "tao/Stub.h"
   3 #include "tao/ORB_Core.h"
   4 #include "tao/debug.h"
   5 #include "tao/AnyTypeCode/Any.h"
   6 #include "ace/Truncate.h"
   7
   8 #if ! defined (__ACE_INLINE__)
   9 #include "tao/Messaging/Messaging_Policy_i.inl"
  10 #endif /* __ACE_INLINE__ */
  11
  12 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
  13
  14 #if (TAO_HAS_RELATIVE_ROUNDTRIP_TIMEOUT_POLICY == 1)
  15
  16 TAO_RelativeRoundtripTimeoutPolicy::TAO_RelativeRoundtripTimeoutPolicy (
  17   const TimeBase::TimeT& relative_expiry)
  18   : ::CORBA::Object ()
  19   , ::CORBA::Policy ()
  20   , Messaging::RelativeRoundtripTimeoutPolicy ()
  21   , ::CORBA::LocalObject ()
  22   , relative_expiry_ (relative_expiry)
  23 {
  24 }
  25
  26 TAO_RelativeRoundtripTimeoutPolicy::TAO_RelativeRoundtripTimeoutPolicy (
  27   const TAO_RelativeRoundtripTimeoutPolicy &rhs)
  28   : ::CORBA::Object ()
  29   , ::CORBA::Policy ()
  30   , Messaging::RelativeRoundtripTimeoutPolicy ()
  31   , ::CORBA::LocalObject ()
  32   , relative_expiry_ (rhs.relative_expiry_)
  33 {
  34 }
  35
  36 TimeBase::TimeT
  37 TAO_RelativeRoundtripTimeoutPolicy::relative_expiry ()
  38 {
  39   return this->relative_expiry_;
  40 }
  41
  42 CORBA::PolicyType
  43 TAO_RelativeRoundtripTimeoutPolicy::policy_type ()
  44 {
  45   return Messaging::RELATIVE_RT_TIMEOUT_POLICY_TYPE;
  46 }
  47
  48 void
  49 TAO_RelativeRoundtripTimeoutPolicy::hook (TAO_ORB_Core *orb_core,
  50                                           TAO_Stub *stub,
  51                                           bool &has_timeout,
  52                                           ACE_Time_Value &time_value)
  53 {
  54   try
  55     {
  56       CORBA::Policy_var policy = CORBA::Policy::_nil ();
  57
  58       if (stub == 0)
  59         {
  60           policy =
  61             orb_core->get_cached_policy_including_current (
  62               TAO_CACHED_POLICY_RELATIVE_ROUNDTRIP_TIMEOUT);
  63         }
  64       else
  65         {
  66           policy =
  67             stub->get_cached_policy (
  68               TAO_CACHED_POLICY_RELATIVE_ROUNDTRIP_TIMEOUT);
  69         }
  70
  71       if (CORBA::is_nil (policy.in ()))
  72         {
  73           has_timeout = false;
  74           return;
  75         }
  76
  77       Messaging::RelativeRoundtripTimeoutPolicy_var p =
  78         Messaging::RelativeRoundtripTimeoutPolicy::_narrow (policy.in ());
  79
  80       TimeBase::TimeT const t = p->relative_expiry ();
  81       TimeBase::TimeT const seconds = t / 10000000u;
  82       TimeBase::TimeT const microseconds = (t % 10000000u) / 10;
  83       time_value.set (ACE_Utils::truncate_cast<time_t> (seconds),
  84                       ACE_Utils::truncate_cast<suseconds_t> (microseconds));
  85
  86       // Set the flag once all operations complete successfully
  87       has_timeout = true;
  88
  89       if (TAO_debug_level > 0)
  90         {
  91           ACE_UINT64 msecs;
  92           const_cast<ACE_Time_Value const &> (time_value).msec (msecs);
  93           TAOLIB_DEBUG ((LM_DEBUG,
  94                       ACE_TEXT ("TAO (%P|%t) - Request timeout is ")
  95                       ACE_TEXT ("%Q milliseconds\n"),
  96                       msecs));
  97         }
  98     }
  99   catch (const ::CORBA::Exception&)
 100     {
 101       // Ignore all exceptions...
 102     }
 103 }
 104
 105 CORBA::Policy_ptr
 106 TAO_RelativeRoundtripTimeoutPolicy::create (const CORBA::Any& val)
 107 {
 108   // Future policy implementors: notice how the following code is
 109   // exception safe!
 110   TimeBase::TimeT value;
 111   if ((val >>= value) == 0)
 112     throw ::CORBA::PolicyError (CORBA::BAD_POLICY_VALUE);
 113
 114   TAO_RelativeRoundtripTimeoutPolicy *tmp = 0;
 115   ACE_NEW_THROW_EX (tmp,
 116                     TAO_RelativeRoundtripTimeoutPolicy (value),
 117                     CORBA::NO_MEMORY (TAO::VMCID,
 118                                       CORBA::COMPLETED_NO));
 119
 120   return tmp;
 121 }
 122
 123 TAO_RelativeRoundtripTimeoutPolicy *
 124 TAO_RelativeRoundtripTimeoutPolicy::clone () const
 125 {
 126   TAO_RelativeRoundtripTimeoutPolicy *copy = 0;
 127   ACE_NEW_RETURN (copy,
 128                   TAO_RelativeRoundtripTimeoutPolicy (*this),
 129                   0);
 130   return copy;
 131 }
 132
 133 CORBA::Policy_ptr
 134 TAO_RelativeRoundtripTimeoutPolicy::copy ()
 135 {
 136   // Future policy implementors: notice how the following code is
 137   // exception safe!
 138
 139   TAO_RelativeRoundtripTimeoutPolicy* tmp = 0;
 140   ACE_NEW_THROW_EX (tmp, TAO_RelativeRoundtripTimeoutPolicy (*this),
 141                     CORBA::NO_MEMORY (TAO::VMCID,
 142                                       CORBA::COMPLETED_NO));
 143
 144   return tmp;
 145 }
 146
 147 void
 148 TAO_RelativeRoundtripTimeoutPolicy::destroy ()
 149 {
 150 }
 151
 152 TAO_Cached_Policy_Type
 153 TAO_RelativeRoundtripTimeoutPolicy::_tao_cached_type () const
 154 {
 155   return TAO_CACHED_POLICY_RELATIVE_ROUNDTRIP_TIMEOUT;
 156 }
 157
 158 void
 159 TAO_RelativeRoundtripTimeoutPolicy::set_time_value (ACE_Time_Value &time_value)
 160 {
 161   TimeBase::TimeT const t = this->relative_expiry_;
 162   TimeBase::TimeT const seconds = t / 10000000u;
 163   TimeBase::TimeT const microseconds = (t % 10000000u) / 10;
 164   time_value.set (ACE_Utils::truncate_cast<time_t> (seconds),
 165                   ACE_Utils::truncate_cast<suseconds_t> (microseconds));
 166
 167   if (TAO_debug_level > 0)
 168     {
 169       ACE_UINT64 msecs;
 170       const_cast<ACE_Time_Value const &> (time_value).msec (msecs);
 171       TAOLIB_DEBUG ((LM_DEBUG,
 172                   ACE_TEXT ("TAO (%P|%t) - Request timeout is ")
 173                   ACE_TEXT ("%Q milliseconds\n"),
 174                   msecs));
 175     }
 176 }
 177
 178 #endif /* TAO_HAS_RELATIVE_ROUNDTRIP_TIMEOUT_POLICY == 1 */
 179
 180 // ****************************************************************
 181
 182 #if (TAO_HAS_SYNC_SCOPE_POLICY == 1)
 183
 184 TAO_Sync_Scope_Policy::TAO_Sync_Scope_Policy (Messaging::SyncScope synchronization)
 185   : ::CORBA::Object ()
 186   , ::CORBA::Policy ()
 187   , Messaging::SyncScopePolicy ()
 188   , ::CORBA::LocalObject ()
 189   , synchronization_ (synchronization)
 190 {
 191 }
 192
 193 TAO_Sync_Scope_Policy::TAO_Sync_Scope_Policy (const TAO_Sync_Scope_Policy &rhs)
 194   : ::CORBA::Object ()
 195   , ::CORBA::Policy ()
 196   , Messaging::SyncScopePolicy ()
 197   , ::CORBA::LocalObject ()
 198   , synchronization_ (rhs.synchronization_)
 199 {
 200 }
 201
 202 CORBA::PolicyType
 203 TAO_Sync_Scope_Policy::policy_type ()
 204 {
 205   return Messaging::SYNC_SCOPE_POLICY_TYPE;
 206 }
 207
 208 void
 209 TAO_Sync_Scope_Policy::hook (TAO_ORB_Core *orb_core,
 210                              TAO_Stub *stub,
 211                              bool &has_synchronization,
 212                              Messaging::SyncScope &scope)
 213 {
 214   try
 215     {
 216       CORBA::Policy_var policy = CORBA::Policy::_nil ();
 217
 218       if (stub == 0)
 219         {
 220           policy =
 221             orb_core->get_cached_policy_including_current (
 222               TAO_CACHED_POLICY_SYNC_SCOPE);
 223         }
 224       else
 225         {
 226           policy =
 227             stub->get_cached_policy (TAO_CACHED_POLICY_SYNC_SCOPE);
 228         }
 229
 230       if (CORBA::is_nil (policy.in ()))
 231         {
 232           has_synchronization = true;
 233           scope = orb_core->default_sync_scope ();
 234           return;
 235         }
 236       Messaging::SyncScopePolicy_var p =
 237         Messaging::SyncScopePolicy::_narrow (policy.in ());
 238
 239       if (CORBA::is_nil (p.in ()))
 240         throw ::CORBA::INTERNAL (
 241                 CORBA::SystemException::_tao_minor_code (
 242                   TAO_POLICY_NARROW_CODE,
 243                   0),
 244                 CORBA::COMPLETED_NO);
 245
 246       has_synchronization = true;
 247       scope = p->synchronization ();
 248     }
 249   catch (const ::CORBA::Exception&)
 250     {
 251       // Ignore all exceptions...
 252     }
 253 }
 254
 255 CORBA::Policy_ptr
 256 TAO_Sync_Scope_Policy::create (const CORBA::Any& val)
 257 {
 258   Messaging::SyncScope synchronization;
 259   if ((val >>= synchronization) == 0)
 260     throw ::CORBA::PolicyError (CORBA::BAD_POLICY_VALUE);
 261
 262   TAO_Sync_Scope_Policy *servant = 0;
 263   ACE_NEW_THROW_EX (servant,
 264                     TAO_Sync_Scope_Policy (synchronization),
 265                     CORBA::NO_MEMORY ());
 266
 267   return servant;
 268 }
 269
 270 TAO_Sync_Scope_Policy *
 271 TAO_Sync_Scope_Policy::clone () const
 272 {
 273   TAO_Sync_Scope_Policy *copy = 0;
 274   ACE_NEW_RETURN (copy,
 275                   TAO_Sync_Scope_Policy (*this),
 276                   0);
 277   return copy;
 278 }
 279
 280 Messaging::SyncScope
 281 TAO_Sync_Scope_Policy::synchronization ()
 282 {
 283   return this->synchronization_;
 284 }
 285
 286 CORBA::Policy_ptr
 287 TAO_Sync_Scope_Policy::copy ()
 288 {
 289   TAO_Sync_Scope_Policy *servant = 0;
 290   ACE_NEW_THROW_EX (servant,
 291                     TAO_Sync_Scope_Policy (*this),
 292                     CORBA::NO_MEMORY ());
 293
 294   return servant;
 295 }
 296
 297 void
 298 TAO_Sync_Scope_Policy::destroy ()
 299 {
 300 }
 301 TAO_Cached_Policy_Type
 302 TAO_Sync_Scope_Policy::_tao_cached_type () const
 303 {
 304   return TAO_CACHED_POLICY_SYNC_SCOPE;
 305 }
 306
 307 #endif /* TAO_HAS_SYNC_SCOPE_POLICY == 1 */
 308
 309 TAO_END_VERSIONED_NAMESPACE_DECL