n_best_iterator.hpp

Go to the documentation of this file.

 
#if !defined(TETENGO_LATTICE_NBESTITERATOR_HPP)
#define TETENGO_LATTICE_NBESTITERATOR_HPP
 
#include <cstddef>
#include <functional>
#include <iterator>
#include <memory>
#include <queue>
#include <vector>
 
#include <boost/operators.hpp>
#include <boost/stl_interfaces/iterator_interface.hpp>
 
#include <tetengo/lattice/node.hpp>
#include <tetengo/lattice/path.hpp>
 
 
namespace tetengo::lattice
{
    class constraint;
    class lattice;
 
 
    class cap : public boost::less_than_comparable<cap>
    {
    public:
        // constructors and destructor
 
        cap(std::vector<node> tail_path, int tail_path_cost, int whole_path_cost);
 
 
        // functions
 
        friend bool operator<(const cap& one, const cap& another);
 
        [[nodiscard]] const std::vector<node>& tail_path() const;
 
        [[nodiscard]] int tail_path_cost() const;
 
        [[nodiscard]] int whole_path_cost() const;
 
 
    private:
        // variables
 
        std::vector<node> m_tail_path;
 
        int m_tail_path_cost;
 
        int m_whole_path_cost;
    };
 
 
    class n_best_iterator :
    public boost::stl_interfaces::iterator_interface<n_best_iterator, std::forward_iterator_tag, path>
    {
    public:
        // constructors and destructor
 
        n_best_iterator();
 
        n_best_iterator(const lattice& lattice_, node eos_node, std::unique_ptr<constraint>&& p_constraint);
 
 
        // functions
 
        [[nodiscard]] const path& operator*() const;
 
        [[nodiscard]] path& operator*();
 
        [[nodiscard]] const path* operator->() const;
 
        [[nodiscard]] path* operator->();
 
        friend bool operator==(const n_best_iterator& one, const n_best_iterator& another);
 
        n_best_iterator& operator++();
 
        n_best_iterator operator++(int);
 
 
    private:
        // variables
 
        const lattice* m_p_lattice;
 
        std::priority_queue<cap, std::vector<cap>, std::greater<cap>> m_caps;
 
        std::size_t m_eos_hash;
 
        std::shared_ptr<constraint> m_p_constraint;
 
        path m_path;
 
        std::size_t m_index;
    };
 
 
}
 
 
#endif