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

448
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)
@ -94,28 +94,29 @@ namespace blt::iterator
} }
}; };
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: protected:
mutable Iter iter; 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;
@ -126,268 +127,293 @@ namespace blt::iterator
} }
}; };
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: private:
Func func; 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: private:
Pred func; 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* d = static_cast<Derived*>(this);
auto begin = d->begin(); auto begin = d->begin();
auto end = d->end(); auto end = d->end();
if constexpr (meta::is_random_access_iterator_category_v<typename Derived::iterator_category>) 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)
{ {
// 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
{
for (blt::size_t i = 0; i < n; i++)
{
if constexpr (check)
{
if (begin == end)
break;
}
++begin;
}
return Derived{std::move(begin), std::move(end)};
}
}
public: public:
auto skip(blt::size_t n) auto skip(blt::size_t n)
{ return skip_base<false>(n); } {
return skip_base<false>(n);
}
auto skip_or(blt::size_t n) auto skip_or(blt::size_t n)
{ return skip_base<true>(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>, static_assert(!meta::is_input_iterator_category_v<typename Derived::iterator_category>,
"Cannot .take() on an input iterator!"); "Cannot .take() on an input iterator!");
auto* d = static_cast<Derived*>(this); auto* d = static_cast<Derived*>(this);
auto begin = d->begin(); auto begin = d->begin();
auto end = d->end(); auto end = d->end();
// take variant for forward and bidirectional iterators // take variant for forward and bidirectional iterators
if constexpr (meta::is_forward_iterator_category_v<typename Derived::iterator_category> || if constexpr (meta::is_forward_iterator_category_v<typename Derived::iterator_category> ||
meta::is_bidirectional_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++)
{ {
// 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: public:
auto take(blt::size_t n) auto take(blt::size_t n)
{ return take_base<false>(n); } {
return take_base<false>(n);
}
auto take_or(blt::size_t n) auto take_or(blt::size_t n)
{ return take_base<true>(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> template <typename Iter>
iterator_container(Iter&& begin, Iter&& end): m_begin(std::forward<Iter>(begin)), m_end(std::forward<Iter>(end)) iterator_container(Iter&& begin, Iter&& end): m_begin(std::forward<Iter>(begin)), m_end(std::forward<Iter>(end))
{} {
}
auto rev() const auto rev() const
{ {
static_assert(meta::is_bidirectional_or_better_category_v<iterator_category>, static_assert(meta::is_bidirectional_or_better_category_v<iterator_category>,
".rev() must be used with bidirectional (or better) iterators!"); ".rev() must be used with bidirectional (or better) iterators!");
return iterator_container<std::reverse_iterator<IterBase>>{std::reverse_iterator<IterBase>{end()}, return iterator_container<std::reverse_iterator<IterBase>>{
std::reverse_iterator<IterBase>{begin()}}; std::reverse_iterator<IterBase>{end()},
} std::reverse_iterator<IterBase>{begin()}
};
}
template<typename... Iter> template <typename... Iter>
auto zip(iterator_pair<Iter>... iterator_pairs) const auto zip(iterator_pair<Iter>... iterator_pairs) const
{ {
return zip_iterator_container(iterator_pair<decltype(begin())>{begin(), end()}, iterator_pairs...); return zip_iterator_container(iterator_pair<decltype(begin())>{begin(), end()}, iterator_pairs...);
} }
template<typename... Container> template <typename... Container>
auto zip(Container& ... containers) const auto zip(Container&... containers) const
{ {
return zip_iterator_container(iterator_pair<decltype(begin())>{begin(), end()}, return zip_iterator_container(iterator_pair<decltype(begin())>{begin(), end()},
iterator_pair{containers.begin(), containers.end()}...); iterator_pair{containers.begin(), containers.end()}...);
} }
template<typename... Container> template <typename... Container>
auto zip(const Container& ... containers) const auto zip(const Container&... containers) const
{ {
return zip_iterator_container(iterator_pair<decltype(begin())>{begin(), end()}, return zip_iterator_container(iterator_pair<decltype(begin())>{begin(), end()},
iterator_pair{containers.begin(), containers.end()}...); iterator_pair{containers.begin(), containers.end()}...);
} }
auto enumerate() const template <typename Iter>
{ auto zip(Iter begin, Iter end)
return enumerate_iterator_container{begin(), end(), static_cast<blt::size_t>(std::distance(begin(), end()))}; {
} return zip(iterator_pair<Iter>{begin, end});
}
template<typename Func> auto enumerate() const
auto map(Func func) const {
{ return enumerate_iterator_container{begin(), end(), static_cast<blt::size_t>(std::distance(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}};
}
template<typename Pred> template <typename Func>
auto filter(Pred pred) const auto map(Func func) const
{ {
return iterator_container<blt::iterator::filter_wrapper<IterBase, Pred>>{ return iterator_container<blt::iterator::map_wrapper<IterBase, Func>>{
blt::iterator::filter_wrapper<IterBase, Pred>{m_begin, pred}, blt::iterator::map_wrapper<IterBase, Func>{m_begin, func},
blt::iterator::filter_wrapper<IterBase, Pred>{m_end, pred}}; blt::iterator::map_wrapper<IterBase, Func>{m_end, func}
} };
}
auto begin() const template <typename Pred>
{ auto filter(Pred pred) const
return m_begin; {
} return iterator_container<blt::iterator::filter_wrapper<IterBase, Pred>>{
blt::iterator::filter_wrapper<IterBase, Pred>{m_begin, pred},
blt::iterator::filter_wrapper<IterBase, Pred>{m_end, pred}
};
}
auto end() const auto begin() const
{ {
return m_end; return m_begin;
} }
protected: auto end() const
IterBase m_begin; {
IterBase m_end; return m_end;
}
protected:
IterBase m_begin;
IterBase m_end;
}; };
} }
#endif //BLT_ITERATOR_ITER_COMMON #endif //BLT_ITERATOR_ITER_COMMON