double_array.hpp

Go to the documentation of this file.

 
#if !defined(TETENGO_TRIE_DOUBLEARRAY_HPP)
#define TETENGO_TRIE_DOUBLEARRAY_HPP
 
#include <cstddef>
#include <cstdint>
#include <functional>
#include <memory>
#include <optional>
#include <string>
#include <string_view>
#include <utility>
#include <vector>
 
#include <boost/core/noncopyable.hpp>
 
namespace tetengo::trie
{
    class double_array_iterator;
 
    class storage;
 

    class double_array : private boost::noncopyable
    {
    public:
        // tyes

        struct building_observer_set_type
        {
            std::function<void(const std::pair<std::string_view, std::int32_t>& element)> adding;

            std::function<void()> done;
        };
 
 
        // static functions

        [[nodiscard]] static const building_observer_set_type& null_building_observer_set();

        [[nodiscard]] static std::size_t default_density_factor();

        [[nodiscard]] static char key_terminator();

        [[nodiscard]] static std::uint8_t vacant_check_value();
 
 
        // constructors and destructor

        double_array();

        explicit double_array(
            const std::vector<std::pair<std::string_view, std::int32_t>>& elements,
            const building_observer_set_type& building_observer_set = null_building_observer_set(),
            std::size_t                       density_factor = default_density_factor());

        explicit double_array(
            const std::vector<std::pair<std::string, std::int32_t>>& elements,
            const building_observer_set_type& building_observer_set = null_building_observer_set(),
            std::size_t                       density_factor = default_density_factor());

        template <typename InputIterator>
        double_array(
            InputIterator                     first,
            InputIterator                     last,
            const building_observer_set_type& building_observer_set = null_building_observer_set(),
            std::size_t                       density_factor = default_density_factor()) :
        double_array{ std::vector<typename InputIterator::value_type>{ first, last },
                      building_observer_set,
                      density_factor }
        {}

        double_array(std::unique_ptr<storage>&& p_storage, std::size_t root_base_check_index);

        ~double_array();
 
 
        // functions

        [[nodiscard]] std::optional<std::int32_t> find(const std::string_view& key) const;

        [[nodiscard]] double_array_iterator begin() const;

        [[nodiscard]] double_array_iterator end() const;

        [[nodiscard]] std::unique_ptr<double_array> subtrie(const std::string_view& key_prefix) const;

        [[nodiscard]] const storage& get_storage() const;

        [[nodiscard]] storage& get_storage();
 
 
    private:
        // types
 
        class impl;
 
 
        // variables
 
        const std::unique_ptr<impl> m_p_impl;
    };
 
 
}
 
 
#endif