Subversion Repositories SmartDukaan

//  Copyright (c) 2007-2008 Facebook
//
//  Licensed under the Apache License, Version 2.0 (the "License");
//  you may not use this file except in compliance with the License.
//  You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
//  Unless required by applicable law or agreed to in writing, software
//  distributed under the License is distributed on an "AS IS" BASIS,
//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//  See the License for the specific language governing permissions and
//  limitations under the License.
//
// See accompanying file LICENSE or visit the Scribe site at:
// http://developers.facebook.com/scribe/
//
// @author Bobby Johnson
// @author Jason Sobel

#include "common.h"
#include "conf.h"

using namespace boost;
using namespace std;

StoreConf::StoreConf() {
}

StoreConf::~StoreConf() {
}

bool StoreConf::getStore(const std::string& storeName, pStoreConf& _return) {
  store_conf_map_t::iterator iter = stores.find(storeName);
  if (iter != stores.end()) {
    _return = iter->second;
    return true;
  } else {
    return false;
  }
}

void StoreConf::getAllStores(std::vector<pStoreConf>& _return) {
  for (store_conf_map_t::iterator iter = stores.begin(); iter != stores.end(); ++iter) {
    _return.push_back(iter->second);
  }
}

bool StoreConf::getInt(const std::string& intName, long int& _return) {
  string str;
  if (getString(intName, str)) {
    _return = strtol(str.c_str(), NULL, 0);
    return true;
  } else {
    return false;
  }
}

bool StoreConf::getUnsigned(const std::string& intName, unsigned long int& _return) {
  string str;
  if (getString(intName, str)) {
    _return = strtoul(str.c_str(), NULL, 0);
    return true;
  } else {
    return false;
  }
}

bool StoreConf::getString(const std::string& stringName, std::string& _return) {
  string_map_t::iterator iter = values.find(stringName);
  if (iter != values.end()) {
    _return = iter->second;
    return true;
  } else {
    return false;
  }
}

void StoreConf::setString(const std::string& stringName, const std::string& value) {
  values[stringName] = value;
}

void StoreConf::setUnsigned(const std::string& stringName, unsigned long value) {
  ostringstream oss;
  oss << value;
  setString(stringName, oss.str());
}

// reads and parses the config data
void StoreConf::parseConfig(const std::string& filename) {

  queue<string> config_strings;

  if (readConfFile(filename, config_strings)) {
    LOG_OPER("got configuration data from file <%s>", filename.c_str());
  } else {
    std::ostringstream msg;
    msg << "Failed to open config file <" << filename << ">";
    throw std::runtime_error(msg.str());
  }

  parseStore(config_strings, this);
}

// Side-effects:  - removes items from raw_config and adds items to parsed_config
//
// Returns true if a valid entry was found
bool StoreConf::parseStore(queue<string>& raw_config, /*out*/ StoreConf* parsed_config) {

  int store_index = 0; // used to give things named "store" different names

  string line;
  while (!raw_config.empty()) {

    line = raw_config.front();
    raw_config.pop();

    // remove leading and trailing whitespace
    line = trimString(line);

    // remove comment
    size_t comment = line.find_first_of('#');
    if (comment != string::npos) {
      line.erase(comment);
    }

    int length = line.size();
    if (0 >= length) {
      continue;
    }
    if (line[0] == '<') {

      if (length > 1 && line[1] == '/') {
        // This is the end of the current store
        return true;
      }

      // This is the start of a new store
      string::size_type pos = line.find('>');
      if (pos == string::npos) {
        LOG_OPER("Bad config - line %s has a < but not a >", line.c_str());
        continue;
      }
      string store_name = line.substr(1, pos - 1);

      pStoreConf new_store(new StoreConf);
      if (parseStore(raw_config, new_store.get())) {
        if (0 == store_name.compare("store")) {
          // This is a special case for the top-level stores. They share
          // the same name, so we append an index to put them in the map
          std::ostringstream oss;
          oss << store_index;
          store_name += oss.str();
          ++store_index;
        }
        if (parsed_config->stores.find(store_name) != parsed_config->stores.end()) {
          LOG_OPER("Bad config - duplicate store name %s", store_name.c_str());
        }
        parsed_config->stores[store_name] = new_store;
      }
    } else {
      string::size_type eq = line.find('=');
      if (eq == string::npos) {
        LOG_OPER("Bad config - line %s is missing an =", line.c_str());
      } else {
        string arg = line.substr(0, eq);
        string val = line.substr(eq + 1, string::npos);

        // remove leading and trailing whitespace
        arg = trimString(arg);
        val = trimString(val);

        if (parsed_config->values.find(arg) != parsed_config->values.end()) {
          LOG_OPER("Bad config - duplicate key %s", arg.c_str());
        }
        parsed_config->values[arg] = val;
      }
    }
  }
  return true;
}

// trims leading and trailing whitespace from a string
string StoreConf::trimString(const string& str) {
  string whitespace = " \t";
  size_t start      = str.find_first_not_of(whitespace);
  size_t end        = str.find_last_not_of(whitespace);

  if (start != string::npos) {
    return str.substr(start, end - start + 1);
  } else {
    return "";
  }
}

// reads every line from the file and pushes then onto _return
// returns false on error
bool StoreConf::readConfFile(const string& filename, queue<string>& _return) {
  std::string line;
  std::ifstream config_file;

  config_file.open(filename.c_str());
  if (!config_file.good()) {
    return false;
  }

  while (std::getline(config_file, line)) {
    _return.push(line);
  }

  config_file.close();
  return true;
}