keyValueFile.hpp

#ifndef KERNEL_KEY_VALUE_FILE_HPP
#define KERNEL_KEY_VALUE_FILE_HPP

#include <typeinfo>
#include <string>
#include <sstream>
#include <map>

#include "kernel/kernelException.hpp"

namespace jafar {
  namespace kernel {

#ifndef SWIG // swig ignores KeyValueFile class

    class KeyValueFile {

    private:

      std::string keyValueSeparator;
      char commentPrefix;

      typedef std::map<std::string, std::string> KeyValueMap;

      KeyValueMap keyValue;

    public:

      KeyValueFile(std::string const& keyValueSeparator_ = ":", char commentPrefix_ = '#');

      void readFile(std::string const& filename);

      void writeFile(std::string const& filename);
      
      bool hasKey(std::string const& key) const;

      template<class T>
      void getItem(std::string const& key, T& value) const {

  KeyValueMap::const_iterator it = keyValue.find(key);

  JFR_PRED_ERROR(it != keyValue.end(),
           KernelException,
           KernelException::KEYVALUEFILE_UNKNOWN_KEY,
           "KeyValueFile:getItem: unknown key: " << key);

  std::istringstream ss(it->second);
  ss >> value;

  JFR_IO_STREAM(ss, 
          "KeyValueFile::getItem: invalid value parsing:" << std::endl << 
          "key: " << key << std::endl <<
          "value: " << it->second << std::endl <<
          "value-type: " << typeid(T).name());
      }

      template<class T>
      void getItem(std::string const& key, T& value, std::string default_value) const
      {
        KeyValueMap::const_iterator it = keyValue.find(key);

        std::istringstream ss(it == keyValue.end() ? default_value : it->second);
        ss >> value;

        JFR_IO_STREAM(ss,
                "KeyValueFile::getItem: invalid value parsing:" << std::endl <<
                "key: " << key << std::endl <<
                "value: " << it->second << std::endl <<
                "value-type: " << typeid(T).name());
      }


      template<class T>
      void setItem(std::string const& key, const T& value) {
  std::ostringstream ss;
  ss << value;
  keyValue[key] = ss.str();
      }

    }; // class KeyValueFile

#endif // SWIG

    class KeyValueFileLoad {

    public:

      void load(std::string const& filename,
    std::string const& keyValueSeparator_ = ":", char commentPrefix_ = '#');

    protected:

      virtual ~KeyValueFileLoad() {};

      virtual void loadKeyValueFile(jafar::kernel::KeyValueFile const& keyValueFile) = 0;
      
    }; // class KeyValueFileLoad


    class KeyValueFileSave {

    public:

      void save(std::string const& filename,
    std::string const& keyValueSeparator_ = ":", char commentPrefix_ = '#');

    protected:

      virtual ~KeyValueFileSave() {};

      virtual void saveKeyValueFile(jafar::kernel::KeyValueFile& keyValueFile) = 0;

    }; // class KeyValueFileSave

    class KeyValueFileSaveLoad : public KeyValueFileLoad, public KeyValueFileSave {

    }; // class KeyValueFileSaveLoad

  } // namespace kernel
} // namespace jafar

#endif // KERNEL_KEY_VALUE_FILE_HPP