ConfigFile.cpp

Go to the documentation of this file.

// ConfigFile.cpp

#include "ConfigFile.hpp"

using std::string;

namespace youbot {

  ConfigFile::ConfigFile(string filename, string filepath, string delimiter,
          string comment, string sectionStartTag, string sectionEndTag, string sentry)
  : myDelimiter(delimiter), myComment(comment), mySectionStartTag(sectionStartTag), mySectionEndTag(sectionEndTag), mySentry(sentry) {

    if(filepath.at(filepath.length()-1) != '/'){
      filepath.append("/");
    }
    filepath.append(filename);

    //Ensure, that we are working with Config Files
    if (filepath.substr(filepath.length() - 4, 4) != ".cfg")
      filepath.append(".cfg");

    //Store for later use
    myFilepath = filepath;
    mySortVectorObj = new SortTreeVector();

    // Construct a ConfigFile, getting keys and values from given file
    std::ifstream in(filepath.c_str());

    if (!in) throw FileNotFoundException(filepath);

    in >> (*this);
  }

  ConfigFile::ConfigFile()
  : myDelimiter(string(1, '=')), myComment(string(1, '#')), mySectionStartTag(string(1, '[')), mySectionEndTag(string(1, ']')) {
    // Construct a ConfigFile without a file; empty
  }

  void ConfigFile::remove(const string& key) {
    // Remove key and its value
    myContents.erase(myContents.find(key));
    return;
  }

  void ConfigFile::remove(const string& sectionKey, const string& key) {
    mapciSect sp = mySectionRelatedContents.find(sectionKey);
    if (sp != mySectionRelatedContents.end()) {
      // Remove key and its value
      myContents = sp->second;

      std::cout << "Size: " << myContents.size() << endl;


      mapi p = myContents.find(key);
      if (p == myContents.end()) throw KeyNotFoundException(key);
      myContents.erase(p);
      mySectionRelatedContents[sectionKey] = myContents;
    }
    return;
  }

  void ConfigFile::save() {

    ofstream outFile(myFilepath.c_str());

    outFile << (*this);

  }

  bool ConfigFile::keyExists(const string& key) const {
    // Indicate whether key is found
    mapci p = myContents.find(key);
    return ( p != myContents.end());
  }

  bool ConfigFile::keyExists(const string& sectionKey, const string& key) {
    mapciSect sp = mySectionRelatedContents.find(sectionKey);
    if (sp == mySectionRelatedContents.end()) {
      return false;
    }

    // Indicate whether key is found
    mapci p = mySectionRelatedContents[sectionKey].find(key);
    return ( p != mySectionRelatedContents[sectionKey].end());
  }

  bool ConfigFile::sectionExists(const string& sectionKey) {

    mapciSect sp = mySectionRelatedContents.find(sectionKey);
    if (sp == mySectionRelatedContents.end()) {
      return false;
    }
    return true;
  }

  /* static */
  void ConfigFile::trim(string& s) {
    // Remove leading and trailing whitespace
    static const char whitespace[] = " \n\t\v\r\f";
    s.erase(0, s.find_first_not_of(whitespace));
    s.erase(s.find_last_not_of(whitespace) + 1U);
  }

  std::ostream & operator<<(std::ostream& os, ConfigFile& cf) {

    for (unsigned int i = 0; i < cf.mySortVector.size(); i++) {

      SortTreeVector currentTreeVector = cf.mySortVector.at(i);
      string currentSector = currentTreeVector.getKey();

      ConfigFile::mapciSect sp = cf.mySectionRelatedContents.find(currentSector.c_str());
      //First section has no empty line
      if (i > 0) {
        os << endl;
      }
      os << "[" << sp->first << "]" << endl;

      cf.myContents = sp->second;

      std::vector<string> contentVector = currentTreeVector.getVector();
      for (unsigned int j = 0; j < contentVector.size(); j++) {
        string currentKey = contentVector.at(j);

        // Save a ConfigFile to os
        ConfigFile::mapci p = cf.myContents.find(currentKey);

        if (p != cf.myContents.end()) {
          os << p->first << " " << cf.myDelimiter << " ";
          os << p->second << std::endl;
        }
      }
    }

    return os;

  }

  std::istream & operator>>(std::istream& is, ConfigFile& cf) {
    // Load a ConfigFile from is
    // Read in keys and values, keeping internal whitespace
    typedef string::size_type pos;
    const string& delim = cf.myDelimiter; // separator
    const string& comm = cf.myComment; // comment
    const string& startTag = cf.mySectionStartTag; // starttag
    const string& endTag = cf.mySectionEndTag; // endtag
    const string& sentry = cf.mySentry; // end of file sentry
    const pos skip = delim.length(); // length of separator



    string nextline = ""; // might need to read ahead to see where value ends
    string sectHeader = "";
    std::vector<string> currentVector; //holds key-value pairs for each section


    while (is || nextline.length() > 0) {

      // Read an entire line at a time
      string line;
      if (nextline.length() > 0) {
        line = nextline; // we read ahead; use it now
        nextline = "";
      } else {
        std::getline(is, line);
      }

      // Ignore comments
      line = line.substr(0, line.find(comm));

      string lncopy = line;
      ConfigFile::trim(lncopy);
      //Sectionheader found
      if (lncopy.substr(0, 1) == startTag && lncopy.substr(lncopy.length() - 1, 1) == endTag) {

        sectHeader = lncopy.substr(1, lncopy.length() - 2);
        ConfigFile::trim(sectHeader);
        //New instance for each section
        string currentKey = cf.mySortVectorObj->getKey();

        if (!cf.mySortVectorObj || sectHeader != currentKey) {

          if (currentVector.size() > 0) {
            cf.mySortVectorObj->setVector(currentVector);
            cf.mySortVector.push_back(*cf.mySortVectorObj);

          }
          cf.mySortVectorObj = new SortTreeVector;
          //Create a new vector for KeyValue-Pairs
          currentVector = cf.mySortVectorObj->getVector();
          cf.mySortVectorObj->setKey(sectHeader);
        }

        cf.mySectionRelatedContents[sectHeader] = cf.myContents;
        continue;
      }

      // Check for end of file sentry
      if (sentry != "" && line.find(sentry) != string::npos) return is;

      // Parse the line if it contains a delimiter
      pos delimPos = line.find(delim);
      if (delimPos < string::npos) {
        // Extract the key
        string key = line.substr(0, delimPos);
        line.replace(0, delimPos + skip, "");

        // See if value continues on the next line
        // Stop at blank line, next line with a key, end of stream,
        // or end of file sentry
        bool terminate = false;
        while (!terminate && is) {
          std::getline(is, nextline);
          terminate = true;

          string nlcopy = nextline;
          ConfigFile::trim(nlcopy);
          if (nlcopy == "") continue;

          nextline = nextline.substr(0, nextline.find(comm));
          if (nextline.find(delim) != string::npos)
            continue;
          if (sentry != "" && nextline.find(sentry) != string::npos)
            continue;

          nlcopy = nextline;
          ConfigFile::trim(nlcopy);
          if (nlcopy != "") line += "\n";
          line += nextline;
          terminate = false;
        }

        // Store key and value
        ConfigFile::trim(key);
        ConfigFile::trim(line);

        currentVector.push_back(key);

        cf.mySectionRelatedContents[sectHeader][key] = line; // overwrites if key is repeated
      }
    }

    //finally get the last things done
    if (currentVector.size() > 0) {
      cf.mySortVectorObj->setVector(currentVector);
      cf.mySortVector.push_back(*cf.mySortVectorObj);
    }


    return is;
  }

} // namespace youbot