source: observatorio/simulacion/SimEscenariosEconomicos-Qtgui/configuration.C @ e98f4d1

/*
  Copyright (C) 2012
  Alejandro Mujica (amujica@cenditel.gob.ve)
  Erwin Paredes (eparedes@cenditel.gob.ve)
  José Ruiz (jruiz@cenditel.gob.ve)
  Rodolfo Rangel (rrangel@cenditel.gob.ve)
  Julie Vera (jvera@cenditel.gob.ve)

  CENDITEL Fundación Centro Nacional de Desarrollo e Investigación en
  Tecnologías Libres

  Este programa es software libre; Usted puede usarlo bajo los términos de la
  licencia de software GPL versión 2.0 de la Free Software Foundation.

  Este programa se distribuye con la esperanza de que sea útil, pero SIN
  NINGUNA GARANTÍA; tampoco las implícitas garantías de MERCANTILIDAD o
  ADECUACIÓN A UN PROPÓSITO PARTICULAR.
  Consulte la licencia GPL para más detalles. Usted debe recibir una copia
  de la GPL junto con este programa; si no, escriba a la Free Software
  Foundation Inc. 51 Franklin Street,5 Piso, Boston, MA 02110-1301, USA.
*/

/*
  Este archivo contiene la implementación de la clase Configuration.

  Autor: Alejandro J. Mujica
  Fecha:
*/

# include <configuration.H>
# include <fstream>

const std::string Configuration::APPLICATION_PATH = "";

const std::string Configuration::APPLICATION_NAME = "ecosim";

const std::string Configuration::DIR_NAME =
        "." + Configuration::APPLICATION_NAME;

const std::string Configuration::XML_DIR_NAME =
        Configuration::DIR_NAME + "/xml";

const std::string Configuration::DOT_DIR_NAME =
        Configuration::DIR_NAME + "/dot";

const std::string Configuration::SVG_DIR_NAME =
        Configuration::DIR_NAME + "/svg";

const std::string Configuration::CONFIGURATION_FILE_NAME = "conf";

const std::string Configuration::ROOTS_FILE_NAME = "roots";

const std::string Configuration::GRAPH_FILE_NAME = "graph";

const std::string Configuration::SIMULATION_FILE_NAME = "simulation";

const std::string Configuration::ALTER_GRAPH_FILE_NAME = "alter";

const std::string Configuration::GRAPH_BUILDER_COMMAND =
        APPLICATION_PATH + APPLICATION_NAME + "_graph_builder";

const std::string Configuration::SIMULATION_COMMAND =
        APPLICATION_PATH + APPLICATION_NAME + "_simulator";

const std::string Configuration::DB_FILE_NAME = "dbserver";

const std::string Configuration::DFT_HOST = "localhost";

const std::string Configuration::DFT_PORT = "5432";

const std::string Configuration::DFT_DATA_BASE = "ecosim_datos_prueba";

const std::string Configuration::DFT_USER = "ecosim";

const std::string Configuration::DFT_PASSWORD = "ecosim";


std::unique_ptr <Configuration> Configuration::instance;

Configuration::Configuration() {

    QDir dir(QDir::home());

    if (not dir.exists(DIR_NAME.c_str())) {

        dir.mkdir(DIR_NAME.c_str());
        dir.mkdir(XML_DIR_NAME.c_str());
        dir.mkdir(DOT_DIR_NAME.c_str());
        dir.mkdir(SVG_DIR_NAME.c_str());
    }

    configurationFileName = QDir::homePath().toStdString() + "/" + DIR_NAME +
            "/" + CONFIGURATION_FILE_NAME;

    readFile();
}

void Configuration::readFile() {

    std::ifstream file;

    file.open(configurationFileName.c_str(), std::ios::binary);

    if (not file)  {
        restoreDefaultValues();
        return;
    }

    size_t size;

    file.read(reinterpret_cast <char *>(&size), sizeof(size_t));
    char host[size];
    file.read(host, size);
    this->host = host;

    file.read(reinterpret_cast <char *>(&size), sizeof(size_t));
    char port[size];
    file.read(port, size);
    this->port = port;

    file.read(reinterpret_cast <char *>(&size), sizeof(size_t));
    char dataBase[size];
    file.read(dataBase, size);
    this->dataBase = dataBase;

    file.read(reinterpret_cast <char *>(&size), sizeof(size_t));
    char user[size];
    file.read(user, size);
    this->user = user;

    file.read(reinterpret_cast <char *>(&size), sizeof(size_t));
    char password[size];
    file.read(password, size);
    this->password = password;

    file.close();
}

void Configuration::writeFile() {

    std::ofstream file;

    file.open(configurationFileName.c_str(), std::ios::binary);

    size_t size;

    size = host.size() + 1;
    file.write(reinterpret_cast <char *>(&size), sizeof(size_t));
    file.write(host.c_str(), size);

    size = port.size() + 1;
    file.write(reinterpret_cast <char *>(&size), sizeof(size_t));
    file.write(port.c_str(), size);

    size = dataBase.size() + 1;
    file.write(reinterpret_cast <char *>(&size), sizeof(size_t));
    file.write(dataBase.c_str(), size);

    size = user.size() + 1;
    file.write(reinterpret_cast <char *>(&size), sizeof(size_t));
    file.write(user.c_str(), size);

    size = password.size() + 1;
    file.write(reinterpret_cast <char *>(&size), sizeof(size_t));
    file.write(password.c_str(), size);

    file.close();
}

Configuration & Configuration::getInstance() {

    if (instance.get() == NULL)
        instance = std::unique_ptr <Configuration> (new Configuration);

    return *instance;
}

void Configuration::setValuesDefault() {
    writeFile();
}

const std::string & Configuration::getHost() const {
    return host;
}

void Configuration::setHost(const std::string & host) {
    this->host = host;
}

void Configuration::setHost(std::string && host) {
    this->host = std::move(host);
}

const std::string &Configuration::getPort() const {
    return port;
}

void Configuration::setPort(const std::string & port) {
    this->port = port;
}

void Configuration::setPort(std::string && port) {
    this->port = std::move(port);
}

const std::string & Configuration::getDataBase() const {
    return dataBase;
}

void Configuration::setDataBase(std::string && dataBase) {
    this->dataBase = std::move(dataBase);
}

void Configuration::setDataBase(const std::string & dataBase) {
    this->dataBase = dataBase;
}

const std::string & Configuration::getUser() const {
    return user;
}

void Configuration::setUser(const std::string & user) {
    this->user = user;
}

void Configuration::setUser(std::string && user) {
    this->user = std::move(user);
}

const std::string & Configuration::getPassword() const {
    return password;
}

void Configuration::setPassword(const std::string & password) {
    this->password = password;
}

void Configuration::setPassword(std::string && password) {
    this->password = std::move(password);
}

const std::string & Configuration::getApplicationName() const {
    return APPLICATION_NAME;
}

const std::string & Configuration::getConfigurationFileName() const {
    return configurationFileName;
}

const std::string & Configuration::getRootsFileName() const {
    return ROOTS_FILE_NAME;
}

const std::string & Configuration::getGraphFileName() const {
    return GRAPH_FILE_NAME;
}

const std::string & Configuration::getSimulationFileName() const {
    return SIMULATION_FILE_NAME;
}

const std::string & Configuration::getAlterFileName() const {
    return ALTER_GRAPH_FILE_NAME;
}

const std::string &Configuration::getGraphBuilderCommand() const {
    return GRAPH_BUILDER_COMMAND;
}

const std::string & Configuration::getSimulationCommand() const {
    return SIMULATION_COMMAND;
}

const std::string & Configuration::getDirName() const {
    return DIR_NAME;
}

const std::string & Configuration::getXmlDirName() const {
    return XML_DIR_NAME;
}

const std::string & Configuration::getDotDirName() const {
    return DOT_DIR_NAME;
}

const std::string & Configuration::getSvgDirName() const {
    return SVG_DIR_NAME;
}

const std::string Configuration::getDbFileName() const {
    return QDir::homePath().toStdString()  + "/"
            + DIR_NAME + "/" + DB_FILE_NAME;
}

void Configuration::createDbFile() {

    std::string fileName = getDbFileName();

    std::ofstream file(fileName.c_str());

    file << host << std::endl;
    file << port << std::endl;
    file << dataBase << std::endl;
    file << user << std::endl;
    file << password;

    file.close();
}

void Configuration::removeDbFile() {
    QDir().remove(getDbFileName().c_str());
}

void Configuration::restoreDefaultValues() {

    host = DFT_HOST;
    port = DFT_PORT;
    dataBase = DFT_DATA_BASE;
    user = DFT_USER;
    password = DFT_PASSWORD;

    writeFile();
}