TAO_Internal.cpp File Reference

#include "tao/TAO_Internal.h"
#include "tao/TAO_Singleton.h"
#include "tao/default_server.h"
#include "tao/default_client.h"
#include "tao/default_resource.h"
#include "tao/IIOP_Factory.h"
#include "tao/MCAST_Parser.h"
#include "tao/CORBANAME_Parser.h"
#include "tao/CORBALOC_Parser.h"
#include "tao/FILE_Parser.h"
#include "tao/HTTP_Parser.h"
#include "tao/DLL_Parser.h"
#include "tao/ORB_Core.h"
#include "tao/Adapter_Factory.h"
#include "tao/Default_Stub_Factory.h"
#include "tao/Default_Endpoint_Selector_Factory.h"
#include "tao/Default_Thread_Lane_Resources_Manager.h"
#include "tao/Default_Collocation_Resolver.h"
#include "tao/Codeset_Manager_Factory_Base.h"
#include "tao/Codeset_Manager.h"
#include "tao/debug.h"
#include "ace/Dynamic_Service.h"
#include "ace/Arg_Shifter.h"
#include "ace/Argv_Type_Converter.h"
#include "ace/ARGV.h"
#include "ace/Env_Value_T.h"
#include "ace/ACE.h"
#include "ace/OS_NS_stdio.h"
#include "ace/Static_Object_Lock.h"

Include dependency graph for TAO_Internal.cpp:

Go to the source code of this file.

Namespaces
namespace	TAO_END_VERSIONED_NAMESPACE_DECL
Defines
#define	TAO_DEFAULT_RESOURCE_FACTORY_ARGS   0
#define	TAO_DEFAULT_SERVER_STRATEGY_FACTORY_ARGS   0
#define	TAO_DEFAULT_CLIENT_STRATEGY_FACTORY_ARGS   0
Functions
int	parse_global_args_i (int &argc, ACE_TCHAR **argv, ACE_ARGV &svc_config_argv, bool apply_values)
	Modifies the argc to reflect any arguments it has "consumed".
int	parse_svcconf_args_i (int &argc, ACE_TCHAR **argv, ACE_ARGV &svc_config_argv)
	Modifies the argc to reflect any arguments it has "consumed".
void	register_global_services_i (ACE_Service_Gestalt *pcfg)
	registers all process-wide (global) services, available to all ORBs
void	register_additional_services_i (ACE_Service_Gestalt *pcfg)
int	parse_private_args_i (int &argc, ACE_TCHAR **argv, ACE_ARGV &svc_config_argv, bool &skip_service_config_open)
	Modifies the argc to reflect any arguments it has "consumed".
int	open_private_services_i (ACE_Intrusive_Auto_Ptr< ACE_Service_Gestalt > pcfg, int &argc, ACE_TCHAR **argv, bool skip_service_config_open=false, bool ignore_default_svc_conf_file=false)
	Open services, belonging to the gestalt instance.
TAO_BEGIN_VERSIONED_NAMESPACE_DECL int	TAO::ORB::open_global_services (int argc, ACE_TCHAR **argv)
	Note that the argument vector will be corrupted upon return.
int	TAO::ORB::open_services (ACE_Intrusive_Auto_Ptr< ACE_Service_Gestalt > pcfg, int &argc, ACE_TCHAR **argv)
int	TAO::ORB::close_services (ACE_Intrusive_Auto_Ptr< ACE_Service_Gestalt > pcfg)
void	TAO::ORB::default_svc_conf_entries (char const *rf_args, char const *ssf_args, char const *csf_args)
int	TAO_END_VERSIONED_NAMESPACE_DECL::open_private_services_i (ACE_Intrusive_Auto_Ptr< ACE_Service_Gestalt > pcfg, int &argc, ACE_TCHAR **argv, bool skip_service_config_open, bool ignore_default_svc_conf_file)
	Open services, belonging to the gestalt instance.
void	TAO_END_VERSIONED_NAMESPACE_DECL::register_global_services_i (ACE_Service_Gestalt *pcfg)
	registers all process-wide (global) services, available to all ORBs
void	TAO_END_VERSIONED_NAMESPACE_DECL::register_additional_services_i (ACE_Service_Gestalt *pcfg)
int	TAO_END_VERSIONED_NAMESPACE_DECL::parse_svcconf_args_i (int &argc, ACE_TCHAR **argv, ACE_ARGV &svc_config_argv)
	Modifies the argc to reflect any arguments it has "consumed".
int	TAO_END_VERSIONED_NAMESPACE_DECL::parse_private_args_i (int &argc, ACE_TCHAR **argv, ACE_ARGV &svc_config_argv, bool &skip_service_config_open)
	Modifies the argc to reflect any arguments it has "consumed".
int	TAO_END_VERSIONED_NAMESPACE_DECL::parse_global_args_i (int &argc, ACE_TCHAR **argv, ACE_ARGV &svc_config_argv, bool apply_values)
	Modifies the argc to reflect any arguments it has "consumed".
Variables
long	service_open_count = 0
bool	is_ubergestalt_ready = false
char const *	resource_factory_args
char const *	server_strategy_factory_args
char const *	client_strategy_factory_args
bool	negotiate_codesets = true

---

Define Documentation

#define TAO_DEFAULT_CLIENT_STRATEGY_FACTORY_ARGS   0

Definition at line 47 of file TAO_Internal.cpp.

#define TAO_DEFAULT_RESOURCE_FACTORY_ARGS   0

Definition at line 39 of file TAO_Internal.cpp.

#define TAO_DEFAULT_SERVER_STRATEGY_FACTORY_ARGS   0

Definition at line 43 of file TAO_Internal.cpp.

---

Function Documentation

int @5::open_private_services_i	(	ACE_Intrusive_Auto_Ptr< ACE_Service_Gestalt >	pcfg,
		int &	argc,
		ACE_TCHAR **	argv,
		bool	skip_service_config_open = false,
		bool	ignore_default_svc_conf_file = false
	)			[static]

Open services, belonging to the gestalt instance.

Initialize ORB-local (private) ACE Service Configurator repository.

Returns:

0 if successful, -1 with errno set if failure.

Definition at line 480 of file TAO_Internal.cpp.

References ACE_DEFAULT_LOGGER_KEY, ACE_Argv_Type_Converter::get_argc(), and ACE_Argv_Type_Converter::get_TCHAR_argv().

Referenced by TAO::ORB::open_global_services(), and TAO::ORB::open_services().

  {

    if (skip_service_config_open)
      {
        return 0;
      }

#if defined (TAO_PLATFORM_SVC_CONF_FILE_NOTSUP)
    ignore_default_svc_conf_file = true;
#endif /* TAO_PLATFORM_SVC_CONF_FILE_NOTSUP */

    // Copy command line parameter to allow conversion
    ACE_Argv_Type_Converter command_line (argc, argv);

    return pcfg->open (command_line.get_argc (),
                       command_line.get_TCHAR_argv (),
                       ACE_DEFAULT_LOGGER_KEY,
                       0, // Don't ignore static services.
                       ignore_default_svc_conf_file);
  }

int @5::parse_global_args_i	(	int &	argc,
		ACE_TCHAR **	argv,
		ACE_ARGV &	svc_config_argv,
		bool	apply_values
	)			[static]

Modifies the argc to reflect any arguments it has "consumed".

Parses the supplied command-line arguments to extract any that apply to the process (globally)

When multiple ORBs are being configured, the global options are only processed for the first ORB loaded. However subsequent ORBs may be supplied with some of these options, so they need to be eliminated as though they were processed. For this reason, this function is called for every ORB, but only the first call sets apply_values to true

Definition at line 843 of file TAO_Internal.cpp.

References ACE_DEBUG, ACE_TEXT, ACE_ARGV_T< CHAR_TYPE >::add(), ACE_OS::atoi(), ACE_Arg_Shifter_T< CHAR_TYPE >::consume_arg(), ACE_Arg_Shifter_T< CHAR_TYPE >::cur_arg_strncasecmp(), ACE::debug(), ACE_OS::getenv(), ACE_Arg_Shifter_T< CHAR_TYPE >::ignore_arg(), ACE_Arg_Shifter_T< CHAR_TYPE >::is_anything_left(), LM_DEBUG, and TAO_debug_level.

Referenced by TAO::ORB::open_global_services(), and TAO::ORB::open_services().

  {
    // NOTE: When adding new global arguments, ensure they are only
    // applied when apply_values is true, but that they are always
    // consumed, if they need to be consumed.
#if defined (TAO_DEBUG) && !defined (ACE_HAS_WINCE)
    // Make it a little easier to debug programs using this code.
    if (apply_values)
      {
        TAO_debug_level = ACE_Env_Value<u_int> ("TAO_ORB_DEBUG", 0);

        char * const value = ACE_OS::getenv ("TAO_ORB_DEBUG");

        if (value != 0)
          {
            TAO_debug_level = ACE_OS::atoi (value);

            if (TAO_debug_level <= 0)
              {
                TAO_debug_level = 1;
              }

            ACE_DEBUG ((LM_DEBUG,
                        ACE_TEXT ("TAO_debug_level == %d\n"),
                        TAO_debug_level));
          }
      }
#endif  /* TAO_DEBUG && !ACE_HAS_WINCE */

    // Extract the Service Configurator ORB options from the argument
    // vector.
    ACE_Arg_Shifter arg_shifter (argc, argv);

    while (arg_shifter.is_anything_left ())
      {
        if (0 == arg_shifter.cur_arg_strncasecmp (ACE_TEXT ("-ORBDebug")))
          {
            if (apply_values)
              {
                // Later, replace all of these
                // warning this turns on a daemon.
                ACE::debug (1);
              }

            arg_shifter.consume_arg ();
          }
        else if (0 == arg_shifter.cur_arg_strncasecmp
                 (ACE_TEXT ("-ORBDaemon")))
          {
            // Be a daemon.
            if (apply_values)
              {
                svc_config_argv.add (ACE_TEXT("-b"));
              }

            arg_shifter.consume_arg ();
          }
        // Can't interpret this argument.
        // Move on to the next argument.
        else
          {
            // Any arguments that don't match are ignored so
            // that the caller can still use them.
            arg_shifter.ignore_arg ();
          }
      }
    return 0;
  } /* parse_global_args_i */

int @5::parse_private_args_i	(	int &	argc,
		ACE_TCHAR **	argv,
		ACE_ARGV &	svc_config_argv,
		bool &	skip_service_config_open
	)			[static]

Modifies the argc to reflect any arguments it has "consumed".

Parses the supplied command-line arguments to extract any instance-specific ones.

Definition at line 767 of file TAO_Internal.cpp.

References ACE_TEXT, ACE_ARGV_T< CHAR_TYPE >::add(), ACE_OS::atoi(), ACE_Arg_Shifter_T< CHAR_TYPE >::consume_arg(), ACE_Arg_Shifter_T< CHAR_TYPE >::cur_arg_strncasecmp(), ACE_Arg_Shifter_T< CHAR_TYPE >::get_current(), ACE_Arg_Shifter_T< CHAR_TYPE >::get_the_parameter(), ACE_Arg_Shifter_T< CHAR_TYPE >::ignore_arg(), ACE_Arg_Shifter_T< CHAR_TYPE >::is_anything_left(), negotiate_codesets, and TAO_debug_level.

Referenced by TAO::ORB::open_global_services(), and TAO::ORB::open_services().

  {
    // Extract the Service Configurator ORB options from the argument
    // vector.
    ACE_Arg_Shifter arg_shifter (argc, argv);

    while (arg_shifter.is_anything_left ())
      {
        const ACE_TCHAR *current_arg = 0;
        if (0 == arg_shifter.cur_arg_strncasecmp
            (ACE_TEXT ("-ORBSkipServiceConfigOpen")))
          {
            skip_service_config_open = true;

            arg_shifter.consume_arg ();
          }
        else if (0 != (current_arg = arg_shifter.get_the_parameter
                       (ACE_TEXT ("-ORBSvcConfDirective"))))
          {
            // This is used to pass arguments to the Service
            // Configurator using the "command line" to provide
            // configuration information rather than using a svc.conf
            // file.  Pass the "-S" to the service configurator.
            svc_config_argv.add (ACE_TEXT ("-S"));
            svc_config_argv.add (current_arg, true); // quote args!

            arg_shifter.consume_arg ();
          }
        else if (0 != (current_arg = arg_shifter.get_the_parameter
                       (ACE_TEXT ("-ORBServiceConfigLoggerKey"))))
          {
            svc_config_argv.add (ACE_TEXT ("-k"));
            svc_config_argv.add (current_arg, true); // quote args!

            arg_shifter.consume_arg ();
          }
        else if (0 == arg_shifter.cur_arg_strncasecmp
                       (ACE_TEXT ("-ORBNegotiateCodesets")))
          {
            // Negotiate codesets must be evaluated prior to calling
            // register_global_services_i.

            // Don't consume, the ORB_Core::init will use it again.
            arg_shifter.ignore_arg();

            if (0 != (current_arg = arg_shifter.get_current()))
              negotiate_codesets = (ACE_OS::atoi (current_arg));

            arg_shifter.ignore_arg();
          }
        else if (0 != (current_arg =
                       arg_shifter.get_the_parameter
                       (ACE_TEXT ("-ORBDebugLevel"))))
          {
            // Allowing different ORBs to change the global debug
            // level may be unexpected, but since this
            TAO_debug_level = ACE_OS::atoi (current_arg);

            arg_shifter.consume_arg ();
          }
        else
          {
            // Can't interpret this argument.  Move on to the next
            // argument.  Any arguments that don't match are ignored
            // so that the caller can still use them.
            arg_shifter.ignore_arg ();
          }
      }

    return 0;
  } /* parse_private_args_i */

int @5::parse_svcconf_args_i	(	int &	argc,
		ACE_TCHAR **	argv,
		ACE_ARGV &	svc_config_argv
	)			[static]

Modifies the argc to reflect any arguments it has "consumed".

Parses the supplied command-line arguments to extract any that specify a Service Configurator file (-ORBSvcConf). This is done separately, because depending on the context, the configuration file may apply to the process-wide service repository, or to the orb-specific (private) one.

Definition at line 714 of file TAO_Internal.cpp.

References ACE_ERROR_RETURN, ACE_TEXT, ACE_ARGV_T< CHAR_TYPE >::add(), ACE_Arg_Shifter_T< CHAR_TYPE >::consume_arg(), ACE_Arg_Shifter_T< CHAR_TYPE >::cur_arg_strncasecmp(), ACE_OS::fclose(), ACE_OS::fopen(), ACE_Arg_Shifter_T< CHAR_TYPE >::get_the_parameter(), ACE_Arg_Shifter_T< CHAR_TYPE >::ignore_arg(), ACE_Arg_Shifter_T< CHAR_TYPE >::is_anything_left(), and LM_ERROR.

Referenced by TAO::ORB::open_global_services(), and TAO::ORB::open_services().

  {
    // Extract the Service Configurator ORB options from the argument
    // vector.
    ACE_Arg_Shifter arg_shifter (argc, argv);

    while (arg_shifter.is_anything_left ())
      {
        // Can't interpret this argument.  Move on to the next argument.
        if (arg_shifter.cur_arg_strncasecmp (ACE_TEXT ("-ORBSvcConf")) == 0)
          {
            const ACE_TCHAR *current_arg =
                        arg_shifter.get_the_parameter (ACE_TEXT ("-ORBSvcConf"));
            arg_shifter.consume_arg ();

            // Proceeds only if the configuration file exists.
            FILE * const conf_file =
              ACE_OS::fopen (current_arg, ACE_TEXT ("r"));
            if (0 == conf_file)
              {
                // Assigning EINVAL to errno to make an exception
                // thrown.  calling code does not throw an exception if
                // the errno is set to ENOENT for some reason.
                errno = EINVAL;

                ACE_ERROR_RETURN ((LM_ERROR,
                                   ACE_TEXT ("TAO (%P|%t) Unable to open file %s")
                                   ACE_TEXT (", referenced by -ORBSvcConf option\n"),
                                   current_arg),
                                  -1);
              }
            else
              {
                ACE_OS::fclose (conf_file);
              }

            svc_config_argv.add (ACE_TEXT ("-f"));
            svc_config_argv.add (current_arg);
          }
        else
          {
            // Any arguments that don't match are ignored so that the
            // caller can still use them.
            arg_shifter.ignore_arg ();
          }
      }

    return 0;
  } /* parse_svcconf_args_i */

void @5::register_additional_services_i

(

ACE_Service_Gestalt *

pcfg

)

[static]

Definition at line 604 of file TAO_Internal.cpp.

References ACE_TEXT_CHAR_TO_TCHAR, client_strategy_factory_args, ACE_Shared_Object::init(), ACE_Dynamic_Service< TYPE >::instance(), ACE_Service_Gestalt::process_directive(), resource_factory_args, and server_strategy_factory_args.

Referenced by TAO::ORB::open_global_services().

  {
    // @@ What the heck do these things do and do we need to avoid
    //    calling them if we're not invoking the svc.conf file?
    // @@ They are needed for platforms that have no file system,
    //    like VxWorks.

    if (resource_factory_args != 0)
      {
        pcfg->process_directive(
          ACE_TEXT_CHAR_TO_TCHAR (resource_factory_args));
      }

    if (client_strategy_factory_args != 0)
      {
        pcfg->process_directive
          (ACE_TEXT_CHAR_TO_TCHAR (client_strategy_factory_args));
      }

    if (server_strategy_factory_args != 0)
      {
        pcfg->process_directive
          (ACE_TEXT_CHAR_TO_TCHAR (server_strategy_factory_args));
      }

    ACE_Service_Object * const pi_server_loader =
      ACE_Dynamic_Service<ACE_Service_Object>::instance (
        pcfg,
        "PI_Server_Loader");

    if (pi_server_loader != 0)
      {
        pi_server_loader->init (0, 0);
      }

    ACE_Service_Object * const bidir_loader =
      ACE_Dynamic_Service<ACE_Service_Object>::instance (
        pcfg,
        "BiDirGIOP_Loader");

    if (bidir_loader != 0)
      {
        bidir_loader->init (0, 0);
      }

    ACE_Service_Object * const messaging_loader =
      ACE_Dynamic_Service<ACE_Service_Object>::instance (
        pcfg,
        "Messaging_Loader");

    if (messaging_loader != 0)
      {
        messaging_loader->init (0, 0);
      }

    // Handle RTCORBA library special case.  Since RTCORBA needs
    // its init method call to register several hooks, call it
    // here if it hasn't already been called.
    ACE_Service_Object * const rt_loader =
      ACE_Dynamic_Service<ACE_Service_Object>::instance (
        pcfg,
        "RT_ORB_Loader");

    if (rt_loader != 0)
      {
        rt_loader->init (0, 0);
      }

    ACE_Service_Object * const rtscheduler_loader =
      ACE_Dynamic_Service<ACE_Service_Object>::instance (
        pcfg,
        "RTScheduler_Loader");

    if (rtscheduler_loader != 0)
      {
        rtscheduler_loader->init (0, 0);
      }

    ACE_Service_Object * const csd_framework_loader =
      ACE_Dynamic_Service<ACE_Service_Object>::instance (
        pcfg,
        "CSD_Framework_Loader");

    if (csd_framework_loader != 0)
      {
        csd_framework_loader->init (0, 0);
      }

    ACE_Service_Object * const endpoint_policy_loader =
      ACE_Dynamic_Service<ACE_Service_Object>::instance (
        pcfg,
        "EndpointPolicy_Initializer");

    if (endpoint_policy_loader != 0)
      {
        endpoint_policy_loader->init (0, 0);
      }

    ACE_Service_Object * const diffserv_policy_loader =
      ACE_Dynamic_Service<ACE_Service_Object>::instance (
        pcfg,
        "DiffservPolicy_Initializer");

    if (diffserv_policy_loader != 0)
      {
        diffserv_policy_loader->init (0, 0);
      }
  } /* register_additional_services_i */

void @5::register_global_services_i

(

ACE_Service_Gestalt *

pcfg

)

[static]

registers all process-wide (global) services, available to all ORBs

Initialize the ACE Service Configurator with the process-global services (available to any ORB).

Returns:

0 if successful, -1 with errno set if failure.

Note:

You can provide your program a set of default `svc.conf' entries by setting ignore_default_svc_conf_file to non-zero and use default_svc_conf_entries() before calling open_global_services(). In addition, you can skip_service_config_open altogether, which used to be important when the ORB is linked in via the ACE_Service_Config, since the ACE_Service_Config was non-reentrant. However, the ACE_Service_Config is now reentrant meaning that it is really no longer necessary to do so.

Definition at line 509 of file TAO_Internal.cpp.

References ACE_DYNAMIC_SERVICE_DIRECTIVE, ACE_ERROR, ACE_REMOVE_SERVICE_DIRECTIVE, ACE_TEXT, ACE_Dynamic_Service< TYPE >::instance(), TAO_Codeset_Manager_Factory_Base::is_default(), LM_ERROR, negotiate_codesets, ACE_Service_Config::process_directive(), ACE_Service_Gestalt::process_directive(), and TAO_debug_level.

Referenced by TAO::ORB::open_global_services().

  {
    // This has to be done before intializing the resource
    // factory. Codesets is a special library since its configuration
    // is optional and it may be linked statically.
    if (negotiate_codesets)
      {
        TAO_Codeset_Manager_Factory_Base *factory =
          ACE_Dynamic_Service<TAO_Codeset_Manager_Factory_Base>::instance (
            "TAO_Codeset");

        if (factory == 0 || factory->is_default ())
          {
#if !defined (TAO_AS_STATIC_LIBS) && !(defined (ACE_VXWORKS) && !defined (__RTP__))
            // only for dynamic libs, check to see if default factory
            // and if so, remove it
            ACE_Service_Config::process_directive (
              ACE_REMOVE_SERVICE_DIRECTIVE ("TAO_Codeset"));

            ACE_Service_Config::process_directive (
              ACE_DYNAMIC_SERVICE_DIRECTIVE (
                "TAO_Codeset",
                "TAO_Codeset",
                "_make_TAO_Codeset_Manager_Factory",
                ""));

            factory =
              ACE_Dynamic_Service<
                  TAO_Codeset_Manager_Factory_Base
                >::instance ("TAO_Codeset");
#endif
          }

        if (factory == 0)
          {
            if (TAO_debug_level > 0)
              {
                ACE_ERROR ((LM_ERROR,
                            ACE_TEXT ("(%P|%t) ORB_Core: ")
                            ACE_TEXT ("Unable to initialize ")
                            ACE_TEXT ("Codeset Manager\n")));
              }
          }
      }

    pcfg->process_directive (
      ace_svc_desc_TAO_Default_Resource_Factory);
    pcfg->process_directive (
      ace_svc_desc_TAO_Default_Client_Strategy_Factory);
    pcfg->process_directive (
      ace_svc_desc_TAO_Default_Server_Strategy_Factory);

    // Configure the IIOP factory. You do *NOT* need modify this
    // code to add your own protocol, instead simply add the
    // following to your svc.conf file:
    //
    // dynamic PN_Factory Service_Object * LIB:_make_PN_Protocol_Factory() ""
    // static Resource_Factory "-ORBProtocolFactory PN_Factory"
    //
    // where PN is the name of your protocol and LIB is the base
    // name of the shared library that implements the protocol.

#if defined (TAO_HAS_IIOP) && (TAO_HAS_IIOP != 0)
    pcfg->process_directive (ace_svc_desc_TAO_IIOP_Protocol_Factory);
#endif /* TAO_HAS_IIOP && TAO_HAS_IIOP != 0 */

    // add descriptor to list of static objects.
#if (TAO_HAS_MCAST_PARSER == 1)
    pcfg->process_directive (ace_svc_desc_TAO_MCAST_Parser);
#endif /* TAO_HAS_MCAST_PARSER == 1 */
#if (TAO_HAS_CORBANAME_PARSER == 1)
    pcfg->process_directive (ace_svc_desc_TAO_CORBANAME_Parser);
#endif /* TAO_HAS_CORBANAME_PARSER == 1 */
#if (TAO_HAS_CORBALOC_PARSER == 1)
    pcfg->process_directive (ace_svc_desc_TAO_CORBALOC_Parser);
#endif /* TAO_HAS_CORBALOC_PARSER == 1 */
#if (TAO_HAS_FILE_PARSER == 1)
    pcfg->process_directive (ace_svc_desc_TAO_FILE_Parser);
#endif /* TAO_HAS_FILE_PARSER == 1 */
#if (TAO_HAS_DDL_PARSER == 1)
    pcfg->process_directive (ace_svc_desc_TAO_DLL_Parser);
#endif /* TAO_HAS_DDL_PARSER == 1 */
#if (TAO_HAS_HTTP_PARSER == 1)
    pcfg->process_directive (ace_svc_desc_TAO_HTTP_Parser);
#endif /* TAO_HAS_HTTP_PARSER */
    pcfg->process_directive (ace_svc_desc_TAO_Default_Stub_Factory);
    pcfg->process_directive (
      ace_svc_desc_TAO_Default_Endpoint_Selector_Factory);
    pcfg->process_directive (
      ace_svc_desc_TAO_Default_Thread_Lane_Resources_Manager_Factory);
    pcfg->process_directive (ace_svc_desc_TAO_Default_Collocation_Resolver);

  } /* register_global_services_i */

---

Variable Documentation

char const* client_strategy_factory_args [static]

Initial value:

    TAO_DEFAULT_CLIENT_STRATEGY_FACTORY_ARGS

Definition at line 156 of file TAO_Internal.cpp.

Referenced by TAO::ORB::default_svc_conf_entries(), and TAO_END_VERSIONED_NAMESPACE_DECL::register_additional_services_i().

bool is_ubergestalt_ready = false [static]

Part of a condition variable, which helps to ensure non-default ORBs can not proceed with their initialization, until the globaly required services have been instantiated by the default ORB. Usually, the first ORB to be created is designated the default ORB (reference the CORBA spec)

Definition at line 150 of file TAO_Internal.cpp.

Referenced by TAO::ORB::open_global_services(), and TAO::ORB::open_services().

bool negotiate_codesets = true [static]

Definition at line 160 of file TAO_Internal.cpp.

Referenced by TAO_ORB_Core::init(), TAO_END_VERSIONED_NAMESPACE_DECL::parse_private_args_i(), and TAO_END_VERSIONED_NAMESPACE_DECL::register_global_services_i().

char const* resource_factory_args [static]

Initial value:

    TAO_DEFAULT_RESOURCE_FACTORY_ARGS

Definition at line 152 of file TAO_Internal.cpp.

Referenced by TAO::ORB::default_svc_conf_entries(), and TAO_END_VERSIONED_NAMESPACE_DECL::register_additional_services_i().

char const* server_strategy_factory_args [static]

Initial value:

    TAO_DEFAULT_SERVER_STRATEGY_FACTORY_ARGS

Definition at line 154 of file TAO_Internal.cpp.

Referenced by TAO::ORB::default_svc_conf_entries(), and TAO_END_VERSIONED_NAMESPACE_DECL::register_additional_services_i().

long service_open_count = 0 [static]

Number of times open_services() has been called. Incremented by open_global_services_i(), and decremented by close_services().

Note:

In/decrement operations are atomic.

Definition at line 141 of file TAO_Internal.cpp.

Referenced by TAO::ORB::close_services(), and TAO::ORB::open_services().

---