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)
include(cmake/color.cmake)
set(BLT_VERSION 2.1.13)
set(BLT_VERSION 2.1.14)
set(BLT_TARGET BLT)

0
commit.py Normal file → Executable file
View File

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

@ -30,7 +30,7 @@
namespace blt::iterator
{
template<typename Derived>
template <typename Derived>
struct base_wrapper
{
base_wrapper operator++(int)
@ -94,12 +94,13 @@ 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>
{
public:
explicit passthrough_wrapper(Iter iter): iter(std::move(iter))
{}
{
}
auto base() const
{
@ -115,7 +116,7 @@ namespace blt::iterator
mutable Iter iter;
};
template<typename Iter, typename Derived>
template <typename Iter, typename Derived>
struct passthrough_wrapper<Iter, Derived, true> : public passthrough_wrapper<Iter, Derived>
{
using passthrough_wrapper<Iter, Derived>::passthrough_wrapper;
@ -126,7 +127,7 @@ namespace blt::iterator
}
};
template<typename Iter, typename Derived>
template <typename Iter, typename Derived>
class deref_only_wrapper : public passthrough_wrapper<Iter, Derived, false>
{
public:
@ -159,7 +160,7 @@ namespace blt::iterator
}
};
template<typename Iter, typename Func>
template <typename Iter, typename Func>
class map_wrapper : public deref_only_wrapper<Iter, map_wrapper<Iter, Func>>
{
public:
@ -171,7 +172,8 @@ namespace blt::iterator
map_wrapper(Iter iter, Func func):
deref_only_wrapper<Iter, map_wrapper<Iter, Func>>(std::move(iter)), func(std::move(func))
{}
{
}
reference operator*() const
{
@ -182,7 +184,7 @@ namespace blt::iterator
Func func;
};
template<typename Iter, typename Pred>
template <typename Iter, typename Pred>
class filter_wrapper : public deref_only_wrapper<Iter, filter_wrapper<Iter, Pred>>
{
public:
@ -197,7 +199,8 @@ namespace blt::iterator
filter_wrapper(Iter iter, Pred func):
deref_only_wrapper<Iter, filter_wrapper<Iter, Pred>>(std::move(iter)), func(std::move(func))
{}
{
}
reference operator*() const
{
@ -214,11 +217,11 @@ namespace blt::iterator
namespace impl
{
template<typename Derived>
template <typename Derived>
class skip_t
{
private:
template<bool check>
template <bool check>
auto skip_base(blt::size_t n)
{
auto* d = static_cast<Derived*>(this);
@ -231,11 +234,13 @@ namespace blt::iterator
if constexpr (check)
{
return Derived{begin + std::min(static_cast<blt::ptrdiff_t>(n), std::distance(begin, end)), end};
} else
}
else
{
return Derived{begin + n, end};
}
} else
}
else
{
for (blt::size_t i = 0; i < n; i++)
{
@ -252,17 +257,21 @@ namespace blt::iterator
public:
auto skip(blt::size_t n)
{ return skip_base<false>(n); }
{
return skip_base<false>(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
{
private:
template<bool check>
template <bool check>
auto take_base(blt::size_t n)
{
static_assert(!meta::is_input_iterator_category_v<typename Derived::iterator_category>,
@ -287,13 +296,15 @@ namespace blt::iterator
++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>)
}
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
}
else
{
return Derived{begin, begin + n};
}
@ -302,14 +313,18 @@ namespace blt::iterator
public:
auto take(blt::size_t n)
{ return take_base<false>(n); }
{
return take_base<false>(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>>,
public impl::skip_t<iterator_container<IterBase>>
{
@ -318,59 +333,71 @@ namespace blt::iterator
using iterator = IterBase;
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))
{}
{
}
auto rev() const
{
static_assert(meta::is_bidirectional_or_better_category_v<iterator_category>,
".rev() must be used with bidirectional (or better) iterators!");
return iterator_container<std::reverse_iterator<IterBase>>{std::reverse_iterator<IterBase>{end()},
std::reverse_iterator<IterBase>{begin()}};
return iterator_container<std::reverse_iterator<IterBase>>{
std::reverse_iterator<IterBase>{end()},
std::reverse_iterator<IterBase>{begin()}
};
}
template<typename... Iter>
template <typename... Iter>
auto zip(iterator_pair<Iter>... iterator_pairs) const
{
return zip_iterator_container(iterator_pair<decltype(begin())>{begin(), end()}, iterator_pairs...);
}
template<typename... Container>
auto zip(Container& ... containers) const
template <typename... Container>
auto zip(Container&... containers) const
{
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
template <typename... Container>
auto zip(const Container&... containers) const
{
return zip_iterator_container(iterator_pair<decltype(begin())>{begin(), end()},
iterator_pair{containers.begin(), containers.end()}...);
}
template <typename Iter>
auto zip(Iter begin, Iter end)
{
return zip(iterator_pair<Iter>{begin, end});
}
auto enumerate() const
{
return enumerate_iterator_container{begin(), end(), static_cast<blt::size_t>(std::distance(begin(), end()))};
}
template<typename Func>
template <typename Func>
auto map(Func func) const
{
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}};
blt::iterator::map_wrapper<IterBase, Func>{m_end, func}
};
}
template<typename Pred>
template <typename Pred>
auto filter(Pred pred) const
{
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}};
blt::iterator::filter_wrapper<IterBase, Pred>{m_end, pred}
};
}
auto begin() const
@ -387,7 +414,6 @@ namespace blt::iterator
IterBase m_begin;
IterBase m_end;
};
}
#endif //BLT_ITERATOR_ITER_COMMON