confparser.h

Go to the documentation of this file.

/* -*- mode:C++; c-basic-offset:4 -*-
     Shore-kits -- Benchmark implementations for Shore-MT

                       Copyright (c) 2007-2009
      Data Intensive Applications and Systems Labaratory (DIAS)
               Ecole Polytechnique Federale de Lausanne

                         All Rights Reserved.

   Permission to use, copy, modify and distribute this software and
   its documentation is hereby granted, provided that both the
   copyright notice and this permission notice appear in all copies of
   the software, derivative works or modified versions, and any
   portions thereof, and that both notices appear in supporting
   documentation.

   This code 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. THE AUTHORS
   DISCLAIM ANY LIABILITY OF ANY KIND FOR ANY DAMAGES WHATSOEVER
   RESULTING FROM THE USE OF THIS SOFTWARE.
*/

// 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") );
//

#ifndef __CONFPARSER_H
#define __CONFPARSER_H

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

using std::string;

struct ConfigOption {
    string _opt_name;

    string _opt_config_entry;

    string _opt_default_value;

    ConfigOption(string name, string entry, string value) {
        _opt_name = name;
        _opt_config_entry = entry;
        _opt_default_value = value;
    }
}; // EOF: ConfigOption


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
    string _fname;

    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;
    }

    // save configuration
    void saveCurrentConfig();

    // 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_) {}
    };
}; // EOF: ConfigFile


/*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 // __CONFPARSER_H