tri11paragon
/
BLT
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

add zip for single iterator pairs

v2
Brett 2025-01-07 13:51:18 -05:00
parent c953ef3544
commit 9860845831
3 changed files with 285 additions and 259 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
CMakeLists.txt
View File

@ -1,6 +1,6 @@
cmake_minimum_required(VERSION 3.20) cmake_minimum_required(VERSION 3.20)
include(cmake/color.cmake) include(cmake/color.cmake)
set(BLT_VERSION 2.1.13) set(BLT_VERSION 2.1.14)
set(BLT_TARGET BLT) set(BLT_TARGET BLT)

0
commit.py Normal file → Executable file
View File

542
include/blt/iterator/common.h
View File

@ -30,7 +30,7 @@
namespace blt::iterator namespace blt::iterator
{ {
template<typename Derived> template <typename Derived>
struct base_wrapper struct base_wrapper
{ {
base_wrapper operator++(int) base_wrapper operator++(int)
@ -39,7 +39,7 @@ namespace blt::iterator
++*this; ++*this;
return tmp; return tmp;
} }
base_wrapper operator--(int) base_wrapper operator--(int)
{ {
static_assert(meta::is_bidirectional_or_better_category_v<typename Derived::iterator_category>, "Iterator must allow random access"); static_assert(meta::is_bidirectional_or_better_category_v<typename Derived::iterator_category>, "Iterator must allow random access");
@ -47,347 +47,373 @@ namespace blt::iterator
--*this; --*this;
return tmp; return tmp;
} }
auto operator[](blt::ptrdiff_t n) const auto operator[](blt::ptrdiff_t n) const
{ {
static_assert(meta::is_random_access_iterator_category_v<typename Derived::iterator_category>, "Iterator must allow random access"); static_assert(meta::is_random_access_iterator_category_v<typename Derived::iterator_category>, "Iterator must allow random access");
return *(*this + n); return *(*this + n);
} }
friend base_wrapper operator+(blt::ptrdiff_t n, const base_wrapper& a) friend base_wrapper operator+(blt::ptrdiff_t n, const base_wrapper& a)
{ {
return a + n; return a + n;
} }
friend bool operator<(const base_wrapper& a, const base_wrapper& b) friend bool operator<(const base_wrapper& a, const base_wrapper& b)
{ {
static_assert(meta::is_random_access_iterator_category_v<typename Derived::iterator_category>, "Iterator must allow random access"); static_assert(meta::is_random_access_iterator_category_v<typename Derived::iterator_category>, "Iterator must allow random access");
return b - a > 0; return b - a > 0;
} }
friend bool operator>(const base_wrapper& a, const base_wrapper& b) friend bool operator>(const base_wrapper& a, const base_wrapper& b)
{ {
static_assert(meta::is_random_access_iterator_category_v<typename Derived::iterator_category>, "Iterator must allow random access"); static_assert(meta::is_random_access_iterator_category_v<typename Derived::iterator_category>, "Iterator must allow random access");
return b < a; return b < a;
} }
friend bool operator>=(const base_wrapper& a, base_wrapper& b) friend bool operator>=(const base_wrapper& a, base_wrapper& b)
{ {
static_assert(meta::is_random_access_iterator_category_v<typename Derived::iterator_category>, "Iterator must allow random access"); static_assert(meta::is_random_access_iterator_category_v<typename Derived::iterator_category>, "Iterator must allow random access");
return !(a < b); // NOLINT return !(a < b); // NOLINT
} }
friend bool operator<=(const base_wrapper& a, const base_wrapper& b) friend bool operator<=(const base_wrapper& a, const base_wrapper& b)
{ {
static_assert(meta::is_random_access_iterator_category_v<typename Derived::iterator_category>, "Iterator must allow random access"); static_assert(meta::is_random_access_iterator_category_v<typename Derived::iterator_category>, "Iterator must allow random access");
return !(a > b); // NOLINT return !(a > b); // NOLINT
} }
friend bool operator==(const base_wrapper& a, const base_wrapper& b) friend bool operator==(const base_wrapper& a, const base_wrapper& b)
{ {
return static_cast<const Derived&>(a).base() == static_cast<const Derived&>(b).base(); return static_cast<const Derived&>(a).base() == static_cast<const Derived&>(b).base();
} }
friend bool operator!=(const base_wrapper& a, const base_wrapper& b) friend bool operator!=(const base_wrapper& a, const base_wrapper& b)
{ {
return !(static_cast<const Derived&>(a).base() == static_cast<const Derived&>(b).base()); // NOLINT return !(static_cast<const Derived&>(a).base() == static_cast<const Derived&>(b).base()); // NOLINT
} }
}; };
template<typename Iter, typename Derived, bool dereference = false> template <typename Iter, typename Derived, bool dereference = false>
struct passthrough_wrapper : public base_wrapper<Derived> struct passthrough_wrapper : public base_wrapper<Derived>
{ {
public: public:
explicit passthrough_wrapper(Iter iter): iter(std::move(iter)) explicit passthrough_wrapper(Iter iter): iter(std::move(iter))
{} {
}
auto base() const
{ auto base() const
return iter; {
} return iter;
}
friend blt::ptrdiff_t operator-(const passthrough_wrapper& a, const passthrough_wrapper& b)
{ friend blt::ptrdiff_t operator-(const passthrough_wrapper& a, const passthrough_wrapper& b)
return a.base() - b.base(); {
} return a.base() - b.base();
}
protected:
mutable Iter iter; protected:
mutable Iter iter;
}; };
template<typename Iter, typename Derived> template <typename Iter, typename Derived>
struct passthrough_wrapper<Iter, Derived, true> : public passthrough_wrapper<Iter, Derived> struct passthrough_wrapper<Iter, Derived, true> : public passthrough_wrapper<Iter, Derived>
{ {
using passthrough_wrapper<Iter, Derived>::passthrough_wrapper; using passthrough_wrapper<Iter, Derived>::passthrough_wrapper;
meta::deref_return_t<Iter> operator*() const meta::deref_return_t<Iter> operator*() const
{ {
return *this->iter; return *this->iter;
} }
}; };
template<typename Iter, typename Derived> template <typename Iter, typename Derived>
class deref_only_wrapper : public passthrough_wrapper<Iter, Derived, false> class deref_only_wrapper : public passthrough_wrapper<Iter, Derived, false>
{ {
public: public:
using passthrough_wrapper<Iter, Derived, false>::passthrough_wrapper; using passthrough_wrapper<Iter, Derived, false>::passthrough_wrapper;
deref_only_wrapper& operator++() deref_only_wrapper& operator++()
{ {
++this->iter; ++this->iter;
return *this; return *this;
} }
deref_only_wrapper& operator--() deref_only_wrapper& operator--()
{ {
--this->iter; --this->iter;
return *this; return *this;
} }
deref_only_wrapper& operator+(blt::ptrdiff_t n) deref_only_wrapper& operator+(blt::ptrdiff_t n)
{ {
static_assert(meta::is_random_access_iterator_v<Iter>, "Iterator must allow random access"); static_assert(meta::is_random_access_iterator_v<Iter>, "Iterator must allow random access");
this->iter = this->iter + n; this->iter = this->iter + n;
return *this; return *this;
} }
deref_only_wrapper& operator-(blt::ptrdiff_t n) deref_only_wrapper& operator-(blt::ptrdiff_t n)
{ {
static_assert(meta::is_random_access_iterator_v<Iter>, "Iterator must allow random access"); static_assert(meta::is_random_access_iterator_v<Iter>, "Iterator must allow random access");
this->iter = this->iter - n; this->iter = this->iter - n;
return *this; return *this;
} }
}; };
template<typename Iter, typename Func> template <typename Iter, typename Func>
class map_wrapper : public deref_only_wrapper<Iter, map_wrapper<Iter, Func>> class map_wrapper : public deref_only_wrapper<Iter, map_wrapper<Iter, Func>>
{ {
public: public:
using iterator_category = typename std::iterator_traits<Iter>::iterator_category; using iterator_category = typename std::iterator_traits<Iter>::iterator_category;
using value_type = std::invoke_result_t<Func, meta::deref_return_t<Iter>>; using value_type = std::invoke_result_t<Func, meta::deref_return_t<Iter>>;
using difference_type = blt::ptrdiff_t; using difference_type = blt::ptrdiff_t;
using pointer = value_type; using pointer = value_type;
using reference = value_type; using reference = value_type;
map_wrapper(Iter iter, Func func): map_wrapper(Iter iter, Func func):
deref_only_wrapper<Iter, map_wrapper<Iter, Func>>(std::move(iter)), func(std::move(func)) deref_only_wrapper<Iter, map_wrapper<Iter, Func>>(std::move(iter)), func(std::move(func))
{} {
}
reference operator*() const
{ reference operator*() const
return func(*this->iter); {
} return func(*this->iter);
}
private:
Func func; private:
Func func;
}; };
template<typename Iter, typename Pred> template <typename Iter, typename Pred>
class filter_wrapper : public deref_only_wrapper<Iter, filter_wrapper<Iter, Pred>> class filter_wrapper : public deref_only_wrapper<Iter, filter_wrapper<Iter, Pred>>
{ {
public: public:
using iterator_category = typename std::iterator_traits<Iter>::iterator_category; using iterator_category = typename std::iterator_traits<Iter>::iterator_category;
using value_type = std::conditional_t< using value_type = std::conditional_t<
std::is_reference_v<meta::deref_return_t<Iter>>, std::is_reference_v<meta::deref_return_t<Iter>>,
std::optional<std::reference_wrapper<std::remove_reference_t<meta::deref_return_t<Iter>>>>, std::optional<std::reference_wrapper<std::remove_reference_t<meta::deref_return_t<Iter>>>>,
std::optional<meta::deref_return_t<Iter>>>; std::optional<meta::deref_return_t<Iter>>>;
using difference_type = blt::ptrdiff_t; using difference_type = blt::ptrdiff_t;
using pointer = value_type; using pointer = value_type;
using reference = value_type; using reference = value_type;
filter_wrapper(Iter iter, Pred func): filter_wrapper(Iter iter, Pred func):
deref_only_wrapper<Iter, filter_wrapper<Iter, Pred>>(std::move(iter)), func(std::move(func)) deref_only_wrapper<Iter, filter_wrapper<Iter, Pred>>(std::move(iter)), func(std::move(func))
{} {
}
reference operator*() const
reference operator*() const
{
if (!func(*this->iter))
{ {
if (!func(*this->iter)) return {};
{
return {};
}
return *this->iter;
} }
return *this->iter;
private: }
Pred func;
private:
Pred func;
}; };
namespace impl namespace impl
{ {
template<typename Derived> template <typename Derived>
class skip_t class skip_t
{ {
private: private:
template<bool check> template <bool check>
auto skip_base(blt::size_t n) auto skip_base(blt::size_t n)
{
auto* d = static_cast<Derived*>(this);
auto begin = d->begin();
auto end = d->end();
if constexpr (meta::is_random_access_iterator_category_v<typename Derived::iterator_category>)
{ {
auto* d = static_cast<Derived*>(this); // random access iterators can have math directly applied to them.
auto begin = d->begin(); if constexpr (check)
auto end = d->end();
if constexpr (meta::is_random_access_iterator_category_v<typename Derived::iterator_category>)
{ {
// random access iterators can have math directly applied to them. return Derived{begin + std::min(static_cast<blt::ptrdiff_t>(n), std::distance(begin, end)), end};
if constexpr (check) }
{ else
return Derived{begin + std::min(static_cast<blt::ptrdiff_t>(n), std::distance(begin, end)), end};
} else
{
return Derived{begin + n, end};
}
} else
{ {
for (blt::size_t i = 0; i < n; i++) return Derived{begin + n, end};
{
if constexpr (check)
{
if (begin == end)
break;
}
++begin;
}
return Derived{std::move(begin), std::move(end)};
} }
} }
else
public: {
auto skip(blt::size_t n) for (blt::size_t i = 0; i < n; i++)
{ return skip_base<false>(n); } {
if constexpr (check)
auto skip_or(blt::size_t n) {
{ return skip_base<true>(n); } if (begin == end)
break;
}
++begin;
}
return Derived{std::move(begin), std::move(end)};
}
}
public:
auto skip(blt::size_t n)
{
return skip_base<false>(n);
}
auto skip_or(blt::size_t n)
{
return skip_base<true>(n);
}
}; };
template<typename Derived> template <typename Derived>
class take_t class take_t
{ {
private: private:
template<bool check> template <bool check>
auto take_base(blt::size_t n) auto take_base(blt::size_t n)
{
static_assert(!meta::is_input_iterator_category_v<typename Derived::iterator_category>,
"Cannot .take() on an input iterator!");
auto* d = static_cast<Derived*>(this);
auto begin = d->begin();
auto end = d->end();
// take variant for forward and bidirectional iterators
if constexpr (meta::is_forward_iterator_category_v<typename Derived::iterator_category> ||
meta::is_bidirectional_iterator_category_v<typename Derived::iterator_category>)
{ {
static_assert(!meta::is_input_iterator_category_v<typename Derived::iterator_category>, // with these guys we have to loop forward to move the iterators. an unfortunate inefficiency
"Cannot .take() on an input iterator!"); auto new_end = begin;
auto* d = static_cast<Derived*>(this); for (blt::size_t i = 0; i < n; i++)
auto begin = d->begin();
auto end = d->end();
// take variant for forward and bidirectional iterators
if constexpr (meta::is_forward_iterator_category_v<typename Derived::iterator_category> ||
meta::is_bidirectional_iterator_category_v<typename Derived::iterator_category>)
{ {
// with these guys we have to loop forward to move the iterators. an unfortunate inefficiency
auto new_end = begin;
for (blt::size_t i = 0; i < n; i++)
{
if constexpr (check)
{
if (new_end == end)
break;
}
++new_end;
}
return Derived{std::move(begin), std::move(new_end)};
} else if constexpr (meta::is_random_access_iterator_category_v<typename Derived::iterator_category>)
{
// random access iterators can have math directly applied to them.
if constexpr (check) if constexpr (check)
{ {
return Derived{begin, begin + std::min(static_cast<blt::ptrdiff_t>(n), std::distance(begin, end))}; if (new_end == end)
} else break;
{
return Derived{begin, begin + n};
} }
++new_end;
}
return Derived{std::move(begin), std::move(new_end)};
}
else if constexpr (meta::is_random_access_iterator_category_v<typename Derived::iterator_category>)
{
// random access iterators can have math directly applied to them.
if constexpr (check)
{
return Derived{begin, begin + std::min(static_cast<blt::ptrdiff_t>(n), std::distance(begin, end))};
}
else
{
return Derived{begin, begin + n};
} }
} }
}
public:
auto take(blt::size_t n) public:
{ return take_base<false>(n); } auto take(blt::size_t n)
{
auto take_or(blt::size_t n) return take_base<false>(n);
{ return take_base<true>(n); } }
auto take_or(blt::size_t n)
{
return take_base<true>(n);
}
}; };
} }
template<typename IterBase> template <typename IterBase>
class iterator_container : public impl::take_t<iterator_container<IterBase>>, class iterator_container : public impl::take_t<iterator_container<IterBase>>,
public impl::skip_t<iterator_container<IterBase>> public impl::skip_t<iterator_container<IterBase>>
{ {
public: public:
using iterator_category = typename std::iterator_traits<IterBase>::iterator_category; using iterator_category = typename std::iterator_traits<IterBase>::iterator_category;
using iterator = IterBase; using iterator = IterBase;
iterator_container(IterBase begin, IterBase end): m_begin(std::move(begin)), m_end(std::move(end)) iterator_container(IterBase begin, IterBase end): m_begin(std::move(begin)), m_end(std::move(end))
{} {
}
template<typename Iter>
iterator_container(Iter&& begin, Iter&& end): m_begin(std::forward<Iter>(begin)), m_end(std::forward<Iter>(end)) template <typename Iter>
{} iterator_container(Iter&& begin, Iter&& end): m_begin(std::forward<Iter>(begin)), m_end(std::forward<Iter>(end))
{
auto rev() const }
{
static_assert(meta::is_bidirectional_or_better_category_v<iterator_category>, auto rev() const
".rev() must be used with bidirectional (or better) iterators!"); {
return iterator_container<std::reverse_iterator<IterBase>>{std::reverse_iterator<IterBase>{end()}, static_assert(meta::is_bidirectional_or_better_category_v<iterator_category>,
std::reverse_iterator<IterBase>{begin()}}; ".rev() must be used with bidirectional (or better) iterators!");
} return iterator_container<std::reverse_iterator<IterBase>>{
std::reverse_iterator<IterBase>{end()},
template<typename... Iter> std::reverse_iterator<IterBase>{begin()}
auto zip(iterator_pair<Iter>... iterator_pairs) const };
{ }
return zip_iterator_container(iterator_pair<decltype(begin())>{begin(), end()}, iterator_pairs...);
} template <typename... Iter>
auto zip(iterator_pair<Iter>... iterator_pairs) const
template<typename... Container> {
auto zip(Container& ... containers) const return zip_iterator_container(iterator_pair<decltype(begin())>{begin(), end()}, iterator_pairs...);
{ }
return zip_iterator_container(iterator_pair<decltype(begin())>{begin(), end()},
iterator_pair{containers.begin(), containers.end()}...); template <typename... Container>
} auto zip(Container&... containers) const
{
template<typename... Container> return zip_iterator_container(iterator_pair<decltype(begin())>{begin(), end()},
auto zip(const Container& ... containers) const iterator_pair{containers.begin(), containers.end()}...);
{ }
return zip_iterator_container(iterator_pair<decltype(begin())>{begin(), end()},
iterator_pair{containers.begin(), containers.end()}...); template <typename... Container>
} auto zip(const Container&... containers) const
{
auto enumerate() const return zip_iterator_container(iterator_pair<decltype(begin())>{begin(), end()},
{ iterator_pair{containers.begin(), containers.end()}...);
return enumerate_iterator_container{begin(), end(), static_cast<blt::size_t>(std::distance(begin(), end()))}; }
}
template <typename Iter>
template<typename Func> auto zip(Iter begin, Iter end)
auto map(Func func) const {
{ return zip(iterator_pair<Iter>{begin, end});
return iterator_container<blt::iterator::map_wrapper<IterBase, Func>>{ }
blt::iterator::map_wrapper<IterBase, Func>{m_begin, func},
blt::iterator::map_wrapper<IterBase, Func>{m_end, func}}; auto enumerate() const
} {
return enumerate_iterator_container{begin(), end(), static_cast<blt::size_t>(std::distance(begin(), end()))};
template<typename Pred> }
auto filter(Pred pred) const
{ template <typename Func>
return iterator_container<blt::iterator::filter_wrapper<IterBase, Pred>>{ auto map(Func func) const
blt::iterator::filter_wrapper<IterBase, Pred>{m_begin, pred}, {
blt::iterator::filter_wrapper<IterBase, Pred>{m_end, pred}}; return iterator_container<blt::iterator::map_wrapper<IterBase, Func>>{
} blt::iterator::map_wrapper<IterBase, Func>{m_begin, func},
blt::iterator::map_wrapper<IterBase, Func>{m_end, func}
auto begin() const };
{ }
return m_begin;
} template <typename Pred>
auto filter(Pred pred) const
auto end() const {
{ return iterator_container<blt::iterator::filter_wrapper<IterBase, Pred>>{
return m_end; blt::iterator::filter_wrapper<IterBase, Pred>{m_begin, pred},
} blt::iterator::filter_wrapper<IterBase, Pred>{m_end, pred}
};
protected: }
IterBase m_begin;
IterBase m_end; auto begin() const
{
return m_begin;
}
auto end() const
{
return m_end;
}
protected:
IterBase m_begin;
IterBase m_end;
}; };
} }
#endif //BLT_ITERATOR_ITER_COMMON #endif //BLT_ITERATOR_ITER_COMMON