Aria  2.8.0
configExample.cpp

Example program demonstrating the use of ArConfigThis program shows how to use ArConfig to store configuration parameters and load/save them from a file.

The ArNetworking library includes server classes that will let you use a remote client such as MobileEyes to view and change the configuration. See ArNetworking documentation and examples.

/*
Adept MobileRobots Robotics Interface for Applications (ARIA)
Copyright (C) 2004, 2005 ActivMedia Robotics LLC
Copyright (C) 2006, 2007, 2008, 2009, 2010 MobileRobots Inc.
Copyright (C) 2011, 2012, 2013 Adept Technology
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
If you wish to redistribute ARIA under different terms, contact
Adept MobileRobots for information about a commercial version of ARIA at
robots@mobilerobots.com or
Adept MobileRobots, 10 Columbia Drive, Amherst, NH 03031; +1-603-881-7960
*/
#include "Aria.h"
class ConfigExample
{
ArConfig* myConfig;
int myIntParam;
double myDoubleParam;
bool myBoolParam;
char myStringParam[256];
public:
ConfigExample():
myIntParam(0),
myDoubleParam(0.5),
myBoolParam(false),
myProcessConfigCB(this, &ConfigExample::processConfigFile)
{
// The global Aria class contains an ArConfig object. You can create
// other instances of ArConfig, but this is how you can share one ArConfig
// among various program modules.
// If you want to store a config parameter in ArConfig, first you must add
// it to the ArConfig object. Parameters are stored in sections, and
// they affect a variable via a pointer provided in an ArConfigArg
// object:
config->setSectionComment("Example Section", "Contains parameters created by the configExample");
// Add an integer which ranges from -10 to 10:
config->addParam( ArConfigArg("ExampleIntegerParameter", &myIntParam, "Example parameter integer.", -10, 10), "Example Section", ArPriority::NORMAL);
// Add a floating point number which ranges from 0.0 to 1.0:
config->addParam( ArConfigArg("ExampleDoubleParameter", &myDoubleParam, "Example double precision floating point number.", 0.0, 1.0), "Example Section", ArPriority::NORMAL);
// Essential parameters can be placed in the "Important" priority level:
config->addParam( ArConfigArg("ExampleBoolParameter", &myBoolParam, "Example boolean parameter."), "Example Section", ArPriority::IMPORTANT);
// Unimportant parameters can be placed in the "Trivial" priority level:
myStringParam[0] = '\0'; // make string empty
config->addParam( ArConfigArg("ExampleStringParameter", myStringParam, "Example string parameter.", 256), "Example Section", ArPriority::TRIVIAL);
// You can set a callback to be invoked when the configuration changes, in
// case you need to respond to any changes in the parameter values:
config->addProcessFileCB(&myProcessConfigCB, 0);
}
// Method called by config process callback when a new file is loaded.
// It can return false to indicate an error, or true to indicate no error.
bool processConfigFile()
{
ArLog::log(ArLog::Normal, "configExample: Config changed. New values: int=%d, float=%f, bool=%s, string=\"%s\".", myIntParam, myDoubleParam, myBoolParam?"true":"false", myStringParam);
return true;
}
};
int main(int argc, char **argv)
{
ArArgumentParser argParser(&argc, argv);
argParser.loadDefaultArguments();
if (argc < 2 || !Aria::parseArgs() || argParser.checkArgument("-help"))
{
ArLog::log(ArLog::Terse, "configExample usage: configExample <config file>.\nFor example, \"configExample examples/configExample.cfg\".");
return 1;
}
// Object containing config parameters, and responding to changes:
ConfigExample configExample;
// Load a config file given on the command line into the global
// ArConfig object kept by Aria. Normally ArConfig expects config
// files to be in the main ARIA directory (i.e. /usr/local/Aria or
// a directory specified by the $ARIA environment variable).
char error[512];
const char* filename = argParser.getArg(1);
ArLog::log(ArLog::Normal, "configExample: loading configuration file \"%s\"...", filename);
if (! config->parseFile(filename, true, false, error, 512) )
{
ArLog::log(ArLog::Terse, "configExample: Error loading configuration file \"%s\" %s. Try \"examples/configExample.cfg\".", filename, error);
return -1;
}
ArLog::log(ArLog::Normal, "configExample: Loaded configuration file \"%s\".", filename);
// After changing a config value, you should invoke the callbacks:
ArConfigSection* section = config->findSection("Example Section");
if (section)
{
ArConfigArg* arg = section->findParam("ExampleBoolParameter");
if (arg)
{
arg->setBool(!arg->getBool());
if (! config->callProcessFileCallBacks(false, error, 512) )
{
ArLog::log(ArLog::Terse, "configExample: Error processing modified config: %s.", error);
}
else
{
ArLog::log(ArLog::Normal, "configExample: Successfully modified config and invoked callbacks.");
}
}
}
// You can save the configuration as well:
ArLog::log(ArLog::Normal, "configExample: Saving configuration...");
if(!config->writeFile(filename))
{
ArLog::log(ArLog::Terse, "configExample: Error saving configuration to file \"%s\"!", filename);
}
// end of program.
ArLog::log(ArLog::Normal, "configExample: end of program.");
return 0;
}
ArConfig::setSectionComment
void setSectionComment(const char *sectionName, const char *comment)
Sets the comment for a section.
Definition: ArConfig.cpp:727
ArConfigSection::findParam
ArConfigArg * findParam(const char *paramName, bool isAllowStringHolders=false)
Finds a parameter item in this section with the given name. Returns NULL if not found.
Definition: ArConfig.cpp:3209
ArConfig::addProcessFileCB
void addProcessFileCB(ArRetFunctor< bool > *functor, int priority=0)
Adds a callback to be invoked when the configuration is loaded or reloaded.
Definition: ArConfig.cpp:2484
ArConfigArg::setBool
bool setBool(bool val, char *errorBuffer=NULL, size_t errorBufferLen=0, bool doNotSet=false)
Sets the argument value, for bool arguments.
Definition: ArConfigArg.cpp:1365
ArConfig
Stores configuration information which may be read to and from files or other sources.
Definition: ArConfig.h:71
ArConfig::writeFile
bool writeFile(const char *fileName, bool append=false, std::set< std::string > *alreadyWritten=NULL, bool writeExtras=false, std::list< std::string > *sectionsToWrite=NULL, ArPriority::Priority highestPriority=ArPriority::FIRST_PRIORITY, ArPriority::Priority lowestPriority=ArPriority::LAST_PRIORITY)
Write out a config file.
Definition: ArConfig.cpp:1796
ArLog::Terse
Use terse logging.
Definition: ArLog.h:61
ArRetFunctorC< bool, ConfigExample >
ArConfigSection
Represents a section in the configuration.
Definition: ArConfig.h:533
Aria::exit
static void exit(int exitCode=0)
Shutdown all Aria processes/threads, call exit callbacks, and exit the program.
Definition: Aria.cpp:367
ArLog::log
static void log(LogLevel level, const char *str,...)
Log a message, with formatting and variable number of arguments.
Definition: ArLog.cpp:93
ArPriority::TRIVIAL
Advanced items (alias for historic reasons)
Definition: ariaUtil.h:1856
ArPriority::IMPORTANT
Basic things that should be modified to suit.
Definition: ariaUtil.h:1848
ArConfig::callProcessFileCallBacks
bool callProcessFileCallBacks(bool continueOnError, char *errorBuffer=NULL, size_t errorBufferLen=0)
Call the processFileCBs.
Definition: ArConfig.cpp:2594
Aria::init
static void init(SigHandleMethod method=SIGHANDLE_THREAD, bool initSockets=true, bool sigHandleExitNotShutdown=true)
Initialize Aria global data struture and perform OS-specific initialization, including adding OS sign...
Definition: Aria.cpp:128
ArConfigArg
Argument class for ArConfig.
Definition: ArConfigArg.h:75
ArArgumentParser
Parse and store program command-line arguments for use by other ARIA classes.
Definition: ArArgumentParser.h:64
Aria::logOptions
static void logOptions(void)
Logs all the options for the program (Calls all the callbacks added with addLogOptionsCB())
Definition: Aria.cpp:794
ArConfig::parseFile
bool parseFile(const char *fileName, bool continueOnError=false, bool noFileNotFoundMessage=false, char *errorBuffer=NULL, size_t errorBufferLen=0, std::list< std::string > *sectionsToParse=NULL, ArPriority::Priority highestPriority=ArPriority::FIRST_PRIORITY, ArPriority::Priority lowestPriority=ArPriority::LAST_PRIORITY, ArConfigArg::RestartLevel *restartLevelNeeded=NULL)
Parse a config file.
Definition: ArConfig.cpp:1676
ArPriority::NORMAL
Intermediate things that users may want to modify.
Definition: ariaUtil.h:1852
ArConfig::findSection
ArConfigSection * findSection(const char *sectionName) const
Find the section with the given name.
Definition: ArConfig.cpp:2878
Aria::parseArgs
static bool parseArgs(void)
Parses the arguments for the program (calls all the callbacks added with addParseArgsCB())
Definition: Aria.cpp:759
ArConfigArg::getBool
bool getBool(bool *ok=NULL) const
Gets the argument value, for bool arguments.
Definition: ArConfigArg.cpp:1353
ArLog::Normal
Use normal logging.
Definition: ArLog.h:62
ArConfig::addParam
bool addParam(const ArConfigArg &arg, const char *sectionName="", ArPriority::Priority priority=ArPriority::NORMAL, const char *displayHint=NULL, ArConfigArg::RestartLevel restart=ArConfigArg::NO_RESTART)
Command to add a parameter to the given section with given priority.
Definition: ArConfig.cpp:817
Aria::getConfig
static ArConfig * getConfig(void)
Gets the ArConfig for this program.
Definition: Aria.cpp:663