array_key.hpp

/* Copyright 2009-2017 Francesco Biscani (bluescarni@gmail.com)

This file is part of the Piranha library.

The Piranha library is free software; you can redistribute it and/or modify
it under the terms of either:

  * the GNU Lesser General Public License as published by the Free
    Software Foundation; either version 3 of the License, or (at your
    option) any later version.

or

  * the GNU General Public License as published by the Free Software
    Foundation; either version 3 of the License, or (at your option) any
    later version.

or both in parallel, as here.

The Piranha library is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
for more details.

You should have received copies of the GNU General Public License and the
GNU Lesser General Public License along with the Piranha library.  If not,
see https://www.gnu.org/licenses/. */

#ifndef PIRANHA_ARRAY_KEY_HPP
#define PIRANHA_ARRAY_KEY_HPP

#include <algorithm>
#include <cstddef>
#include <functional>
#include <initializer_list>
#include <iterator>
#include <stdexcept>
#include <string>
#include <tuple>
#include <type_traits>
#include <utility>
#include <vector>

#include <piranha/config.hpp>
#include <piranha/exceptions.hpp>
#include <piranha/math.hpp>
#include <piranha/safe_cast.hpp>
#include <piranha/small_vector.hpp>
#include <piranha/symbol_utils.hpp>
#include <piranha/type_traits.hpp>

namespace piranha
{


template <typename T, typename Derived, typename S = std::integral_constant<std::size_t, 0u>>
class array_key
{
    // NOTE: the general idea about requirements here is that these are the bare minimum
    // to make a simple array_key suitable as key in a piranha::series. There are additional
    // requirements which are optional and checked in the member functions.
    PIRANHA_TT_CHECK(std::is_constructible, T, int);
    PIRANHA_TT_CHECK(is_less_than_comparable, T);
    PIRANHA_TT_CHECK(is_equality_comparable, T);
    PIRANHA_TT_CHECK(is_hashable, T);
    PIRANHA_TT_CHECK(has_is_zero, T);

public:
    using container_type = small_vector<T, S>;
    using value_type = typename container_type::value_type;
    using iterator = typename container_type::iterator;
    using const_iterator = typename container_type::const_iterator;
    using size_type = typename container_type::size_type;

    array_key() = default;

    array_key(const array_key &) = default;
    array_key(array_key &&) = default;

private:
    // Enabler for constructor from init list.
    template <typename U>
    using init_list_enabler = enable_if_t<std::is_constructible<container_type, std::initializer_list<U>>::value, int>;

public:

    template <typename U, init_list_enabler<U> = 0>
    explicit array_key(std::initializer_list<U> list) : m_container(list)
    {
    }

    explicit array_key(const symbol_fset &args)
    {
        // NOTE: the back inserter transforms the assignment into a push_back() operation.
        std::fill_n(std::back_inserter(m_container), args.size(), value_type(0));
    }

private:
    // Enabler for generic ctor.
    template <typename U>
    using generic_ctor_enabler = enable_if_t<has_safe_cast<value_type, U>::value, int>;

public:

    template <typename U, typename Derived2, typename S2, generic_ctor_enabler<U> = 0>
    explicit array_key(const array_key<U, Derived2, S2> &other, const symbol_fset &args)
    {
        if (unlikely(other.size() != args.size())) {
            piranha_throw(std::invalid_argument,
                          "inconsistent sizes in the generic array_key constructor: the size of the array ("
                              + std::to_string(other.size()) + ") differs from the size of the symbol set ("
                              + std::to_string(args.size()) + ")");
        }
        std::transform(other.begin(), other.end(), std::back_inserter(m_container),
                       [](const U &x) { return safe_cast<value_type>(x); });
    }
    ~array_key()
    {
        PIRANHA_TT_CHECK(is_container_element, Derived);
        PIRANHA_TT_CHECK(std::is_base_of, array_key, Derived);
    }

    array_key &operator=(const array_key &other) = default;

    array_key &operator=(array_key &&other) = default;

    iterator begin()
    {
        return m_container.begin();
    }

    iterator end()
    {
        return m_container.end();
    }

    const_iterator begin() const
    {
        return m_container.begin();
    }

    const_iterator end() const
    {
        return m_container.end();
    }

    size_type size() const
    {
        return m_container.size();
    }

    void resize(const size_type &new_size)
    {
        m_container.resize(new_size);
    }

    value_type &operator[](const size_type &i)
    {
        return m_container[i];
    }

    const value_type &operator[](const size_type &i) const
    {
        return m_container[i];
    }

    std::size_t hash() const
    {
        return m_container.hash();
    }

    void push_back(value_type &&x)
    {
        m_container.push_back(std::move(x));
    }

    void push_back(const value_type &x)
    {
        m_container.push_back(x);
    }

    bool operator==(const array_key &other) const
    {
        return m_container == other.m_container;
    }

    bool operator!=(const array_key &other) const
    {
        return !operator==(other);
    }

    void trim_identify(std::vector<char> &trim_mask, const symbol_fset &args) const
    {
        auto sbe = size_begin_end();
        if (unlikely(std::get<0>(sbe) != args.size())) {
            piranha_throw(std::invalid_argument, "invalid symbol set for trim_identify(): the size of the array ("
                                                     + std::to_string(std::get<0>(sbe))
                                                     + ") differs from the size of the reference symbol set ("
                                                     + std::to_string(args.size()) + ")");
        }
        if (unlikely(std::get<0>(sbe) != trim_mask.size())) {
            piranha_throw(std::invalid_argument,
                          "invalid mask for trim_identify(): the size of the array (" + std::to_string(std::get<0>(sbe))
                              + ") differs from the size of the mask (" + std::to_string(trim_mask.size()) + ")");
        }
        for (decltype(trim_mask.size()) i = 0; std::get<1>(sbe) != std::get<2>(sbe); ++i, ++std::get<1>(sbe)) {
            if (!math::is_zero(*std::get<1>(sbe))) {
                // The current element of the array is nonzero, set the
                // corresponding element in the mask to zero.
                trim_mask[i] = 0;
            }
        }
    }

    Derived trim(const std::vector<char> &trim_mask, const symbol_fset &args) const
    {
        auto sbe = size_begin_end();
        if (unlikely(std::get<0>(sbe) != args.size())) {
            piranha_throw(std::invalid_argument, "invalid arguments set for trim(): the size of the array ("
                                                     + std::to_string(std::get<0>(sbe))
                                                     + ") differs from the size of the reference symbol set ("
                                                     + std::to_string(args.size()) + ")");
        }
        if (unlikely(std::get<0>(sbe) != trim_mask.size())) {
            piranha_throw(std::invalid_argument,
                          "invalid mask for trim(): the size of the array (" + std::to_string(std::get<0>(sbe))
                              + ") differs from the size of the mask (" + std::to_string(trim_mask.size()) + ")");
        }
        Derived retval;
        for (decltype(trim_mask.size()) i = 0; std::get<1>(sbe) != std::get<2>(sbe); ++i, ++std::get<1>(sbe)) {
            if (!trim_mask[i]) {
                retval.push_back(*std::get<1>(sbe));
            }
        }
        return retval;
    }

private:
    // Enabler for addition and subtraction.
    template <typename U>
    using add_t = decltype(std::declval<U const &>().add(std::declval<U &>(), std::declval<U const &>()));
    template <typename U>
    using sub_t = decltype(std::declval<U const &>().sub(std::declval<U &>(), std::declval<U const &>()));
    template <typename U>
    using add_enabler = enable_if_t<is_detected<add_t, U>::value, int>;
    template <typename U>
    using sub_enabler = enable_if_t<is_detected<sub_t, U>::value, int>;

public:

    template <typename U = container_type, add_enabler<U> = 0>
    void vector_add(array_key &retval, const array_key &other) const
    {
        m_container.add(retval.m_container, other.m_container);
    }

    template <typename U = container_type, sub_enabler<U> = 0>
    void vector_sub(array_key &retval, const array_key &other) const
    {
        m_container.sub(retval.m_container, other.m_container);
    }

    Derived merge_symbols(const symbol_idx_fmap<symbol_fset> &ins_map, const symbol_fset &args) const
    {
        Derived retval;
        vector_key_merge_symbols(retval.m_container, m_container, ins_map, args);
        return retval;
    }

protected:
    container_type m_container;

public:

    auto size_begin_end() const -> decltype(m_container.size_begin_end())
    {
        return m_container.size_begin_end();
    }

    auto size_begin_end() -> decltype(m_container.size_begin_end())
    {
        return m_container.size_begin_end();
    }
};
}

namespace std
{

template <typename T, typename Derived, typename S>
struct hash<piranha::array_key<T, Derived, S>> {
    typedef size_t result_type;
    typedef piranha::array_key<T, Derived, S> argument_type;

    result_type operator()(const argument_type &a) const
    {
        return a.hash();
    }
};
}

#endif