ArConfig.h

/*
MobileRobots Advanced Robotics Interface for Applications (ARIA)
Copyright (C) 2004, 2005 ActivMedia Robotics LLC
Copyright (C) 2006, 2007 MobileRobots Inc.

     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 
MobileRobots for information about a commercial version of ARIA at 
robots@mobilerobots.com or 
MobileRobots Inc, 19 Columbia Drive, Amherst, NH 03031; 800-639-9481
*/

#ifndef ARCONFIG_H
#define ARCONFIG_H

#include "ArConfigArg.h"
#include "ArFileParser.h"
#include <set>

class ArArgumentBuilder;
class ArConfigSection;


class ArConfig
{
public:
  AREXPORT ArConfig(const char *baseDirectory = NULL, 
                        bool noBlanksBetweenParams = false,
                        bool ignoreBounds = false,
                        bool failOnBadSection = false,
                        bool saveUnknown = true);

  AREXPORT ArConfig(const ArConfig &config);

  AREXPORT ArConfig &operator=(const ArConfig &config);

  AREXPORT virtual ~ArConfig();

  AREXPORT virtual void setConfigName(const char *configName,
                                      const char *robotName = NULL);

  AREXPORT bool parseFile(const char *fileName, 
                          bool continueOnError = false,
                                bool noFileNotFoundMessage = false, 
                                char *errorBuffer = NULL,
                                size_t errorBufferLen = 0,
                          std::list<std::string> *sectionsToParse = NULL);

  AREXPORT bool writeFile(const char *fileName, 
                         bool append = false,
                               std::set<std::string> *alreadyWritten = NULL,
                               bool writePriorities = false,
                         std::list<std::string> *sectionsToWrite = NULL);
                         
  AREXPORT bool addParam(const ArConfigArg &arg, 
                         const char *sectionName = "", 
             ArPriority::Priority priority = ArPriority::NORMAL,
                         const char *displayHint = NULL);

  AREXPORT bool addComment(const char *comment, const char *sectionName = "", 
               ArPriority::Priority priority = ArPriority::NORMAL);
  AREXPORT void setSectionComment(const char *sectionName, 
                  const char *comment);
  AREXPORT void useArgumentParser(ArArgumentParser *parser);

  AREXPORT virtual bool processFile(void) { return true; }
  AREXPORT void addProcessFileCB(ArRetFunctor<bool> *functor, 
                 int priority = 0);
  AREXPORT void addProcessFileWithErrorCB(
      ArRetFunctor2<bool, char *, size_t> *functor, 
      int priority = 0);
  AREXPORT void remProcessFileCB(ArRetFunctor<bool> *functor);
  AREXPORT void remProcessFileCB(
      ArRetFunctor2<bool, char *, size_t> *functor);
  AREXPORT bool callProcessFileCallBacks(bool continueOnError,
                     char *errorBuffer = NULL,
                     size_t errorBufferLen = 0);
  AREXPORT bool parseArgument(ArArgumentBuilder *arg, 
                  char *errorBuffer = NULL,
                  size_t errorBufferLen = 0);
  AREXPORT bool parseSection(ArArgumentBuilder *arg, 
                  char *errorBuffer = NULL,
                  size_t errorBufferLen = 0);
  AREXPORT bool parseUnknown(ArArgumentBuilder *arg, 
                 char *errorBuffer = NULL,
                 size_t errorBufferLen = 0);
  AREXPORT const char *getBaseDirectory(void) const;
  AREXPORT void setBaseDirectory(const char *baseDirectory);
  AREXPORT const char *getFileName(void) const;
  AREXPORT void setNoBlanksBetweenParams(bool noBlanksBetweenParams);

  AREXPORT bool getNoBlanksBetweenParams(void);

  AREXPORT bool parseArgumentParser(ArArgumentParser *parser,
                    bool continueOnError = false,
                    char *errorBuffer = NULL,
                    size_t errorBufferLen = 0);

  AREXPORT std::list<ArConfigSection *> *getSections(void);

  AREXPORT ArConfigSection *findSection(const char *sectionName) const;
  AREXPORT void setProcessFileCallbacksLogLevel(ArLog::LogLevel level) 
    {  myProcessFileCallbacksLogLevel = level; }
  AREXPORT ArLog::LogLevel getProcessFileCallbacksLogLevel(void)
    {  return myProcessFileCallbacksLogLevel; }
  AREXPORT void setSaveUnknown(bool saveUnknown) 
    { mySaveUnknown = saveUnknown; }
  AREXPORT bool getSaveUnknown(void) { return mySaveUnknown; }
  AREXPORT void clearSections(void);
  AREXPORT void clearAll(void);
  AREXPORT bool addSectionFlags(const char *sectionName, 
                const char *flags);
  AREXPORT bool remSectionFlag(const char *sectionName, 
                   const char *flag);

  AREXPORT void clearAllValueSet(void);
  AREXPORT void removeAllUnsetValues(void);

  AREXPORT void log(bool isSummary = true);

protected:
  AREXPORT void writeSection(ArConfigSection *section, FILE *file,
                 std::set<std::string> *alreadyWritten,
                 bool writePriorities);

  void copySectionsToParse(std::list<std::string> *from);

  class ProcessFileCBType
  {
    public:
    ProcessFileCBType(
        ArRetFunctor2<bool, char *, size_t> *functor)
    {
      myCallbackWithError = functor;
      myCallback = NULL;
    }
    ProcessFileCBType(ArRetFunctor<bool> *functor)
    {
      myCallbackWithError = NULL;
      myCallback = functor;
    }
    ~ProcessFileCBType() {}
    bool call(char *errorBuffer, size_t errorBufferLen) 
    { 
      if (myCallbackWithError != NULL) 
    return myCallbackWithError->invokeR(errorBuffer, errorBufferLen);
      else if (myCallback != NULL) 
    return myCallback->invokeR(); 
      // if we get here there's a problem
      ArLog::log(ArLog::Terse, "ArConfig: Horrible problem with process callbacks");
      return false;
    }
    bool haveFunctor(ArRetFunctor2<bool, char *, size_t> *functor)
    { 
      if (myCallbackWithError == functor) 
    return true; 
      else 
    return false; 
    }
    bool haveFunctor(ArRetFunctor<bool> *functor)
    { 
      if (myCallback == functor) 
    return true; 
      else 
    return false; 
    }
    const char *getName(void) 
    { 
      if (myCallbackWithError != NULL)
    return myCallbackWithError->getName();
      else if (myCallback != NULL)
    return myCallback->getName();
      // if we get here there's a problem
      ArLog::log(ArLog::Terse, "ArConfig: Horrible problem with process callback names");
      return NULL;
    }
    protected:
    ArRetFunctor2<bool, char *, size_t> *myCallbackWithError;
    ArRetFunctor<bool> *myCallback;
  };
  void addParserHandlers(void);

  std::string myRobotName;
  std::string myConfigName;
  std::string myLogPrefix;

  ArArgumentParser *myArgumentParser;
  std::multimap<int, ProcessFileCBType *> myProcessFileCBList;
  bool myNoBlanksBetweenParams;
  std::string mySection;
  std::list<std::string> *mySectionsToParse;
  bool mySectionBroken;
  bool mySectionIgnored;
  bool myUsingSections;
  std::string myFileName;
  std::string myBaseDirectory;
  ArFileParser myParser;
  bool myIgnoreBounds;
  bool myFailOnBadSection;
  bool myDuplicateParams;
  bool mySaveUnknown;
  ArLog::LogLevel myProcessFileCallbacksLogLevel;
  // our list of sections which has in it the argument list for each
  std::list<ArConfigSection *> mySections;
  // callback for the file parser
  ArRetFunctor3C<bool, ArConfig, ArArgumentBuilder *, char *, size_t> myParserCB;
  // callback for the section in the file parser
  ArRetFunctor3C<bool, ArConfig, ArArgumentBuilder *, char *, size_t> mySectionCB;
  // callback for the unknown param (or wahtever) file parser
  ArRetFunctor3C<bool, ArConfig, ArArgumentBuilder *, char *, size_t> myUnknownCB;
};


class ArConfigSection
{
public:
  AREXPORT ArConfigSection(const char *name = NULL, 
                           const char *comment = NULL);
  AREXPORT virtual ~ArConfigSection();
  AREXPORT ArConfigSection(const ArConfigSection &section);
  AREXPORT ArConfigSection &operator=(const ArConfigSection &section);

  const char *getName(void) const { return myName.c_str(); }

  const char *getComment(void) const { return myComment.c_str(); }
  const char *getFlags(void) const { return myFlags->getFullString(); }
  AREXPORT bool hasFlag(const char *flag) const;
  std::list<ArConfigArg> *getParams(void) { return &myParams; }
  void setName(const char *name) { myName = name; }
  void setComment(const char *comment) { myComment = comment; }
  bool addFlags(const char *flags) { myFlags->add(flags); return true; }
  AREXPORT bool remFlag(const char *dataFlag);
  AREXPORT ArConfigArg *findParam(const char *paramName); 
  AREXPORT bool remStringHolder(const char *paramName); 

protected:
  std::string myName;
  std::string myComment;
  ArArgumentBuilder *myFlags;
  std::list<ArConfigArg> myParams;
};

#endif // ARCONFIG

---