TAO: CORBA Namespace Reference

01144 {
01145   // Use this string variable to hold the orbid
01146   ACE_CString orbid_string (orbid);
01147 
01148   // Copy command line parameter not to use original.
01149   ACE_Argv_Type_Converter command_line(argc, argv);
01150 
01151   {
01152     // Using ACE_Static_Object_Lock::instance() precludes ORB_init()
01153     // from being called within a static object CTOR.
01154     ACE_MT (ACE_GUARD_RETURN (TAO_SYNCH_RECURSIVE_MUTEX,
01155                               guard,
01156                               *ACE_Static_Object_Lock::instance (),
01157                               CORBA::ORB::_nil ()));
01158 
01159     // Make sure TAO's singleton manager is initialized.
01160     // We need to initialize before TAO_default_environment() is called
01161     // since that call instantiates a TAO_TSS_Singleton.
01162     if (TAO_Singleton_Manager::instance ()->init () == -1)
01163       {
01164         return CORBA::ORB::_nil ();
01165       }
01166 
01167     TAO::ORB::init_orb_globals ();
01168   }
01169 
01170   // Make sure the following is done after the global ORB
01171   // initialization since we need to have exceptions initialized.
01172 
01173   // It doesn't make sense for argc to be zero and argv to be
01174   // non-empty/zero, or for argc to be greater than zero and argv be
01175   // zero.
01176   size_t const argv0_len =
01177     (command_line.get_TCHAR_argv ()
01178      ? (*command_line.get_TCHAR_argv ()
01179         ? ACE_OS::strlen (*command_line.get_TCHAR_argv ())
01180         : 0)
01181      : 0);
01182 
01183   if ((command_line.get_argc () == 0 && argv0_len != 0)
01184       || (command_line.get_argc () != 0
01185           && (command_line.get_TCHAR_argv () == 0
01186               || command_line.get_TCHAR_argv ()[0] == 0)))
01187     {
01188       throw ::CORBA::BAD_PARAM (
01189         CORBA::SystemException::_tao_minor_code (
01190           0,
01191           EINVAL),
01192         CORBA::COMPLETED_NO);
01193     }
01194 
01195   TAO::parse_orb_opt (command_line, ACE_TEXT("-ORBid"), orbid_string);
01196 
01197   // Get ORB Core
01198   TAO_ORB_Core_Auto_Ptr oc (
01199     TAO::ORB_Table::instance ()->find (orbid_string.c_str ()));
01200 
01201     // The ORB was already initialized.  Just return that one.
01202   if (oc.get () != 0)
01203     {
01204       return CORBA::ORB::_duplicate (oc->orb ());
01205     }
01206 
01207 
01208   // Determine the service object registry this ORB will use. The choises
01209   // are: (a) the legacy (global); (b) its own, local, or (c) share somebody
01210   // else's configuration
01211 
01212   // By default use the process (application?) global configuration context
01213   ACE_Service_Gestalt* gestalt = ACE_Service_Config::current ();
01214 
01215   // Use this string variable to hold the config identity
01216   ACE_CString orbconfig_string;
01217   ACE_Auto_Ptr<ACE_Service_Gestalt> guard_gestalt(0);
01218 
01219   if (TAO::parse_orb_opt (command_line,
01220                          ACE_TEXT("-ORBGestalt"),
01221                          orbconfig_string))
01222     {
01223       const ACE_TCHAR *arg = ACE_TEXT_CHAR_TO_TCHAR(orbconfig_string.c_str ());
01224       const ACE_TCHAR *local = ACE_TEXT("LOCAL");
01225       const ACE_TCHAR *shared = ACE_TEXT("ORB:");
01226       // Need a local repo? Make one which typically should not be as
01227       // big as the default repository
01228       if  (ACE_OS::strcasecmp (arg,local) == 0)
01229         {
01230           ACE_NEW_THROW_EX (gestalt,
01231                             ACE_Service_Gestalt
01232                             (ACE_Service_Gestalt::MAX_SERVICES / 4, true),
01233                             CORBA::NO_MEMORY
01234                             (CORBA::SystemException::_tao_minor_code (0,
01235                                                                       ENOMEM),
01236                              CORBA::COMPLETED_NO));
01237           guard_gestalt.reset(gestalt);
01238         }
01239       else if (ACE_OS::strncmp (arg, shared, sizeof (shared) - 1) == 0)
01240         {
01241           // @TODO: At some point, we need to implement a lookup of an
01242           // existing configuration context based on the orbid
01243           // following the "ORB:" It may be the case that contexts may
01244           // be initialized separate from the ORB of the same ID, in
01245           // which case we would need some sort of table of contexts
01246           // at which point we would either find this one or make a
01247           // new one. And making a new one would require assigning it
01248           // to the guard_gestalt just like the local.
01249           if (TAO_debug_level > 0)
01250             {
01251               ACE_ERROR ((LM_ERROR,
01252                           ACE_TEXT ("ERROR: Sharing ORB configuration ")
01253                           ACE_TEXT ("contexts is not yet supported\n")));
01254             }
01255 
01256           throw ::CORBA::BAD_PARAM
01257             (CORBA::SystemException::_tao_minor_code
01258              ( TAO_ORB_CORE_INIT_LOCATION_CODE,
01259                ENOTSUP),
01260              CORBA::COMPLETED_NO);
01261         }
01262       else
01263         {
01264           if (TAO_debug_level > 0)
01265             {
01266               ACE_ERROR ((LM_ERROR,
01267                           ACE_TEXT ("ERROR: -ORBGestalt unknown value <%s>\n"),
01268                           orbconfig_string.c_str()));
01269             }
01270 
01271           throw ::CORBA::BAD_PARAM
01272             (CORBA::SystemException::_tao_minor_code
01273              ( TAO_ORB_CORE_INIT_LOCATION_CODE,
01274                EINVAL),
01275              CORBA::COMPLETED_NO);
01276         }
01277     }
01278 
01279   // An ORB corresponding to the desired ORBid doesn't exist so create
01280   // a new one.
01281   TAO_ORB_Core * tmp = 0;
01282   ACE_NEW_THROW_EX (tmp,
01283                     TAO_ORB_Core (orbid_string.c_str (), gestalt),
01284                     CORBA::NO_MEMORY (
01285                       CORBA::SystemException::_tao_minor_code (0,
01286                                                                ENOMEM),
01287                       CORBA::COMPLETED_NO));
01288 
01289   // The ORB table increases the reference count on the ORB Core
01290   // so do not release it here.  Allow the TAO_ORB_Core_Auto_Ptr
01291   // to decrease the reference count on the ORB Core when it goes
01292   // out of scope.
01293   oc.reset (tmp);
01294 
01295   // The ORB now owns its configuration and the auto pointer is not
01296   // necessary anymore.
01297   guard_gestalt.release ();
01298 
01299   // Having the ORB's default static services be shared among all ORBs
01300   // is tempting from the point of view of reducing the dynamic
01301   // footprint. However, if the ORB in a DLL and the rest of that
01302   // application most likely neither cares, nor wishes to know about
01303   // them. Furthermore, if the ORB DLL gets unloaded, the static
01304   // services it had registered globaly will no longer be accesible,
01305   // which will have disastrous consequences at the process
01306   // shutdown. Hence, the ACE_Service_Config_Guard ensures that for
01307   // the current thread, any references to the global
01308   // ACE_Service_Config will be re-routed to this ORB's service gestalt.
01309 
01310   ACE_Service_Config_Guard scg (oc->configuration ());
01311 
01312   // Initialize the Service Configurator.  This must occur before the
01313   // ORBInitializer::pre_init() method is invoked on each registered
01314   // ORB initializer.
01315   int result = TAO::ORB::open_services (oc->configuration (),
01316                                         command_line.get_argc (),
01317                                         command_line.get_TCHAR_argv ());
01318 
01319   // Check for errors returned from <TAO_Internal::open_services>.
01320   if (result != 0 && errno != ENOENT)
01321     {
01322       ACE_ERROR ((LM_ERROR,
01323                   ACE_TEXT ("(%P|%t) %p\n"),
01324                   ACE_TEXT ("Unable to initialize the ")
01325                   ACE_TEXT ("Service Configurator")));
01326       throw ::CORBA::INITIALIZE (
01327         CORBA::SystemException::_tao_minor_code (
01328           TAO_ORB_CORE_INIT_LOCATION_CODE,
01329           0),
01330         CORBA::COMPLETED_NO);
01331     }
01332 
01333   TAO::ORBInitializer_Registry_Adapter * orbinitializer_registry =
01334     oc.get ()->orbinitializer_registry ();
01335 
01336   PortableInterceptor::SlotId slotid = 0;
01337   size_t pre_init_count = 0;
01338 
01339   if (orbinitializer_registry != 0)
01340     {
01341       pre_init_count =
01342         orbinitializer_registry->pre_init (oc.get (),
01343                                            command_line.get_argc(),
01344                                            command_line.get_ASCII_argv(),
01345                                            slotid);
01346     }
01347 
01348   // Initialize the ORB Core instance.
01349   result = oc->init (command_line.get_argc(),
01350                      command_line.get_ASCII_argv());
01351 
01352   if (orbinitializer_registry != 0)
01353     {
01354       orbinitializer_registry->post_init (pre_init_count,
01355                                           oc.get (),
01356                                           command_line.get_argc(),
01357                                           command_line.get_ASCII_argv(),
01358                                           slotid);
01359     }
01360 
01361   if (TAO_debug_level > 2)
01362     {
01363       ACE_DEBUG ((LM_DEBUG,
01364                   ACE_TEXT("TAO (%P|%t) created new ORB <%s>\n"),
01365                   ACE_TEXT_CHAR_TO_TCHAR (orbid_string.c_str ())));
01366     }
01367 
01368   // Before returning remember to store the ORB into the table...
01369   if (TAO::ORB_Table::instance ()->bind (orbid_string.c_str (),
01370                                          oc.get ()) != 0)
01371     throw ::CORBA::INTERNAL (0, CORBA::COMPLETED_NO);
01372 
01373   // Return a duplicate since the ORB_Core should release the last
01374   // reference to the ORB.
01375   return CORBA::ORB::_duplicate (oc->orb ());
01376 }


Classes
interface	Current
class	Environment
	Environment. More...
class	Exception
	Exception. More...
interface	ORB
	ORB pseudo-object. More...
exception	ORB::InvalidName
	UserException for resolve_initial_references(). More...
class	LocalObject
class	Object
	Implementation of a CORBA object reference. More...
struct	NamedValue
exception	PolicyError
exception	InvalidPolicies
interface	Policy
interface	PolicyCurrent
interface	PolicyManager
class	Principal
	A "Principal" identifies an authenticated entity in the network administration framework. More...
struct	ServiceDetail
struct	ServiceInformation
class	SystemException
	SystemException. More...
class	UserException
	Application- or OMG- defined CORBA exception sub-class. More...
exception	WrongTransaction
	UserException for DII requests. More...
CORBA Primitive Types
Declarations of all CORBA primitive types.
typedef ACE_CDR::Boolean	Boolean
typedef Boolean &	Boolean_out
typedef ACE_CDR::Octet	Octet
typedef Octet &	Octet_out
typedef ACE_CDR::Short	Short
typedef Short &	Short_out
typedef ACE_CDR::UShort	UShort
typedef UShort &	UShort_out
typedef ACE_CDR::Long	Long
typedef Long &	Long_out
typedef ACE_CDR::ULong	ULong
typedef ULong &	ULong_out
typedef ACE_CDR::LongLong	LongLong
typedef LongLong &	LongLong_out
typedef ACE_CDR::ULongLong	ULongLong
typedef ULongLong &	ULongLong_out
typedef ACE_CDR::Float	Float
typedef Float &	Float_out
typedef ACE_CDR::Double	Double
typedef Double &	Double_out
typedef ACE_CDR::LongDouble	LongDouble
typedef LongDouble &	LongDouble_out
typedef ACE_CDR::Char	Char
typedef Char &	Char_out
typedef ACE_CDR::WChar	WChar
typedef WChar &	WChar_out
CORBA String Memory Management
CORBA string memory management functions.
TAO_Export char *	string_alloc (ULong len)
TAO_Export char *	string_dup (const char *)
TAO_Export void	string_free (char *)
CORBA Wide String Memory Management
CORBA wide string memory management functions.
TAO_Export WChar *	wstring_alloc (ULong len)
TAO_Export WChar *	wstring_dup (const WChar *const )
TAO_Export void	wstring_free (WChar *const )
Typedefs
typedef InterfaceDef *	InterfaceDef_ptr
typedef Object *	Object_ptr
typedef TAO_Pseudo_Var_T< Object >	Object_var
typedef TAO_Pseudo_Out_T< Object >	Object_out
typedef TypeCode *	TypeCode_ptr
typedef Policy *	Policy_ptr
typedef TAO::String_var< CORBA::Char >	String_var
typedef TAO::String_out< CORBA::Char >	String_out
typedef TAO::String_var< CORBA::WChar >	WString_var
typedef TAO::String_out< CORBA::WChar >	WString_out
typedef sequence< boolean >	BooleanSeq
typedef sequence< char >	CharSeq
typedef ORB *	ORB_ptr
typedef Environment *	Environment_ptr
typedef Principal *	Principal_ptr
typedef OperationDef *	OperationDef_ptr
typedef sequence< double >	DoubleSeq
typedef NVList *	NVList_ptr
typedef NamedValue *	NamedValue_ptr
typedef ExceptionList *	ExceptionList_ptr
typedef Request *	Request_ptr
typedef Context *	Context_ptr
typedef ServerRequest *	ServerRequest_ptr
typedef ULong	Flags
typedef TAO_Pseudo_Var_T< Environment >	Environment_var
typedef TAO_Pseudo_Out_T< Environment >	Environment_out
typedef Any *	Any_ptr
typedef sequence< float >	FloatSeq
typedef LocalObject *	LocalObject_ptr
typedef TAO_Pseudo_Var_T< LocalObject >	LocalObject_var
typedef TAO_Pseudo_Out_T< LocalObject >	LocalObject_out
typedef sequence< long double >	LongDoubleSeq
typedef sequence< long long >	LongLongSeq
typedef sequence< long >	LongSeq
typedef ImplementationDef *	ImplementationDef_ptr
typedef ContextList *	ContextList_ptr
typedef string	ORB_ObjectId
typedef sequence< ORB_ObjectId >	ORB_ObjectIdList
typedef sequence< octet >	OctetSeq
typedef CORBA::ULong	PolicyType
typedef TAO_VarSeq_Var_T< ORB_ObjectIdList >	ORB_ObjectIdList_var
typedef TAO_Seq_Out_T< ORB_ObjectIdList >	ORB_ObjectIdList_out
typedef ValueFactoryBase *	ValueFactory
typedef UShort	ServiceType
typedef TAO_Pseudo_Var_T< Request >	Request_var
typedef TAO_Pseudo_Out_T< Request >	Request_out
typedef TAO_Pseudo_Var_T< ORB >	ORB_var
typedef TAO_Pseudo_Out_T< ORB >	ORB_out
typedef CORBA::Short	ValueModifier
typedef TAO::unbounded_object_reference_sequence< CORBA::Request, CORBA::Request_var >	RequestSeq
typedef TAO_VarSeq_Var_T< RequestSeq >	RequestSeq_var
typedef TAO_Seq_Out_T< RequestSeq >	RequestSeq_out
typedef string	ORBid
typedef string	Identifier
typedef string	RepositoryId
typedef short	PolicyErrorCode
typedef sequence< Policy >	PolicyList
typedef sequence< PolicyType >	PolicyTypeSeq
typedef TAO_Objref_Var_T< Policy >	Policy_var
typedef TAO_Objref_Out_T< Policy >	Policy_out
typedef CORBA::Short_out	PolicyErrorCode_out
typedef TAO_Pseudo_Var_T< Principal >	Principal_var
typedef TAO_Pseudo_Out_T< Principal >	Principal_out
typedef unsigned long	ServiceOption
typedef unsigned long	ServiceDetailType
typedef OctetSeq	ServiceDetailData
typedef sequence< ServiceOption >	ServiceOptionSeq
typedef sequence< ServiceDetail >	ServiceDetailSeq
typedef sequence< short >	ShortSeq
typedef sequence< string >	StringSeq
typedef TCKind &	TCKind_out
typedef TAO_Pseudo_Var_T< TypeCode >	TypeCode_var
typedef TAO_Pseudo_Out_T< TypeCode >	TypeCode_out
typedef sequence< unsigned long long >	ULongLongSeq
typedef sequence< unsigned long >	ULongSeq
typedef sequence< unsigned short >	UShortSeq
typedef AbstractBase *	AbstractBase_ptr
typedef sequence< wchar >	WCharSeq
typedef sequence< wstring >	WStringSeq
Enumerations
enum	exception_type { NO_EXCEPTION, USER_EXCEPTION, SYSTEM_EXCEPTION }
	Enumeration used to identify the type of CORBA exception. More...
enum	exception_type { NO_EXCEPTION, USER_EXCEPTION, SYSTEM_EXCEPTION }
enum	ParameterMode { PARAM_IN, PARAM_OUT, PARAM_INOUT }
enum	SetOverrideType { SET_OVERRIDE, ADD_OVERRIDE }
enum	CompletionStatus { COMPLETED_YES, COMPLETED_NO, COMPLETED_MAYBE }
	Completion status for CORBA system exceptions. More...
enum	TCKind { tk_null, tk_void, tk_short, tk_long, tk_ushort, tk_ulong, tk_float, tk_double, tk_boolean, tk_char, tk_octet, tk_any, tk_TypeCode, tk_Principal, tk_objref, tk_struct, tk_union, tk_enum, tk_string, tk_sequence, tk_array, tk_alias, tk_except, tk_longlong, tk_ulonglong, tk_longdouble, tk_wchar, tk_wstring, tk_fixed, tk_value, tk_value_box, tk_native, tk_abstract_interface, tk_local_interface, tk_component, tk_home, tk_event }
enum	TCKind { tk_null, tk_void, tk_short, tk_long, tk_ushort, tk_ulong, tk_float, tk_double, tk_boolean, tk_char, tk_octet, tk_any, tk_TypeCode, tk_Principal, tk_objref, tk_struct, tk_union, tk_enum, tk_string, tk_sequence, tk_array, tk_alias, tk_except, tk_longlong, tk_ulonglong, tk_longdouble, tk_wchar, tk_wstring, tk_fixed, tk_value, tk_value_box, tk_native, tk_abstract_interface, tk_local_interface, tk_component, tk_home, tk_event, TAO_TC_KIND_COUNT }
Functions
TAO_Export ORB_ptr	ORB_init (int &argc, char argv[], const char orb_name=0)
TAO_NAMESPACE_INLINE_FUNCTION Boolean	is_nil (Environment_ptr)
TAO_NAMESPACE_INLINE_FUNCTION void	release (Environment_ptr)
TAO_NAMESPACE_INLINE_FUNCTION Boolean	is_nil (ORB_ptr)
TAO_NAMESPACE_INLINE_FUNCTION void	release (ORB_ptr)
TAO_NAMESPACE_INLINE_FUNCTION Boolean	is_nil (Object_ptr)
TAO_NAMESPACE_INLINE_FUNCTION void	release (Object_ptr)
TAO_NAMESPACE_INLINE_FUNCTION Boolean	is_nil (Principal_ptr)
TAO_NAMESPACE_INLINE_FUNCTION void	release (Principal_ptr)
ACE_OSTREAM_TYPE &	operator<< (ACE_OSTREAM_TYPE &os, const CORBA::Exception &e)
ACE_OSTREAM_TYPE &	operator<< (ACE_OSTREAM_TYPE &os, const CORBA::Exception *e)
Variables
const ULong	OMGVMCID = 0x4f4d0000U
	The OMG Vendor Minor Codeset ID (VMCID).
const PolicyErrorCode	BAD_POLICY = 0
const PolicyErrorCode	UNSUPPORTED_POLICY = 1
const PolicyErrorCode	BAD_POLICY_TYPE = 2
const PolicyErrorCode	BAD_POLICY_VALUE = 3
const PolicyErrorCode	UNSUPPORTED_POLICY_VALUE = 4
local interface	PolicyCurrent
const ServiceType	Security = 1

CORBA Namespace Reference

Classes

CORBA Primitive Types

CORBA String Memory Management

CORBA Wide String Memory Management

Typedefs

Enumerations

Functions

Variables

Detailed Description

Typedef Documentation

Enumeration Type Documentation

Function Documentation

Variable Documentation