CRNConfigurationFile.cpp

Go to the documentation of this file.

/* Copyright 2010-2016 CoReNum, INSA-Lyon, ENS-lyon
 *
 * This file is part of libcrn.
 *
 * libcrn is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * libcrn 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.  See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with libcrn.  If not, see <http://www.gnu.org/licenses/>.
 *
 * file: CRNConfigurationFile.cpp
 * \author Yann LEYDIER
 */

#include <CRNUtils/CRNConfigurationFile.h>
#include <CRNString.h>
#include <CRNData/CRNInt.h>
#include <CRNData/CRNReal.h>
#include <CRNException.h>
#include <CRNIO/CRNIO.h>
#include <CRNXml/CRNXml.h>
#include <CRNi18n.h>
#ifdef _MSC_VER
#   include <direct.h> // for getcwd
#   define getcwd _getcwd
#else
#   include <unistd.h>
#endif

using namespace crn;

ConfigurationFile::ConfigurationFile(const String &application_name, const StringUTF8 &file_name, ConfigurationType ctype):
    appname(application_name),
    filename(file_name),
    type(ctype)
{
    if (file_name.IsEmpty())
        filename = application_name.CStr();
}

Path ConfigurationFile::Load()
{
    std::vector<Path> dirs, files;
    char cwd[4096];
    getcwd(cwd, 4096);
    if (type == ConfigurationType::APP)
    {
        dirs.push_back(cwd);
        dirs.push_back(GetUserDirectory());
        dirs.push_back(CRN_CONFIG_PATH);
    }
    else
    {
        dirs.push_back(GetUserDirectory());
        dirs.push_back(cwd);
        dirs.push_back(CRN_CONFIG_PATH);
    }
    files.push_back(filename + ".xml");
    files.push_back("_" + filename + ".xml");
    files.push_back("." + filename + ".xml");

    data.Clear();
    for (auto idir = dirs.begin(); (idir != dirs.end()); ++idir)
    {
        for (auto ifn = files.begin(); (ifn != files.end()); ++ifn)
        {
            Path confname(*idir);
            confname += Path::Separator();
            confname += *ifn;
            CRNdout << confname.CStr() << std::endl;
            try
            {
                data.Load(confname);
                CRNdout << "Configuration loaded from: " << confname.CStr() << std::endl;
                return confname;
            }
            catch (...)
            { }
        }
    }
    return "";
}

Path ConfigurationFile::Save()
{
#ifdef CRN_PF_ANDROID
    const auto fname = filename + ".xml"; // MT : temp or good ?
#else
    const auto fname = GetUserDirectory() / filename + ".xml";
#endif
    try
    {
        data.Save(fname);
        return fname;
    }
    catch (std::exception &ex)
    {
        CRNError(crn::StringUTF8(_("Cannot save configuration file: ")) + ex.what());
        return "";
    }
}

SObject& ConfigurationFile::operator[](const String &key)
{
    return data[key];
}

SObject ConfigurationFile::GetData(const String &key)
{
    auto it(data.Find(key));
    if (it != data.end())
        return it->second;
    else
        return nullptr;
}

SCObject ConfigurationFile::GetData(const String &key) const
{
    Map::const_iterator it(data.Find(key));
    if (it != data.end())
        return it->second;
    else
        return nullptr;
}

Path ConfigurationFile::GetPath(const String &key) const
{
    auto str = std::dynamic_pointer_cast<const Path>(GetData(key));
    if (str)
    {
        if (str->IsRelative())
        {
            char cwd[4096];
            getcwd(cwd, 4096);
            return crn::Path{cwd} / *str;
        }
        else
            return *str;
    }
    throw ExceptionInvalidArgument(key.CStr() + StringUTF8(_(" is not a Path.")));
}

String ConfigurationFile::GetString(const String &key) const
{
    SCString str(std::dynamic_pointer_cast<const String>(GetData(key)));
    if (str)
        return *str;
    throw ExceptionInvalidArgument(key.CStr() + StringUTF8(_(" is not a String.")));
}

StringUTF8 ConfigurationFile::GetStringUTF8(const String &key) const
{
    SCStringUTF8 str(std::dynamic_pointer_cast<const StringUTF8>(GetData(key)));
    if (str)
        return *str;
    throw ExceptionInvalidArgument(key.CStr() + StringUTF8(_(" is not a StringUTF8.")));
}

Prop3 ConfigurationFile::GetProp3(const String &key) const
{
    SCProp3 val(std::dynamic_pointer_cast<const Prop3>(GetData(key)));
    if (val)
        return *val;
    throw ExceptionInvalidArgument(key.CStr() + StringUTF8(_(" is not a Prop3.")));
}

int ConfigurationFile::GetInt(const String &key) const
{
    auto val = std::dynamic_pointer_cast<const Int>(GetData(key));
    if (val)
        return *val;
    throw ExceptionInvalidArgument(key.CStr() + StringUTF8(_(" is not an int.")));
}

double ConfigurationFile::GetDouble(const String &key) const
{
    auto val = std::dynamic_pointer_cast<const Real>(GetData(key));
    if (val)
        return *val;
    throw ExceptionInvalidArgument(key.CStr() + StringUTF8(_(" is not a double.")));
}

Path ConfigurationFile::GetUserDirectory() const
{
#ifdef _MSC_VER
    crn::Path p(getenv("APPDATA"));
#else
    crn::Path p(getenv("HOME"));
    p /= ".config";
#endif
    if (!crn::IO::Access(p, crn::IO::EXISTS))
    {
        try
        {
            crn::IO::Mkdir(p);
        }
        catch (...)
        {
            return "";
        }
    }
    p /= appname;
    if (!crn::IO::Access(p, crn::IO::EXISTS))
    {
        try
        {
            crn::IO::Mkdir(p);
        }
        catch (...)
        {
            return "";
        }
    }
    return p;
}

CRN_BEGIN_CLASS_CONSTRUCTOR(ConfigurationFile)
    String::Initialize();
    StringUTF8::Initialize();
    Path::Initialize();
    Int::Initialize();
    Real::Initialize();
    Prop3::Initialize();
    Map::Initialize();
CRN_END_CLASS_CONSTRUCTOR(ConfigurationFile)