index_mapper.hpp

/****************************************************************************
 *  hipipe library
 *  Copyright (c) 2017, Cognexa Solutions s.r.o.
 *  Copyright (c) 2018, Iterait a.s.
 *  Author(s) Filip Matzner
 *
 *  This file is distributed under the MIT License.
 *  See the accompanying file LICENSE.txt for the complete license agreement.
 ****************************************************************************/
 
#ifndef HIPIPE_CORE_INDEX_MAPPER_HPP
#define HIPIPE_CORE_INDEX_MAPPER_HPP
 
#include <range/v3/range/conversion.hpp>
#include <range/v3/view/transform.hpp>
 
#include <unordered_map>
#include <vector>
 
namespace hipipe {
 
namespace rgv = ranges::views;
 
template<typename T>
class index_mapper {
public:
    index_mapper() = default;
 
    template<typename Rng>
    index_mapper(Rng&& values)
    {
        insert(std::forward<Rng>(values));
    }
 
    index_mapper(std::initializer_list<T> values)
    {
        insert(rgv::all(values));
    }
 
    // index_for //
 
    std::size_t index_for(const T& val) const
    {
        if (!contains(val)) {
            throw std::out_of_range{"The index_mapper does not contain the given value."};
        }
        return val2idx_.at(val);
    }
 
    std::size_t index_for(const T& val, std::size_t defval) const
    {
        auto pos = val2idx_.find(val);
        if (pos == val2idx_.end()) return defval;
        return pos->second;
    }
 
    std::vector<std::size_t> index_for(const std::vector<T>& vals) const
    {
        return ranges::to_vector(rgv::transform(
          vals, [this](const T& val) {
              return this->index_for(val);
          }));
    }
 
    std::vector<std::size_t> index_for(const std::vector<T>& vals, std::size_t defval) const
    {
        return ranges::to_vector(rgv::transform(
          vals, [this, defval](const T& val) {
              return this->index_for(val, defval);
          }));
    }
 
    // at //
 
    const T& at(const std::size_t& idx) const
    {
        if (idx >= size()) {
            throw std::out_of_range{"Index " + std::to_string(idx) + " cannot be found in "
                                    "index_mapper of size " + std::to_string(size()) + "."};
        }
        return idx2val_[idx];
    }
 
 
    std::vector<T> at(const std::vector<std::size_t>& idxs) const
    {
        return ranges::to_vector(rgv::transform(
          idxs, [this](std::size_t idx) {
              return this->at(idx);
          }));
    }
 
    // insert //
 
    std::size_t insert(T val)
    {
        if (contains(val)) {
            throw std::invalid_argument{"The element is already present in the index mapper."};
        }
        val2idx_[val] = idx2val_.size();
        idx2val_.push_back(std::move(val));
        return idx2val_.size() - 1;
    }
 
    CPP_template(class Rng)(requires ranges::container<Rng>)
    void insert(Rng rng)
    {
        for (auto& val : rng) insert(std::move(val));
    }
 
    CPP_template(class Rng)(requires ranges::view_<Rng>)
    void insert(Rng rng)
    {
        for (auto&& val : rng) insert(std::forward<decltype(val)>(val));
    }
 
    // try_insert //
 
    bool try_insert(T val)
    {
        if (contains(val)) return false;
        insert(std::move(val));
        return true;
    }
 
    CPP_template(class Rng)(requires ranges::container<Rng>)
    void try_insert(Rng rng)
    {
        for (auto& val : rng) try_insert(std::move(val));
    }
 
    CPP_template(class Rng)(requires ranges::view_<Rng>)
    void try_insert(Rng rng)
    {
        for (auto&& val : rng) try_insert(std::forward<decltype(val)>(val));
    }
 
    // helper functions //
 
    bool contains(const T& val) const
    {
        return val2idx_.count(val);
    }
 
    std::size_t size() const
    {
        return val2idx_.size();
    }
 
    // data access //
 
    const std::vector<T>& values() const
    {
        return idx2val_;
    }
 
private:
    std::unordered_map<T, std::size_t> val2idx_;
    std::vector<T> idx2val_;
};
 
template<typename Rng, typename T = ranges::range_value_t<Rng>>
index_mapper<T> make_unique_index_mapper(Rng&& rng)
{
    index_mapper<T> mapper;
    mapper.try_insert(std::forward<Rng>(rng));
    return mapper;
}
 
}  // end namespace hipipe
#endif