FilterMap.hpp

Go to the documentation of this file.

#ifndef AI_TOOLBOX_FACTORED_FILTER_MAP_HEADER_FILE
#define AI_TOOLBOX_FACTORED_FILTER_MAP_HEADER_FILE
 
#include <AIToolbox/Utils/IndexMap.hpp>
#include <AIToolbox/Factored/Types.hpp>
#include <AIToolbox/Factored/Utils/Trie.hpp>
#include <AIToolbox/Factored/Utils/FasterTrie.hpp>
 
namespace AIToolbox::Factored {
    template <typename T, typename TrieType = FasterTrie>
    class FilterMap {
        public:
            using ItemsContainer = std::vector<T>;
            using Iterable = IndexMap<std::vector<size_t>, ItemsContainer>;
            using ConstIterable = IndexMap<std::vector<size_t>, const ItemsContainer>;
 
            FilterMap(Factors f) : ids_(std::move(f)) {}
 
            FilterMap(TrieType t, ItemsContainer c) :
                    ids_(std::move(t)), items_(std::move(c))
            {
                if (ids_.size() != items_.size())
                    throw std::invalid_argument("Input trie and container have different sizes!");
            }
 
            Factors getF() const {
                return ids_.getF();
            }
 
            template <typename... Args>
            void emplace(const PartialFactors & pf, Args&&... args) {
                ids_.insert(pf);
                items_.emplace_back(std::forward<Args>(args)...);
            }
 
            Iterable filter(const Factors & f) {
                return Iterable(ids_.filter(f), items_);
            }
 
            ConstIterable filter(const Factors & f) const {
                return ConstIterable(ids_.filter(f), items_);
            }
 
            template <typename TT = TrieType, typename = std::enable_if_t<std::is_same_v<TT, Trie>>>
            Iterable filter(const Factors & f, size_t offset) {
                return Iterable(ids_.filter(f, offset), items_);
            }
 
            template <typename TT = TrieType, typename = std::enable_if_t<std::is_same_v<TT, Trie>>>
            ConstIterable filter(const Factors & f, size_t offset) const {
                return ConstIterable(ids_.filter(f, offset), items_);
            }
 
            Iterable filter(const PartialFactors & pf) {
                return Iterable(ids_.filter(pf), items_);
            }
 
            ConstIterable filter(const PartialFactors & pf) const {
                return ConstIterable(ids_.filter(pf), items_);
            }
 
            void reserve(size_t size) {
                if constexpr (std::is_same_v<TrieType, Trie>)
                    ids_.reserve(size);
 
                items_.reserve(size);
            }
 
            size_t size() const {
                return items_.size();
            }
 
            typename ItemsContainer::iterator begin() {
                return items_.begin();
            }
 
            typename ItemsContainer::const_iterator begin() const {
                return items_.begin();
            }
 
            typename ItemsContainer::iterator end() {
                return items_.end();
            }
 
            typename ItemsContainer::const_iterator end() const {
                return items_.end();
            }
 
            const T & operator[](size_t id) const {
                return items_[id];
            }
 
            T & operator[](size_t id) {
                return items_[id];
            }
 
            const ItemsContainer & getContainer() const {
                return items_;
            }
 
            const TrieType & getTrie() const {
                return ids_;
            }
 
        private:
            TrieType ids_;
            ItemsContainer items_;
    };
}
 
#endif