Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | File List | Namespace Members | Class Members | File Members | Related Pages | Search for 

ACE_ARGV_T< CHAR_TYPE > Class Template Reference

Builds a counted argument vector (ala argc/argv) from either a string or a set of separate tokens. This class preserves whitespace within tokens only if the whitespace-containing token is enclosed in either single (') or double (") quotes. This is consistent with the expected behavior if an argument vector obtained using this class is passed to, for example, ACE_Get_Opt. More...

#include <ARGV.h>

Collaboration diagram for ACE_ARGV_T< CHAR_TYPE >:

Collaboration graph
[legend]
List of all members.

Public Member Functions

 ACE_ARGV_T (const CHAR_TYPE buf[], bool substitute_env_args=true)
 ACE_ARGV_T (CHAR_TYPE *argv[], bool substitute_env_args=true)
 ACE_ARGV_T (CHAR_TYPE *first_argv[], CHAR_TYPE *second_argv[], bool substitute_env_args=true)
 ACE_ARGV_T (bool substitute_env_args=true)
 ~ACE_ARGV_T (void)
 Destructor.

void dump (void) const
 Dump the state of this object.

int add (const CHAR_TYPE *next_arg)
int add (CHAR_TYPE *argv[])
Accessor methods
These methods access the argument vector contained in this object.

const CHAR_TYPE * operator[] (size_t index)
CHAR_TYPE ** argv (void)
int argc (void) const
 Returns the current number of arguments.

const CHAR_TYPE * buf (void)

Public Attributes

 ACE_ALLOC_HOOK_DECLARE

Private Member Functions

 ACE_ARGV_T (const ACE_ARGV_T< CHAR_TYPE > &)
 Copy constructor not implemented.

ACE_ARGV_T operator= (const ACE_ARGV_T< CHAR_TYPE > &)
 Assignment operator not implemented.

int create_buf_from_queue (void)
 Creates buf_ from the queue of added args, deletes previous buf_.

int string_to_argv (void)
 Converts buf_ into the CHAR_TYPE *argv[] format.

int argv_to_string (CHAR_TYPE **argv, CHAR_TYPE *&buf)

Private Attributes

bool substitute_env_args_
 Replace args with environment variable values?

bool iterative_
int argc_
 Number of arguments in the ARGV array.

CHAR_TYPE ** argv_
 The array of string arguments.

CHAR_TYPE * buf_
 Buffer containing the contents.

size_t length_
ACE_Unbounded_Queue< CHAR_TYPE * > queue_

Detailed Description

template<typename CHAR_TYPE>
class ACE_ARGV_T< CHAR_TYPE >

Builds a counted argument vector (ala argc/argv) from either a string or a set of separate tokens. This class preserves whitespace within tokens only if the whitespace-containing token is enclosed in either single (') or double (") quotes. This is consistent with the expected behavior if an argument vector obtained using this class is passed to, for example, ACE_Get_Opt.

This class can substitute environment variable values for tokens that are environment variable references (e.g., $VAR). This only works if the token is an environment variable reference and nothing else; it doesn't substitute environment variable references within a token. For example, $HOME/file will not substitute the value of the HOME environment variable.

Definition at line 47 of file ARGV.h.

Constructor & Destructor Documentation

template<typename CHAR_TYPE>
ACE_ARGV_T< CHAR_TYPE >::ACE_ARGV_T (  const CHAR_TYPE  buf[],
bool  substitute_env_args = true
) 
 

Splits the specified string into an argument vector. Arguments in the string are delimited by whitespace. Whitespace-containing arguments must be enclosed in quotes, either single (') or double (").

Parameters:
buf A nul-terminated CHAR_TYPE array to split into arguments for the vector.
substitute_env_args If non-zero, any token that is an environment variable reference (e.g., $VAR) will have its environment variable value in the resultant vector in place of the environment variable name.

Definition at line 71 of file ARGV.cpp.

References ACE_ERROR, ACE_LIB_TEXT, ACE_NEW, ACE_TRACE, LM_ERROR, ACE_OS::strcpy(), and ACE_ARGV_T< CHAR_TYPE >::string_to_argv(). 

00073   : substitute_env_args_ (substitute_env_args),
00074     iterative_ (false),
00075     argc_ (0),
00076     argv_ (0),
00077     buf_ (0),
00078     length_ (0),
00079     queue_ ()
00080 {
00081   ACE_TRACE ("ACE_ARGV_T::ACE_ARGV_T CHAR_TYPE[] to CHAR_TYPE *[]");
00082 
00083   if (buf == 0 || buf[0] == 0)
00084     return;
00085 
00086   // Make an internal copy of the string.
00087   ACE_NEW (this->buf_,
00088            CHAR_TYPE[ACE_OS::strlen (buf) + 1]);
00089   ACE_OS::strcpy (this->buf_, buf);
00090 
00091   // Create this->argv_.
00092   if (this->string_to_argv () == -1)
00093     ACE_ERROR ((LM_ERROR,
00094                 ACE_LIB_TEXT ("%p\n"),
00095                 ACE_LIB_TEXT ("string_to_argv")));
00096 }

template<typename CHAR_TYPE>
ACE_ARGV_T< CHAR_TYPE >::ACE_ARGV_T (  CHAR_TYPE *  argv[],
bool  substitute_env_args = true
) 
 

Initializes the argument vector from a set of arguments. Any environment variable references are translated (if applicable) during execution of this method.

Parameters:
argv An array of tokens to initialize the object with. The array must be terminated with a 0 pointer. All needed data is copied from argv during this call; the pointers in argv are not needed after this call, and the memory referred to by argv is not referenced by this object.
substitute_env_args If non-zero, any element of argv that is an environment variable reference (e.g., $VAR) will have its environment variable value in the resultant vector in place of the environment variable name.

Definition at line 99 of file ARGV.cpp.

References ACE_TRACE, and ACE_OS::argv_to_string(). 

00101   : substitute_env_args_ (substitute_env_args),
00102     iterative_ (false),
00103     argc_ (0),
00104     argv_ (0),
00105     buf_ (0),
00106     length_ (0),
00107     queue_ ()
00108 {
00109   ACE_TRACE ("ACE_ARGV_T::ACE_ARGV_T CHAR_TYPE*[] to CHAR_TYPE[]");
00110 
00111   if (argv == 0 || argv[0] == 0)
00112     return;
00113 
00114   this->argc_ = ACE_OS::argv_to_string (argv, this->buf_, substitute_env_args);
00115 }

template<typename CHAR_TYPE>
ACE_ARGV_T< CHAR_TYPE >::ACE_ARGV_T (  CHAR_TYPE *  first_argv[],
CHAR_TYPE *  second_argv[],
bool  substitute_env_args = true
) 
 

Initializes the argument vector from two combined argument vectors.

Parameters:
first_argv An array of tokens to initialize the object with. The array must be terminated with a 0 pointer.
second_argv An array of tokens that is concatenated with the the tokens in first_argv. The array must be terminated with a 0 pointer.
substitute_env_args If non-zero, any element of first_argv or second_argv that is an environment variable reference (e.g., $VAR) will have its environment variable value in the resultant vector in place of the environment variable name.

Definition at line 118 of file ARGV.cpp.

References ACE_NEW, ACE_TRACE, ACE_ARGV_T< CHAR_TYPE >::argv_to_string(), ACE_OS::strcat(), ACE_OS::strcpy(), and ACE_OS::strlen(). 

00121   : substitute_env_args_ (substitute_env_args),
00122     iterative_ (false),
00123     argc_ (0),
00124     argv_ (0),
00125     buf_ (0),
00126     length_ (0),
00127     queue_ ()
00128 {
00129   ACE_TRACE ("ACE_ARGV_T::ACE_ARGV_T CHAR_TYPE*[] + CHAR_TYPE *[] to CHAR_TYPE[]");
00130 
00131   int first_argc;
00132   int second_argc;
00133 
00134   CHAR_TYPE *first_buf;
00135   CHAR_TYPE *second_buf;
00136 
00137   // convert the first argv to a string
00138   first_argc = this->argv_to_string (first_argv, first_buf);
00139 
00140   // convert the second argv to a string
00141   second_argc = this->argv_to_string (second_argv, second_buf);
00142 
00143   // Add the number of arguments in both the argvs.
00144   this->argc_ = first_argc + second_argc;
00145 
00146   size_t buf_len =
00147     ACE_OS::strlen (first_buf) + ACE_OS::strlen (second_buf) + 1;
00148 
00149   // Allocate memory to the lenght of the combined argv string.
00150   ACE_NEW (this->buf_,
00151            CHAR_TYPE[buf_len + 1]);
00152 
00153   // copy the first argv string to the buffer
00154   ACE_OS::strcpy (this->buf_, first_buf);
00155 
00156   // concatenate the second argv string to the buffer
00157   ACE_OS::strcat (this->buf_, second_buf);
00158 
00159   //   Delete the first and second buffers
00160 
00161   delete [] first_buf;
00162 
00163   delete [] second_buf;
00164 }

template<typename CHAR_TYPE>
ACE_ARGV_T< CHAR_TYPE >::ACE_ARGV_T (  bool  substitute_env_args = true  ) 
 

Initialize this object so arguments can be added later using one of the add methods. This is referred to as the iterative method of adding arguments to this object.

Definition at line 167 of file ARGV.cpp.

References ACE_TRACE. 

00168   : substitute_env_args_ (substitute_env_args),
00169     iterative_ (true),
00170     argc_ (0),
00171     argv_ (0),
00172     buf_ (0),
00173     length_ (0),
00174     queue_ ()
00175 {
00176   ACE_TRACE ("ACE_ARGV_T::ACE_ARGV_T Iterative");
00177 
00178   // Nothing to do yet -- the user puts in arguments via add ()
00179 }

template<typename CHAR_TYPE>
ACE_ARGV_T< CHAR_TYPE >::~ACE_ARGV_T (  void   ) 
 

Destructor.

Definition at line 234 of file ARGV.cpp.

References ACE_TRACE, ACE_ARGV_T< CHAR_TYPE >::buf_, and ACE_OS::free(). 

00235 {
00236   ACE_TRACE ("ACE_ARGV_T::~ACE_ARGV_T");
00237 
00238   if (this->argv_ != 0)
00239     for (int i = 0; this->argv_[i] != 0; i++)
00240       ACE_OS::free ((void *) this->argv_[i]);
00241 
00242   delete [] this->argv_;
00243   delete [] this->buf_;
00244 }

template<typename CHAR_TYPE>
ACE_ARGV_T< CHAR_TYPE >::ACE_ARGV_T (  const ACE_ARGV_T< CHAR_TYPE > &   )  [private]
 

Copy constructor not implemented.

Member Function Documentation

template<typename CHAR_TYPE>
int ACE_ARGV_T< CHAR_TYPE >::add (  CHAR_TYPE *  argv[]  ) 
 

Add an array of arguments. This only works in the iterative mode.

Note:
This method copies the specified pointers, but not the data contained in the referenced memory. Thus, if the content of the memory referred to by any of the argv elements is changed after this method returns, the results are undefined.
Parameters:
argv Pointers to the arguments to add to the vector. argv must be terminated by a 0 pointer.
Return values:
0 on success; -1 on failure. Most likely errno values are:
  • EINVAL: This object is not in iterative mode.
  • ENOMEM: Not enough memory available to save next_arg.

Definition at line 222 of file ARGV.cpp.

References ACE_ARGV_T< CHAR_TYPE >::add(). 

00223 {
00224   for (int i = 0; argv[i] != 0; i++)
00225     if (this->add (argv[i]) == -1)
00226       return -1;
00227 
00228   return 0;
00229 }

template<typename CHAR_TYPE>
int ACE_ARGV_T< CHAR_TYPE >::add (  const CHAR_TYPE *  next_arg  ) 
 

Add another argument. This only works in the iterative mode.

Note:
This method copies the specified pointer, but not the data contained in the referenced memory. Thus, if the content of the memory referred to by next_arg are changed after this method returns, the results are undefined.
Parameters:
next_arg Pointer to the next argument to add to the vector.
Return values:
0 on success; -1 on failure. Most likely errno values are:
  • EINVAL: This object is not in iterative mode.
  • ENOMEM: Not enough memory available to save next_arg.

Definition at line 183 of file ARGV.cpp.

References ACE_ERROR_RETURN, ACE_LIB_TEXT, ACE_ARGV_T< CHAR_TYPE >::buf_, ACE_Unbounded_Queue< CHAR_TYPE * >::enqueue_tail(), ACE_OS::free(), ACE_ARGV_T< CHAR_TYPE >::iterative_, ACE_ARGV_T< CHAR_TYPE >::length_, LM_ERROR, and ACE_OS::strlen().

Referenced by ACE_ARGV_T< CHAR_TYPE >::add(). 

00184 {
00185   // Only allow this to work in the "iterative" verion -- the
00186   // ACE_ARGVs created with the one argument constructor.
00187   if (!this->iterative_)
00188     {
00189       errno = EINVAL;
00190       return -1;
00191     }
00192 
00193   // Put the new argument at the end of the queue.
00194   if (this->queue_.enqueue_tail (const_cast <CHAR_TYPE *> (next_arg)) == -1)
00195     ACE_ERROR_RETURN ((LM_ERROR,
00196                        ACE_LIB_TEXT ("Can't add more to ARGV queue")),
00197                       -1);
00198 
00199   this->length_ += ACE_OS::strlen (next_arg);
00200 
00201   this->argc_++;
00202 
00203   // Wipe argv_ and buf_ away so that they will be recreated if the
00204   // user calls argv () or buf ().
00205   if (this->argv_ != 0)
00206     {
00207       for (int i = 0; this->argv_[i] != 0; i++)
00208         ACE_OS::free ((void *) this->argv_[i]);
00209 
00210       delete [] this->argv_;
00211       this->argv_ = 0;
00212     }
00213 
00214   delete [] this->buf_;
00215   this->buf_ = 0;
00216 
00217   return 0;
00218 }

template<typename CHAR_TYPE>
ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE int ACE_ARGV_T< CHAR_TYPE >::argc (  void   )  const
 

Returns the current number of arguments.

Definition at line 12 of file ARGV.inl.

References ACE_TRACE.

Referenced by ace_yyparse(), ACE_Service_Gestalt::initialize(), and ACE_Service_Gestalt::initialize_i(). 

00013 {
00014   ACE_TRACE ("ACE_ARGV_T::argc");
00015   return this->argc_;
00016 }

template<typename CHAR_TYPE>
ACE_INLINE CHAR_TYPE ** ACE_ARGV_T< CHAR_TYPE >::argv (  void   ) 
 

Returns the current argument vector. The returned pointers are to data maintained internally to this class. Do not change or delete either the pointers or the memory to which they refer.

Definition at line 35 of file ARGV.inl.

References ACE_TRACE, ACE_ARGV_T< CHAR_TYPE >::buf_, ACE_ARGV_T< CHAR_TYPE >::create_buf_from_queue(), ACE_ARGV_T< CHAR_TYPE >::iterative_, and ACE_ARGV_T< CHAR_TYPE >::string_to_argv().

Referenced by ace_yyparse(), ACE_ARGV_T< CHAR_TYPE >::dump(), ACE_Service_Gestalt::initialize(), ACE_Service_Gestalt::initialize_i(), and ACE_ARGV_T< CHAR_TYPE >::operator[](). 

00036 {
00037   ACE_TRACE ("ACE_ARGV_T::argv");
00038 
00039   // Try to create the argv_ if it isn't there
00040   if (this->argv_ == 0)
00041     {
00042       if (this->iterative_ && this->buf_ == 0)
00043         this->create_buf_from_queue ();
00044 
00045       // Convert buf_ to argv_
00046       if (this->string_to_argv () == -1)
00047         return (CHAR_TYPE **) 0;
00048     }
00049 
00050   return (CHAR_TYPE **) this->argv_;
00051 }

template<typename CHAR_TYPE>
int ACE_ARGV_T< CHAR_TYPE >::argv_to_string (  CHAR_TYPE **  argv,
CHAR_TYPE *&  buf
)  [private]
 

Returns the string created from argv in buf and returns the number of arguments.

Definition at line 65 of file ARGV.cpp.

References ACE_OS::argv_to_string().

Referenced by ACE_ARGV_T< CHAR_TYPE >::ACE_ARGV_T(). 

00066 {
00067   return ACE_OS::argv_to_string (argv, buf);
00068 }

template<typename CHAR_TYPE>
ACE_INLINE const CHAR_TYPE * ACE_ARGV_T< CHAR_TYPE >::buf (  void   ) 
 

Returns a single string form of the current arguments. The returned pointer refers to memory maintained internally to this class. Do not change or delete it.

Definition at line 21 of file ARGV.inl.

References ACE_TRACE, ACE_ARGV_T< CHAR_TYPE >::buf_, ACE_ARGV_T< CHAR_TYPE >::create_buf_from_queue(), and ACE_ARGV_T< CHAR_TYPE >::iterative_. 

00022 {
00023   ACE_TRACE ("ACE_ARGV_T::buf");
00024 
00025   if (this->buf_ == 0 && this->iterative_)
00026     this->create_buf_from_queue ();
00027 
00028   return (const CHAR_TYPE *) this->buf_;
00029 }

template<typename CHAR_TYPE>
int ACE_ARGV_T< CHAR_TYPE >::create_buf_from_queue (  void   )  [private]
 

Creates buf_ from the queue of added args, deletes previous buf_.

Definition at line 251 of file ARGV.cpp.

References ACE_NEW_RETURN, ACE_TRACE, ACE_Unbounded_Queue_Iterator< T >::advance(), ACE_ARGV_T< CHAR_TYPE >::buf_, ACE_Unbounded_Queue_Iterator< T >::done(), ACE_OS::memcpy(), ACE_Unbounded_Queue_Iterator< T >::next(), and ACE_OS::strlen().

Referenced by ACE_ARGV_T< CHAR_TYPE >::argv(), and ACE_ARGV_T< CHAR_TYPE >::buf(). 

00252 {
00253   ACE_TRACE ("ACE_ARGV_T::create_buf_from_queue");
00254 
00255   // If the are no arguments, don't do anything
00256   if (this->argc_ <= 0)
00257     return -1;
00258 
00259   delete [] this->buf_;
00260 
00261   ACE_NEW_RETURN (this->buf_,
00262                   CHAR_TYPE[this->length_ + this->argc_],
00263                   -1);
00264 
00265   // Get an iterator over the queue
00266   ACE_Unbounded_Queue_Iterator<CHAR_TYPE *> iter (this->queue_);
00267 
00268   CHAR_TYPE **arg = 0;
00269   CHAR_TYPE *ptr = this->buf_;
00270   size_t len;
00271   int more = 0;
00272 
00273   while (!iter.done ())
00274     {
00275       // Get next argument from the queue.
00276       iter.next (arg);
00277 
00278       more = iter.advance ();
00279 
00280       len = ACE_OS::strlen (*arg);
00281 
00282       // Copy the argument into buf_
00283       ACE_OS::memcpy ((void *) ptr,
00284                       (const void *) (*arg),
00285                       len * sizeof (CHAR_TYPE));
00286       // Move the pointer down.
00287       ptr += len;
00288 
00289       // Put in an argument separating space.
00290       if (more != 0)
00291         *ptr++ = ' ';
00292     }
00293 
00294   // Put in the NUL terminator
00295   *ptr = '\0';
00296 
00297   return 0;
00298 }

template<typename CHAR_TYPE>
ACE_BEGIN_VERSIONED_NAMESPACE_DECL void ACE_ARGV_T< CHAR_TYPE >::dump (  void   )  const
 

Dump the state of this object.

Definition at line 24 of file ARGV.cpp.

References ACE_ARGV, ACE_BEGIN_DUMP, ACE_DEBUG, ACE_END_DUMP, ACE_LIB_TEXT, ACE_TRACE, ACE_ARGV_T< CHAR_TYPE >::argv(), and LM_DEBUG. 

00025 {
00026 #if defined (ACE_HAS_DUMP)
00027   ACE_TRACE ("ACE_ARGV_T::dump");
00028 
00029   ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
00030   ACE_DEBUG ((LM_DEBUG,  ACE_LIB_TEXT ("argc_ = %d"), this->argc_));
00031 
00032   ACE_ARGV *this_obj = const_cast<ACE_ARGV *> (this);
00033 
00034   for (int i = 0; i < this->argc_; i++)
00035     ACE_DEBUG ((LM_DEBUG,
00036                 ACE_LIB_TEXT ("\nargv_[%i] = %s"),
00037                 i,
00038                 this_obj->argv ()[i]));
00039 
00040   ACE_DEBUG ((LM_DEBUG,  ACE_LIB_TEXT ("\nbuf = %s\n"), this->buf_));
00041   ACE_DEBUG ((LM_DEBUG,  ACE_LIB_TEXT ("\n")));
00042   ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
00043 #endif /* ACE_HAS_DUMP */
00044 }

template<typename CHAR_TYPE>
ACE_ARGV_T ACE_ARGV_T< CHAR_TYPE >::operator= (  const ACE_ARGV_T< CHAR_TYPE > &   )  [private]
 

Assignment operator not implemented.

template<typename CHAR_TYPE>
ACE_INLINE const CHAR_TYPE * ACE_ARGV_T< CHAR_TYPE >::operator[] (  size_t  index  ) 
 

Returns the specified element of the current argument vector.

Parameters:
index Index to the desired element.
Return values:
Pointer to the indexed string.
0 if index is out of bounds.

Definition at line 57 of file ARGV.inl.

References ACE_TRACE, and ACE_ARGV_T< CHAR_TYPE >::argv(). 

00058 {
00059   ACE_TRACE ("ACE_ARGV_T::operator[]");
00060 
00061   // Don't go out of bounds.
00062   if (i >= static_cast<size_t> (this->argc_))
00063     return 0;
00064 
00065   return (const CHAR_TYPE *) this->argv ()[i];
00066 }

template<typename CHAR_TYPE>
int ACE_ARGV_T< CHAR_TYPE >::string_to_argv (  void   )  [private]
 

Converts buf_ into the CHAR_TYPE *argv[] format.

Definition at line 53 of file ARGV.cpp.

References ACE_TRACE, and ACE_OS::string_to_argv().

Referenced by ACE_ARGV_T< CHAR_TYPE >::ACE_ARGV_T(), and ACE_ARGV_T< CHAR_TYPE >::argv(). 

00054 {
00055   ACE_TRACE ("ACE_ARGV_T::string_to_argv");
00056 
00057   return ACE_OS::string_to_argv (this->buf_,
00058                                  this->argc_,
00059                                  this->argv_,
00060                                  this->substitute_env_args_);
00061 }

Member Data Documentation

template<typename CHAR_TYPE>
ACE_ARGV_T< CHAR_TYPE >::ACE_ALLOC_HOOK_DECLARE
 

Definition at line 152 of file ARGV.h.

template<typename CHAR_TYPE>
int ACE_ARGV_T< CHAR_TYPE >::argc_ [private]
 

Number of arguments in the ARGV array.

Definition at line 210 of file ARGV.h.

template<typename CHAR_TYPE>
CHAR_TYPE** ACE_ARGV_T< CHAR_TYPE >::argv_ [private]
 

The array of string arguments.

Definition at line 213 of file ARGV.h.

template<typename CHAR_TYPE>
CHAR_TYPE* ACE_ARGV_T< CHAR_TYPE >::buf_ [private]
 

Buffer containing the contents.

Definition at line 216 of file ARGV.h.

Referenced by ACE_ARGV_T< CHAR_TYPE >::add(), ACE_ARGV_T< CHAR_TYPE >::argv(), ACE_ARGV_T< CHAR_TYPE >::buf(), ACE_ARGV_T< CHAR_TYPE >::create_buf_from_queue(), and ACE_ARGV_T< CHAR_TYPE >::~ACE_ARGV_T().

template<typename CHAR_TYPE>
bool ACE_ARGV_T< CHAR_TYPE >::iterative_ [private]
 

Definition at line 207 of file ARGV.h.

Referenced by ACE_ARGV_T< CHAR_TYPE >::add(), ACE_ARGV_T< CHAR_TYPE >::argv(), and ACE_ARGV_T< CHAR_TYPE >::buf().

template<typename CHAR_TYPE>
size_t ACE_ARGV_T< CHAR_TYPE >::length_ [private]
 

Total length of the arguments in the queue, not counting separating spaces

Definition at line 220 of file ARGV.h.

Referenced by ACE_ARGV_T< CHAR_TYPE >::add().

template<typename CHAR_TYPE>
ACE_Unbounded_Queue<CHAR_TYPE *> ACE_ARGV_T< CHAR_TYPE >::queue_ [private]
 

Queue which keeps user supplied arguments. This is only active in the "iterative" mode.

Definition at line 224 of file ARGV.h.

template<typename CHAR_TYPE>
bool ACE_ARGV_T< CHAR_TYPE >::substitute_env_args_ [private]
 

Replace args with environment variable values?

Definition at line 205 of file ARGV.h.

The documentation for this class was generated from the following files:
Generated on Thu Nov 9 11:19:12 2006 for ACE by doxygen 1.3.6