#include "ace/OS_NS_string.h" #include "ace/Configuration.h" #include "ace/Configuration_Import_Export.h" #include "ace/Get_Opt.h" #include "ace/Log_Msg.h" #include "ace/INET_Addr.h" #include "ace/Service_Object.h" class HA_Status: public ACE_Service_Object { public: virtual int init(int argc, ACE_TCHAR *argv[]); private: ACE_INET_Addr listen_addr_; }; int HA_Status::init(int argc, ACE_TCHAR *argv[]) { // Listing 1 code/ch04 // define the valid options, A colon following an option letter means // the options requires an arguemnt. Use a double colon if the argument // is optional. examp: "a:b:cd::e" has "-a ,-b , -c ,-d, -e". static const ACE_TCHAR options[] = ACE_TEXT(":f:"); ACE_Get_Opt cmd_opts(argc, argv, options); // use the long_option()method to equate a long option string // with one of the short options; if (cmd_opts.long_option(ACE_TEXT("config"),'f', ACE_Get_Opt::ARG_REQUIRED) == -1) return -1; int option; ACE_TCHAR config_file[MAXPATHLEN]; ACE_OS::strcpy(config_file, ACE_TEXT("HAStatus.conf")); // Use operator() (or the get_opt() method) to iterate through the // command line options.It returns the short option character when // located, and the short option equivalent when a long option is processed. // operator() returns EOF when all the options have been processed. while((option = cmd_opts()) != EOF) switch (option) { case 'f': // The option's argument is accessed via the opt_arg() method. ACE_OS::strncpy(config_file, cmd_opts.opt_arg(), MAXPATHLEN); break; case ':': //If it is a ':',get_opt() return a ':' when a required argument is missing. ACE_ERROR_RETURN((LM_ERROR, ACE_TEXT("-%c requires an argument "), cmd_opts.opt_opt()), -1); default: ACE_ERROR_RETURN((LM_ERROR, ACE_TEXT("Parse error. ")), -1); } // Listint 1 // Listint 2 code/ch04 ACE_Configuration_Heap config; if (config.open() == -1) ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT("config")), -1); ACE_Registry_ImpExp config_importer(config); if (config_importer.import_config(config_file) == -1) ACE_ERROR_RETURN((LM_ERROR, ACE_TEXT("%p "), config_file), -1); ACE_Configuration_Section_Key status_section; if (config.open_section(config.root_section(), ACE_TEXT("HAStatus"), 0, status_section) == -1) ACE_ERROR_RETURN((LM_ERROR, ACE_TEXT("%p "), ACE_TEXT("Can't open HAStatus sections")), -1); u_int status_port; if (config.get_integer_value(status_section, ACE_TEXT("ListenPort"), status_port) == -1) ACE_ERROR_RETURN((LM_ERROR, "HAStatus ListenPort does not exist "), -1); this->listen_addr_.set(static_cast<u_short> (status_port)); return 0; } int ACE_TMAIN(int argc, ACE_TCHAR *argv[]) { HA_Status status; status.init(argc, argv); return 0; } /* ACE_Get_Opt (int argc, ACE_TCHAR **argv, const ACE_TCHAR *optstring, int skip_args = 1, int report_error = 0, int ordering = PERMUTE_ARGS, int long_only = 0); # 1.start parsing at an arbitrary index ACE_Get_Opt can be directed to start processing the argument vector at an arbi- trary point specified by the skip_args parameter. The default value is 1, which causes ACE_Get_Opt to skip argv[0] (traditionally, the program name) when parsing a command line passed to main(). When using ACE_Get_Opt to parse options received when initializing a dynamic service skip_args is often specified as 0, because arguments passed to services initialized via the ACE Service Configurator framework start in argv[0]. # 2.Report errors while parsing By default, ACE_Get_Opt is silent about parsing errors; it simply returns the appropriate value from operator() (or the get_opt() method), allowing your application to handle and report errors in the most sensible way. If, however, you’d rather have ACE_Get_Opt display an error message when it detects an error in the specified argument vector, the constructor’s report_errors argu- ment should be non-zero. In this case, ACE_Get_Opt will use ACE_ERROR with the LM_ERROR severity to report the error. # 3.Alternate long option specification If "W" is included in the options definitions string, ACE_Get_Opt treats -W similarly to --. For example, -W foo will be parsed the same as --foo. This can be useful when manipulating argument vectors to change parameters into long options by inserting an element with -W instead of inserting -- on an existing element. # 4.About argument ordering Some applications require you to specify all options at the beginning of the command line, while others allow you to mix options and other non-option tokens (such as file names). ACE_Get_Opt supports selection of use cases defined by enumerators defined in ACE_Get_Opt. ## 1.ACE_Get_Opt::PERMUTE_ARGS: As the argument vector is parsed, the elements are dynamically rearranged so that those with valid options(and their arguments) appear at the front of the argument vector, in their original relative ordering. Non-option elements are placed after the option elements. They can be processed by some other part of your system, or processed as known non-options. When operator() returns EOF to indicate the end of options, opt_ind() returns the index to the first non-option element in the argumet vector. ## 2.ACE_Get_Opt::REQUIRED_ORDER: The argument vector is not reordered and all options and their their arguments must be at the front of the argument vector. If a non-option element is encountered, operator() returns EOF; opt_ind() returns the index of the non-option element. (What is the non-option element?) ## 3.ACE_Get_Opt::RETURN_IN_ORDER: The argument vector is not reordered. Any non-option element causes operator() to return 1 and the actual element is accessible via the opt_arg() method. This mode is useful for situations in which options and other arguments can be specified in any order and in which the relative ordering makes a difference. This is a situation where it may be useful to parse options, examine non-options, and and continue parsing after the non-options using the skip_args argument to specify the new starting point. ## The other two method to change the argument order 1. If the POSIXLY_CORRECT environment variable is set, the ordering mode is set to REQUIRE_ORDER 2. A + or - character at the beginning of the options string. + changes the ordering mode to REQUIRE_ORDER; - changes it to RETURN_IN_ORDER. If both are at the start of the options string, the last ont is used. # 5.Long optins only If the long_only parameter to the ACE_Get_Opt constructor is non-zero, command line tokens that begin with a single - are checked as long options. For example, if the long_only argument were set to 1, the user could type either --config or -config. */ /* # ACE_Configuration is a class that defines the configuration interface for the following two classes available for accessing and manipulating configuration information: ## 1. ACE_Configuration_Heap is available on all platforms. It keeps all information in memory. The memory allocation can be customized to use a persistent backing store, but the most common use is with dynamically-allocated heap memory. ## 2. ACE_Configuration_Win32Registry is available only on Windows. It implements the ACE_Configuration interface to access and manipulate information in the Windows registry. # Configuration data is organized hierarchically in sections, analogous to a filesystem directory tree. Each configuration object contains a root section that has no name, similar to the filesystem root in UNIX.All other sections are created hierar- chically beneath the root section and are named by the application. Sections can be nested to an arbitrary depth. # Configuration Backing Stores ## 1. ACE_Registry_ImpExp uses a text format that includes type information with each value. This allows type information to be preserved across export/import, even on machines with different byte orders. ## 2. ACE_Ini_ImpExp uses the older Windows "INI" file format which does not have type information associated with the values. Therefore, configuration data exported using ACE_Ini_ImpExp is always imported as string data, regardless of the original type. */