This ADT operates on a specified set of arguments (argv). As known arguments are scanned, they are shifted to the back of the argv vector, so deeper levels of argument parsing can locate the yet unprocessed arguments at the beginning of the vector. More...
#include <Arg_Shifter.h>
Public Member Functions | |
ACE_Arg_Shifter_T (int &argc, const CHAR_TYPE **argv, const CHAR_TYPE **temp=0) | |
ACE_Arg_Shifter_T (int &argc, CHAR_TYPE **argv, CHAR_TYPE **temp=0) | |
~ACE_Arg_Shifter_T (void) | |
Destructor. | |
const CHAR_TYPE * | get_current (void) const |
Get the current head of the vector. | |
const CHAR_TYPE * | get_the_parameter (const CHAR_TYPE *flag) |
int | cur_arg_strncasecmp (const CHAR_TYPE *flag) |
int | consume_arg (int number=1) |
int | ignore_arg (int number=1) |
int | is_anything_left (void) const |
Returns the number of args left to see in the vector. | |
int | is_option_next (void) const |
int | is_parameter_next (void) const |
int | num_ignored_args (void) const |
Returns the number of irrelevant args seen. | |
Private Member Functions | |
ACE_Arg_Shifter_T (const ACE_Arg_Shifter_T< CHAR_TYPE > &) | |
Copy Constructor should not be used. | |
ACE_Arg_Shifter_T | operator= (const ACE_Arg_Shifter_T< CHAR_TYPE > &) |
Assignment '=' operator should not be used. | |
void | init (void) |
Refactor the constructor logic. | |
Private Attributes | |
int & | argc_ |
The size of the argument vector. | |
int | total_size_ |
The size of argv_. | |
const CHAR_TYPE ** | temp_ |
The temporary array over which we traverse. | |
const CHAR_TYPE ** | argv_ |
The array in which the arguments are reordered. | |
int | current_index_ |
The element in <temp_> we're currently examining. | |
int | back_ |
int | front_ |
This ADT operates on a specified set of arguments (argv). As known arguments are scanned, they are shifted to the back of the argv vector, so deeper levels of argument parsing can locate the yet unprocessed arguments at the beginning of the vector.
The ACE_Arg_Shifter
copies the pointers of the argv vector into a temporary array. As the ACE_Arg_Shifter
iterates over the copied vector, it places known arguments in the rear of the vector, leaving the unknown ones in the beginning. So, after having visited all the arguments in the temporary vector, ACE_Arg_Shifter
has placed all the unknown arguments in their original order at the front of original argv.
Definition at line 45 of file Arg_Shifter.h.
ACE_Arg_Shifter_T< CHAR_TYPE >::ACE_Arg_Shifter_T | ( | int & | argc, | |
const CHAR_TYPE ** | argv, | |||
const CHAR_TYPE ** | temp = 0 | |||
) |
Initialize the ACE_Arg_Shifter to the vector over which to iterate. Optionally, also provide the temporary array for use in shifting the arguments. If ACE_Arg_Shifter must allocate the temporary vector internally and dynamic allocation fails, the ACE_Arg_Shifter will set all indicators to end of the vector, forbidding iteration. Following iteration over argv, the argc value will be updated to contain the number of unconsumed arguments.
argc | The number of strings in argv. argc will be updated to reflect the number of unconsumed arguments. | |
argv | The argument vector to shift. The string pointers in the vector will be reordered to place the argc unconsumed arguments at the front of the vector. | |
temp | A vector of CHAR_TYPE pointers at least argc elements long. The vector will be used for argument shifting as the specified argv vector is consumed. The vector must not be modified while this object exists. If this argument is 0 (the default) the object will allocate and free the temporary vector transparently. |
ACE_Arg_Shifter_T< CHAR_TYPE >::ACE_Arg_Shifter_T | ( | int & | argc, | |
CHAR_TYPE ** | argv, | |||
CHAR_TYPE ** | temp = 0 | |||
) |
Same behavior as the preceding constructor, but without the "const" qualifier.
Definition at line 33 of file Arg_Shifter.cpp.
: argc_ (argc), total_size_ (argc), temp_ ((const CHAR_TYPE **) temp), argv_ ((const CHAR_TYPE **) argv), current_index_ (0), back_ (argc - 1), front_ (0) { this->init (); }
ACE_Arg_Shifter_T< CHAR_TYPE >::~ACE_Arg_Shifter_T | ( | void | ) |
Destructor.
Definition at line 75 of file Arg_Shifter.cpp.
{ // Delete the temporary vector. delete [] temp_; }
ACE_Arg_Shifter_T< CHAR_TYPE >::ACE_Arg_Shifter_T | ( | const ACE_Arg_Shifter_T< CHAR_TYPE > & | ) | [private] |
Copy Constructor should not be used.
int ACE_Arg_Shifter_T< CHAR_TYPE >::consume_arg | ( | int | number = 1 |
) |
Consume number argument(s) by sticking them/it on the end of the vector.
Definition at line 157 of file Arg_Shifter.cpp.
{ int retval = 0; // Stick knowns at the end of the vector (consumed). if (this->is_anything_left() >= number) { for (int i = 0, j = this->back_ - (number - 1); i < number; ++i, ++j, ++this->current_index_) this->argv_[j] = this->temp_[this->current_index_]; this->back_ -= number; retval = 1; } return retval; }
int ACE_Arg_Shifter_T< CHAR_TYPE >::cur_arg_strncasecmp | ( | const CHAR_TYPE * | flag | ) |
Check if the current argument matches (case insensitive) flag
------------------------------------------------------------
Case A: Perfect Match (case insensitive) 0 is returned.
ie: when current_arg = "-foobar" or "-FOOBAR" or "-fooBAR" this->cur_arg_strncasecmp ("-FooBar); will return 0
------------------------------------------------------------
Case B: Perfect Match (case insensitive) but the current_arg is longer than the flag. Returns a number equal to the index in the char* indicating the start of the extra characters
ie: when current_arg = "-foobar98023" this->cur_arg_strncasecmp ("-FooBar); will return 7
Notice: this number will always be > 0
------------------------------------------------------------
Case C: If neither of Case A or B is met (no match) then -1 is returned
Definition at line 124 of file Arg_Shifter.cpp.
{ // Check for a current argument if (this->is_anything_left()) { size_t const flag_length = ACE_OS::strlen (flag); // Check for presence of the flag if (ACE_OS::strncasecmp(this->temp_[current_index_], flag, flag_length) == 0) { if (ACE_OS::strlen(temp_[current_index_]) == flag_length) { // match and lengths are equal return 0; } else { // matches, with more info to boot! size_t const remaining = ACE_OS::strspn (this->temp_[current_index_] + flag_length, ACE_TEXT (" ")) + flag_length; return static_cast<int> (remaining); } } } // failure return -1; }
const CHAR_TYPE * ACE_Arg_Shifter_T< CHAR_TYPE >::get_current | ( | void | ) | const |
Get the current head of the vector.
Definition at line 83 of file Arg_Shifter.cpp.
{ const CHAR_TYPE * retval = 0; if (this->is_anything_left ()) retval = this->temp_[current_index_]; return retval; }
const CHAR_TYPE * ACE_Arg_Shifter_T< CHAR_TYPE >::get_the_parameter | ( | const CHAR_TYPE * | flag | ) |
If the flag matches the current_arg of arg shifter this method will attempt to return the associated parameter value
Safe to call without checking that a current arg exists
In the following examples, a pointer to the char* "value" is ret
eg: main -foobar value, main -FooBar value main -FOOBARvalue
all of the above will all match the flag == -FooBar and will return a char* to "value"
main -foobar 4 would succeed and return a char* to "4" main -foobar -4 does not succeed (-4 is not a parameter) but instead, would return 0
0 is returned: If the current argument does not match flag If there is no parameter found after a 'matched' flag
If the flag is matched and the flag and parameter DO NOT RUN together, the flag is consumed, the parameter is returned, and the new current argument is the parameter value. ie '-foobarflag VALUE' leaves the new cur arg == "VALUE"
If the flag is matched and the flag and parameter RUN together '-foobarflagVALUE', the flag is NOT consumed and the cur arg is left pointing to the entire flag/value pair
Definition at line 95 of file Arg_Shifter.cpp.
{ // the return 0's abound because this method // would otherwise be a deep if { } else { } // check to see if any arguments still exist if (!this->is_anything_left()) return 0; // check to see if the flag is the argument int const offset = this->cur_arg_strncasecmp (flag); if (offset == -1) return 0; if (offset == 0) { this->consume_arg (); if (!this->is_parameter_next()) { return 0; } } // the parameter is in the middle somewhere... return this->temp_[current_index_] + offset; }
int ACE_Arg_Shifter_T< CHAR_TYPE >::ignore_arg | ( | int | number = 1 |
) |
Place number arguments in the same relative order ahead of the known arguments in the vector.
Definition at line 178 of file Arg_Shifter.cpp.
{ int retval = 0; // Keep unknowns at the head of the vector. if (this->is_anything_left () >= number) { for (int i = 0; i < number; i++, this->current_index_++, this->front_++) this->argv_[this->front_] = this->temp_[this->current_index_]; retval = 1; this->argc_ += number; } return retval; }
void ACE_Arg_Shifter_T< CHAR_TYPE >::init | ( | void | ) | [private] |
Refactor the constructor logic.
Definition at line 49 of file Arg_Shifter.cpp.
{ // If not provided with one, allocate a temporary array. if (this->temp_ == 0) ACE_NEW (this->temp_, const CHAR_TYPE *[this->total_size_]); if (this->temp_ != 0) { // Fill the temporary array. this->argc_ = 0; for (int i = 0; i < this->total_size_; i++) { this->temp_[i] = this->argv_[i]; this->argv_[i] = 0; } } else { // Allocation failed, prohibit iteration. this->current_index_ = this->argc_; this->front_ = this->argc_; } }
int ACE_Arg_Shifter_T< CHAR_TYPE >::is_anything_left | ( | void | ) | const |
Returns the number of args left to see in the vector.
Definition at line 199 of file Arg_Shifter.cpp.
{ return this->total_size_ - this->current_index_; }
int ACE_Arg_Shifter_T< CHAR_TYPE >::is_option_next | ( | void | ) | const |
Returns 1 if there's a next item in the vector and it begins with '-'.
Definition at line 206 of file Arg_Shifter.cpp.
{ return this->is_anything_left () && this->temp_[this->current_index_][0] == '-'; }
int ACE_Arg_Shifter_T< CHAR_TYPE >::is_parameter_next | ( | void | ) | const |
Returns 1 if there's a next item in the vector and it doesn't begin with '-'.
Definition at line 214 of file Arg_Shifter.cpp.
{ return this->is_anything_left () && this->temp_[this->current_index_][0] != '-'; }
int ACE_Arg_Shifter_T< CHAR_TYPE >::num_ignored_args | ( | void | ) | const |
Returns the number of irrelevant args seen.
Definition at line 222 of file Arg_Shifter.cpp.
{ return this->front_; }
ACE_Arg_Shifter_T ACE_Arg_Shifter_T< CHAR_TYPE >::operator= | ( | const ACE_Arg_Shifter_T< CHAR_TYPE > & | ) | [private] |
Assignment '=' operator should not be used.
int& ACE_Arg_Shifter_T< CHAR_TYPE >::argc_ [private] |
The size of the argument vector.
Definition at line 184 of file Arg_Shifter.h.
const CHAR_TYPE** ACE_Arg_Shifter_T< CHAR_TYPE >::argv_ [private] |
The array in which the arguments are reordered.
Definition at line 193 of file Arg_Shifter.h.
int ACE_Arg_Shifter_T< CHAR_TYPE >::back_ [private] |
The index of <argv_> in which we'll stick the next unknown argument.
Definition at line 200 of file Arg_Shifter.h.
int ACE_Arg_Shifter_T< CHAR_TYPE >::current_index_ [private] |
The element in <temp_> we're currently examining.
Definition at line 196 of file Arg_Shifter.h.
int ACE_Arg_Shifter_T< CHAR_TYPE >::front_ [private] |
The index of <argv_> in which we'll stick the next known argument.
Definition at line 204 of file Arg_Shifter.h.
const CHAR_TYPE** ACE_Arg_Shifter_T< CHAR_TYPE >::temp_ [private] |
The temporary array over which we traverse.
Definition at line 190 of file Arg_Shifter.h.
int ACE_Arg_Shifter_T< CHAR_TYPE >::total_size_ [private] |
The size of argv_.
Definition at line 187 of file Arg_Shifter.h.