xdgcfg.hpp

/*  Public Domain / CC-0
 *  Author: tastytea <tastytea@tastytea.de>
 */

#ifndef XDGCFG_HPP
#define XDGCFG_HPP

#if __cplusplus >= 201703L
    #include <filesystem>
#else
    #include <experimental/filesystem>
#endif
#include <string>
#include <iostream>
#include <cstdint>
#include <libconfig.h++>
#include <basedir.h>

#if __cplusplus >= 201703L
    namespace fs = std::filesystem;
#else
    namespace fs = std::experimental::filesystem;
#endif
using std::string;
using std::uint_fast8_t;
using std::cerr;
using std::endl;

class xdgcfg
{
public:
    explicit xdgcfg(const string &filename, const string &subdir = "")
        : _cfg()
        , _verbose(false)
    {
        xdgHandle xdg;
        xdgInitHandle(&xdg);
        _filepath = xdgConfigHome(&xdg);
        xdgWipeHandle(&xdg);

        if (!subdir.empty())
        {
            _filepath /= subdir;
        }
        if (!fs::exists(_filepath))
        {
            fs::create_directories(_filepath);
        }
        _filepath /= filename;
    }

    uint_fast8_t read()
    {
        try
        {
            _cfg.readFile(_filepath.c_str());
        }
        catch (const libconfig::FileIOException &e)
        {
            if (_verbose)
            {
                cerr << "I/O error while reading " << _filepath
                     << " - " << e.what() << endl;
            }
            return 1;
        }
        catch (const libconfig::ParseException &e)
        {
            if (_verbose)
            {
                cerr << "Parse error at " << e.getFile() << ":" << e.getLine()
                     << " - " << e.getError() << endl;
            }
            return 2;
        }

        return 0;
    }

    bool write()
    {
        try
        {
            _cfg.writeFile(_filepath.c_str());
        }
        catch (const libconfig::FileIOException &e)
        {
            if (_verbose)
            {
                cerr << "I/O error while writing " << _filepath
                     << " - " << e.what() << endl;
            }
            return false;
        }

        return true;
    }

    libconfig::Config &get_cfg()
    {
        return _cfg;
    }

    const fs::path get_filepath() const
    {
        return _filepath;
    }

    void set_verbose(bool verbose)
    {
        _verbose = verbose;
    }

    bool get_verbose() const
    {
        return _verbose;
    }

private:
    libconfig::Config _cfg;

    fs::path _filepath;

    bool _verbose;
};

#endif  // XDGCFG_HPP