ACE/ace/Parse_Node.h

   1 // -*- C++ -*-
   2
   3 //=============================================================================
   4 /**
   5  *  @file    Parse_Node.h
   6  *
   7  *  @author Doug Schmidt
   8  */
   9 //=============================================================================
  10
  11 #ifndef ACE_PARSE_NODE_H
  12 #define ACE_PARSE_NODE_H
  13
  14 #include /**/ "ace/pre.h"
  15
  16 #include /**/ "ace/config-all.h"
  17
  18 #if !defined (ACE_LACKS_PRAGMA_ONCE)
  19 # pragma once
  20 #endif /* ACE_LACKS_PRAGMA_ONCE */
  21
  22 #if (ACE_USES_CLASSIC_SVC_CONF == 1)
  23
  24 #include "ace/DLL.h"
  25 #include "ace/SString.h"
  26 #include "ace/Svc_Conf.h"
  27 #include <memory>
  28
  29 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  30
  31 /// Forward declarations.
  32 class ACE_Service_Config;
  33 class ACE_Service_Type;
  34
  35 /**
  36  * @class ACE_Parse_Node
  37  *
  38  * @brief Provide the base of the object hierarchy that defines the parse
  39  * tree of Service Nodes.
  40  *
  41  * @note This class is only meant for INTERNAL use by ACE.
  42  *
  43  * @internal
  44  */
  45 class ACE_Parse_Node
  46 {
  47 public:
  48   ACE_Parse_Node ();
  49   explicit ACE_Parse_Node (const ACE_TCHAR *name);
  50   virtual ~ACE_Parse_Node ();
  51
  52   ACE_Parse_Node *link () const;
  53   void link (ACE_Parse_Node *);
  54
  55   /// Will update the yyereno member and/or the corresponding configuration
  56   virtual void apply (ACE_Service_Gestalt *cfg, int &yyerrno) = 0;
  57
  58   const ACE_TCHAR *name () const;
  59   void print () const;
  60
  61   /// Dump the state of an object.
  62   void dump () const;
  63
  64   /// Declare the dynamic allocation hooks.
  65   ACE_ALLOC_HOOK_DECLARE;
  66
  67 private:
  68   const ACE_TCHAR *name_;
  69   ACE_Parse_Node *next_;
  70
  71 private:
  72   ACE_Parse_Node (const ACE_Parse_Node&) = delete;
  73   ACE_Parse_Node& operator= (const ACE_Parse_Node&) = delete;
  74 };
  75
  76 /**
  77  * @class ACE_Suspend_Node
  78  *
  79  * @brief Suspend a Service Node.
  80  *
  81  * @note This class is only meant for INTERNAL use by ACE.
  82  *
  83  * @internal
  84  */
  85 class ACE_Suspend_Node : public ACE_Parse_Node
  86 {
  87 public:
  88   ACE_Suspend_Node (const ACE_TCHAR *name);
  89   ~ACE_Suspend_Node ();
  90
  91   virtual void apply (ACE_Service_Gestalt *cfg, int &yyerrno);
  92
  93   /// Dump the state of an object.
  94   void dump () const;
  95
  96   /// Declare the dynamic allocation hooks.
  97   ACE_ALLOC_HOOK_DECLARE;
  98
  99 private:
 100   ACE_Suspend_Node (const ACE_Suspend_Node&) = delete;
 101   ACE_Suspend_Node& operator= (const ACE_Suspend_Node&) = delete;
 102 };
 103
 104 /**
 105  * @class ACE_Resume_Node
 106  *
 107  * @brief Resume a Service Node.
 108  *
 109  * @note This class is only meant for INTERNAL use by ACE.
 110  *
 111  * @internal
 112  */
 113 class ACE_Resume_Node : public ACE_Parse_Node
 114 {
 115 public:
 116   ACE_Resume_Node (const ACE_TCHAR *name);
 117   ~ACE_Resume_Node ();
 118
 119   virtual void apply (ACE_Service_Gestalt *cfg, int &yyerrno);
 120
 121   /// Dump the state of an object.
 122   void dump () const;
 123
 124   /// Declare the dynamic allocation hooks.
 125   ACE_ALLOC_HOOK_DECLARE;
 126
 127 private:
 128   ACE_Resume_Node (const ACE_Resume_Node&) = delete;
 129   ACE_Resume_Node& operator= (const ACE_Resume_Node&) = delete;
 130 };
 131
 132 /**
 133  * @class ACE_Remove_Node
 134  *
 135  * @brief Remove a Service Node.
 136  *
 137  * @note This class is only meant for INTERNAL use by ACE.
 138  *
 139  * @internal
 140  */
 141 class ACE_Remove_Node : public ACE_Parse_Node
 142 {
 143 public:
 144   ACE_Remove_Node (const ACE_TCHAR *name);
 145   ~ACE_Remove_Node ();
 146
 147   virtual void apply (ACE_Service_Gestalt *cfg, int &yyerrno);
 148
 149   /// Dump the state of an object.
 150   void dump () const;
 151
 152   /// Declare the dynamic allocation hooks.
 153   ACE_ALLOC_HOOK_DECLARE;
 154
 155 private:
 156   ACE_Remove_Node (const ACE_Remove_Node&) = delete;
 157   ACE_Remove_Node& operator= (const ACE_Remove_Node&) = delete;
 158 };
 159
 160 /**
 161  * @class ACE_Static_Node
 162  *
 163  * @brief Handle a statically linked node.
 164  *
 165  * @note This class is only meant for INTERNAL use by ACE.
 166  *
 167  * @internal
 168  */
 169 class ACE_Static_Node : public ACE_Parse_Node
 170 {
 171 public:
 172   ACE_Static_Node (const ACE_TCHAR *name, ACE_TCHAR *params = 0);
 173   virtual ~ACE_Static_Node ();
 174
 175   virtual void apply (ACE_Service_Gestalt *cfg, int &yyerrno);
 176   virtual const ACE_Service_Type *record (const ACE_Service_Gestalt *g) const;
 177
 178   ACE_TCHAR *parameters () const;
 179
 180   /// Dump the state of an object.
 181   void dump () const;
 182
 183   /// Declare the dynamic allocation hooks.
 184   ACE_ALLOC_HOOK_DECLARE;
 185
 186 private:
 187   /// "Command-line" parameters.
 188   ACE_TCHAR *parameters_;
 189
 190 private:
 191   ACE_Static_Node (const ACE_Static_Node&) = delete;
 192   ACE_Static_Node& operator= (const ACE_Static_Node&) = delete;
 193 };
 194
 195
 196 class ACE_Service_Type_Factory;
 197
 198 /**
 199  * @class ACE_Dynamic_Node
 200  *
 201  * @brief Handle a dynamically linked node.
 202  *
 203  * @note This class is only meant for INTERNAL use by ACE.
 204  *
 205  * @internal
 206  */
 207 class ACE_Dynamic_Node : public ACE_Static_Node
 208 {
 209 public:
 210   ACE_Dynamic_Node (ACE_Service_Type_Factory const *, ACE_TCHAR *params);
 211
 212   virtual ~ACE_Dynamic_Node ();
 213
 214   //  virtual const ACE_Service_Type *record () const;
 215   virtual void apply (ACE_Service_Gestalt *cfg, int &yyerrno);
 216
 217   /// Dump the state of an object.
 218   void dump () const;
 219
 220   /// Declare the dynamic allocation hooks.
 221   ACE_ALLOC_HOOK_DECLARE;
 222
 223 private:
 224   /// Pointer to a descriptor that describes this node.
 225   std::unique_ptr<const ACE_Service_Type_Factory> factory_;
 226
 227 private:
 228   ACE_Dynamic_Node (const ACE_Dynamic_Node&) = delete;
 229   ACE_Dynamic_Node& operator= (const ACE_Dynamic_Node&) = delete;
 230 };
 231
 232 /**
 233  * @class ACE_Stream_Node
 234  *
 235  * @brief Handle a Stream.
 236  *
 237  * @note This class is only meant for INTERNAL use by ACE.
 238  *
 239  * @internal
 240  */
 241 class ACE_Stream_Node : public ACE_Parse_Node
 242 {
 243 public:
 244   ACE_Stream_Node (const ACE_Static_Node *, const ACE_Parse_Node *);
 245   virtual ~ACE_Stream_Node ();
 246
 247   virtual void apply (ACE_Service_Gestalt *cfg, int &yyerrno);
 248
 249   /// Dump the state of an object.
 250   void dump () const;
 251
 252   /// Declare the dynamic allocation hooks.
 253   ACE_ALLOC_HOOK_DECLARE;
 254
 255 private:
 256   /// Linked list of modules that are part of the stream.
 257   const ACE_Static_Node *node_;
 258   const ACE_Parse_Node *mods_;
 259
 260 private:
 261   ACE_Stream_Node (const ACE_Stream_Node&) = delete;
 262   ACE_Stream_Node& operator= (const ACE_Stream_Node&) = delete;
 263 };
 264
 265 /**
 266  * @class ACE_Dummy_Node
 267  *
 268  * @brief I forget why this is here... ;-)
 269  * @brief Used in a special case of static STREAM definintion
 270  *
 271  * @note This class is only meant for INTERNAL use by ACE.
 272  */
 273 class ACE_Dummy_Node : public ACE_Parse_Node
 274 {
 275 public:
 276   ACE_Dummy_Node (const ACE_Static_Node *, const ACE_Parse_Node *);
 277   ~ACE_Dummy_Node ();
 278
 279   virtual void apply (ACE_Service_Gestalt *cfg, int &yyerrno);
 280
 281   /// Dump the state of an object.
 282   void dump () const;
 283
 284   /// Declare the dynamic allocation hooks.
 285   ACE_ALLOC_HOOK_DECLARE;
 286
 287 private:
 288   /// Linked list of modules that we're dealing with.
 289   const ACE_Static_Node *node_;
 290   const ACE_Parse_Node *mods_;
 291
 292 private:
 293   ACE_Dummy_Node (const ACE_Dummy_Node&) = delete;
 294   ACE_Dummy_Node& operator= (const ACE_Dummy_Node&) = delete;
 295 };
 296
 297 /**
 298  * @class ACE_Location_Node
 299  *
 300  * @brief Keep track of where a shared library is located.
 301  *
 302  * @note This class is only meant for INTERNAL use by ACE.
 303  *
 304  * @internal
 305  */
 306 class ACE_Location_Node
 307 {
 308 public:
 309   ACE_Location_Node ();
 310   const ACE_DLL &dll ();
 311   const ACE_TCHAR *pathname () const;
 312   void pathname (const ACE_TCHAR *h);
 313   int dispose () const;
 314
 315   virtual ~ACE_Location_Node ();
 316   virtual void set_symbol (void *h);
 317
 318   /// Will update the yyerrno member and/or corresponding configuration
 319   /// repository
 320   virtual void *symbol (ACE_Service_Gestalt *cfgptr,
 321                         int &yyerrno,
 322                         ACE_Service_Object_Exterminator * = 0) = 0;
 323
 324   /// Dump the state of an object.
 325   void dump () const;
 326
 327   /// Declare the dynamic allocation hooks.
 328   ACE_ALLOC_HOOK_DECLARE;
 329
 330 protected:
 331   int open_dll (int & yyerrno);
 332
 333   /// Pathname to the shared library we are working on.
 334   const ACE_TCHAR *pathname_;
 335
 336   /**
 337    * Flag indicating whether the Service_Object generated by this
 338    * Location Node should be deleted or not
 339    * (ACE_Service_Type::DELETE_OBJ.)
 340    */
 341   int must_delete_;
 342
 343   /// The open shared library.
 344   ACE_DLL dll_;
 345
 346   /// Symbol that we've obtained from the shared library.
 347   void *symbol_;
 348
 349 private:
 350   ACE_Location_Node (const ACE_Location_Node&) = delete;
 351   ACE_Location_Node& operator= (const ACE_Location_Node&) = delete;
 352 };
 353
 354 /**
 355  * @class ACE_Object_Node
 356  *
 357  * @brief Keeps track of the symbol name for a shared object.
 358  *
 359  * @note This class is only meant for INTERNAL use by ACE.
 360  *
 361  * @internal
 362  */
 363 class ACE_Object_Node : public ACE_Location_Node
 364 {
 365 public:
 366   ACE_Object_Node (const ACE_TCHAR *pathname, const ACE_TCHAR *obj_name);
 367   virtual void *symbol (ACE_Service_Gestalt *config,
 368                         int &yyerrno,
 369                         ACE_Service_Object_Exterminator * = 0);
 370   virtual ~ACE_Object_Node ();
 371
 372   /// Dump the state of an object.
 373   void dump () const;
 374
 375   /// Declare the dynamic allocation hooks.
 376   ACE_ALLOC_HOOK_DECLARE;
 377
 378 private:
 379   /// Name of the object that we're parsing.
 380   const ACE_TCHAR *object_name_;
 381
 382 private:
 383   ACE_Object_Node (const ACE_Object_Node&) = delete;
 384   ACE_Object_Node& operator= (const ACE_Object_Node&) = delete;
 385 };
 386
 387 /**
 388  * @class ACE_Function_Node
 389  *
 390  * @brief Keeps track of the symbol name of for a shared function.
 391  *
 392  * @note This class is only meant for INTERNAL use by ACE.
 393  *
 394  * @internal
 395  */
 396 class ACE_Function_Node : public ACE_Location_Node
 397 {
 398 public:
 399   ACE_Function_Node (const ACE_TCHAR *pathname, const ACE_TCHAR *func_name);
 400   virtual void *symbol (ACE_Service_Gestalt *config,
 401                         int &yyerrno,
 402                         ACE_Service_Object_Exterminator *gobbler = 0);
 403   virtual ~ACE_Function_Node ();
 404
 405   /// Dump the state of an object.
 406   void dump () const;
 407
 408   /// Declare the dynamic allocation hooks.
 409   ACE_ALLOC_HOOK_DECLARE;
 410
 411 private:
 412   /// Return mangled function name that takes into account ACE
 413   /// versioned namespace.
 414   /**
 415    * This function embeds the ACE versioned namespace name into the
 416    * original function name if versioned namespace support has been
 417    * enabled and the original function name conforms to the ACE
 418    * Service Object factory function naming conventions.  For example
 419    * "@c _make_Foo" becomes "@c make_ACE_5_4_7_Foo".
 420    * @par
 421    * If versioned namespace support is disabled or the factory
 422    * function name does conform to ACE conventions, no mangling will
 423    * occur and the verbatim function name is returned.
 424    *
 425    * @return Function name that takes into account versioned namespace
 426    *         name.  Caller is responsible for calling operator
 427    *         delete[] or ACE::strdelete() on the returned string.
 428    */
 429   ACE_TCHAR * make_func_name (ACE_TCHAR const * func_name);
 430
 431 private:
 432   /// Name of the function that we're parsing.
 433   const ACE_TCHAR *function_name_;
 434
 435 private:
 436   ACE_Function_Node (const ACE_Function_Node&) = delete;
 437   ACE_Function_Node& operator= (const ACE_Function_Node&) = delete;
 438 };
 439
 440 /**
 441  * @class ACE_Static_Function_Node
 442  *
 443  * @brief Keeps track of the symbol name for a function that is not
 444  * linked in from a DLL, but is statically linked with the
 445  * application.
 446  *
 447  * @note This class is only meant for INTERNAL use by ACE.
 448  *
 449  * @internal
 450  */
 451 class ACE_Static_Function_Node : public ACE_Location_Node
 452 {
 453 public:
 454   explicit ACE_Static_Function_Node (const ACE_TCHAR *func_name);
 455   virtual void *symbol (ACE_Service_Gestalt *config,
 456                         int &yyerrno,
 457                         ACE_Service_Object_Exterminator * = 0);
 458   virtual ~ACE_Static_Function_Node ();
 459
 460   /// Dump the state of an object.
 461   void dump () const;
 462
 463   /// Declare the dynamic allocation hooks.
 464   ACE_ALLOC_HOOK_DECLARE;
 465
 466 private:
 467   /// Name of the function that we're parsing.
 468   const ACE_TCHAR *function_name_;
 469
 470 private:
 471   ACE_Static_Function_Node (const ACE_Static_Function_Node&) = delete;
 472   ACE_Static_Function_Node& operator= (const ACE_Static_Function_Node&) = delete;
 473 };
 474
 475 /// A helper class used to safely register dynamic services, which may contains
 476 /// subordinate static services. It is used to capture the necessary data during
 477 /// the parsing, but perform the actual instantiation later.
 478 class ACE_Service_Type_Factory
 479 {
 480 public:
 481   ACE_Service_Type_Factory (ACE_TCHAR const *name,
 482                             int type,
 483                             ACE_Location_Node *location,
 484                             bool active);
 485
 486   ~ACE_Service_Type_Factory ();
 487
 488   ACE_Service_Type *make_service_type (ACE_Service_Gestalt *pcfg) const;
 489
 490   ACE_TCHAR const* name () const;
 491
 492   /// Declare the dynamic allocation hooks.
 493   ACE_ALLOC_HOOK_DECLARE;
 494
 495 private:
 496   /**
 497    * Not implemented to enforce no copying
 498    */
 499   ACE_Service_Type_Factory(const ACE_Service_Type_Factory&) = delete;
 500   ACE_Service_Type_Factory& operator=(const ACE_Service_Type_Factory&) = delete;
 501
 502 private:
 503   ACE_TString name_;
 504   int type_;
 505   std::unique_ptr<ACE_Location_Node> location_;
 506   bool const is_active_;
 507 };
 508
 509 ACE_END_VERSIONED_NAMESPACE_DECL
 510
 511 #endif /* ACE_USES_CLASSIC_SVC_CONF == 1 */
 512
 513 #include /**/ "ace/post.h"
 514
 515 #endif  /* ACE_PARSE_NODE_H */