#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
namespace blt::iterator
{
template
struct base_wrapper
{
base_wrapper operator++(int)
{
auto tmp = *this;
++*this;
return tmp;
}
base_wrapper operator--(int)
{
static_assert(std::is_same_v ||
std::is_same_v,
"Iterator must allow random access");
auto tmp = *this;
--*this;
return tmp;
}
auto operator[](blt::ptrdiff_t n) const
{
static_assert(std::is_same_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(std::is_same_v,
"Iterator must allow random access");
return b - a > 0;
}
friend bool operator>(const base_wrapper& a, const base_wrapper& b)
{
static_assert(std::is_same_v,
"Iterator must allow random access");
return b < a;
}
friend bool operator>=(const base_wrapper& a, base_wrapper& b)
{
static_assert(std::is_same_v,
"Iterator must allow random access");
return !(a < b); // NOLINT
}
friend bool operator<=(const base_wrapper& a, const base_wrapper& b)
{
static_assert(std::is_same_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;
}
};
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 (std::is_same_v ||
std::is_same_v)
{
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)};
} else if constexpr (std::is_same_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};
}
}
}
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(!std::is_same_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 (std::is_same_v ||
std::is_same_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 (std::is_same_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 IterBase::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()
{
static_assert((std::is_same_v ||
std::is_same_v),
".rev() must be used with bidirectional (or better) iterators!");
return iterator_container>{std::reverse_iterator{end()},
std::reverse_iterator{begin()}};
}
auto begin() const
{
return m_begin;
}
auto end() const
{
return m_end;
}
protected:
IterBase m_begin;
IterBase m_end;
};
}
#endif //BLT_ITERATOR_ITER_COMMON