245 lines
8.4 KiB
C++
245 lines
8.4 KiB
C++
/*
|
|
* Copyright 2015-2020 Michele "King_DuckZ" Santullo
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include "vectorwrapper/vectorwrapper.hpp"
|
|
#include "vectorwrapper/sequence_bt.hpp"
|
|
#include "vectorwrapper/size_type.hpp"
|
|
#include <iterator>
|
|
#include <ciso646>
|
|
#include <cassert>
|
|
#include <array>
|
|
|
|
#if defined VWR_OUTER_NAMESPACE
|
|
namespace VWR_OUTER_NAMESPACE {
|
|
#endif
|
|
|
|
namespace vwr {
|
|
namespace implem {
|
|
//sets value to the index of the first I >= MAX or to sizeof...(I) if
|
|
//no such value is found
|
|
template <size_type MAX, size_type IDX, size_type... I>
|
|
struct find_ge_than_max;
|
|
|
|
template <size_type MAX, size_type IDX, size_type I>
|
|
struct find_ge_than_max<MAX, IDX, I> {
|
|
static constexpr size_type value =
|
|
IDX + (I >= MAX ? 0 : 1);
|
|
};
|
|
template <size_type MAX, size_type IDX, size_type L, size_type... I>
|
|
struct find_ge_than_max<MAX, IDX, L, I...> {
|
|
static constexpr size_type value =
|
|
(L >= MAX ? IDX : find_ge_than_max<MAX, IDX + 1, I...>::value);
|
|
};
|
|
|
|
//helper to identify the invalid index in the build error messages
|
|
template <size_type INVALID_INDEX, bool INVALID>
|
|
struct is_invalid_index {
|
|
static_assert(not INVALID,
|
|
"Invalid index specified, indices must all be >= 0 and <= dimensions"
|
|
);
|
|
enum {
|
|
value = 0
|
|
};
|
|
};
|
|
} //namespace implem
|
|
|
|
template <typename V, typename OP, typename CMP, size_type... I>
|
|
class sequence_range;
|
|
|
|
template <typename V, typename OP, typename CMP, size_type... I>
|
|
class sequence_range_iterator : OP, CMP {
|
|
static_assert(not implem::is_invalid_index<
|
|
implem::find_ge_than_max<V::dimensions, 0, I...>::value,
|
|
sizeof...(I) != implem::find_ge_than_max<V::dimensions, 0, I...>::value
|
|
>::value, "");
|
|
static_assert(sizeof...(I) > 0, "At least one index must be specified");
|
|
|
|
typedef sequence_range<V, OP, CMP, I...> sequence_range_type;
|
|
public:
|
|
explicit sequence_range_iterator (const sequence_range_type& parSeq);
|
|
sequence_range_iterator (const V& parCurrent, const sequence_range_type& parSeq);
|
|
~sequence_range_iterator() = default;
|
|
|
|
sequence_range_iterator& operator++ ();
|
|
const V& operator*() const { return m_current; }
|
|
bool operator!= (const sequence_range_iterator& parOther) const;
|
|
bool operator== (const sequence_range_iterator& parOther) const;
|
|
|
|
private:
|
|
V m_current;
|
|
const sequence_range_type& m_seq;
|
|
size_type m_active_elem;
|
|
};
|
|
|
|
template <typename V, typename OP, typename CMP, size_type... I>
|
|
class sequence_range {
|
|
public:
|
|
typedef sequence_range_iterator<V, OP, CMP, I...> const_iterator;
|
|
|
|
sequence_range (const V& parFrom, const V& parUpper);
|
|
sequence_range (const V& parFrom, const V& parUpper, const V& parStep);
|
|
const_iterator cbegin() const;
|
|
const_iterator cend() const;
|
|
const_iterator begin() const { return cbegin(); }
|
|
const_iterator end() const { return cend(); }
|
|
[[gnu::always_inline]] const V& from() const { return m_from; }
|
|
[[gnu::always_inline]] const V& upper() const { return m_upper; }
|
|
[[gnu::always_inline]] const V& step() const { return m_step; }
|
|
|
|
private:
|
|
V m_from;
|
|
V m_upper;
|
|
V m_end;
|
|
V m_step;
|
|
};
|
|
|
|
template <typename V, typename OP, typename CMP, size_type... I>
|
|
class stepping_sequence_range : public sequence_range<V, OP, CMP, I...> {
|
|
public:
|
|
stepping_sequence_range (const V& parFrom, const V& parUpper, const V& parStep);
|
|
private:
|
|
V m_step;
|
|
};
|
|
|
|
namespace implem {
|
|
template <size_type SEEK, size_type IDX, size_type... I>
|
|
struct get_at_index;
|
|
template <size_type N>
|
|
struct get_at_index<N, N> {
|
|
static constexpr size_type value = N;
|
|
};
|
|
template <size_type SEEK, size_type IDX>
|
|
struct get_at_index<SEEK, IDX> {
|
|
static_assert(SEEK < IDX, "Index out of range");
|
|
static constexpr size_type value = 0;
|
|
};
|
|
template <size_type SEEK, size_type IDX, size_type L, size_type... I>
|
|
struct get_at_index<SEEK, IDX, L, I...> {
|
|
static constexpr size_type value = (IDX == SEEK ? L : get_at_index<SEEK, IDX + 1, I...>::value);
|
|
};
|
|
|
|
template <typename T, typename OP, typename CMP, typename U>
|
|
struct make_sequence_helper;
|
|
|
|
template <typename T, typename OP, typename CMP, size_type... I>
|
|
struct make_sequence_helper<T, OP, CMP, bt::number_seq<size_type, I...>> {
|
|
typedef sequence_range<Vec<T>, OP, CMP, I...> type;
|
|
};
|
|
|
|
template <typename V, size_type... I>
|
|
inline V make_end_vector (V parFrom, const V& parUpper) {
|
|
constexpr const size_type last_idx = get_at_index<sizeof...(I) - 1, 0, I...>::value;
|
|
auto& last = parFrom[last_idx];
|
|
const auto& upper_last = parUpper[last_idx];
|
|
last = upper_last;
|
|
return parFrom;
|
|
}
|
|
} //namespace implem
|
|
|
|
template <typename V, typename OP, typename CMP, size_type... I>
|
|
sequence_range_iterator<V, OP, CMP, I...>::sequence_range_iterator (const sequence_range_type& parSeq) :
|
|
sequence_range_iterator(parSeq.from(), parSeq)
|
|
{
|
|
}
|
|
|
|
template <typename V, typename OP, typename CMP, size_type... I>
|
|
sequence_range_iterator<V, OP, CMP, I...>::sequence_range_iterator (const V& parCurrent, const sequence_range_type& parSeq) :
|
|
m_current(parCurrent),
|
|
m_seq(parSeq),
|
|
m_active_elem(implem::get_at_index<0, 0, I...>::value)
|
|
{
|
|
}
|
|
|
|
template <typename V, typename OP, typename CMP, size_type... I>
|
|
auto sequence_range_iterator<V, OP, CMP, I...>::operator++ () -> sequence_range_iterator& {
|
|
static_assert(sizeof...(I) > 0, "At least one index must be given");
|
|
const OP& advance_op = *static_cast<OP*>(this);
|
|
const CMP& cmp_op = *static_cast<CMP*>(this);
|
|
|
|
std::array<size_type, sizeof...(I)> lst {I...};
|
|
size_type index = lst[0];
|
|
m_current[index] = advance_op(m_current[index], m_seq.step()[index]);
|
|
if (1 < sizeof...(I) and not cmp_op(m_current[index], m_seq.upper()[index])) {
|
|
size_type count = 1;
|
|
do {
|
|
m_current[index] = m_seq.from()[index];
|
|
index = lst[count++];
|
|
m_current[index] = advance_op(m_current[index], m_seq.step()[index]);
|
|
m_active_elem = index;
|
|
} while (count < sizeof...(I) and not cmp_op(m_current[index], m_seq.upper()[index]));
|
|
}
|
|
|
|
return *this;
|
|
}
|
|
|
|
template <typename V, typename OP, typename CMP, size_type... I>
|
|
bool sequence_range_iterator<V, OP, CMP, I...>::operator!= (const sequence_range_iterator& parOther) const {
|
|
return not this->operator==(parOther);
|
|
}
|
|
|
|
template <typename V, typename OP, typename CMP, size_type... I>
|
|
bool sequence_range_iterator<V, OP, CMP, I...>::operator== (const sequence_range_iterator& parOther) const {
|
|
assert(&m_seq.from() == &parOther.m_seq.from() and &m_seq.upper() == &parOther.m_seq.upper());
|
|
const CMP& cmp_op = *static_cast<const CMP*>(this);
|
|
return m_current == parOther.m_current or (
|
|
implem::get_at_index<sizeof...(I) - 1, 0, I...>::value == m_active_elem and
|
|
not cmp_op(m_current[m_active_elem], m_seq.upper()[m_active_elem])
|
|
);
|
|
}
|
|
|
|
template <typename V, typename OP, typename CMP, size_type... I>
|
|
sequence_range<V, OP, CMP, I...>::sequence_range (const V& parFrom, const V& parUpper) :
|
|
m_from(parFrom),
|
|
m_upper(parUpper),
|
|
m_end(implem::make_end_vector<V, I...>(parFrom, parUpper)),
|
|
m_step(1)
|
|
{
|
|
}
|
|
|
|
template <typename V, typename OP, typename CMP, size_type... I>
|
|
sequence_range<V, OP, CMP, I...>::sequence_range (const V& parFrom, const V& parUpper, const V& parStep) :
|
|
m_from(parFrom),
|
|
m_upper(parUpper),
|
|
m_end(implem::make_end_vector<V, I...>(parFrom, parUpper)),
|
|
m_step(parStep)
|
|
{
|
|
}
|
|
|
|
template <typename V, typename OP, typename CMP, size_type... I>
|
|
auto sequence_range<V, OP, CMP, I...>::cbegin() const -> const_iterator {
|
|
return sequence_range_iterator<V, OP, CMP, I...>(*this);
|
|
}
|
|
|
|
template <typename V, typename OP, typename CMP, size_type... I>
|
|
auto sequence_range<V, OP, CMP, I...>::cend() const -> const_iterator {
|
|
return sequence_range_iterator<V, OP, CMP, I...>(m_end, *this);
|
|
}
|
|
|
|
template <typename V>
|
|
using increasing_sequence_range = typename implem::make_sequence_helper<
|
|
typename V::vector_type,
|
|
std::plus<typename V::scalar_type>,
|
|
std::less<typename V::scalar_type>,
|
|
bt::number_range<size_type, 0, V::dimensions>
|
|
>::type;
|
|
} //namespace vwr
|
|
|
|
#if defined VWR_OUTER_NAMESPACE
|
|
} //namespace VWR_OUTER_NAMESPACE
|
|
#endif
|