bluecore/engine/Utilities/CfgParser.cpp

#include "CfgParser.h"
#include "StringUtilities.h"

#include <fstream>

using namespace std;

namespace BlueCore {

void CfgParser::parseFile (const std::string& filename)
{
	ifstream file (filename.c_str(), ios::in);
  std::string line;

  while (file.good())
  {
    getline (file, line);
    parseLine (line);
  }
}



void CfgParser::parseLine (const std::string& line)
{
	std::string::size_type i (line.find_first_of ('='));

	if (i == std::string::npos)
		return;

	std::string key = trim (string (line, 0, i-1));
	std::string value = trim (string (line, i+1));

	_Pairs[key] = value;
}



void CfgParser::parse (const char* buffer, unsigned int length)
{
  const char* ptr = buffer;
  const char* end = buffer + length; 
  unsigned int l = 0;
  
  while (ptr < end)
  {
    // find end of line
    while (ptr[l] != '\n')
    {
      l++;
      if (ptr + l >= end)
        break;
    }
    
    parseLine (string(ptr, l));
    ptr += l+1;
    l = 0;
  }
}



double CfgParser::get (const std::string& key, double defaultValue)
{
  double value;

  if (getDouble (key, value) == false)
    return defaultValue;
  else
    return value;
}



bool CfgParser::getDouble (const std::string& key, double& value)
{
	std::map<std::string, std::string>::const_iterator result;
	result = _Pairs.find (key);

	if (result != _Pairs.end())
	{
		value = atof (result->second.c_str());
    return true;
	}
  else
    return false;
}



int CfgParser::get (const std::string& key, int defaultValue)
{
  int value;

  if (getInteger (key, value) == false)
    return defaultValue;
  else
    return value;
}



bool CfgParser::getInteger (const std::string& key, int& value)
{
	std::map<std::string, std::string>::const_iterator result;
	result = _Pairs.find (key);

	if (result != _Pairs.end())
	{
		value = atoi (result->second.c_str());
    return true;
	}
  else
    return false;
}


bool CfgParser::get (const std::string& key, bool defaultValue)
{
  bool value;

  if (getBoolean (key, value) == false)
    return defaultValue;
  else
    return value;
}



bool CfgParser::getBoolean (const std::string& key, bool& value)
{
	std::map<std::string, std::string>::const_iterator result;
	result = _Pairs.find (key);

	if (result != _Pairs.end())
	{
    value = false;

    if (result->second == "true")
      value = true;
    else if (result->second == "1")
      value = true;
    else if (result->second == "yes")
      value = true;

    return true;
	}
  else
    return false;
}



std::string CfgParser::get (const std::string& key, std::string defaultValue)
{
  std::string value;

  if (getString (key, value) == false)
    return defaultValue;
  else
    return value;
}



bool CfgParser::getString (const std::string& key, std::string& value)
{
	std::map<std::string, std::string>::const_iterator result;
	result = _Pairs.find (key);

	if (result != _Pairs.end())
	{
		value = result->second;
    return true;
	}
  else
    return false;
}



bool CfgParser::getStrings (const std::string& key, std::vector<string>& strings)
{
  std::map<std::string, std::string>::const_iterator result;
  result = _Pairs.find (key);

  if (result != _Pairs.end())
  {
    explode (result->second, strings, true, ",");
    return true;
  }
  else
    return false;
}


} // namespace BlueCore