ACE/ace/Service_Config.inl

   1 // -*- C++ -*-
   2 #include "ace/OS_NS_string.h"
   3
   4 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
   5
   6 // This is the primary entry point into the ACE_Service_Config (the
   7 // constructor just handles simple initializations).
   8 ACE_INLINE int
   9 ACE_Service_Config::open (const ACE_TCHAR program_name[],
  10                           const ACE_TCHAR *logger_key,
  11                           bool ignore_static_svcs,
  12                           bool ignore_default_svc_conf,
  13                           bool ignore_debug_flag)
  14 {
  15   ACE_TRACE ("ACE_Service_Config::open");
  16   if (singleton()->open_i (program_name,
  17                            logger_key,
  18                            ignore_static_svcs,
  19                            ignore_default_svc_conf,
  20                            ignore_debug_flag) == -1)
  21     return -1;
  22
  23   return current()->open (program_name,
  24                           logger_key,
  25                           ignore_static_svcs,
  26                           ignore_default_svc_conf,
  27                           ignore_debug_flag);
  28 }
  29
  30
  31 ACE_INLINE int
  32 ACE_Service_Config::open (int argc,
  33                           ACE_TCHAR *argv[],
  34                           const ACE_TCHAR *logger_key,
  35                           bool ignore_static_svcs,
  36                           bool ignore_default_svc_conf,
  37                           bool ignore_debug_flag)
  38 {
  39   ACE_TRACE ("ACE_Service_Config::open");
  40
  41   if (singleton()->parse_args_i(argc, argv) == -1)
  42     return -1;
  43
  44   if (singleton()->open_i (argv[0],
  45                            logger_key,
  46                            ignore_static_svcs,
  47                            ignore_default_svc_conf,
  48                            ignore_debug_flag) == -1)
  49     return -1;
  50
  51   return current()->open (argc,
  52                           argv,
  53                           logger_key,
  54                           ignore_static_svcs,
  55                           ignore_default_svc_conf,
  56                           ignore_debug_flag);
  57 }
  58
  59 // Handle the command-line options intended for the
  60 // ACE_Service_Config.
  61 ACE_INLINE int
  62 ACE_Service_Config::parse_args (int argc, ACE_TCHAR *argv[])
  63 {
  64   return ACE_Service_Config::current ()->parse_args (argc, argv);
  65 }
  66
  67 /// Return the global configuration instance. Allways returns the same
  68 /// instance
  69 ACE_INLINE ACE_Service_Gestalt *
  70 ACE_Service_Config::global ()
  71 {
  72   return ACE_Service_Config::singleton()->instance_.get ();
  73 }
  74
  75 /// Return the configuration instance, considered "global" in the
  76 /// current thread. This may be the same as instance(), but on some
  77 /// occasions, it may be a different one. For example,
  78 /// ACE_Service_Config_Guard provides a way of temporarily replacing
  79 /// the "current" configuration instance in the context of a thread.
  80 ACE_INLINE ACE_Service_Gestalt *
  81 ACE_Service_Config::instance ()
  82 {
  83   return ACE_Service_Config::current ();
  84 }
  85
  86 // This method has changed to return the gestalt instead of the
  87 // container, underlying the service repository and defined
  88 // ACE_Service_Gestalt::insert (ACE_Static_Svc_Descriptor*). This way
  89 // the existing source code can keep using
  90 // ACE_Service_Config::static_svcs(), however now it is not necessary
  91 // to expose the repository storage *and* it is much easier to debug
  92 // service registration problems.
  93
  94 ACE_INLINE ACE_Service_Gestalt*
  95 ACE_Service_Config::static_svcs ()
  96 {
  97   return ACE_Service_Config::current ();
  98 }
  99
 100 /// Compare two service descriptors for equality.
 101 ACE_INLINE bool
 102 ACE_Static_Svc_Descriptor::operator== (ACE_Static_Svc_Descriptor &d) const
 103 {
 104   return ACE_OS::strcmp (name_, d.name_) == 0;
 105 }
 106
 107 /// Compare two service descriptors for inequality.
 108 ACE_INLINE bool
 109 ACE_Static_Svc_Descriptor::operator!= (ACE_Static_Svc_Descriptor &d) const
 110 {
 111   return !(*this == d);
 112 }
 113
 114 ACE_INLINE void
 115 ACE_Service_Config::signal_handler (ACE_Sig_Adapter *signal_handler)
 116 {
 117   signal_handler_ = signal_handler;
 118 }
 119
 120 /// Initialize and activate a statically linked service.
 121 ACE_INLINE int
 122 ACE_Service_Config::initialize (const ACE_TCHAR *svc_name,
 123                                 const ACE_TCHAR *parameters)
 124 {
 125   ACE_TRACE ("ACE_Service_Config::initialize");
 126   return ACE_Service_Config::current ()->initialize (svc_name,
 127                                                      parameters);
 128 }
 129
 130 /// Dynamically link the shared object file and retrieve a pointer to
 131 /// the designated shared object in this file.
 132 ACE_INLINE int
 133 ACE_Service_Config::initialize (const ACE_Service_Type *sr,
 134                                 const ACE_TCHAR *parameters)
 135 {
 136   ACE_TRACE ("ACE_Service_Config::initialize");
 137   return ACE_Service_Config::current ()->initialize (sr, parameters);
 138 }
 139
 140 /// Process a file containing a list of service configuration
 141 /// directives.
 142 ACE_INLINE int ACE_Service_Config::process_file (const ACE_TCHAR file[])
 143 {
 144   return ACE_Service_Config::current ()->process_file (file);
 145 }
 146
 147 ///
 148 ACE_INLINE int
 149 ACE_Service_Config::process_directive (const ACE_TCHAR directive[])
 150 {
 151   return ACE_Service_Config::current ()->process_directive (directive);
 152 }
 153
 154 /// Process service configuration requests as indicated in the queue of
 155 /// svc.conf files.
 156 ACE_INLINE int
 157 ACE_Service_Config::process_directives ()
 158 {
 159   return ACE_Service_Config::current ()->process_directives (false);
 160 }
 161
 162 ACE_INLINE int
 163 ACE_Service_Config::process_directive (const ACE_Static_Svc_Descriptor &ssd,
 164                                        bool force_replace)
 165 {
 166   return ACE_Service_Config::current ()->process_directive (ssd, force_replace);
 167 }
 168
 169
 170 #if defined (ACE_HAS_WINCE) && defined (ACE_USES_WCHAR)
 171 // We must provide these function to bridge Svc_Conf parser with ACE.
 172
 173 ACE_INLINE int
 174 ACE_Service_Config::initialize (const ACE_Service_Type *sp, ACE_ANTI_TCHAR parameters[])
 175 {
 176   return ACE_Service_Config::initialize (sp, ACE_TEXT_ANTI_TO_TCHAR (parameters));
 177 }
 178
 179 ACE_INLINE int
 180 ACE_Service_Config::initialize (const ACE_ANTI_TCHAR svc_name[], ACE_ANTI_TCHAR parameters[])
 181 {
 182   return ACE_Service_Config::initialize (ACE_TEXT_ANTI_TO_TCHAR (svc_name),
 183                                          ACE_TEXT_ANTI_TO_TCHAR (parameters));
 184 }
 185
 186 ACE_INLINE int
 187 ACE_Service_Config::resume (const ACE_ANTI_TCHAR svc_name[])
 188 {
 189   return ACE_Service_Config::resume (ACE_TEXT_ANTI_TO_TCHAR (svc_name));
 190 }
 191
 192 ACE_INLINE int
 193 ACE_Service_Config::suspend (const ACE_ANTI_TCHAR svc_name[])
 194 {
 195   return ACE_Service_Config::suspend (ACE_TEXT_ANTI_TO_TCHAR (svc_name));
 196 }
 197
 198 ACE_INLINE int
 199 ACE_Service_Config::remove (const ACE_ANTI_TCHAR svc_name[])
 200 {
 201   return ACE_Service_Config::remove (ACE_TEXT_ANTI_TO_TCHAR (svc_name));
 202 }
 203 #endif /* ACE_HAS_WINCE && !ACE_USES_WCHAR */
 204
 205 ACE_END_VERSIONED_NAMESPACE_DECL