bibliotheque.hpp

Go to the documentation of this file.

/*********************************************************************/
// webdar - a web server and interface program to libdar
// Copyright (C) 2013-2025 Denis Corbin
//
// This file is part of Webdar
//
//  Webdar is free software: you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation, either version 3 of the License, or
//  (at your option) any later version.
//
//  Webdar 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 General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with Webdar.  If not, see <http://www.gnu.org/licenses/>
//
//----
//  to contact the author: dar.linux@free.fr
/*********************************************************************/
 
#ifndef BIBLIOTHEQUE_HPP
#define BIBLIOTHEQUE_HPP
 
    // C system header files
#include "my_config.h"
extern "C"
{
 
}
 
    // C++ system header files
#include <map>
#include <string>
#include <memory>
#include <set>
 
    // webdar headers
#include "jsoner.hpp"
#include "events.hpp"
 
 
 
 
 
class bibliotheque : public jsoner, public events
{
public:
 
 
    enum category
    {
    filefilter = 0,
    pathfilter = 1,
    command = 2,
    repo = 3,
    compress = 4,
    confsave = 5,
    conftest = 6,
    confdiff = 7,
    conflist = 8,
    confrest = 9,
    confmerge = 10,
    confrepair = 11,
    confcommon = 12,
    slicing = 13,
    ciphering = 14,
    delta_sig = 15,
    over_policy = 16,
    confread = 17,
    confisolate = 18,
    EOE = 19 
    };
 
    static constexpr const char* default_config_name = "default";
    static constexpr const char* default_no_compression = "no-compress";
    static constexpr const char* default_full_from_diff = "full from diff";
 
 
    static std::string changed(category cat);
 
 
    static std::string category_to_string(category cat);
 
    static category string_to_category(const std::string & s);
 
    static std::string category_description(category cat, bool capitalized);
 
 
    struct coordinates
    {
    category cat;
    std::string confname;
 
    coordinates(category c, const std::string & name): cat(c), confname(name) {};
    bool operator < (const coordinates & ref) const { return cat < ref.cat || (cat == ref.cat && confname < ref.confname); };
    };
 
    typedef std::set<coordinates> using_set;
 
    bibliotheque();
    bibliotheque(const bibliotheque & ref) = default;
    bibliotheque(bibliotheque && ref) noexcept(false) = default;
    bibliotheque & operator = (const bibliotheque & ref) = default;
    bibliotheque & operator = (bibliotheque && ref) noexcept(false) = default;
    virtual ~bibliotheque() = default;
 
 
    void add_config(category categ, const std::string & name, const json & config, const using_set & refs = std::set<coordinates>());
 
 
    void add_external_ref_to(category categ, const std::string & name, const void* from_where);
 
 
    void update_config(category categ, const std::string & name, const json & config, const using_set & refs = std::set<coordinates>());
 
 
    void delete_config(category categ, const std::string & name);
 
 
 
    void delete_external_ref_to(category categ, const std::string & name, const void* from_where);
 
    bool has_config(category categ, const std::string & name) const;
 
 
    json fetch_config(category categ, const std::string & name) const;
 
 
    std::string display_config(category categ, const std::string & name) const;
 
    std::deque<std::string> listing(category categ) const;
 
 
    bool get_saved_status() const { return saved; };
 
 
    bool get_autosave_status() const { return autosave; };
 
 
    void set_autosave_status(bool val) { autosave = val; };
 
    void clear();
 
    bool is_empty() const;
 
    virtual void load_json(const json & source) override;
 
    virtual json save_json() const override;
 
    virtual void clear_json() override { clear(); };
 
private:
 
    // DATASTRUCTURE FOR INTERNAL DATA
    //
 
    struct linked_config
    {
    json config;
    using_set dependency;
 
    linked_config() {};
    linked_config(const json & conf) { config = conf; };
    linked_config(const json & conf, const std::set<coordinates> & deps): config(conf), dependency(deps) {};
    };
 
    typedef std::map<std::string, linked_config> asso;
 
    typedef std::map<category, asso> table;
 
    table content;       
    mutable bool saved;  
 
    // GLOBAL PROPERTIES
    bool autosave;
 
 
 
    // DATASTRUCTURE STORING REFERENCE
    // FROM EXTERNAL DATA
    //
 
    typedef std::set<const void*> refs;
 
    std::map<coordinates, refs> outside;
 
 
    void init();
 
 
    bool lookup(category cat,
        const std::string & name,
        asso::iterator & it,
        table::iterator & catit) const;
 
    void add_dependency_for(coordinates user, const using_set & referred);
    void remove_dependency_for(coordinates user);
    using_set get_direct_dependencies_of(coordinates user) const;
    void check_against_cyclic_dependencies(coordinates source, const std::set<coordinates> & seen);
 
    static constexpr const unsigned int format_version = 1;
    static constexpr const char* myclass_id = "bibliotheque";
 
    static constexpr const char* category_label = "category";
    static constexpr const char* asso_label = "list";
    static constexpr const char* config_label = "name";
    static constexpr const char* config_def_label = "config";
    static constexpr const char* config_depend = "used-by";
 
    static constexpr const char* jlabel_categprop  = "categories";
    static constexpr const char* jlabel_globalprop = "global";
 
    static constexpr const char* jlabel_autosave   = "auto-save";
 
};
 
bibliotheque::category & operator++(bibliotheque::category & cat);
 
#endif