body_builder.hpp

/*********************************************************************/
// 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 BODY_BUILDER_HPP
#define BODY_BUILDER_HPP
 
    // C system header files
#include "my_config.h"
extern "C"
{
 
}
 
    // C++ system header files
#include <string>
#include <map>
#include <vector>
 
    // webdar headers
#include "request.hpp"
#include "chemin.hpp"
#include "css_library.hpp"
#include "css_class_group.hpp"
 
 
 
 
class body_builder
{
public:
    body_builder() { clear(); };
 
 
    body_builder(const body_builder & ref);
 
 
    body_builder(body_builder && ref) noexcept = delete;
 
 
    body_builder & operator = (const body_builder & ref);
 
 
    body_builder & operator = (body_builder && ref) noexcept = delete;
 
    virtual ~body_builder();
 
 
 
 
    void set_prefix(const chemin & prefix);
 
 
    void adopt(body_builder* obj);
 
    bool is_adopted() const { return parent != nullptr; };
 
    void foresake(body_builder* obj);
 
 
    void set_visible(bool mode);
 
 
    bool get_visible() const { return visible; };
 
    bool get_visible_recursively() const;
 
    void add_css_class(const std::string & name);
 
    void add_css_class(const css_class_group & cg);
 
    bool has_css_class(const std::string & name) const;
 
    void remove_css_class(const std::string & name);
 
    void remove_css_class(const css_class_group & cg);
 
    void clear_css_classes() { css_class_names.clear(); css_classes_have_changed(); };
 
    const std::set<std::string> & get_css_classes_as_a_set() const { return css_class_names; };
 
    css_class_group get_css_class_group() const;
 
 
 
    std::string get_css_classes(const std::string & extra = "") const;
 
    void define_css_class_in_library(const css_class & csscl);
    void define_css_class_in_library(const std::string & name, const css & cssdef);
 
    bool is_css_class_defined_in_library(const std::string & name) const;
 
    std::string get_body_part(const chemin & path,
                  const request & req);
 
 
    void ignore_body_changed_from_my_children(bool mode) { ignore_children_body_changed = mode; if(mode) body_changed = false; };
 
    bool get_ignore_body_changed_from_my_children() const { return ignore_children_body_changed; };
 
 
    void set_no_CR(bool no_cr = true);
 
 
    void assign_anchor(bool mode);
 
 
    std::string get_assigned_anchor() const { return anchor; };
 
    virtual void bind_to_anchor(const std::string & val) {};
 
protected:
 
 
    virtual std::string inherited_get_body_part(const chemin & path,
                        const request & req) = 0;
 
 
    void my_body_part_has_changed();
 
 
    virtual void my_visibility_has_changed() {};
 
 
    bool has_my_body_part_changed() const { return body_changed; };
 
    chemin get_path() const;
 
    std::string get_recorded_name() const;
 
 
 
    void store_css_library() { library_asked = true; };
 
    bool has_local_css_library() const { return library_asked || bool(library); };
 
 
    std::unique_ptr<css_library> & lookup_css_library() const;
 
    std::string get_body_part_from_target_child(const chemin & path,
                                                const request & req);
 
    std::string get_body_part_from_all_children(const chemin & path,
                                                const request & req);
 
 
    virtual void path_has_changed() {};
 
    virtual void has_adopted(body_builder *obj) {};
 
    virtual void will_foresake(body_builder *obj) {};
 
    virtual void has_been_adopted_by(body_builder *obj) {};
 
    virtual void will_be_foresaken_by(body_builder *obj) {};
 
    virtual void css_classes_have_changed() {};
 
    virtual void new_css_library_available() {};
 
    unsigned int size() const { return order.size(); };
 
    body_builder *operator[] (unsigned int i) { return order[i]; };
 
    body_builder* get_parent() const { return parent; };
 
 
    template <class T> void closest_ancestor_of_type(T* & ancestor)
    {
    body_builder* ptr = parent;
 
    do
    {
        if(ptr != nullptr)
        {
        ancestor = dynamic_cast<T*>(ptr);
        ptr = ptr->parent;
        }
        else
        ancestor = nullptr;
    }
    while(ptr != nullptr && ancestor == nullptr);
    }
 
 
    void orphan_all_children();
 
    bool get_no_CR() const { return no_CR; };
 
private:
    bool visible;                                       
    chemin x_prefix;                                    
    bool no_CR;                                         
    body_builder* parent;                               
    std::vector<body_builder*> order;                   
    std::map<std::string, body_builder*> children;      
    std::map<body_builder*, std::string> revert_child;  
    chemin last_body_path;                              
    uri last_body_req_uri;                              
    std::string last_body_req_body;                     
    std::string last_body_part;                         
    bool body_changed;                                  
    bool ignore_children_body_changed;                  
    bool library_asked;                                 
    std::unique_ptr<css_library> library;               
    std::set<std::string> css_class_names;              
    std::string anchor;                                 
 
    void unrecord_from_parent();
 
    void recursive_path_has_changed();
 
    void recursive_new_css_library_available();
 
    void clear();
 
    void create_css_lib_if_needed();
 
    void flush_all_cached_body_part();
 
 
    std::string get_body_part_or_cache(const chemin & path,
                       const request & req);
 
 
    static libthreadar::mutex assigned_anchors_ctrl;
    static std::set<unsigned int> assigned_anchors; 
 
    static std::string get_available_anchor();
    static void release_anchor(std::string & val);
};
 
#endif