node.hpp

Go to the documentation of this file.

 
#if !defined(TETENGO_LATTICE_NODE_HPP)
#define TETENGO_LATTICE_NODE_HPP
 
#include <any>
#include <cassert>
#include <cstddef>
#include <vector>
 
#include <boost/operators.hpp>
 
#include <tetengo/lattice/entry.hpp>
#include <tetengo/lattice/input.hpp>
 
 
namespace tetengo::lattice
{
    class node : public boost::equality_comparable<node>
    {
    public:
        // static functions
 
        [[nodiscard]] static node bos(const std::vector<int>* p_preceding_edge_costs);
 
        [[nodiscard]] static node
        eos(std::size_t             preceding_step,
            const std::vector<int>* p_preceding_edge_costs,
            std::size_t             best_preceding_node,
            int                     path_cost);
 
 
        // constructors and destructor
 
        constexpr node(
            const input*            p_key,
            const std::any*         p_value,
            std::size_t             index_in_step,
            std::size_t             preceding_step,
            const std::vector<int>* p_preceding_edge_costs,
            std::size_t             best_preceding_node,
            int                     node_cost,
            int                     path_cost) :
        m_p_key{ p_key },
        m_p_value{ p_value },
        m_index_in_step{ index_in_step },
        m_preceding_step{ preceding_step },
        m_p_preceding_edge_costs{ p_preceding_edge_costs },
        m_best_preceding_node{ best_preceding_node },
        m_node_cost{ node_cost },
        m_path_cost{ path_cost }
        {}
 
        constexpr node(
            const entry_view&       entry,
            std::size_t             index_in_step,
            std::size_t             preceding_step,
            const std::vector<int>* p_preceding_edge_costs,
            std::size_t             best_preceding_node,
            int                     path_cost) :
        node{ entry.p_key(),          entry.value(),       index_in_step, preceding_step,
              p_preceding_edge_costs, best_preceding_node, entry.cost(),  path_cost }
        {}
 
 
        // functions
 
        friend constexpr bool operator==(const node& one, const node& another)
        {
            return ((!one.p_key() && !another.p_key()) ||
                    (one.p_key() && another.p_key() && *one.p_key() == *another.p_key())) &&
                   one.preceding_step() == another.preceding_step() &&
                   one.best_preceding_node() == another.best_preceding_node() &&
                   one.node_cost() == another.node_cost() && one.path_cost() == another.path_cost();
        }
 
        [[nodiscard]] constexpr const input* p_key() const
        {
            return m_p_key;
        }
 
        [[nodiscard]] constexpr const std::any& value() const
        {
            assert(m_p_value);
            return *m_p_value;
        }
 
        [[nodiscard]] constexpr std::size_t index_in_step() const
        {
            return m_index_in_step;
        }
 
        [[nodiscard]] constexpr std::size_t preceding_step() const
        {
            return m_preceding_step;
        }
 
        [[nodiscard]] constexpr const std::vector<int>& preceding_edge_costs() const
        {
            assert(m_p_preceding_edge_costs);
            return *m_p_preceding_edge_costs;
        }
 
        [[nodiscard]] constexpr std::size_t best_preceding_node() const
        {
            return m_best_preceding_node;
        }
 
        [[nodiscard]] constexpr int node_cost() const
        {
            return m_node_cost;
        }
 
        [[nodiscard]] constexpr int path_cost() const
        {
            return m_path_cost;
        }
 
        [[nodiscard]] bool is_bos() const;
 
 
    private:
        // variables
 
        const input* m_p_key;
 
        const std::any* m_p_value;
 
        std::size_t m_index_in_step;
 
        std::size_t m_preceding_step;
 
        const std::vector<int>* m_p_preceding_edge_costs;
 
        std::size_t m_best_preceding_node;
 
        int m_node_cost;
 
        int m_path_cost;
    };
 
 
}
 
 
#endif