// ConfigFile.h
// Class for reading named values from configuration files
// Richard J. Wagner  v2.1  24 May 2004  wagnerr@umich.edu

// Copyright (c) 2004 Richard J. Wagner
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
// IN THE SOFTWARE.

// Typical usage
// -------------
//
// Given a configuration file "settings.inp":
//   atoms  = 25
//   length = 8.0  # nanometers
//   name = Reece Surcher
//
// Named values are read in various ways, with or without default values:
//   ConfigFile config ("settings.inp");
//   int atoms = config.read<int>( "atoms");
//   double length = config.read ("length", 10.0);
//   string author, title;
//   config.readInto (author, "name");
//   config.readInto (title, "title", string("Untitled"));
//
// See file example.cpp for more examples.

#ifndef CONFIGFILE_H
#define CONFIGFILE_H

#include <string>
#include <map>
#include <iostream>
#include <fstream>
#include <sstream>

using std::string;

class ConfigFile {
// Data
protected:
  string                  myDelimiter;  // separator between key and value
  string                  myComment;    // separator between value and comments
  string                  mySentry;     // optional string to signal end of file
  std::map<string,string> myContents;   // extracted keys and values

  typedef std::map<string,string>::iterator mapi;
  typedef std::map<string,string>::const_iterator mapci;

// Methods
public:
  ConfigFile (string filename,
              string delimiter = "=",
              string comment = "#",
              string sentry = "EndConfigFile");
  ConfigFile();

  // Search for key and read value or optional default value
  template<class T> T     read (const string& key) const;  // call as read<T>
  template<class T> T     read (const string& key, const T& value) const;
  template<class T> bool  readInto (T& var, const string& key) const;
  template<class T> bool  readInto (T& var, const string& key, const T& value) const;

  // Modify keys and values
  template<class T> void  add (string key, const T& value);
  void                    remove (const string& key);

  // Check whether key exists in configuration
  bool keyExists (const string& key) const;

  // Check or change configuration syntax
  string getDelimiter() const { return myDelimiter; }
  string getComment() const { return myComment; }
  string getSentry() const { return mySentry; }
  string setDelimiter (const string& s)
    { string old = myDelimiter;  myDelimiter = s;  return old; }
  string setComment (const string& s)
    { string old = myComment;  myComment = s;  return old; }

  // Write or read configuration
  friend std::ostream& operator<<(std::ostream& os, const ConfigFile& cf);
  friend std::istream& operator>>(std::istream& is, ConfigFile& cf);

protected:
  template<class T> static string T_as_string (const T& t);
  template<class T> static T      string_as_T (const string& s);
  static void                     trim (string& s);


// Exception types
public:
  struct file_not_found {
    string filename;
    file_not_found (const string& filename_ = string())
      : filename(filename_) {} };
  struct key_not_found {  // thrown only by T read(key) variant of read()
    string key;
    key_not_found (const string& key_ = string())
      : key(key_) {} };
};


/* static */
template<class T>
string ConfigFile::T_as_string (const T& t)
{
  // Convert from a T to a string
  // Type T must support << operator
  std::ostringstream ost;

  ost << t;
  return ost.str();
}


/* static */
template<class T>
T ConfigFile::string_as_T (const string& s)
{
  // Convert from a string to a T
  // Type T must support >> operator
  T t;
  std::istringstream ist (s);

  ist >> t;
  return t;
}


/* static */
template<>
inline string ConfigFile::string_as_T<string>(const string& s)
{
  // Convert from a string to a string
  // In other words, do nothing
  return s;
}


/* static */
template<>
inline bool ConfigFile::string_as_T<bool>(const string& s)
{
  // Convert from a string to a bool
  // Interpret "false", "F", "no", "n", "0" as false
  // Interpret "true", "T", "yes", "y", "1", "-1", or anything else as true
  bool b = true;
  string sup = s;

  for (string::iterator p = sup.begin();  p != sup.end();  ++p)
    *p = toupper (*p);  // make string all caps
  if (    sup==string ("FALSE")  ||  sup==string ("F")
      ||  sup==string ("NO")  ||  sup==string ("N")
      ||  sup==string ("0")  ||  sup==string ("NONE"))
    b = false;
  return b;
}


template<class T>
T ConfigFile::read (const string& key) const
{
  // Read the value corresponding to key
  mapci p = myContents.find (key);
  if (p == myContents.end()) throw key_not_found (key);
  return string_as_T<T>(p->second);
}


template<class T>
T ConfigFile::read (const string& key, const T& value) const
{
  // Return the value corresponding to key or given default value
  // if key is not found
  mapci p = myContents.find (key);
  if (p == myContents.end()) return value;
  return string_as_T<T>(p->second);
}


template<class T>
bool ConfigFile::readInto (T& var, const string& key) const
{
  // Get the value corresponding to key and store in var
  // Return true if key is found
  // Otherwise leave var untouched
  mapci p = myContents.find (key);
  bool found = (p != myContents.end());

  if (found) var = string_as_T<T>(p->second);
  return found;
}


template<class T>
bool ConfigFile::readInto (T& var, const string& key, const T& value) const
{
  // Get the value corresponding to key and store in var
  // Return true if key is found
  // Otherwise set var to given default
  mapci p = myContents.find (key);
  bool found = (p != myContents.end());

  if (found)
    var = string_as_T<T>(p->second);
  else
    var = value;
  return found;
}


template<class T>
void ConfigFile::add (string key, const T& value)
{
  // Add a key with given value
  string v = T_as_string (value);

  trim (key);
  trim (v);
  myContents[key] = v;
  return;
}

#endif  // CONFIGFILE_H

// Release notes:
// v1.0  21 May 1999
//   + First release
//   + Template read() access only through non-member readConfigFile()
//   + ConfigurationFileBool is only built-in helper class
//
// v2.0  3 May 2002
//   + Shortened name from ConfigurationFile to ConfigFile
//   + Implemented template member functions
//   + Changed default comment separator from % to #
//   + Enabled reading of multiple-line values
//
// v2.1  24 May 2004
//   + Made template specializations inline to avoid compiler-dependent linkage
//   + Allowed comments within multiple-line values
//   + Enabled blank line termination for multiple-line values
//   + Added optional sentry to detect end of configuration file
//   + Rewrote messy trimWhitespace() function as elegant trim()