import "InvalidName.pidl";
Collaboration diagram for CORBA::ORB:
The "ORB" pseudo-object is used in bootstrapping, such as to create object references from strings. This class is intended to be inherited by others, which will provide some more of the CORBA support. Implementations of this "CORBA::ORB" class must know how to create stringify/destringify their objrefs, as well as how to marshal and unmarshal them.
Definition at line 39 of file InvalidName.pidl.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Definition at line 191 of file ORB.h. Referenced by TAO_ORB_Core::list_initial_references(). |
|
|
|
|
|
|
|
|
Definition at line 192 of file ORB.h. Referenced by TAO_ORB_Core::list_initial_references(). |
|
|
Definition at line 144 of file ORB.cpp. References use_omg_ior_format_.
00145 : lock_ () 00146 , refcount_ (1) 00147 , orb_core_ (orb_core) 00148 , use_omg_ior_format_ (1) 00149 , timeout_ (0) 00150 { 00151 } |
|
|
Destructor. Protected destructor to enforce proper memory management through the reference counting mechanism. Definition at line 153 of file ORB.cpp.
00154 {
00155 // This destructor is only invoked when the last ORB reference (not
00156 // instance) is being destroyed.
00157 }
|
|
|
|
|
|
Create an empty policy, usually to be filled in later by demarshaling. Definition at line 1794 of file ORB.cpp. References TAO::PolicyFactory_Registry_Adapter::_create_policy(), ACE_CHECK_RETURN, ACE_ENV_ARG_PARAMETER, ACE_ENV_SINGLE_ARG_PARAMETER, ACE_THROW_RETURN, check_shutdown(), TAO_ORB_Core::policy_factory_registry(), and CORBA::PolicyType. Referenced by TAO_Profile::get_policies().
01796 {
01797 this->check_shutdown (ACE_ENV_SINGLE_ARG_PARAMETER);
01798 ACE_CHECK_RETURN (CORBA::Policy::_nil ());
01799
01800 TAO::PolicyFactory_Registry_Adapter *adapter =
01801 this->orb_core_->policy_factory_registry ();
01802
01803 if (adapter == 0)
01804 {
01805 ACE_THROW_RETURN (CORBA::INTERNAL (),
01806 CORBA::Policy::_nil ());
01807 }
01808
01809 // Attempt to obtain the policy from the policy factory registry.
01810 return adapter->_create_policy (
01811 type
01812 ACE_ENV_ARG_PARAMETER);
01813 }
|
|
|
Definition at line 22 of file ORB.i. References ACE_GUARD_RETURN, and TAO_SYNCH_MUTEX. Referenced by CORBA::release().
00023 {
00024 {
00025 ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, mon, this->lock_, 0);
00026 --this->refcount_;
00027
00028 if (this->refcount_ != 0)
00029 {
00030 return this->refcount_;
00031 }
00032 }
00033
00034 delete this;
00035 return 0;
00036 }
|
|
|
Return a duplicate of When work with this duplicate is complete, it should be freed up using CORBA::release(). Definition at line 39 of file ORB.i. References _incr_refcnt(), and CORBA::ORB_ptr. Referenced by CORBA::Object::_get_orb(), CORBA::ORB_init(), TAO_Stub::servant_orb(), TAO_Stub::servant_orb_ptr(), and TAO_Stub::TAO_Stub().
00040 {
00041 if (obj)
00042 {
00043 obj->_incr_refcnt ();
00044 }
00045
00046 return obj;
00047 }
|
|
|
Definition at line 12 of file ORB.i. References ACE_GUARD_RETURN, and TAO_SYNCH_MUTEX. Referenced by _duplicate().
00013 {
00014 ACE_GUARD_RETURN (TAO_SYNCH_MUTEX,
00015 guard,
00016 lock_,
00017 0);
00018 return ++this->refcount_;
00019 }
|
|
|
Returns a pointer to a nil ORB, i.e., an non-existent ORB. This can be used for initialization or in comparisons. Definition at line 52 of file ORB.i. Referenced by _tao_make_ORB(), CORBA::is_nil(), and CORBA::ORB_init().
00053 {
00054 return 0;
00055 }
|
|
|
Definition at line 1313 of file ORB.cpp. References TAO_Fault_Tolerance_Service::client_id(), TAO_ORB_Core::fault_tolerance_service(), and orb_core().
01314 {
01315 this->orb_core ()->fault_tolerance_service ().client_id (id);
01316 }
|
|
|
TAO specific extension to get and set the client ID. The client id can be set by the application which would be used by the FT service. As there are no specific interfaces defined in the spec, we have this proprietary extension. Definition at line 1307 of file ORB.cpp. References TAO_Fault_Tolerance_Service::client_id(), TAO_ORB_Core::fault_tolerance_service(), and orb_core().
01308 {
01309 return this->orb_core ()->fault_tolerance_service ().client_id ();
01310 }
|
|
|
Factory method that creates an ORB.
Definition at line 1319 of file ORB.cpp. References _nil(), ACE_NEW_RETURN, and CORBA::ORB_ptr.
01320 {
01321 CORBA::ORB_ptr orb = CORBA::ORB::_nil ();
01322
01323 ACE_NEW_RETURN (orb,
01324 CORBA::ORB (orb_core),
01325 CORBA::ORB::_nil ());
01326
01327 return orb;
01328 }
|
|
|
Get the IOR flag.
Definition at line 64 of file ORB.i. References use_omg_ior_format_.
00065 {
00066 return this->use_omg_ior_format_;
00067 }
|
|
|
Set the IOR flag.
Definition at line 58 of file ORB.i. References use_omg_ior_format_. Referenced by TAO_Profile::verify_orb_configuration().
00059 {
00060 this->use_omg_ior_format_ = ior;
00061 }
|
|
|
Check if ORB has shutdown. If it has, throw the appropriate exception. Definition at line 1252 of file ORB.cpp. References ACE_CHECK, ACE_ENV_SINGLE_ARG_PARAMETER, ACE_THROW, TAO_ORB_Core::check_shutdown(), and orb_core(). Referenced by _create_policy(), create_policy(), list_initial_services(), object_to_string(), perform_work(), resolve_initial_references(), run(), shutdown(), string_to_object(), and work_pending().
01253 {
01254 if (this->orb_core () != 0)
01255 {
01256 this->orb_core ()->check_shutdown (ACE_ENV_SINGLE_ARG_PARAMETER);
01257 ACE_CHECK;
01258 }
01259 else
01260 {
01261 // If the ORB_Core pointer is zero, assume that the ORB_Core has
01262 // been destroyed.
01263
01264 // As defined by the CORBA 2.3 specification, throw a
01265 // CORBA::OBJECT_NOT_EXIST exception if the ORB has been
01266 // destroyed by the time an ORB function is called.
01267
01268 ACE_THROW (CORBA::OBJECT_NOT_EXIST (0,
01269 CORBA::COMPLETED_NO));
01270 }
01271 }
|
|
||||||||||||
|
Definition at line 822 of file ORB.cpp. References ACE_ENV_ARG_PARAMETER, ACE_THROW_RETURN, TAO_TypeCodeFactory_Adapter::create_abstract_interface_tc(), and ACE_Dynamic_Service< TYPE >::instance().
00827 {
00828 TAO_TypeCodeFactory_Adapter *adapter =
00829 ACE_Dynamic_Service<TAO_TypeCodeFactory_Adapter>::instance (
00830 TAO_ORB_Core::typecodefactory_adapter_name ()
00831 );
00832
00833 if (adapter == 0)
00834 {
00835 ACE_THROW_RETURN (CORBA::INTERNAL (),
00836 0);
00837 }
00838
00839 return adapter->create_abstract_interface_tc (id,
00840 name
00841 ACE_ENV_ARG_PARAMETER);
00842 }
|
|
||||||||||||||||
|
Definition at line 540 of file ORB.cpp. References ACE_ENV_ARG_PARAMETER, ACE_THROW_RETURN, TAO_TypeCodeFactory_Adapter::create_alias_tc(), ACE_Dynamic_Service< TYPE >::instance(), and CORBA::TypeCode_ptr.
00546 {
00547 TAO_TypeCodeFactory_Adapter *adapter =
00548 ACE_Dynamic_Service<TAO_TypeCodeFactory_Adapter>::instance (
00549 TAO_ORB_Core::typecodefactory_adapter_name ()
00550 );
00551
00552 if (adapter == 0)
00553 {
00554 ACE_THROW_RETURN (CORBA::INTERNAL (),
00555 0);
00556 }
00557
00558 return adapter->create_alias_tc (id,
00559 name,
00560 original_type
00561 ACE_ENV_ARG_PARAMETER);
00562 }
|
|
||||||||||||
|
Definition at line 701 of file ORB.cpp. References ACE_ENV_ARG_PARAMETER, ACE_THROW_RETURN, TAO_TypeCodeFactory_Adapter::create_array_tc(), ACE_Dynamic_Service< TYPE >::instance(), and CORBA::TypeCode_ptr.
00706 {
00707 TAO_TypeCodeFactory_Adapter *adapter =
00708 ACE_Dynamic_Service<TAO_TypeCodeFactory_Adapter>::instance (
00709 TAO_ORB_Core::typecodefactory_adapter_name ()
00710 );
00711
00712 if (adapter == 0)
00713 {
00714 ACE_THROW_RETURN (CORBA::INTERNAL (),
00715 0);
00716 }
00717
00718 return adapter->create_array_tc (length,
00719 element_type
00720 ACE_ENV_ARG_PARAMETER);
00721 }
|
|
||||||||||||
|
Definition at line 868 of file ORB.cpp. References ACE_ENV_ARG_PARAMETER, ACE_THROW_RETURN, TAO_TypeCodeFactory_Adapter::create_component_tc(), and ACE_Dynamic_Service< TYPE >::instance().
00873 {
00874 TAO_TypeCodeFactory_Adapter *adapter =
00875 ACE_Dynamic_Service<TAO_TypeCodeFactory_Adapter>::instance (
00876 TAO_ORB_Core::typecodefactory_adapter_name ()
00877 );
00878
00879 if (adapter == 0)
00880 {
00881 ACE_THROW_RETURN (CORBA::INTERNAL (),
00882 0);
00883 }
00884
00885 return adapter->create_component_tc (id,
00886 name
00887 ACE_ENV_ARG_PARAMETER);
00888 }
|
|
|
Definition at line 395 of file ORB.cpp. References ACE_THROW, CORBA::ContextList_ptr, and ENOTSUP.
00397 {
00398 ACE_THROW (CORBA::NO_IMPLEMENT (
00399 CORBA::SystemException::_tao_minor_code (
00400 0,
00401 ENOTSUP),
00402 CORBA::COMPLETED_NO));
00403 }
|
|
||||||||||||||||
|
Definition at line 515 of file ORB.cpp. References ACE_ENV_ARG_PARAMETER, ACE_THROW_RETURN, TAO_TypeCodeFactory_Adapter::create_enum_tc(), and ACE_Dynamic_Service< TYPE >::instance().
00521 {
00522 TAO_TypeCodeFactory_Adapter *adapter =
00523 ACE_Dynamic_Service<TAO_TypeCodeFactory_Adapter>::instance (
00524 TAO_ORB_Core::typecodefactory_adapter_name ()
00525 );
00526
00527 if (adapter == 0)
00528 {
00529 ACE_THROW_RETURN (CORBA::INTERNAL (),
00530 0);
00531 }
00532
00533 return adapter->create_enum_tc (id,
00534 name,
00535 members
00536 ACE_ENV_ARG_PARAMETER);
00537 }
|
|
|
Definition at line 343 of file ORB.cpp. References ACE_NEW_THROW_EX, and CORBA::Environment_ptr.
00345 {
00346 ACE_NEW_THROW_EX (environment,
00347 CORBA::Environment (),
00348 CORBA::NO_MEMORY (
00349 CORBA::SystemException::_tao_minor_code (
00350 0,
00351 ENOMEM),
00352 CORBA::COMPLETED_NO));
00353 }
|
|
||||||||||||||||||||||||
|
Definition at line 914 of file ORB.cpp. References ACE_ENV_ARG_PARAMETER, ACE_THROW_RETURN, TAO_TypeCodeFactory_Adapter::create_event_tc(), ACE_Dynamic_Service< TYPE >::instance(), CORBA::TypeCode_ptr, and CORBA::ValueModifier.
00922 {
00923 TAO_TypeCodeFactory_Adapter *adapter =
00924 ACE_Dynamic_Service<TAO_TypeCodeFactory_Adapter>::instance (
00925 TAO_ORB_Core::typecodefactory_adapter_name ()
00926 );
00927
00928 if (adapter == 0)
00929 {
00930 ACE_THROW_RETURN (CORBA::INTERNAL (),
00931 0);
00932 }
00933
00934 return adapter->create_event_tc (id,
00935 name,
00936 type_modifier,
00937 concrete_base,
00938 members
00939 ACE_ENV_ARG_PARAMETER);
00940 }
|
|
|
Definition at line 308 of file ORB.cpp. References ACE_ENV_ARG_PARAMETER, TAO_Dynamic_Adapter::create_exception_list(), CORBA::ExceptionList_ptr, and ACE_Dynamic_Service< TYPE >::instance().
00310 {
00311 TAO_Dynamic_Adapter *dynamic_adapter =
00312 ACE_Dynamic_Service<TAO_Dynamic_Adapter>::instance (
00313 TAO_ORB_Core::dynamic_adapter_name ()
00314 );
00315
00316 dynamic_adapter->create_exception_list (list
00317 ACE_ENV_ARG_PARAMETER);
00318 }
|
|
||||||||||||||||
|
Definition at line 565 of file ORB.cpp. References ACE_ENV_ARG_PARAMETER, ACE_THROW_RETURN, TAO_TypeCodeFactory_Adapter::create_exception_tc(), and ACE_Dynamic_Service< TYPE >::instance().
00571 {
00572 TAO_TypeCodeFactory_Adapter *adapter =
00573 ACE_Dynamic_Service<TAO_TypeCodeFactory_Adapter>::instance (
00574 TAO_ORB_Core::typecodefactory_adapter_name ()
00575 );
00576
00577 if (adapter == 0)
00578 {
00579 ACE_THROW_RETURN (CORBA::INTERNAL (),
00580 0);
00581 }
00582
00583 return adapter->create_exception_tc (id,
00584 name,
00585 members
00586 ACE_ENV_ARG_PARAMETER);
00587 }
|
|
||||||||||||
|
Definition at line 655 of file ORB.cpp. References ACE_ENV_ARG_PARAMETER, ACE_THROW_RETURN, TAO_TypeCodeFactory_Adapter::create_fixed_tc(), and ACE_Dynamic_Service< TYPE >::instance().
00660 {
00661 TAO_TypeCodeFactory_Adapter *adapter =
00662 ACE_Dynamic_Service<TAO_TypeCodeFactory_Adapter>::instance (
00663 TAO_ORB_Core::typecodefactory_adapter_name ()
00664 );
00665
00666 if (adapter == 0)
00667 {
00668 ACE_THROW_RETURN (CORBA::INTERNAL (),
00669 0);
00670 }
00671
00672 return adapter->create_fixed_tc (digits,
00673 scale
00674 ACE_ENV_ARG_PARAMETER);
00675 }
|
|
||||||||||||
|
Definition at line 891 of file ORB.cpp. References ACE_ENV_ARG_PARAMETER, ACE_THROW_RETURN, TAO_TypeCodeFactory_Adapter::create_home_tc(), and ACE_Dynamic_Service< TYPE >::instance().
00896 {
00897 TAO_TypeCodeFactory_Adapter *adapter =
00898 ACE_Dynamic_Service<TAO_TypeCodeFactory_Adapter>::instance (
00899 TAO_ORB_Core::typecodefactory_adapter_name ()
00900 );
00901
00902 if (adapter == 0)
00903 {
00904 ACE_THROW_RETURN (CORBA::INTERNAL (),
00905 0);
00906 }
00907
00908 return adapter->create_home_tc (id,
00909 name
00910 ACE_ENV_ARG_PARAMETER);
00911 }
|
|
||||||||||||
|
Definition at line 590 of file ORB.cpp. References ACE_ENV_ARG_PARAMETER, ACE_THROW_RETURN, TAO_TypeCodeFactory_Adapter::create_interface_tc(), and ACE_Dynamic_Service< TYPE >::instance().
00595 {
00596 TAO_TypeCodeFactory_Adapter *adapter =
00597 ACE_Dynamic_Service<TAO_TypeCodeFactory_Adapter>::instance (
00598 TAO_ORB_Core::typecodefactory_adapter_name ()
00599 );
00600
00601 if (adapter == 0)
00602 {
00603 ACE_THROW_RETURN (CORBA::INTERNAL (),
00604 0);
00605 }
00606
00607 return adapter->create_interface_tc (id,
00608 name
00609 ACE_ENV_ARG_PARAMETER);
00610 }
|
|
||||||||||||
|
Definition at line 286 of file ORB.cpp. References ACE_ENV_ARG_PARAMETER, ACE_ERROR, ACE_TEXT, ACE_THROW, TAO_NVList_Adapter::create_list(), ACE_Dynamic_Service< TYPE >::instance(), LM_ERROR, and CORBA::NVList_ptr.
00289 {
00290 TAO_NVList_Adapter *adapter =
00291 ACE_Dynamic_Service<TAO_NVList_Adapter>::instance (
00292 "TAO_NVList_Adapter"
00293 );
00294
00295 if (adapter == 0)
00296 {
00297 ACE_ERROR ((LM_ERROR,
00298 ACE_TEXT ("(%P|%t) %p\n"),
00299 ACE_TEXT ("ORB unable to find the ")
00300 ACE_TEXT ("NVList Adapter instance")));
00301 ACE_THROW (CORBA::INTERNAL ());
00302 }
00303
00304 adapter->create_list (count, new_list ACE_ENV_ARG_PARAMETER);
00305 }
|
|
||||||||||||
|
Definition at line 845 of file ORB.cpp. References ACE_ENV_ARG_PARAMETER, ACE_THROW_RETURN, TAO_TypeCodeFactory_Adapter::create_local_interface_tc(), and ACE_Dynamic_Service< TYPE >::instance().
00850 {
00851 TAO_TypeCodeFactory_Adapter *adapter =
00852 ACE_Dynamic_Service<TAO_TypeCodeFactory_Adapter>::instance (
00853 TAO_ORB_Core::typecodefactory_adapter_name ()
00854 );
00855
00856 if (adapter == 0)
00857 {
00858 ACE_THROW_RETURN (CORBA::INTERNAL (),
00859 0);
00860 }
00861
00862 return adapter->create_local_interface_tc (id,
00863 name
00864 ACE_ENV_ARG_PARAMETER);
00865 }
|
|
|
Definition at line 356 of file ORB.cpp. References ACE_ENV_ARG_PARAMETER, ACE_ERROR, ACE_TEXT, ACE_THROW, TAO_NVList_Adapter::create_named_value(), ACE_Dynamic_Service< TYPE >::instance(), LM_ERROR, and CORBA::NamedValue_ptr.
00358 {
00359 TAO_NVList_Adapter *adapter =
00360 ACE_Dynamic_Service<TAO_NVList_Adapter>::instance (
00361 "TAO_NVList_Adapter"
00362 );
00363
00364 if (adapter == 0)
00365 {
00366 ACE_ERROR ((LM_ERROR,
00367 ACE_TEXT ("(%P|%t) %p\n"),
00368 ACE_TEXT ("ORB unable to find the ")
00369 ACE_TEXT ("NVList Adapter instance")));
00370
00371 ACE_THROW (CORBA::INTERNAL ());
00372 }
00373
00374 adapter->create_named_value (nv ACE_ENV_ARG_PARAMETER);
00375 }
|
|
||||||||||||
|
Definition at line 778 of file ORB.cpp. References ACE_ENV_ARG_PARAMETER, ACE_THROW_RETURN, TAO_TypeCodeFactory_Adapter::create_native_tc(), and ACE_Dynamic_Service< TYPE >::instance().
00783 {
00784 TAO_TypeCodeFactory_Adapter *adapter =
00785 ACE_Dynamic_Service<TAO_TypeCodeFactory_Adapter>::instance (
00786 TAO_ORB_Core::typecodefactory_adapter_name ()
00787 );
00788
00789 if (adapter == 0)
00790 {
00791 ACE_THROW_RETURN (CORBA::INTERNAL (),
00792 0);
00793 }
00794
00795 return adapter->create_native_tc (id,
00796 name
00797 ACE_ENV_ARG_PARAMETER);
00798 }
|
|
||||||||||||
|
Definition at line 321 of file ORB.cpp. References ACE_ENV_ARG_PARAMETER, ACE_THROW, TAO_IFR_Client_Adapter::create_operation_list(), ACE_Dynamic_Service< TYPE >::instance(), CORBA::NVList_ptr, and CORBA::OperationDef_ptr.
00324 {
00325 TAO_IFR_Client_Adapter *adapter =
00326 ACE_Dynamic_Service<TAO_IFR_Client_Adapter>::instance (
00327 TAO_ORB_Core::ifr_client_adapter_name ()
00328 );
00329
00330 if (adapter == 0)
00331 {
00332 ACE_THROW (CORBA::INTF_REPOS ());
00333 }
00334
00335 adapter->create_operation_list (this,
00336 opDef,
00337 result
00338 ACE_ENV_ARG_PARAMETER);
00339 }
|
|
||||||||||||
|
Definition at line 1768 of file ORB.cpp. References ACE_CHECK_RETURN, ACE_ENV_ARG_PARAMETER, ACE_ENV_SINGLE_ARG_PARAMETER, ACE_THROW_RETURN, check_shutdown(), TAO::PolicyFactory_Registry_Adapter::create_policy(), TAO_ORB_Core::policy_factory_registry(), and CORBA::PolicyType.
01771 {
01772 this->check_shutdown (ACE_ENV_SINGLE_ARG_PARAMETER);
01773 ACE_CHECK_RETURN (CORBA::Policy::_nil ());
01774
01775 TAO::PolicyFactory_Registry_Adapter *adapter =
01776 this->orb_core_->policy_factory_registry ();
01777
01778 if (adapter == 0)
01779 {
01780 ACE_THROW_RETURN (CORBA::INTERNAL (),
01781 CORBA::Policy::_nil ());
01782 }
01783
01784 // Attempt to obtain the policy from the policy factory registry.
01785 return adapter->create_policy (
01786 type,
01787 val
01788 ACE_ENV_ARG_PARAMETER);
01789 }
|
|
|
Definition at line 801 of file ORB.cpp. References ACE_ENV_ARG_PARAMETER, ACE_THROW_RETURN, TAO_TypeCodeFactory_Adapter::create_recursive_tc(), and ACE_Dynamic_Service< TYPE >::instance().
00805 {
00806 TAO_TypeCodeFactory_Adapter *adapter =
00807 ACE_Dynamic_Service<TAO_TypeCodeFactory_Adapter>::instance (
00808 TAO_ORB_Core::typecodefactory_adapter_name ()
00809 );
00810
00811 if (adapter == 0)
00812 {
00813 ACE_THROW_RETURN (CORBA::INTERNAL (),
00814 0);
00815 }
00816
00817 return adapter->create_recursive_tc (id
00818 ACE_ENV_ARG_PARAMETER);
00819 }
|
|
||||||||||||
|
Definition at line 678 of file ORB.cpp. References ACE_ENV_ARG_PARAMETER, ACE_THROW_RETURN, TAO_TypeCodeFactory_Adapter::create_sequence_tc(), ACE_Dynamic_Service< TYPE >::instance(), and CORBA::TypeCode_ptr.
00683 {
00684 TAO_TypeCodeFactory_Adapter *adapter =
00685 ACE_Dynamic_Service<TAO_TypeCodeFactory_Adapter>::instance (
00686 TAO_ORB_Core::typecodefactory_adapter_name ()
00687 );
00688
00689 if (adapter == 0)
00690 {
00691 ACE_THROW_RETURN (CORBA::INTERNAL (),
00692 0);
00693 }
00694
00695 return adapter->create_sequence_tc (bound,
00696 element_type
00697 ACE_ENV_ARG_PARAMETER);
00698 }
|
|
|
Definition at line 613 of file ORB.cpp. References ACE_ENV_ARG_PARAMETER, ACE_THROW_RETURN, TAO_TypeCodeFactory_Adapter::create_string_tc(), and ACE_Dynamic_Service< TYPE >::instance().
00617 {
00618 TAO_TypeCodeFactory_Adapter *adapter =
00619 ACE_Dynamic_Service<TAO_TypeCodeFactory_Adapter>::instance (
00620 TAO_ORB_Core::typecodefactory_adapter_name ()
00621 );
00622
00623 if (adapter == 0)
00624 {
00625 ACE_THROW_RETURN (CORBA::INTERNAL (),
00626 0);
00627 }
00628
00629 return adapter->create_string_tc (bound
00630 ACE_ENV_ARG_PARAMETER);
00631 }
|
|
||||||||||||||||
|
The ORB TypeCode creation functions.
Definition at line 463 of file ORB.cpp. References ACE_ENV_ARG_PARAMETER, ACE_THROW_RETURN, TAO_TypeCodeFactory_Adapter::create_struct_tc(), and ACE_Dynamic_Service< TYPE >::instance().
00469 {
00470 TAO_TypeCodeFactory_Adapter *adapter =
00471 ACE_Dynamic_Service<TAO_TypeCodeFactory_Adapter>::instance (
00472 TAO_ORB_Core::typecodefactory_adapter_name ()
00473 );
00474
00475 if (adapter == 0)
00476 {
00477 ACE_THROW_RETURN (CORBA::INTERNAL (),
00478 0);
00479 }
00480
00481 return adapter->create_struct_tc (id,
00482 name,
00483 members
00484 ACE_ENV_ARG_PARAMETER);
00485 }
|
|
||||||||||||||||||||
|
Definition at line 488 of file ORB.cpp. References ACE_ENV_ARG_PARAMETER, ACE_THROW_RETURN, TAO_TypeCodeFactory_Adapter::create_union_tc(), ACE_Dynamic_Service< TYPE >::instance(), and CORBA::TypeCode_ptr.
00495 {
00496 TAO_TypeCodeFactory_Adapter *adapter =
00497 ACE_Dynamic_Service<TAO_TypeCodeFactory_Adapter>::instance (
00498 TAO_ORB_Core::typecodefactory_adapter_name ()
00499 );
00500
00501 if (adapter == 0)
00502 {
00503 ACE_THROW_RETURN (CORBA::INTERNAL (),
00504 0);
00505 }
00506
00507 return adapter->create_union_tc (id,
00508 name,
00509 discriminator_type,
00510 members
00511 ACE_ENV_ARG_PARAMETER);
00512 }
|
|
||||||||||||||||
|
Definition at line 753 of file ORB.cpp. References ACE_ENV_ARG_PARAMETER, ACE_THROW_RETURN, TAO_TypeCodeFactory_Adapter::create_value_box_tc(), ACE_Dynamic_Service< TYPE >::instance(), and CORBA::TypeCode_ptr.
00759 {
00760 TAO_TypeCodeFactory_Adapter *adapter =
00761 ACE_Dynamic_Service<TAO_TypeCodeFactory_Adapter>::instance (
00762 TAO_ORB_Core::typecodefactory_adapter_name ()
00763 );
00764
00765 if (adapter == 0)
00766 {
00767 ACE_THROW_RETURN (CORBA::INTERNAL (),
00768 0);
00769 }
00770
00771 return adapter->create_value_box_tc (id,
00772 name,
00773 boxed_type
00774 ACE_ENV_ARG_PARAMETER);
00775 }
|
|
||||||||||||||||||||||||
|
Definition at line 724 of file ORB.cpp. References ACE_ENV_ARG_PARAMETER, ACE_THROW_RETURN, TAO_TypeCodeFactory_Adapter::create_value_tc(), ACE_Dynamic_Service< TYPE >::instance(), CORBA::TypeCode_ptr, and CORBA::ValueModifier.
00732 {
00733 TAO_TypeCodeFactory_Adapter *adapter =
00734 ACE_Dynamic_Service<TAO_TypeCodeFactory_Adapter>::instance (
00735 TAO_ORB_Core::typecodefactory_adapter_name ()
00736 );
00737
00738 if (adapter == 0)
00739 {
00740 ACE_THROW_RETURN (CORBA::INTERNAL (),
00741 0);
00742 }
00743
00744 return adapter->create_value_tc (id,
00745 name,
00746 type_modifier,
00747 concrete_base,
00748 members
00749 ACE_ENV_ARG_PARAMETER);
00750 }
|
|
|
Definition at line 634 of file ORB.cpp. References ACE_ENV_ARG_PARAMETER, ACE_THROW_RETURN, TAO_TypeCodeFactory_Adapter::create_wstring_tc(), and ACE_Dynamic_Service< TYPE >::instance().
00638 {
00639 TAO_TypeCodeFactory_Adapter *adapter =
00640 ACE_Dynamic_Service<TAO_TypeCodeFactory_Adapter>::instance (
00641 TAO_ORB_Core::typecodefactory_adapter_name ()
00642 );
00643
00644 if (adapter == 0)
00645 {
00646 ACE_THROW_RETURN (CORBA::INTERNAL (),
00647 0);
00648 }
00649
00650 return adapter->create_wstring_tc (bound
00651 ACE_ENV_ARG_PARAMETER);
00652 }
|
|
|
Explicitly destroy the ORB, releasing any resources. Note that TAO *cannot* implicitly release the resources even if you have destroyed all the references to a particular ORB since CORBA::ORB_init() is required to return the same pointer if called with the same ORBid, only after ORB::destroy() is called it may return a new one. The results of multi-threaded applications, trying to destroy () the ORB in one thread and trying to service a request in another thread are not well defined. TAO does not support such cases. Definition at line 174 of file ORB.cpp. References ACE_CHECK, ACE_DEBUG, ACE_ENV_SINGLE_ARG_PARAMETER, ACE_TEXT, ACE_TEXT_CHAR_TO_TCHAR, ACE_THROW, TAO_ORB_Core::destroy(), LM_DEBUG, orb_core(), and TAO_debug_level.
00175 {
00176 if (this->orb_core () == 0)
00177 {
00178 // If the ORB_Core pointer is zero, assume that the ORB_Core has
00179 // been destroyed.
00180
00181 // As defined by the CORBA 2.3 specification, throw a
00182 // CORBA::OBJECT_NOT_EXIST exception if the ORB has been
00183 // destroyed by the time an ORB function is called.
00184
00185 ACE_THROW (CORBA::OBJECT_NOT_EXIST (0,
00186 CORBA::COMPLETED_NO));
00187 }
00188
00189 if (TAO_debug_level > 2)
00190 {
00191 ACE_DEBUG ((LM_DEBUG,
00192 ACE_TEXT ("CORBA::ORB::destroy() called on ORB <%s>.\n"),
00193 ACE_TEXT_CHAR_TO_TCHAR (this->orb_core ()->orbid ())));
00194 }
00195
00196 this->orb_core ()->destroy (ACE_ENV_SINGLE_ARG_PARAMETER);
00197 ACE_CHECK;
00198
00199 // Now invalidate the pointer to the ORB_Core that created this
00200 // ORB.
00201 this->orb_core_ = 0;
00202 }
|
|
|
Definition at line 406 of file ORB.cpp. References ACE_THROW, CORBA::Context_ptr, and ENOTSUP.
00408 {
00409 ACE_THROW (CORBA::NO_IMPLEMENT (
00410 CORBA::SystemException::_tao_minor_code (
00411 0,
00412 ENOTSUP),
00413 CORBA::COMPLETED_NO));
00414 }
|
|
|
Definition at line 439 of file ORB.cpp. References ACE_THROW, ENOTSUP, and CORBA::Request_ptr.
00441 {
00442 ACE_THROW (CORBA::NO_IMPLEMENT (
00443 CORBA::SystemException::_tao_minor_code (
00444 0,
00445 ENOTSUP),
00446 CORBA::COMPLETED_NO));
00447 }
|
|
||||||||||||
|
Definition at line 381 of file ORB.cpp. References ACE_THROW_RETURN, ENOTSUP, CORBA::ServiceInformation_out, and CORBA::ServiceType.
00385 {
00386 ACE_THROW_RETURN (CORBA::NO_IMPLEMENT (
00387 CORBA::SystemException::_tao_minor_code (
00388 0,
00389 ENOTSUP),
00390 CORBA::COMPLETED_NO),
00391 0);
00392 }
|
|
|
Get the Timeout value.
Definition at line 1934 of file ORB.cpp.
01935 {
01936 return this->timeout_;
01937 }
|
|
|
Return this ORB's ORBid.
Definition at line 1759 of file ORB.cpp. References CORBA::string_dup().
01760 {
01761 return CORBA::string_dup (this->orb_core_->orbid ());
01762 }
|
|
|
Convert an OMG IOR into an object reference.
Definition at line 1822 of file ORB.cpp. References CORBA::Object::_nil(), ACE_THROW_RETURN, ACE::hex2byte(), ACE_CDR::mb_align(), CORBA::Object_ptr, ACE_Message_Block::rd_ptr(), TAO_DEF_GIOP_MAJOR, TAO_DEF_GIOP_MINOR, and ACE_Message_Block::wr_ptr(). Referenced by string_to_object().
01824 {
01825 // Unhex the bytes, and make a CDR deencapsulation stream from the
01826 // resulting data.
01827 ACE_Message_Block mb (ACE_OS::strlen (str) / 2 + 1
01828 + ACE_CDR::MAX_ALIGNMENT + 1);
01829
01830 ACE_CDR::mb_align (&mb);
01831
01832 char *buffer = mb.rd_ptr ();
01833 const char *tmp = str;
01834 size_t len = 0;
01835
01836 while (tmp [0] && tmp [1])
01837 {
01838 // Some platforms define 'byte' as a macro, solve the problem
01839 // here.
01840 #undef byte
01841 unsigned char byte;
01842
01843 if (!(isxdigit (tmp [0]) && isxdigit (tmp [1])))
01844 break;
01845
01846 byte = (u_char) (ACE::hex2byte (tmp [0]) << 4);
01847 byte |= ACE::hex2byte (tmp [1]);
01848
01849 buffer [len++] = byte;
01850 tmp += 2;
01851 }
01852
01853 if (tmp [0] && !isspace (tmp [0]))
01854 {
01855 ACE_THROW_RETURN (CORBA::BAD_PARAM (),
01856 CORBA::Object::_nil ());
01857 }
01858
01859 // Create deencapsulation stream ... then unmarshal objref from that
01860 // stream.
01861
01862 int byte_order = *(mb.rd_ptr ());
01863 mb.rd_ptr (1);
01864 mb.wr_ptr (len);
01865 TAO_InputCDR stream (&mb,
01866 byte_order,
01867 TAO_DEF_GIOP_MAJOR,
01868 TAO_DEF_GIOP_MINOR,
01869 this->orb_core_);
01870
01871 CORBA::Object_ptr objref = CORBA::Object::_nil ();
01872 stream >> objref;
01873 return objref;
01874 }
|
|
|
Returns a sequence of ObjectIds that lists which objects have references available via the initial references mechanism. Definition at line 1242 of file ORB.cpp. References ACE_CHECK_RETURN, ACE_ENV_SINGLE_ARG_PARAMETER, check_shutdown(), TAO_ORB_Core::list_initial_references(), and orb_core().
01243 {
01244 this->check_shutdown (ACE_ENV_SINGLE_ARG_PARAMETER);
01245 ACE_CHECK_RETURN (0);
01246
01247 return
01248 this->orb_core ()->list_initial_references (ACE_ENV_SINGLE_ARG_PARAMETER);
01249 }
|
|
|
Definition at line 1996 of file ORB.cpp. References orb_core(), TAO_ORB_Core::valuetype_adapter(), and TAO_Valuetype_Adapter::vf_map_find().
01998 {
01999 TAO_Valuetype_Adapter *vta = this->orb_core ()->valuetype_adapter ();
02000
02001 if (vta)
02002 {
02003 return vta->vf_map_find (repository_id);
02004 }
02005
02006 return 0;
02007 }
|
|
|
Turn an object reference into a string. Each type of ORB, e.g. an IIOP ORB, must implement this. This can be used by servers to publish their whereabouts to clients. The output of this is typically eventually given to Definition at line 1578 of file ORB.cpp. References TAO::String_var< charT >::_retn(), ACE_ALLOCATOR_RETURN, ACE_CHECK_RETURN, ACE_ENV_SINGLE_ARG_PARAMETER, ACE_ERROR, ACE_TEXT, ACE_THROW_RETURN, ACE_OutputCDR::begin(), TAO_ORB_Parameters::cdr_memcpy_tradeoff(), check_shutdown(), ACE_Message_Block::cont(), TAO_MProfile::get_profile(), ior_prefix, CORBA::is_nil(), ACE_Message_Block::length(), LM_ERROR, ACE_OS::memset(), ACE::nibble2hex(), CORBA::Object_ptr, TAO_ORB_Core::orb_params(), TAO_ORB_Core::output_cdr_dblock_allocator(), TAO_ORB_Core::output_cdr_msgblock_allocator(), TAO_MProfile::profile_count(), ACE_Message_Block::rd_ptr(), ACE_OS::strcpy(), CORBA::String_var, TAO_debug_level, TAO_DEF_GIOP_MAJOR, TAO_DEF_GIOP_MINOR, TAO_ENCAP_BYTE_ORDER, TAO_Profile::to_string(), ACE_OutputCDR::total_length(), use_omg_ior_format_, and ACE_OutputCDR::write_octet().
01580 {
01581 // This method should not be called if the ORB has been shutdown.
01582 this->check_shutdown (ACE_ENV_SINGLE_ARG_PARAMETER);
01583 ACE_CHECK_RETURN (0);
01584
01585 if (!CORBA::is_nil (obj) && obj->_is_local ())
01586 ACE_THROW_RETURN (CORBA::MARSHAL (CORBA::OMGVMCID | 4,
01587 CORBA::COMPLETED_NO),
01588 0);
01589
01590
01591 // Application writer controls what kind of objref strings they get,
01592 // maybe along with other things, by how they initialize the ORB.
01593
01594 if (use_omg_ior_format_)
01595 {
01596 // By default, orbs use IOR strings; these are ugly (and error
01597 // prone) but specified by CORBA.
01598 //
01599 // XXX there should be a simple way to reuse this code in other
01600 // ORB implementations ...
01601
01602 #if defined (ACE_INITIALIZE_MEMORY_BEFORE_USE)
01603 char buf [ACE_CDR::DEFAULT_BUFSIZE] = { 0 };
01604 #else
01605 // Avoid the initialization overhead if not compiling with
01606 // support for a memory profiler. There is no need to actually perform
01607 // initialization otherwise.
01608 char buf [ACE_CDR::DEFAULT_BUFSIZE];
01609 #endif /* ACE_INITIALIZE_MEMORY_BEFORE_USE */
01610
01611 TAO_OutputCDR cdr (buf, sizeof buf,
01612 TAO_ENCAP_BYTE_ORDER,
01613 this->orb_core_->output_cdr_buffer_allocator (),
01614 this->orb_core_->output_cdr_dblock_allocator (),
01615 this->orb_core_->output_cdr_msgblock_allocator (),
01616 this->orb_core_->orb_params ()->cdr_memcpy_tradeoff (),
01617 TAO_DEF_GIOP_MAJOR,
01618 TAO_DEF_GIOP_MINOR);
01619
01620 // There is no translator currently available for stringifying an object
01621 // reference, since there is no transport with which to choose an NCS/TCS
01622 // pair.
01623
01624 // support limited oref ACE_OS::strcmp.
01625 (void) ACE_OS::memset (buf, 0, sizeof (buf));
01626
01627 // Marshal the objref into an encapsulation bytestream.
01628 (void) cdr.write_octet (TAO_ENCAP_BYTE_ORDER);
01629 if ((cdr << obj) == 0)
01630 ACE_THROW_RETURN (CORBA::MARSHAL (), 0);
01631
01632 // Now hexify the encapsulated CDR data into a string, and
01633 // return that string.
01634
01635 const size_t total_len = cdr.total_length ();
01636
01637 char *cp = 0;
01638 ACE_ALLOCATOR_RETURN (cp,
01639 CORBA::string_alloc (
01640 sizeof ior_prefix
01641 + 2
01642 * static_cast<CORBA::ULong> (total_len)),
01643 0);
01644
01645 CORBA::String_var string = cp;
01646
01647 ACE_OS::strcpy (cp, ior_prefix);
01648 cp += sizeof (ior_prefix) - 1;
01649
01650 for (const ACE_Message_Block *i = cdr.begin ();
01651 i != 0;
01652 i = i->cont ())
01653 {
01654 const char *bytes = i->rd_ptr ();
01655 size_t len = i->length ();
01656
01657 while (len--)
01658 {
01659 *cp++ = ACE::nibble2hex ((*bytes) >> 4);
01660 *cp++ = ACE::nibble2hex (*bytes);
01661 ++bytes;
01662 }
01663 }
01664 // Null terminate the string..
01665 *cp = 0;
01666
01667 return string._retn ();
01668 }
01669 else
01670 {
01671 // It is perfectly valid to marshal a nil object reference.
01672 // However, it is not possible to convert a nil object reference
01673 // to a URL IOR, so throw an exception.
01674 if (CORBA::is_nil (obj) || obj->_stubobj () == 0)
01675 {
01676 if (TAO_debug_level > 0)
01677 ACE_ERROR ((LM_ERROR,
01678 ACE_TEXT ("Nil object reference or TAO_Stub ")
01679 ACE_TEXT ("pointer is zero when converting\n")
01680 ACE_TEXT ("object reference to URL IOR.\n")));
01681
01682 ACE_THROW_RETURN (CORBA::MARSHAL (
01683 CORBA::SystemException::_tao_minor_code (
01684 0,
01685 EINVAL),
01686 CORBA::COMPLETED_NO),
01687 0);
01688 }
01689
01690 TAO_MProfile &mp = obj->_stubobj ()->base_profiles ();
01691
01692 if (mp.profile_count () == 0)
01693 {
01694 if (TAO_debug_level > 0)
01695 ACE_ERROR ((LM_ERROR,
01696 ACE_TEXT ("(%P|%t) Cannot stringify given ")
01697 ACE_TEXT ("object. No profiles.\n")));
01698
01699
01700 ACE_THROW_RETURN (CORBA::MARSHAL (
01701 CORBA::SystemException::_tao_minor_code (
01702 0,
01703 EINVAL),
01704 CORBA::COMPLETED_NO),
01705 0);
01706 }
01707
01708 // For now we just use the first profile.
01709 TAO_Profile *profile = mp.get_profile (0);
01710
01711 return profile->to_string (ACE_ENV_SINGLE_ARG_PARAMETER);
01712 }
01713 }
|
|
|
|
|
|
Get the ORB core.
Definition at line 70 of file ORB.i. Referenced by _tao_ft_client_id(), check_shutdown(), destroy(), list_initial_services(), lookup_value_factory(), TAO_MCAST_Parser::multicast_query(), perform_work(), register_value_factory(), resolve_initial_references(), run(), shutdown(), and unregister_value_factory().
00071 {
00072 return this->orb_core_;
00073 }
|
|
|
Definition at line 239 of file ORB.cpp. References ACE_CHECK, ACE_ENV_ARG_PARAMETER, ACE_ENV_SINGLE_ARG_PARAMETER, check_shutdown(), orb_core(), and TAO_ORB_Core::run().
00241 {
00242 // This method should not be called if the ORB has been shutdown.
00243 this->check_shutdown (ACE_ENV_SINGLE_ARG_PARAMETER);
00244 ACE_CHECK;
00245
00246 this->orb_core ()->run (tv, 1 ACE_ENV_ARG_PARAMETER);
00247 }
|
|
|
Definition at line 233 of file ORB.cpp. References ACE_ENV_ARG_PARAMETER, and perform_work().
00234 {
00235 this->perform_work (&tv ACE_ENV_ARG_PARAMETER);
00236 }
|
|
|
This operation performs an implementation-defined unit of work. Note that the default behavior is to block if the unit of work is not present; this behavior can be modified by passing an appropriate Definition at line 227 of file ORB.cpp. References ACE_ENV_ARG_PARAMETER. Referenced by perform_work().
00228 {
00229 this->perform_work (0 ACE_ENV_ARG_PARAMETER);
00230 }
|
|
|
Definition at line 450 of file ORB.cpp. References ACE_THROW_RETURN, and ENOTSUP.
00451 {
00452 ACE_THROW_RETURN (CORBA::NO_IMPLEMENT (
00453 CORBA::SystemException::_tao_minor_code (
00454 0,
00455 ENOTSUP),
00456 CORBA::COMPLETED_NO),
00457 0);
00458 }
|
|
||||||||||||
|
Register an object reference with the ORB.
Definition at line 1221 of file ORB.cpp. References ACE_CHECK, ACE_THROW, CORBA::is_nil(), CORBA::Object_ptr, TAO_ORB_Core::object_ref_table(), TAO_Object_Ref_Table::register_initial_reference(), and ACE_OS::strlen().
01224 {
01225 if (id == 0 || ACE_OS::strlen (id) == 0)
01226 ACE_THROW (CORBA::ORB::InvalidName ());
01227 ACE_CHECK;
01228
01229 if (CORBA::is_nil (obj))
01230 ACE_THROW (CORBA::BAD_PARAM (CORBA::OMGVMCID | 27,
01231 CORBA::COMPLETED_NO));
01232 ACE_CHECK;
01233
01234 TAO_Object_Ref_Table &table = this->orb_core_->object_ref_table ();
01235
01236 if (table.register_initial_reference (id, obj) == -1)
01237 ACE_THROW (CORBA::ORB::InvalidName ());
01238 }
|
|
||||||||||||
|
Definition at line 1951 of file ORB.cpp. References ACE_THROW_RETURN, orb_core(), CORBA::ValueFactory, TAO_ORB_Core::valuetype_adapter(), and TAO_Valuetype_Adapter::vf_map_rebind().
01954 {
01955 TAO_Valuetype_Adapter *vta = this->orb_core ()->valuetype_adapter ();
01956
01957 if (vta)
01958 {
01959 int const result = vta->vf_map_rebind (repository_id,
01960 factory);
01961
01962 if (result == 0) // No previous factory found
01963 {
01964 return 0;
01965 }
01966
01967 if (result == -1)
01968 {
01969 // Error on bind.
01970 ACE_THROW_RETURN (CORBA::MARSHAL (),
01971 0);
01972 }
01973 }
01974
01975 return factory; // previous factory was found
01976 }
|
|
||||||||||||
|
This method acts as a mini-bootstrapping Naming Service, which is provided by the ORB for certain well-known object references. TAO supports the "NameService", "TradingService", "RootPOA", "ImplRepo", and "POACurrent" via this method. The
Definition at line 1061 of file ORB.cpp. References TAO_Pseudo_Var_T< T >::_retn(), ACE_CHECK_RETURN, ACE_CString, ACE_ENV_ARG_PARAMETER, ACE_ENV_SINGLE_ARG_PARAMETER, ACE_THROW_RETURN, check_shutdown(), ACE_OS::getenv(), TAO::String_var< charT >::in(), TAO_Pseudo_Var_T< T >::in(), TAO_ORB_Core::init_ref_map(), TAO::String_var< charT >::inout(), CORBA::is_nil(), TAO_ORB_Core::object_ref_table(), CORBA::Object_var, orb_core(), TAO_ORB_Core::resolve_codecfactory(), TAO_ORB_Core::resolve_dynanyfactory(), TAO_Object_Ref_Table::resolve_initial_reference(), TAO_ORB_Core::resolve_ior_manipulation(), TAO_ORB_Core::resolve_ior_table(), TAO_ORB_Core::resolve_picurrent(), TAO_ORB_Core::resolve_poa_current(), resolve_policy_current(), resolve_policy_manager(), TAO_ORB_Core::resolve_rir(), resolve_service(), TAO_ORB_Core::resolve_typecodefactory(), TAO_ORB_Core::root_poa(), set_timeout(), ACE_OS::strcat(), ACE_OS::strcmp(), ACE_OS::strcpy(), CORBA::string_alloc(), string_to_object(), CORBA::String_var, TAO_OBJID_CODECFACTORY, TAO_OBJID_DYNANYFACTORY, TAO_OBJID_IMPLREPOSERVICE, TAO_OBJID_INTERFACEREP, TAO_OBJID_IORMANIPULATION, TAO_OBJID_IORTABLE, TAO_OBJID_NAMESERVICE, TAO_OBJID_PICurrent, TAO_OBJID_POACURRENT, TAO_OBJID_POLICYCURRENT, TAO_OBJID_POLICYMANAGER, TAO_OBJID_ROOTPOA, TAO_OBJID_TRADINGSERVICE, and TAO_OBJID_TYPECODEFACTORY.
01064 {
01065 // This method should not be called if the ORB has been shutdown.
01066 this->check_shutdown (ACE_ENV_SINGLE_ARG_PARAMETER);
01067 ACE_CHECK_RETURN (CORBA::Object::_nil ());
01068
01069 CORBA::Object_var result;
01070
01071 if (ACE_OS::strcmp (name, TAO_OBJID_ROOTPOA) == 0)
01072 {
01073 result = this->orb_core ()->root_poa (ACE_ENV_SINGLE_ARG_PARAMETER);
01074 ACE_CHECK_RETURN (CORBA::Object::_nil ());
01075 }
01076 else if (ACE_OS::strcmp (name, TAO_OBJID_POACURRENT) == 0)
01077 {
01078 result = this->orb_core ()->resolve_poa_current
01079 (ACE_ENV_SINGLE_ARG_PARAMETER);
01080 ACE_CHECK_RETURN (CORBA::Object::_nil ());
01081 }
01082 else if (ACE_OS::strcmp (name, TAO_OBJID_POLICYMANAGER) == 0)
01083 {
01084 result = this->resolve_policy_manager ();
01085 }
01086 else if (ACE_OS::strcmp (name, TAO_OBJID_POLICYCURRENT) == 0)
01087 {
01088 result = this->resolve_policy_current ();
01089 }
01090 else if (ACE_OS::strcmp (name, TAO_OBJID_IORMANIPULATION) == 0)
01091 {
01092 result = this->orb_core ()->resolve_ior_manipulation
01093 (ACE_ENV_SINGLE_ARG_PARAMETER);
01094 ACE_CHECK_RETURN (CORBA::Object::_nil ());
01095 }
01096 else if (ACE_OS::strcmp (name, TAO_OBJID_IORTABLE) == 0)
01097 {
01098 result = this->orb_core ()->resolve_ior_table
01099 (ACE_ENV_SINGLE_ARG_PARAMETER);
01100 ACE_CHECK_RETURN (CORBA::Object::_nil ());
01101 }
01102 else if (ACE_OS::strcmp (name, TAO_OBJID_DYNANYFACTORY) == 0)
01103 {
01104 result = this->orb_core ()->resolve_dynanyfactory
01105 (ACE_ENV_SINGLE_ARG_PARAMETER);
01106 ACE_CHECK_RETURN (CORBA::Object::_nil ());
01107 }
01108 else if (ACE_OS::strcmp (name, TAO_OBJID_TYPECODEFACTORY) == 0)
01109 {
01110 result = this->orb_core ()->resolve_typecodefactory
01111 (ACE_ENV_SINGLE_ARG_PARAMETER);
01112 ACE_CHECK_RETURN (CORBA::Object::_nil ());
01113 }
01114 else if (ACE_OS::strcmp (name, TAO_OBJID_CODECFACTORY) == 0)
01115 {
01116 result = this->orb_core ()->resolve_codecfactory
01117 (ACE_ENV_SINGLE_ARG_PARAMETER);
01118 ACE_CHECK_RETURN (CORBA::Object::_nil ());
01119 }
01120 #if TAO_HAS_INTERCEPTORS == 1
01121 else if (ACE_OS::strcmp (name, TAO_OBJID_PICurrent) == 0)
01122 {
01123 result = this->orb_core ()->resolve_picurrent
01124 (ACE_ENV_SINGLE_ARG_PARAMETER);
01125 ACE_CHECK_RETURN (CORBA::Object::_nil ());
01126 }
01127 #endif
01128
01129 // -----------------------------------------------------------------
01130
01131 if (CORBA::is_nil (result.in ()))
01132 {
01133 // Search the object reference table. This search must occur before
01134 // the InitRef table search, since it may contain local objects.
01135 result =
01136 this->orb_core ()->object_ref_table ().resolve_initial_reference (
01137 name);
01138 }
01139
01140 if (!CORBA::is_nil (result.in ()))
01141 return result._retn ();
01142
01143 // -----------------------------------------------------------------
01144
01145 // Check ORBInitRef options.
01146
01147 // @@ There appears to be long standing (i.e. back when the map was
01148 // an ACE_Hash_Map_Manager) race condition here since the map
01149 // access is not synchronized.
01150
01151 // Is the service name in the IOR Table.
01152 TAO_ORB_Core::InitRefMap::iterator ior =
01153 this->orb_core_->init_ref_map ()->find (ACE_CString (name));
01154
01155 if (ior != this->orb_core_->init_ref_map ()->end ())
01156 return this->string_to_object ((*ior).second.c_str ()
01157 ACE_ENV_ARG_PARAMETER);
01158
01159 // Look for an environment variable called "<name>IOR".
01160 //
01161 CORBA::String_var ior_env_var_name =
01162 CORBA::string_alloc (static_cast<CORBA::ULong> (ACE_OS::strlen (name) + 3));
01163
01164 ACE_OS::strcpy (ior_env_var_name.inout (),
01165 name);
01166
01167 ACE_OS::strcat (ior_env_var_name.inout (),
01168 "IOR");
01169
01170 ACE_CString service_ior = ACE_OS::getenv (ior_env_var_name.in ());
01171
01172 if (ACE_OS::strcmp (service_ior.c_str (), "") != 0 )
01173 {
01174 result =
01175 this->string_to_object (service_ior.c_str()
01176 ACE_ENV_ARG_PARAMETER);
01177 ACE_CHECK_RETURN (CORBA::Object::_nil ());
01178
01179 return result._retn ();
01180 }
01181
01182 // May be trying the explicitly specified services and the well
01183 // known services should be tried first before falling on to default
01184 // services.
01185
01186 // Set the timeout value.
01187 this->set_timeout (timeout);
01188
01189 if (ACE_OS::strcmp (name, TAO_OBJID_NAMESERVICE) == 0)
01190 {
01191 this->resolve_service (TAO::MCAST_NAMESERVICE);
01192 }
01193 else if (ACE_OS::strcmp (name, TAO_OBJID_TRADINGSERVICE) == 0)
01194 {
01195 this->resolve_service (TAO::MCAST_TRADINGSERVICE);
01196 }
01197 else if (ACE_OS::strcmp (name, TAO_OBJID_IMPLREPOSERVICE) == 0)
01198 {
01199 this->resolve_service (TAO::MCAST_IMPLREPOSERVICE);
01200 }
01201 else if (ACE_OS::strcmp (name, TAO_OBJID_INTERFACEREP) == 0)
01202 {
01203 this->resolve_service (TAO::MCAST_INTERFACEREPOSERVICE);
01204 }
01205
01206 // Is not one of the well known services, try to find it in the
01207 // InitRef table....check the defaultinitref values also.
01208
01209 result = this->orb_core ()->resolve_rir (name ACE_ENV_ARG_PARAMETER);
01210 ACE_CHECK_RETURN (CORBA::Object::_nil ());
01211
01212 if (!CORBA::is_nil (result.in ()))
01213 return result._retn ();
01214 // -----------------------------------------------------------------
01215
01216 ACE_THROW_RETURN (CORBA::ORB::InvalidName (), CORBA::Object::_nil ());
01217 }
|
|
|
Definition at line 1052 of file ORB.cpp. References ACE_ENV_ARG_PARAMETER. Referenced by TAO_ORB_Core::implrepo_service().
01054 {
01055 return this->resolve_initial_references (name,
01056 0
01057 ACE_ENV_ARG_PARAMETER);
01058 }
|
|
|
Resolve the Policy Current for this thread.
Definition at line 969 of file ORB.cpp. References CORBA::Object::_duplicate(), CORBA::Object::_nil(), and TAO_ORB_Core::policy_current(). Referenced by resolve_initial_references().
00970 {
00971
00972 #if (TAO_HAS_CORBA_MESSAGING == 1)
00973
00974 TAO_Policy_Current &policy_current = this->orb_core_->policy_current ();
00975 return CORBA::Object::_duplicate (&policy_current);
00976
00977 #else
00978
00979 return CORBA::Object::_nil ();
00980
00981 #endif /* TAO_HAS_CORBA_MESSAGING == 1 */
00982 }
|
|
|
Resolve the Policy Manager for this ORB.
Definition at line 947 of file ORB.cpp. References CORBA::Object::_duplicate(), CORBA::Object::_nil(), and TAO_ORB_Core::policy_manager(). Referenced by resolve_initial_references().
00948 {
00949 #if (TAO_HAS_CORBA_MESSAGING == 1)
00950
00951 TAO_Policy_Manager *policy_manager =
00952 this->orb_core_->policy_manager ();
00953
00954 if (policy_manager == 0)
00955 {
00956 return CORBA::Object::_nil ();
00957 }
00958
00959 return CORBA::Object::_duplicate (policy_manager);
00960
00961 #else
00962
00963 return CORBA::Object::_nil ();
00964
00965 #endif /* TAO_HAS_CORBA_MESSAGING == 1 */
00966 }
|
|
|
Resolve the given service based on the service ID. "@c resolve_service" is a legacy name. This method now simply sets up a default initial reference that will be subsequently used in resolve_initial_references(). Definition at line 985 of file ORB.cpp. References ACE_OS::atoi(), TAO_ORB_Parameters::default_init_ref(), ACE_OS::getenv(), TAO::String_var< charT >::in(), TAO_ORB_Core::orb_params(), TAO_ORB_Parameters::service_port(), ACE_OS::snprintf(), CORBA::String_var, ACE_OS::strncmp(), TAO_DEFAULT_IMPLREPO_SERVER_REQUEST_PORT, TAO_DEFAULT_INTERFACEREPO_SERVER_REQUEST_PORT, TAO_DEFAULT_NAME_SERVER_REQUEST_PORT, and TAO_DEFAULT_TRADING_SERVER_REQUEST_PORT. Referenced by resolve_initial_references().
00986 {
00987 static char const * const env_service_port[] =
00988 {
00989 "NameServicePort",
00990 "TradingServicePort",
00991 "ImplRepoServicePort",
00992 "InterfaceRepoServicePort"
00993 };
00994
00995 static unsigned short const default_service_port[] =
00996 {
00997 TAO_DEFAULT_NAME_SERVER_REQUEST_PORT,
00998 TAO_DEFAULT_TRADING_SERVER_REQUEST_PORT,
00999 TAO_DEFAULT_IMPLREPO_SERVER_REQUEST_PORT,
01000 TAO_DEFAULT_INTERFACEREPO_SERVER_REQUEST_PORT
01001 };
01002
01003 // By now, the table filled in with -ORBInitRef arguments has been
01004 // checked. We only get here if the table didn't contain an initial
01005 // reference for the requested Service.
01006
01007 CORBA::String_var default_init_ref =
01008 this->orb_core_->orb_params ()->default_init_ref ();
01009
01010 static char const mcast_prefix[] = "mcast://:::";
01011
01012 if ((ACE_OS::strncmp (default_init_ref.in (),
01013 mcast_prefix,
01014 sizeof (mcast_prefix) - 1) == 0))
01015 {
01016 // First, determine if the port was supplied on the command line
01017 unsigned short port =
01018 this->orb_core_->orb_params ()->service_port (mcast_service_id);
01019
01020 if (port == 0)
01021 {
01022 // Look for the port among our environment variables.
01023 char const * const port_number =
01024 ACE_OS::getenv (env_service_port[mcast_service_id]);
01025
01026 if (port_number != 0)
01027 port = static_cast<unsigned short> (ACE_OS::atoi (port_number));
01028 else
01029 port = default_service_port[mcast_service_id];
01030 }
01031
01032 // Set the port value in ORB_Params: modify the default mcast
01033 // value.
01034 static char const mcast_fmt[] = "mcast://:%d::";
01035 static size_t const PORT_BUF_SIZE = 256;
01036
01037 char def_init_ref[PORT_BUF_SIZE] = { 0 }; // snprintf() doesn't
01038 // null terminate.
01039 // Make sure we do.
01040
01041 ACE_OS::snprintf (def_init_ref,
01042 PORT_BUF_SIZE - 1, // Account for null
01043 // terminator.
01044 mcast_fmt,
01045 port);
01046
01047 this->orb_core_->orb_params ()->default_init_ref (def_init_ref);
01048 }
01049 }
|
|
|
Instructs the ORB to initialize itself and run its event loop in the current thread, not returning until the ORB has shut down or the time value specified through tv has expired. If an error occurs during initialization or at runtime, a CORBA system exception will be thrown. tv is reduced by the amount of time spent in this call. If tv is 0, it means that the timeout is infinite. If tv is If this function is called with tv value, client threads making invocations will continue their operations. When the operation timesout and returns, any invocations showing up on the server will be buffered by TCP. Definition at line 217 of file ORB.cpp. References ACE_CHECK, ACE_ENV_ARG_PARAMETER, ACE_ENV_SINGLE_ARG_PARAMETER, check_shutdown(), orb_core(), and TAO_ORB_Core::run().
00219 {
00220 this->check_shutdown (ACE_ENV_SINGLE_ARG_PARAMETER);
00221 ACE_CHECK;
00222
00223 this->orb_core ()->run (tv, 0 ACE_ENV_ARG_PARAMETER);
00224 }
|
|
|
Instructs the ORB to initialize itself and run its event loop in the current thread, not returning until the ORB has shut down or the time value specified through tv has expired. If an error occurs during initialization or at runtime, a CORBA system exception will be thrown. tv is reduced by the amount of time spent in this call. If this function is called with a @ tv value, client threads making invocations will continue their operations. When the operation timesout and returns, any invocations showing up on the server will be buffered by TCP. Definition at line 211 of file ORB.cpp. References ACE_ENV_ARG_PARAMETER, and run().
00212 {
00213 this->run (&tv ACE_ENV_ARG_PARAMETER);
00214 }
|
|
|
Instructs the ORB to initialize itself and run its event loop in the current thread, not returning until the ORB has shut down. If an error occurs during initialization or at runtime, a CORBA system exception will be thrown. Definition at line 205 of file ORB.cpp. References ACE_ENV_ARG_PARAMETER. Referenced by run().
00206 {
00207 this->run (0 ACE_ENV_ARG_PARAMETER);
00208 }
|
|
|
Definition at line 428 of file ORB.cpp. References ACE_THROW, ENOTSUP, and CORBA::RequestSeq.
00430 {
00431 ACE_THROW (CORBA::NO_IMPLEMENT (
00432 CORBA::SystemException::_tao_minor_code (
00433 0,
00434 ENOTSUP),
00435 CORBA::COMPLETED_NO));
00436 }
|
|
|
Definition at line 417 of file ORB.cpp. References ACE_THROW, ENOTSUP, and CORBA::RequestSeq.
00419 {
00420 ACE_THROW (CORBA::NO_IMPLEMENT (
00421 CORBA::SystemException::_tao_minor_code (
00422 0,
00423 ENOTSUP),
00424 CORBA::COMPLETED_NO));
00425 }
|
|
|
Set the timeout value.
Definition at line 1940 of file ORB.cpp. Referenced by resolve_initial_references().
01941 {
01942 this->timeout_ = timeout;
01943 }
|
|
|
This operation instructs the ORB to shut down. Shutting down the ORB causes all Object Adapters to be shut down. If Definition at line 160 of file ORB.cpp. References ACE_CHECK, ACE_ENV_ARG_PARAMETER, ACE_ENV_SINGLE_ARG_PARAMETER, check_shutdown(), orb_core(), and TAO_ORB_Core::shutdown().
00162 {
00163 // We cannot lock the exceptions here. We need to propogate
00164 // BAD_INV_ORDER exceptions if needed to the caller. Locking
00165 // exceptions down would render us non-compliant with the spec.
00166 this->check_shutdown (ACE_ENV_SINGLE_ARG_PARAMETER);
00167 ACE_CHECK;
00168
00169 this->orb_core ()->shutdown (wait_for_completion
00170 ACE_ENV_ARG_PARAMETER);
00171 }
|
|
|
Turn a string-ified object reference back into an object pointer. Typically these strings are created using object_to_string(), but not necessarily locally. Definition at line 1719 of file ORB.cpp. References ACE_CHECK_RETURN, ACE_ENV_ARG_PARAMETER, ACE_ENV_SINGLE_ARG_PARAMETER, ACE_THROW_RETURN, check_shutdown(), ior_prefix, ior_string_to_object(), TAO_Parser_Registry::match_parser(), TAO_IOR_Parser::parse_string(), TAO_ORB_Core::parser_registry(), ACE_OS::strncmp(), and url_ior_string_to_object(). Referenced by resolve_initial_references(), and TAO_ORB_Core::resolve_rir().
01721 {
01722 // This method should not be called if the ORB has been shutdown.
01723 this->check_shutdown (ACE_ENV_SINGLE_ARG_PARAMETER);
01724 ACE_CHECK_RETURN (CORBA::Object::_nil ());
01725
01726 // Check for NULL pointer
01727 if (str == 0)
01728 ACE_THROW_RETURN (CORBA::INV_OBJREF (
01729 CORBA::SystemException::_tao_minor_code (
01730 0,
01731 EINVAL),
01732 CORBA::COMPLETED_NO),
01733 CORBA::Object::_nil ());
01734
01735 TAO_IOR_Parser *ior_parser =
01736 this->orb_core_->parser_registry ()->match_parser (str);
01737
01738 if (ior_parser != 0)
01739 {
01740 return ior_parser->parse_string (str,
01741 this
01742 ACE_ENV_ARG_PARAMETER);
01743 }
01744
01745
01746 if (ACE_OS::strncmp (str,
01747 ior_prefix,
01748 sizeof ior_prefix - 1) == 0)
01749 return this->ior_string_to_object (str + sizeof ior_prefix - 1
01750 ACE_ENV_ARG_PARAMETER);
01751 else
01752 return this->url_ior_string_to_object (str
01753 ACE_ENV_ARG_PARAMETER);
01754 }
|
|
|
Definition at line 1981 of file ORB.cpp. References orb_core(), TAO_ORB_Core::valuetype_adapter(), and TAO_Valuetype_Adapter::vf_map_unbind().
01983 {
01984 TAO_Valuetype_Adapter *vta = this->orb_core ()->valuetype_adapter ();
01985
01986 if (vta)
01987 {
01988 // Dont care whther it was successful or not!
01989 (void) vta->vf_map_unbind (repository_id);
01990 }
01991 }
|
|
|
Convert an URL style IOR into an object reference.
Definition at line 1881 of file ORB.cpp. References CORBA::Object::_nil(), ACE_CHECK_RETURN, ACE_ENV_ARG_PARAMETER, ACE_ENV_SINGLE_ARG_PARAMETER, ACE_THROW_RETURN, TAO_ORB_Core::connector_registry(), TAO_ORB_Core::create_object(), TAO_ORB_Core::create_stub(), TAO_Stub_Auto_Ptr::get(), CORBA::is_nil(), TAO_Connector_Registry::make_mprofile(), CORBA::Object_ptr, and TAO_Stub_Auto_Ptr::release(). Referenced by string_to_object().
01883 {
01884 TAO_MProfile mprofile;
01885 // It is safe to declare this on the stack since the contents of
01886 // mprofile get copied. No memory is allocated for profile storage
01887 // here. The Connector Registry will determine the exact number
01888 // of profiles and tell the MProfile object to allocate enough memory
01889 // to hold them all.
01890
01891 TAO_Connector_Registry *conn_reg =
01892 this->orb_core_->connector_registry (ACE_ENV_SINGLE_ARG_PARAMETER);
01893 ACE_CHECK_RETURN (0);
01894
01895 int const retv =
01896 conn_reg->make_mprofile (str,
01897 mprofile
01898 ACE_ENV_ARG_PARAMETER);
01899 ACE_CHECK_RETURN (CORBA::Object::_nil ()); // Return nil.
01900
01901 if (retv != 0)
01902 {
01903 ACE_THROW_RETURN (CORBA::INV_OBJREF (
01904 CORBA::SystemException::_tao_minor_code (
01905 0,
01906 EINVAL),
01907 CORBA::COMPLETED_NO),
01908 CORBA::Object::_nil ());
01909 }
01910
01911 // Now make the TAO_Stub.
01912 TAO_Stub *data = this->orb_core_->create_stub ((char *) 0,
01913 mprofile
01914 ACE_ENV_ARG_PARAMETER);
01915 ACE_CHECK_RETURN (CORBA::Object::_nil ());
01916
01917 TAO_Stub_Auto_Ptr safe_objdata (data);
01918
01919 // Figure out if the servant is collocated.
01920 CORBA::Object_ptr obj =
01921 this->orb_core_->create_object (safe_objdata.get ());
01922 if (CORBA::is_nil (obj))
01923 return CORBA::Object::_nil ();
01924
01925 // Transfer ownership to the CORBA::Object
01926 (void) safe_objdata.release ();
01927
01928 return obj;
01929 }
|
|
|
Definition at line 250 of file ORB.cpp. References ACE_CHECK_RETURN, ACE_ENV_SINGLE_ARG_PARAMETER, ACE_THROW_RETURN, check_shutdown(), ETIME, TAO_ORB_Core::reactor(), and ACE_Reactor::work_pending().
00251 {
00252 // This method should not be called if the ORB has been shutdown.
00253 this->check_shutdown (ACE_ENV_SINGLE_ARG_PARAMETER);
00254 ACE_CHECK_RETURN (0);
00255
00256 int const result = this->orb_core_->reactor ()->work_pending (tv);
00257 if (result == 0 || (result == -1 && errno == ETIME))
00258 return 0;
00259
00260 if (result == -1)
00261 ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
00262
00263 return 1;
00264 }
|
|
|
Returns an indication of whether the ORB needs to perform some work. Definition at line 267 of file ORB.cpp. References ACE_CHECK_RETURN, ACE_ENV_SINGLE_ARG_PARAMETER, ACE_THROW_RETURN, check_shutdown(), TAO_ORB_Core::reactor(), and ACE_Reactor::work_pending().
00268 {
00269 // This method should not be called if the ORB has been shutdown.
00270 this->check_shutdown (ACE_ENV_SINGLE_ARG_PARAMETER);
00271 ACE_CHECK_RETURN (0);
00272
00273 const int result = this->orb_core_->reactor ()->work_pending ();
00274 if (result == 0)
00275 return 0;
00276
00277 if (result == -1)
00278 ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
00279
00280 return 1;
00281 }
|
|
|
|
|
|
|
|
|
Lock required for mutual exclusion between multiple threads.
|
|
|
The ORB_Core that created us....
|
|
|
Maintains a reference count of number of instantiations of the ORB. |
|
|
Timeout value.
|
|
|
Decides whether to use the URL notation or to use IOR notation.
Definition at line 646 of file ORB.h. Referenced by _use_omg_ior_format(), object_to_string(), and ORB(). |
1.3.6