TAO/tao/ORB_Core.inl

   1 // -*- C++ -*-
   2 #include "tao/ORB_Core_TSS_Resources.h"
   3 #include "tao/ORB_Table.h"
   4
   5 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
   6
   7 ACE_INLINE ACE_Service_Gestalt*
   8 TAO_ORB_Core::configuration () const
   9 {
  10   return this->config_.get ();
  11 }
  12
  13 ACE_INLINE unsigned long
  14 TAO_ORB_Core::_incr_refcnt ()
  15 {
  16   return this->refcount_++;
  17 }
  18
  19 ACE_INLINE unsigned long
  20 TAO_ORB_Core::_refcnt () const
  21 {
  22   return this->refcount_;
  23 }
  24
  25 ACE_INLINE unsigned long
  26 TAO_ORB_Core::_decr_refcnt ()
  27 {
  28   unsigned long const count = --this->refcount_;
  29   if (count != 0)
  30     return count;
  31
  32   this->fini ();
  33   return 0;
  34 }
  35
  36 ACE_INLINE ACE_Lock *
  37 TAO_ORB_Core::locking_strategy ()
  38 {
  39   if (this->resource_factory ()->use_locked_data_blocks ())
  40     return &this->data_block_lock_;
  41
  42   return 0;
  43 }
  44
  45 ACE_INLINE CORBA::Boolean
  46 TAO_ORB_Core::bidir_giop_policy ()
  47 {
  48   return this->bidir_giop_policy_;
  49 }
  50
  51 ACE_INLINE void
  52 TAO_ORB_Core::bidir_giop_policy (CORBA::Boolean val)
  53 {
  54   this->bidir_giop_policy_ = val;
  55 }
  56
  57 ACE_INLINE TAO_Object_Ref_Table &
  58 TAO_ORB_Core::object_ref_table ()
  59 {
  60   return this->object_ref_table_;
  61 }
  62
  63 ACE_INLINE TAO::ObjectKey_Table &
  64 TAO_ORB_Core::object_key_table ()
  65 {
  66   return this->object_key_table_;
  67 }
  68
  69 ACE_INLINE TAO_Flushing_Strategy *
  70 TAO_ORB_Core::flushing_strategy ()
  71 {
  72   return this->flushing_strategy_;
  73 }
  74
  75 ACE_INLINE TAO_Protocols_Hooks *
  76 TAO_ORB_Core::get_protocols_hooks ()
  77 {
  78   return this->protocols_hooks_;
  79 }
  80
  81 ACE_INLINE TAO_Network_Priority_Protocols_Hooks *
  82 TAO_ORB_Core::get_network_priority_protocols_hooks ()
  83 {
  84   return this->network_priority_protocols_hooks_;
  85 }
  86
  87 ACE_INLINE CORBA::Boolean
  88 TAO_ORB_Core::service_profile_selection (const TAO_MProfile &mprofile,
  89                                          TAO_Profile  *&profile)
  90 {
  91   CORBA::Boolean retval = false;
  92   // @@ If different services have the same feature we may want to
  93   // prioritise them here. We need to decide here whose selection of
  94   // profile is more important.
  95   if (this->ft_service_.service_callback ())
  96     {
  97       retval =
  98         this->ft_service_.service_callback ()->select_profile (mprofile,
  99                                                                 profile);
 100     }
 101   return retval;
 102 }
 103
 104 ACE_INLINE CORBA::Boolean
 105 TAO_ORB_Core::object_is_nil (CORBA::Object_ptr obj)
 106 {
 107   CORBA::Boolean retval = false;
 108   if (this->ft_service_.service_callback ())
 109     {
 110       retval = this->ft_service_.service_callback ()->object_is_nil (obj);
 111     }
 112   return retval;
 113 }
 114
 115
 116 ACE_INLINE TAO_Service_Callbacks::Profile_Equivalence
 117 TAO_ORB_Core::is_profile_equivalent (const TAO_Profile *this_p,
 118                                      const TAO_Profile *that_p)
 119 {
 120   TAO_Service_Callbacks::Profile_Equivalence retval
 121     = TAO_Service_Callbacks::DONT_KNOW;
 122
 123   if (this->ft_service_.service_callback ())
 124     {
 125       retval =
 126         this->ft_service_.service_callback ()->is_profile_equivalent (this_p,
 127                                                                       that_p);
 128     }
 129
 130   return retval;
 131 }
 132
 133 ACE_INLINE CORBA::ULong
 134 TAO_ORB_Core::hash_service (TAO_Profile *p, CORBA::ULong m)
 135 {
 136   if (this->ft_service_.service_callback ())
 137     {
 138       return this->ft_service_.service_callback ()->hash_ft (p, m);
 139     }
 140
 141   return 0;
 142 }
 143
 144 ACE_INLINE TAO_Fault_Tolerance_Service &
 145 TAO_ORB_Core::fault_tolerance_service ()
 146 {
 147   return this->ft_service_;
 148 }
 149
 150 ACE_INLINE CORBA::Boolean
 151 TAO_ORB_Core::ft_send_extended_sc ()
 152 {
 153   return this->ft_send_extended_sc_;
 154 }
 155
 156 ACE_INLINE ACE_Thread_Manager *
 157 TAO_ORB_Core::thr_mgr ()
 158 {
 159   return &this->tm_;
 160 }
 161
 162 ACE_INLINE CORBA::ORB_ptr
 163 TAO_ORB_Core::orb ()
 164 {
 165   return this->orb_;
 166 }
 167
 168 ACE_INLINE TAO_Adapter_Registry &
 169 TAO_ORB_Core::adapter_registry ()
 170 {
 171   return this->adapter_registry_;
 172 }
 173
 174 ACE_INLINE TAO_Request_Dispatcher *
 175 TAO_ORB_Core::request_dispatcher ()
 176 {
 177   return this->request_dispatcher_;
 178 }
 179
 180 ACE_INLINE TAO_ORB_Core::InitRefMap *
 181 TAO_ORB_Core::init_ref_map ()
 182 {
 183   return &this->init_ref_map_;
 184 }
 185
 186 ACE_INLINE void
 187 TAO_ORB_Core::set_default (const char * orb_id)
 188 {
 189   TAO::ORB_Table * const table = TAO::ORB_Table::instance ();
 190   table->set_default (orb_id);
 191 }
 192
 193 ACE_INLINE void
 194 TAO_ORB_Core::not_default (const char * orb_id)
 195 {
 196   TAO::ORB_Table * const table = TAO::ORB_Table::instance ();
 197   table->not_default (orb_id);
 198 }
 199
 200 ACE_INLINE void
 201 TAO_ORB_Core::optimize_collocation_objects (CORBA::Boolean opt)
 202 {
 203   this->opt_for_collocation_ = opt;
 204 }
 205
 206 ACE_INLINE CORBA::Boolean
 207 TAO_ORB_Core::optimize_collocation_objects () const
 208 {
 209   return this->opt_for_collocation_;
 210 }
 211
 212 ACE_INLINE void
 213 TAO_ORB_Core::use_global_collocation (CORBA::Boolean opt)
 214 {
 215   this->use_global_collocation_ = opt;
 216 }
 217
 218 ACE_INLINE CORBA::Boolean
 219 TAO_ORB_Core::use_global_collocation () const
 220 {
 221   return this->use_global_collocation_;
 222 }
 223
 224 ACE_INLINE CORBA::ULong
 225 TAO_ORB_Core::get_collocation_strategy () const
 226 {
 227   return this->collocation_strategy_;
 228 }
 229
 230 ACE_INLINE TAO_ORB_Parameters *
 231 TAO_ORB_Core::orb_params()
 232 {
 233   return &(this->orb_params_);
 234 }
 235
 236 #define TAO_OC_RETRIEVE(member) \
 237 ((this->member##_ == 0) \
 238   ? (this->member##_ = this->resource_factory ()->get_##member ()) \
 239   : (this->member##_))
 240
 241 ACE_INLINE TAO_ProtocolFactorySet *
 242 TAO_ORB_Core::protocol_factories ()
 243 {
 244   return TAO_OC_RETRIEVE (protocol_factories);
 245 }
 246
 247 ACE_INLINE TAO_Parser_Registry *
 248 TAO_ORB_Core::parser_registry ()
 249 {
 250   return &this->parser_registry_;
 251 }
 252
 253 #undef TAO_OC_RETRIEVE
 254
 255 #if (TAO_HAS_CORBA_MESSAGING == 1)
 256
 257 ACE_INLINE TAO_Policy_Manager *
 258 TAO_ORB_Core::policy_manager ()
 259 {
 260   return this->policy_manager_;
 261 }
 262
 263 #endif /* TAO_HAS_CORBA_MESSAGING == 1 */
 264
 265 ACE_INLINE TAO_ORB_Core_TSS_Resources*
 266 TAO_ORB_Core::get_tss_resources ()
 267 {
 268   return ACE_TSS_GET (&this->tss_resources_,TAO_ORB_Core_TSS_Resources);
 269 }
 270
 271 ACE_INLINE void *
 272 TAO_ORB_Core::get_tss_resource (size_t slot_id)
 273 {
 274   TAO_ORB_Core_TSS_Resources *tss_resources =
 275     this->get_tss_resources ();
 276
 277   if (slot_id >= tss_resources->ts_objects_.size ())
 278     return 0;
 279
 280   return tss_resources->ts_objects_[slot_id];
 281 }
 282
 283 ACE_INLINE int
 284 TAO_ORB_Core::set_tss_resource (size_t slot_id, void *ts_object)
 285 {
 286   TAO_ORB_Core_TSS_Resources *tss_resources =
 287     this->get_tss_resources ();
 288
 289   // The number of allocated slots is equal to the number of
 290   // registered TSS cleanup functions, *not* the size of the array in
 291   // the ORB core TSS resources.
 292   if (slot_id >= this->tss_cleanup_funcs_.size ())
 293     {
 294       errno = EINVAL;
 295       return -1;
 296     }
 297
 298   // If the TSS array isn't large enough, then increase its size.
 299   // We're guaranteed not to exceed the number of allocated slots by
 300   // the above check.
 301   const size_t old_size = tss_resources->ts_objects_.size ();
 302   const size_t new_size = slot_id + 1;
 303   if (slot_id >= old_size
 304       && tss_resources->ts_objects_.size (new_size) != 0)
 305     return -1;
 306
 307   // Initialize intermediate array elements to zero, since they
 308   // haven't been initialized yet.  This ensures that garbage is not
 309   // returned when accessing any of those elements at a later point in
 310   // time.
 311   for (size_t i = old_size; i < slot_id; ++i)
 312     tss_resources->ts_objects_[i] = 0;
 313
 314   tss_resources->ts_objects_[slot_id] = ts_object;
 315
 316   // Make sure the ORB core pointer is set in the ORB core's TSS
 317   // resources so that the TSS cleanup functions stored in the ORB
 318   // core can be invoked.
 319   tss_resources->orb_core_ = this;
 320
 321   return 0;
 322 }
 323
 324 ACE_INLINE void
 325 TAO_ORB_Core::tss_cleanup (ACE_Array_Base<void *> &ts_objects)
 326 {
 327   this->tss_cleanup_funcs_.cleanup (ts_objects);
 328 }
 329
 330 ACE_INLINE bool
 331 TAO_ORB_Core::has_shutdown () const
 332 {
 333   return this->has_shutdown_;
 334 }
 335
 336 ACE_INLINE int
 337 TAO_ORB_Core::thread_per_connection_timeout (ACE_Time_Value &timeout) const
 338 {
 339   timeout = this->thread_per_connection_timeout_;
 340   return this->thread_per_connection_use_timeout_;
 341 }
 342
 343 ACE_INLINE const char *
 344 TAO_ORB_Core::orbid () const
 345 {
 346   return this->orbid_;
 347 }
 348
 349 ACE_INLINE void
 350 TAO_ORB_Core::implrepo_service (const CORBA::Object_ptr ir)
 351 {
 352   this->implrepo_service_ = ir;
 353 }
 354
 355 ACE_INLINE CORBA::Boolean
 356 TAO_ORB_Core::use_implrepo ()
 357 {
 358   return use_implrepo_;
 359 }
 360
 361 ACE_INLINE CORBA::Boolean
 362 TAO_ORB_Core::imr_endpoints_in_ior ()
 363 {
 364   return imr_endpoints_in_ior_;
 365 }
 366
 367 ACE_INLINE CORBA::Object_ptr
 368 TAO_ORB_Core::resolve_typecodefactory ()
 369 {
 370   ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, mon, this->lock_,
 371                     CORBA::Object::_nil ());
 372   if (CORBA::is_nil (this->typecode_factory_))
 373     {
 374       this->resolve_typecodefactory_i ();
 375     }
 376   return CORBA::Object::_duplicate (this->typecode_factory_);
 377 }
 378
 379 #if TAO_HAS_INTERCEPTORS == 1
 380
 381 ACE_INLINE CORBA::Object_ptr
 382 TAO_ORB_Core::resolve_picurrent ()
 383 {
 384   ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, mon, this->lock_,
 385                     CORBA::Object::_nil ());
 386   if (CORBA::is_nil (this->pi_current_))
 387     {
 388       this->resolve_picurrent_i ();
 389     }
 390   return CORBA::Object::_duplicate (this->pi_current_);
 391 }
 392
 393 #endif  /* TAO_HAS_INTERCEPTORS == 1 */
 394
 395 ACE_INLINE CORBA::Object_ptr
 396 TAO_ORB_Core::resolve_codecfactory ()
 397 {
 398   ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, mon, this->lock_,
 399                     CORBA::Object::_nil ());
 400   if (CORBA::is_nil (this->codec_factory_))
 401     {
 402       this->resolve_codecfactory_i ();
 403     }
 404   return CORBA::Object::_duplicate (this->codec_factory_);
 405 }
 406
 407 ACE_INLINE CORBA::Object_ptr
 408 TAO_ORB_Core::resolve_compression_manager ()
 409 {
 410   ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, mon, this->lock_,
 411                     CORBA::Object::_nil ());
 412   if (CORBA::is_nil (this->compression_manager_))
 413     {
 414       this->resolve_compression_manager_i ();
 415     }
 416   return CORBA::Object::_duplicate (this->compression_manager_);
 417 }
 418
 419 ACE_INLINE const char *
 420 TAO_ORB_Core::server_id () const
 421 {
 422   return this->server_id_.c_str();
 423 }
 424
 425 ACE_INLINE TAO_Codeset_Manager *
 426 TAO_ORB_Core::codeset_manager()
 427 {
 428   if (this->orb_params()->negotiate_codesets() == 0)
 429     return 0;
 430   if (this->codeset_manager_ == 0)
 431     {
 432       // This causes a factory to be loaded which will call
 433       // the codeset_manager setter in this thread.
 434       this->codeset_manager_ =
 435         this->resource_factory()->codeset_manager();
 436       if (this->codeset_manager_ == 0)
 437         this->orb_params()->negotiate_codesets(false);
 438     }
 439   return this->codeset_manager_;
 440 }
 441
 442 ACE_INLINE TAO_ZIOP_Adapter *
 443 TAO_ORB_Core::ziop_adapter () const
 444 {
 445   return this->ziop_adapter_;
 446 }
 447
 448 ACE_INLINE void
 449 TAO_ORB_Core::ziop_adapter (TAO_ZIOP_Adapter *adapter)
 450 {
 451   this->ziop_adapter_ = adapter;
 452 }
 453
 454 ACE_INLINE TAO::ORBInitializer_Registry_Adapter *
 455 TAO_ORB_Core::orbinitializer_registry ()
 456 {
 457   ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, mon, this->lock_,
 458                     0);
 459   if (orbinitializer_registry_ == 0)
 460     {
 461       return this->orbinitializer_registry_i ();
 462     }
 463   return this->orbinitializer_registry_;
 464 }
 465
 466 ACE_INLINE TAO_Service_Context_Registry &
 467 TAO_ORB_Core::service_context_registry ()
 468 {
 469   return this->service_context_registry_;
 470 }
 471
 472 ACE_INLINE TAO::PolicyFactory_Registry_Adapter *
 473 TAO_ORB_Core::policy_factory_registry ()
 474 {
 475   ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, mon, this->lock_,
 476                     0);
 477   if (policy_factory_registry_ == 0)
 478     {
 479       return this->policy_factory_registry_i ();
 480     }
 481   return this->policy_factory_registry_;
 482 }
 483
 484 ACE_INLINE CORBA::Object_ptr
 485 TAO_ORB_Core::resolve_dynanyfactory ()
 486 {
 487   ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, mon, this->lock_,
 488                     CORBA::Object::_nil ());
 489   if (CORBA::is_nil (this->dynany_factory_))
 490     {
 491       this->resolve_dynanyfactory_i ();
 492     }
 493   return CORBA::Object::_duplicate (this->dynany_factory_);
 494 }
 495
 496 ACE_INLINE CORBA::Object_ptr
 497 TAO_ORB_Core::resolve_ior_manipulation ()
 498 {
 499   ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, mon, this->lock_,
 500                     CORBA::Object::_nil ());
 501   if (CORBA::is_nil (this->ior_manip_factory_))
 502     {
 503       this->resolve_iormanipulation_i ();
 504     }
 505   return CORBA::Object::_duplicate (this->ior_manip_factory_);
 506 }
 507
 508 ACE_INLINE CORBA::Object_ptr
 509 TAO_ORB_Core::resolve_ior_table ()
 510 {
 511   ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, mon, this->lock_,
 512                     CORBA::Object::_nil ());
 513   if (CORBA::is_nil (this->ior_table_))
 514     {
 515       this->resolve_ior_table_i ();
 516     }
 517   return CORBA::Object::_duplicate (this->ior_table_);
 518 }
 519
 520 ACE_INLINE CORBA::Object_ptr
 521 TAO_ORB_Core::resolve_async_ior_table ()
 522 {
 523   ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, mon, this->lock_,
 524                     CORBA::Object::_nil ());
 525   if (CORBA::is_nil (this->async_ior_table_))
 526     {
 527       this->resolve_async_ior_table_i ();
 528     }
 529   return CORBA::Object::_duplicate (this->async_ior_table_);
 530 }
 531
 532 ACE_INLINE CORBA::Object_ptr
 533 TAO_ORB_Core::resolve_monitor ()
 534 {
 535   ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, mon, this->lock_,
 536                     CORBA::Object::_nil ());
 537   if (CORBA::is_nil (this->monitor_))
 538     {
 539       this->resolve_monitor_i ();
 540     }
 541   return CORBA::Object::_duplicate (this->monitor_);
 542 }
 543
 544 // ****************************************************************
 545
 546 #if (TAO_HAS_CORBA_MESSAGING == 1)
 547
 548 ACE_INLINE TAO_Policy_Current &
 549 TAO_ORB_Core::policy_current ()
 550 {
 551   return *this->policy_current_;
 552 }
 553
 554 #endif /* TAO_HAS_CORBA_MESSAGING == 1 */
 555
 556 ACE_INLINE CORBA::Object_ptr
 557 TAO_ORB_Core::resolve_poa_current ()
 558 {
 559   ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, mon, this->lock_,
 560                     CORBA::Object::_nil ());
 561   if (CORBA::is_nil (this->poa_current_.in ()))
 562     {
 563       this->resolve_poa_current_i ();
 564     }
 565   return CORBA::Object::_duplicate (this->poa_current_.in ());
 566 }
 567
 568 #if (TAO_HAS_CORBA_MESSAGING == 1)
 569
 570 ACE_INLINE  TAO_Policy_Set *
 571 TAO_ORB_Core::get_default_policies ()
 572 {
 573   return this->default_policies_;
 574 }
 575
 576 #endif /* TAO_HAS_CORBA_MESSAGING == 1 */
 577
 578 #if defined (TAO_HAS_CORBA_MESSAGING) && TAO_HAS_CORBA_MESSAGING != 0
 579 ACE_INLINE CORBA::Object_ptr
 580 TAO_ORB_Core::resolve_rt_orb ()
 581 {
 582   if (CORBA::is_nil (this->rt_orb_.in ()))
 583     {
 584       ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, mon, this->lock_,
 585                         CORBA::Object::_nil ());
 586       if (CORBA::is_nil (this->rt_orb_.in ()))
 587         {
 588           // Save a reference to the priority mapping manager.
 589           this->rt_orb_ =
 590               this->object_ref_table ().resolve_initial_reference (
 591               TAO_OBJID_RTORB);
 592         }
 593     }
 594
 595   return CORBA::Object::_duplicate (this->rt_orb_.in ());
 596 }
 597 #endif
 598
 599 #if (TAO_HAS_INTERCEPTORS == 1)
 600 ACE_INLINE CORBA::Object_ptr
 601 TAO_ORB_Core::pi_current ()
 602 {
 603   // A pointer/reference to PICurrent is cached in the ORB Core since
 604   // it is accessed in the critical path (i.e. the request invocation
 605   // path).  Caching it prevents additional overhead to due object
 606   // resolution from occurring.
 607   return this->pi_current_;
 608 }
 609
 610 ACE_INLINE void
 611 TAO_ORB_Core::pi_current (CORBA::Object_ptr current)
 612 {
 613   // Not duplicated since the ORB Core's "object_ref_table" already
 614   // contains a duplicate of the PICurrent object.
 615   this->pi_current_ = current;
 616 }
 617
 618 ACE_INLINE TAO::ClientRequestInterceptor_Adapter *
 619 TAO_ORB_Core::clientrequestinterceptor_adapter ()
 620 {
 621   return this->client_request_interceptor_adapter_;
 622 }
 623
 624 ACE_INLINE TAO::ServerRequestInterceptor_Adapter *
 625 TAO_ORB_Core::serverrequestinterceptor_adapter ()
 626 {
 627   return this->server_request_interceptor_adapter_;
 628 }
 629
 630 #endif /* TAO_HAS_INTERCEPTORS */
 631
 632 /// Verify condition for  permanent forward is given,
 633 /// both parameters must provide group attributes.
 634 ACE_INLINE  CORBA::Boolean
 635 TAO_ORB_Core::is_permanent_forward_condition
 636 (const CORBA::Object_ptr obj,
 637  const TAO_Service_Context &service_context)
 638 {
 639   const TAO_Service_Callbacks *service_callback =
 640       this->fault_tolerance_service ().service_callback ();
 641
 642   // Since forward location is allowed to be nil then check for it.
 643   CORBA::Boolean const permanent_forward_condition =
 644       service_callback && obj &&
 645       service_callback->is_permanent_forward_condition (obj,
 646                                                         service_context);
 647
 648   return permanent_forward_condition;
 649 }
 650
 651 ACE_INLINE
 652 void
 653 TAO_ORB_Core::set_sync_scope_hook (Sync_Scope_Hook hook)
 654 {
 655   this->sync_scope_hook_ = hook;
 656 }
 657
 658 ACE_INLINE
 659 Messaging::SyncScope
 660 TAO_ORB_Core::default_sync_scope ()
 661 {
 662   return this->default_sync_scope_;
 663 }
 664
 665 ACE_INLINE
 666 void
 667 TAO_ORB_Core::set_timeout_hook (Timeout_Hook hook)
 668 {
 669   // Saving the hook pointer so that we can use it later when needed.
 670   this->timeout_hook_ = hook;
 671 }
 672
 673 #if (TAO_HAS_BUFFERING_CONSTRAINT_POLICY == 1)
 674
 675 ACE_INLINE
 676 void
 677 TAO_ORB_Core::set_eager_transport_queueing_strategy (
 678   TAO::Transport_Queueing_Strategy* strategy)
 679 {
 680   this->eager_transport_queueing_strategy_ = strategy;
 681 }
 682
 683 ACE_INLINE
 684 void
 685 TAO_ORB_Core::set_delayed_transport_queueing_strategy (
 686   TAO::Transport_Queueing_Strategy* strategy)
 687 {
 688   this->delayed_transport_queueing_strategy_ = strategy;
 689 }
 690
 691 #endif
 692
 693 TAO_END_VERSIONED_NAMESPACE_DECL