/* ARIA header files for use with ARNL 1.7.1 Copyright(C) 2004, 2005 ActivMedia Robotics, LLC. Copyright(C) 2006, 2007, 2008, 2009 MobileRobots Inc. All rights reserved. This copy of Aria was relicensed for use with Arnl and the Arnl license by MobileRobots Inc. If you wish to download a seperate distribution of Aria licensed under the GPL or a commercial license go to http://www.mobilerobots.com/SOFTWARE/aria.html or contact MobileRobots Inc, at robots@mobilerobots.com or MobileRobots Inc, 10 Columbia Drive, Amherst, NH 03031; 800-639-9481 MobileRobots Inc hereby grants to other individuals or organizations permission to use this software with Arnl and in compliance with the Arnl license. This software may not be distributed to others except by MobileRobots Inc. MobileRobots Inc does not make any representations about the suitability of this software for any purpose. It is provided "as is" without express or implied warranty. */ #ifndef ARARGUMENTPARSER_H #define ARARGUMENTPARSER_H #include "ariaTypedefs.h" #include "ArArgumentBuilder.h" /// Class for parsing arguments /** This class is made for parsing arguments from the argv and argc variables passed into a program's main() function by the operating system, from an ArArgumentBuilder object, or just from a string (e.g. provided by WinMain() in a Windows MFC program.) It will also load default argument values if you call loadDefaultArguments(). Aria::init() adds the file /etc/Aria.args and the environment variable ARIAARGS as locations for argument defaults, so loadDefaultArguments() will always search those. You can use this mechanism to avoid needing to always supply command line parameters to all programs. For example, if you use different serial ports than the defaults for the robot and laser, you can put a -robotPort or -laserPort argument in /etc/Aria.args for all programs that call loadDefaultArguments() to use. You can add other files or environment variables to the list of default argument locations with addDefaultArgumentFile() and addDefaultArgumentEnv(). Note that the wasReallySet behavior has changed. It used to set the variable to false or to true, now it will only set it to false if 'setWasReallySetOnlyTrue' is set to false. By default that is set to false, but you can just set it to true after you make the parser with no ill effects since all of the built in Aria parsers will play nicely with this value, setting it to true or false while they parse but then setting it to whatever it was when they started. This change in behavior is so that checking for two things (like -robotPort and -rp) can work without a lot of extra work. **/ class ArArgumentParser { public: /// Constructor, takes the argc argv AREXPORT ArArgumentParser(int *argc, char **argv); /// Constructor, takes an argument builder AREXPORT ArArgumentParser(ArArgumentBuilder *builder); /// Destructor AREXPORT ~ArArgumentParser(); /// If we should only set wasReallySet to true AREXPORT void setWasReallySetOnlyTrue(bool wasReallySetOnlyTrue); /// If we only set wasReallySet to true AREXPORT bool getWasReallySetOnlyTrue(void); /// Returns true if the argument was found AREXPORT bool checkArgument(const char *argument); /// Returns the word/argument after given argument AREXPORT char *checkParameterArgument(const char *argument, bool returnFirst = false); /// Returns the word/argument after given argument AREXPORT bool checkParameterArgumentString(const char *argument, const char **dest, bool *wasReallySet = NULL, bool returnFirst = false); /// Returns the integer after given argument AREXPORT bool checkParameterArgumentInteger(const char *argument, int *dest, bool *wasReallySet = NULL, bool returnFirst = false); /// Returns the word/argument after given argument AREXPORT bool checkParameterArgumentBool(const char *argument, bool *dest, bool *wasReallySet = NULL, bool returnFirst = false); /// Returns the floating point number after given argument AREXPORT bool checkParameterArgumentFloat(const char *argument, float *dest, bool *wasReallySet = NULL, bool returnFirst = false); /// Returns the floating point number after given argument AREXPORT bool checkParameterArgumentDouble(const char *argument, double *dest, bool *wasReallySet = NULL, bool returnFirst = false); /// Adds a string as a default argument AREXPORT void addDefaultArgument(const char *argument, int position = -1); /// Adds args from default files and environmental variables AREXPORT void loadDefaultArguments(int positon = 1); /// Checks for the help strings and warns about unparsed arguments AREXPORT bool checkHelpAndWarnUnparsed(unsigned int numArgsOkay = 0); /// Gets how many arguments are left in this parser AREXPORT size_t getArgc(void) const; /// Gets the argv AREXPORT char** getArgv(void) const; /// Gets a specific argument AREXPORT const char* getArg(size_t whichArg) const; /// Prints out the arguments left in this parser AREXPORT void log(void) const; /// Gets the arguments this parser started with (if possible, NULL otherwise) AREXPORT const char *getStartingArguments(void) const; /// Internal function to remove an argument that was parsed AREXPORT void removeArg(size_t which); /// Adds another file or environmental variable to the list of defaults AREXPORT static void addDefaultArgumentFile(const char *file); /// Adds another file or environmental variable to the list of defaults AREXPORT static void addDefaultArgumentEnv(const char *env); /// Logs the default argument locations AREXPORT static void logDefaultArgumentLocations(void); #ifndef SWIG /** @brief Returns true if the argument was found * @swigomit */ AREXPORT bool checkArgumentVar(const char *argument, ...); /** @brief Returns the word/argument after given argument * @swigomit */ AREXPORT char *checkParameterArgumentVar(const char *argument, ...); /** @brief Returns the word/argument after given argument * @swigomit */ AREXPORT bool checkParameterArgumentStringVar(bool *wasReallySet, const char **dest, const char *argument, ...); /** @brief Returns the word/argument after given argument * @swigomit */ AREXPORT bool checkParameterArgumentBoolVar(bool *wasReallySet, bool *dest, const char *argument, ...); /** @brief Returns the integer after given argument * @swigomit */ AREXPORT bool checkParameterArgumentIntegerVar(bool *wasReallySet, int *dest, const char *argument, ...); /** @brief Returns the float after given argument * @swigomit */ AREXPORT bool checkParameterArgumentFloatVar(bool *wasReallySet, float *dest, const char *argument, ...); /** @brief Returns the double after given argument * @swigomit */ AREXPORT bool checkParameterArgumentDoubleVar(bool *wasReallySet, double *dest, const char *argument, ...); #endif protected: static std::list ourDefaultArgumentLocs; static std::list ourDefaultArgumentLocIsFile; bool myOwnBuilder; ArArgumentBuilder *myBuilder; bool myUsingBuilder; char **myArgv; int *myArgc; bool myHelp; char myEmptyArg[1]; bool myReallySetOnlyTrue; }; #endif // ARARGUMENTPARSER_H