Read configuration files with C++

2020-09-24: These classes were originally developed around 2004 and intended to be a lightweight C / C++ library to read ini-like config files. I seem to remember that at that time, I was able to use them with Microsoft's compiler (cl). I have never used them productively, though. Recently, I received two mails that told me that these classes cannot be compiled. They are right: when trying to compile them with GNU compiler, I get some errors like error: ambiguous overload for 'operator=' (operand types are 'std::__cxx11::string {aka std::__cxx11::basic_string<char>}' and 'const Chameleon') etc.

I have decided to nevertheless create a github repository for these classes. Maybe, someone still finds the idea useful or can improve the code so that it meets its original expectation.

Unfortunately, I am unable to find one of the emails that were sent to me regarding this config file reader. In case you should read this, please forgive me, I would have liked to answer you.

This code was originally hosted on my «other» website adp-gmbh.ch. On the original site, I had the following thank you notes for people than helped me improve the code at that time:

• Dieter Vrancken
• Lars Schouw
• Christian Decker

#ifndef __CONFIG_FILE_H__
#define __CONFIG_FILE_H__

#include <string>
#include <map>

#include "Chameleon.h"

class ConfigFile {
  std::map<std::string,Chameleon> content_;

public:
  ConfigFile(std::string const& configFile);

  Chameleon const& Value(std::string const& section, std::string const& entry) const;

  Chameleon const& Value(std::string const& section, std::string const& entry, double value);
  Chameleon const& Value(std::string const& section, std::string const& entry, std::string const& value);
};

#endif

#include "ConfigFile.h"

#include <fstream>

std::string trim(std::string const& source, char const* delims = " \t\r\n") {
  std::string result(source);
  std::string::size_type index = result.find_last_not_of(delims);
  if(index != std::string::npos)
    result.erase(++index);

  index = result.find_first_not_of(delims);
  if(index != std::string::npos)
    result.erase(0, index);
  else
    result.erase();
  return result;
}

ConfigFile::ConfigFile(std::string const& configFile) {
  std::ifstream file(configFile.c_str());

  std::string line;
  std::string name;
  std::string value;
  std::string inSection;
  int posEqual;
  while (std::getline(file,line)) {

    if (! line.length()) continue;

    if (line[0] == '#') continue;
    if (line[0] == ';') continue;

    if (line[0] == '[') {
      inSection=trim(line.substr(1,line.find(']')-1));
      continue;
    }

    posEqual=line.find('=');
    name  = trim(line.substr(0,posEqual));
    value = trim(line.substr(posEqual+1));

    content_[inSection+'/'+name]=Chameleon(value);
  }
}

Chameleon const& ConfigFile::Value(std::string const& section, std::string const& entry) const {

  std::map<std::string,Chameleon>::const_iterator ci = content_.find(section + '/' + entry);

  if (ci == content_.end()) throw "does not exist";

  return ci->second;
}

Chameleon const& ConfigFile::Value(std::string const& section, std::string const& entry, double value) {
  try {
    return Value(section, entry);
  } catch(const char *) {
    return content_.insert(std::make_pair(section+'/'+entry, Chameleon(value))).first->second;
  }
}

Chameleon const& ConfigFile::Value(std::string const& section, std::string const& entry, std::string const& value) {
  try {
    return Value(section, entry);
  } catch(const char *) {
    return content_.insert(std::make_pair(section+'/'+entry, Chameleon(value))).first->second;
  }
}

/* 
   Chameleon.h

   Copyright (C) 2002-2004 René Nyffenegger

   This source code is provided 'as-is', without any express or implied
   warranty. In no event will the author be held liable for any damages
   arising from the use of this software.

   Permission is granted to anyone to use this software for any purpose,
   including commercial applications, and to alter it and redistribute it
   freely, subject to the following restrictions:

   1. The origin of this source code must not be misrepresented; you must not
      claim that you wrote the original source code. If you use this source code
      in a product, an acknowledgment in the product documentation would be
      appreciated but is not required.

   2. Altered source versions must be plainly marked as such, and must not be
      misrepresented as being the original source code.

   3. This notice may not be removed or altered from any source distribution.

   René Nyffenegger rene.nyffenegger@adp-gmbh.ch
*/

#ifndef CHAMELEON_H__
#define CHAMELEON_H__

#include <string>

class Chameleon {
public:
  Chameleon() {};
  explicit Chameleon(const std::string&);
  explicit Chameleon(double);
  explicit Chameleon(const char*);

  Chameleon(const Chameleon&);
  Chameleon& operator=(Chameleon const&);

  Chameleon& operator=(double);
  Chameleon& operator=(std::string const&);

public:
  operator std::string() const;
  operator double     () const;
private:
  std::string value_;
};

#endif

/* 
   Chameleon.cpp

   Copyright (C) 2002-2004 René Nyffenegger

   This source code is provided 'as-is', without any express or implied
   warranty. In no event will the author be held liable for any damages
   arising from the use of this software.

   Permission is granted to anyone to use this software for any purpose,
   including commercial applications, and to alter it and redistribute it
   freely, subject to the following restrictions:

   1. The origin of this source code must not be misrepresented; you must not
      claim that you wrote the original source code. If you use this source code
      in a product, an acknowledgment in the product documentation would be
      appreciated but is not required.

   2. Altered source versions must be plainly marked as such, and must not be
      misrepresented as being the original source code.

   3. This notice may not be removed or altered from any source distribution.

   René Nyffenegger rene.nyffenegger@adp-gmbh.ch
*/

#include <string>
#include <sstream>

#include "Chameleon.h"

Chameleon::Chameleon(std::string const& value) {
  value_=value;
}

#include <iostream>

Chameleon::Chameleon(const char* c) {
  value_=c;
}

Chameleon::Chameleon(double d) {
  std::stringstream s;
  s<<d;
  value_=s.str();
}

Chameleon::Chameleon(Chameleon const& other) {
  value_=other.value_;
}

Chameleon& Chameleon::operator=(Chameleon const& other) {
  value_=other.value_;
  return *this;
}

Chameleon& Chameleon::operator=(double i) {
  std::stringstream s;
  s << i;
  value_ = s.str();
  return *this;
}

Chameleon& Chameleon::operator=(std::string const& s) {
  value_=s;
  return *this;
}

Chameleon::operator std::string() const {
  return value_;
}

Chameleon::operator double() const {
  return atof(value_.c_str());
}

//
//  g++ ../ConfigFile.cpp ../Chameleon.cpp read-config.txt.cpp -o read-config.txt
//

#include "../ConfigFile.h"

#include <iostream>

int main() {
  ConfigFile cf("config.txt");

  std::string foo;
  std::string water;
  double      four;

  foo   = cf.Value("section_1","foo"  );
  water = cf.Value("section_2","water");
  four  = cf.Value("section_2","four" );

  std::cout << foo   << std::endl;
  std::cout << water << std::endl;
  std::cout << four  << std::endl;

  return 0;
}

[section_1]
foo  = bar
water= h2o

[section_2]
foo  = foo
water= wet
four = 4.2