tree_generator.hpp

#pragma once
 
// lal includes
#include <lal/graphs/free_tree.hpp>
#include <lal/graphs/rooted_tree.hpp>
 
namespace lal {
namespace generate {
 
template<
    class tree_type,
    bool is_free = std::is_base_of_v<graphs::free_tree, tree_type>,
    std::enable_if_t<
        std::is_base_of_v<graphs::free_tree, tree_type> ||
        std::is_base_of_v<graphs::rooted_tree, tree_type>,
        bool
    > = true
>
class _tree_generator {
public:
    typedef std::conditional_t<is_free, graphs::free_tree, graphs::rooted_tree>
    tree_type_t;
 
public:
    /* CONSTRUCTORS */
 
    _tree_generator(uint32_t n) noexcept : m_n(n) { }
    _tree_generator(const _tree_generator& Gen) = default;
#ifndef SWIG
    _tree_generator(_tree_generator&& Gen) = default;
#endif
    virtual ~_tree_generator() = default;
 
    /* OPERATORS */
 
#ifndef SWIG
    _tree_generator& operator= (const _tree_generator& Gen) = default;
    _tree_generator& operator= (_tree_generator&& Gen) = default;
#endif
 
    /* GETTERS */
 
    inline tree_type_t get_tree() noexcept
    {
        auto t = __get_tree();
 
        // free and rooted trees
        if (m_normalise_tree) {
            t.normalise();
        }
        if (m_calculate_tree_type) {
            t.calculate_tree_type();
        }
 
        // only free trees
        if constexpr (is_free) {
 
        }
 
        // only rooted trees
        if constexpr (not is_free) {
            if (m_calculate_size_subtrees) {
                t.calculate_size_subtrees();
            }
        }
        return t;
    }
 
    /* MODIFIERS */
 
    virtual tree_type_t yield_tree() noexcept = 0;
 
    inline void activate_all_postprocessing_actions() noexcept {
        set_normalise_tree(true);
        set_calculate_size_subtrees(true);
        set_calculate_tree_type(true);
    }
 
    inline void deactivate_all_postprocessing_actions() noexcept {
        set_normalise_tree(false);
        set_calculate_size_subtrees(false);
        set_calculate_tree_type(false);
    }
 
    /* SETTERS */
 
    inline void set_normalise_tree(bool v) noexcept
    { m_normalise_tree = v; }
 
    inline void set_calculate_size_subtrees(bool v) noexcept
    { m_calculate_size_subtrees = v; }
 
    inline void set_calculate_tree_type(bool v) noexcept
    { m_calculate_tree_type = v; }
 
protected:
    virtual tree_type_t __get_tree() noexcept = 0;
 
    const uint32_t m_n;
 
    bool m_normalise_tree = true;
    bool m_calculate_size_subtrees = true;
    bool m_calculate_tree_type = true;
};
 
} // -- namespace generate
} // -- namespace lal