#pragma once
/*
* Copyright (C) 2024 Brett Terpstra
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of 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.
*
* This program 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 a copy of the GNU General Public License
* along with this program. If not, see .
*/
#ifndef BLT_ITERATOR_ITER_COMMON
#define BLT_ITERATOR_ITER_COMMON
#include
#include
#include
#include
#include
#include
namespace blt::iterator
{
template
struct base_wrapper
{
base_wrapper operator++(int)
{
auto tmp = *this;
++*this;
return tmp;
}
base_wrapper operator--(int)
{
static_assert(meta::is_bidirectional_or_better_category_v, "Iterator must allow random access");
auto tmp = *this;
--*this;
return tmp;
}
auto operator[](blt::ptrdiff_t n) const
{
static_assert(meta::is_random_access_iterator_category_v, "Iterator must allow random access");
return *(*this + n);
}
friend base_wrapper operator+(blt::ptrdiff_t n, const base_wrapper& a)
{
return a + n;
}
friend bool operator<(const base_wrapper& a, const base_wrapper& b)
{
static_assert(meta::is_random_access_iterator_category_v, "Iterator must allow random access");
return b - a > 0;
}
friend bool operator>(const base_wrapper& a, const base_wrapper& b)
{
static_assert(meta::is_random_access_iterator_category_v, "Iterator must allow random access");
return b < a;
}
friend bool operator>=(const base_wrapper& a, base_wrapper& b)
{
static_assert(meta::is_random_access_iterator_category_v, "Iterator must allow random access");
return !(a < b); // NOLINT
}
friend bool operator<=(const base_wrapper& a, const base_wrapper& b)
{
static_assert(meta::is_random_access_iterator_category_v, "Iterator must allow random access");
return !(a > b); // NOLINT
}
friend bool operator==(const base_wrapper& a, const base_wrapper& b)
{
return static_cast(a).base() == static_cast(b).base();
}
friend bool operator!=(const base_wrapper& a, const base_wrapper& b)
{
return !(static_cast(a).base() == static_cast(b).base()); // NOLINT
}
};
template
struct passthrough_wrapper : public base_wrapper
{
public:
explicit passthrough_wrapper(Iter iter): iter(std::move(iter))
{}
auto base() const
{
return iter;
}
friend blt::ptrdiff_t operator-(const passthrough_wrapper& a, const passthrough_wrapper& b)
{
return a.base() - b.base();
}
protected:
Iter iter;
};
template
struct passthrough_wrapper : public passthrough_wrapper
{
using passthrough_wrapper::passthrough_wrapper;
meta::deref_return_t operator*() const
{
return *this->iter;
}
// zip_wrapper& operator++()
// {
// return *this;
// }
//
// zip_wrapper& operator--()
// {
// return *this;
// }
//
// friend zip_wrapper operator+(const zip_wrapper& a, blt::ptrdiff_t n)
// {
// static_assert(std::is_same_v,
// "Iterator must allow random access");
// }
//
// friend zip_wrapper operator-(const zip_wrapper& a, blt::ptrdiff_t n)
// {
// static_assert(std::is_same_v,
// "Iterator must allow random access");
// }
};
namespace impl
{
template
class skip_t
{
private:
template
auto skip_base(blt::size_t n)
{
auto* d = static_cast(this);
auto begin = d->begin();
auto end = d->end();
if constexpr (meta::is_random_access_iterator_category_v)
{
// random access iterators can have math directly applied to them.
if constexpr (check)
{
return Derived{begin + std::min(static_cast(n), std::distance(begin, end)), end};
} else
{
return Derived{begin + n, 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:
auto skip(blt::size_t n)
{ return skip_base(n); }
auto skip_or(blt::size_t n)
{ return skip_base(n); }
};
template
class take_t
{
private:
template
auto take_base(blt::size_t n)
{
static_assert(!meta::is_input_iterator_category_v,
"Cannot .take() on an input iterator!");
auto* d = static_cast(this);
auto begin = d->begin();
auto end = d->end();
// take variant for forward and bidirectional iterators
if constexpr (meta::is_forward_iterator_category_v ||
meta::is_bidirectional_iterator_category_v)
{
// 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)
{
// random access iterators can have math directly applied to them.
if constexpr (check)
{
return Derived{begin, begin + std::min(static_cast(n), std::distance(begin, end))};
} else
{
return Derived{begin, begin + n};
}
}
}
public:
auto take(blt::size_t n)
{ return take_base(n); }
auto take_or(blt::size_t n)
{ return take_base(n); }
};
}
template
class iterator_container : public impl::take_t>,
public impl::skip_t>
{
public:
using iterator_category = typename std::iterator_traits::iterator_category;
using iterator = IterBase;
iterator_container(IterBase begin, IterBase end): m_begin(std::move(begin)), m_end(std::move(end))
{}
template
iterator_container(Iter&& begin, Iter&& end): m_begin(std::forward(begin)), m_end(std::forward(end))
{}
auto rev() const
{
static_assert(meta::is_bidirectional_or_better_category_v,
".rev() must be used with bidirectional (or better) iterators!");
return iterator_container>{std::reverse_iterator{end()},
std::reverse_iterator{begin()}};
}
template
auto zip(iterator_pair... iterator_pairs) const
{
return zip_iterator_container(iterator_pair{begin(), end()}, iterator_pairs...);
}
template
auto zip(Container& ... containers) const
{
return zip_iterator_container(iterator_pair{begin(), end()},
iterator_pair{containers.begin(), containers.end()}...);
}
template
auto zip(const Container& ... containers) const
{
return zip_iterator_container(iterator_pair{begin(), end()},
iterator_pair{containers.begin(), containers.end()}...);
}
auto enumerate() const
{
return enumerate_iterator_container{begin(), end(), static_cast(std::distance(begin(), 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