ArConfig.h

/*
ActivMedia Robotics Interface for Applications (ARIA)
Copyright (C) 2004,2005 ActivMedia Robotics, LLC


     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 
ActivMedia Robotics for information about a commercial version of ARIA at 
robots@activmedia.com or 
ActivMedia Robotics, 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:
  ArConfig(const char *baseDirectory = NULL, 
                    bool noBlanksBetweenParams = false,
                    bool ignoreBounds = false,
                    bool failOnBadSection = false);
  ArConfig(const ArConfig &config);

  ArConfig &operator=(const ArConfig &config);

  virtual ~ArConfig();
  bool parseFile(const char *fileName, bool continueOnError = false,
                          bool noFileNotFoundMessage = false, 
                          char *errorBuffer = NULL,
                          size_t errorBufferLen = 0);
  bool writeFile(const char *fileName, bool append = false,
                          std::set<std::string> *alreadyWritten = NULL,
                          bool writePriorities = false);
  bool addParam(const ArConfigArg &arg, const char *sectionName = "", 
                         ArPriority::Priority priority = ArPriority::NORMAL);
  bool addComment(const char *comment, const char *sectionName = "", 
                           ArPriority::Priority priority = ArPriority::NORMAL);
  void setSectionComment(const char *sectionName, 
                                  const char *comment);
  void useArgumentParser(ArArgumentParser *parser);

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

  bool getNoBlanksBetweenParams(void);

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

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

  ArConfigSection *findSection(const char *sectionName) const;
  void setProcessFileCallbacksLogLevel(ArLog::LogLevel level) 
    {  myProcessFileCallbacksLogLevel = level; }
  ArLog::LogLevel getProcessFileCallbacksLogLevel(void)
    {  return myProcessFileCallbacksLogLevel; }
  void clearSections(void);
  void clearAll(void);
protected:
  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);
  ArArgumentParser *myArgumentParser;
  std::multimap<int, ProcessFileCBType *> myProcessFileCBList;
  bool myNoBlanksBetweenParams;
  std::string mySection;
  bool mySectionBroken;
  bool myUsingSections;
  std::string myFileName;
  std::string myBaseDirectory;
  ArFileParser myParser;
  bool myIgnoreBounds;
  bool myFailOnBadSection;
  bool myDuplicateParams;
  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;
};


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

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

  const char *getComment(void) const { return myComment.c_str(); }
  std::list<ArConfigArg> *getParams(void) { return &myParams; }
  void setName(const char *name) { myName = name; }
  void setComment(const char *comment) { myComment = comment; }

  ArConfigArg *findParam(const char *paramName); 

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

#endif // ARCONFIG

---