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

silly

v1
Brett 2024-09-30 02:38:36 -04:00
parent 1830a3936b
commit 0e5d8b6043
6 changed files with 158 additions and 169 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 1.0.6)
set(BLT_VERSION 1.1.1)
set(BLT_TARGET BLT)

130
include/blt/iterator/common.h Normal file
View File

@ -0,0 +1,130 @@
#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 <https://www.gnu.org/licenses/>.
*/
#ifndef BLT_ITERATOR_ITER_COMMON
#define BLT_ITERATOR_ITER_COMMON
#include <type_traits>
#include <iterator>
namespace blt::iterator
{
template<typename Derived>
struct wrapper_base
{
wrapper_base operator++(int)
{
auto tmp = *this;
++*this;
return tmp;
}
wrapper_base operator--(int)
{
static_assert(std::is_same_v<typename Derived::iterator_category, std::bidirectional_iterator_tag> ||
std::is_same_v<typename Derived::iterator_category, std::random_access_iterator_tag>,
"Iterator must allow random access");
auto tmp = *this;
--*this;
return tmp;
}
auto operator[](blt::ptrdiff_t n) const
{
static_assert(std::is_same_v<typename Derived::iterator_category, std::random_access_iterator_tag>,
"Iterator must allow random access");
return *(*this + n);
}
friend wrapper_base operator+(const wrapper_base& a, blt::ptrdiff_t n)
{
static_assert(std::is_same_v<typename Derived::iterator_category, std::random_access_iterator_tag>,
"Iterator must allow random access");
auto copy = a;
copy += n;
return copy;
}
friend wrapper_base operator+(blt::ptrdiff_t n, const wrapper_base& a)
{
static_assert(std::is_same_v<typename Derived::iterator_category, std::random_access_iterator_tag>,
"Iterator must allow random access");
auto copy = a;
copy += n;
return copy;
}
friend wrapper_base operator-(const wrapper_base& a, blt::ptrdiff_t n)
{
static_assert(std::is_same_v<typename Derived::iterator_category, std::random_access_iterator_tag>,
"Iterator must allow random access");
auto copy = a;
copy -= n;
return copy;
}
friend wrapper_base operator-(blt::ptrdiff_t n, const wrapper_base& a)
{
static_assert(std::is_same_v<typename Derived::iterator_category, std::random_access_iterator_tag>,
"Iterator must allow random access");
auto copy = a;
copy -= n;
return copy;
}
friend bool operator<(const wrapper_base& a, const wrapper_base& b)
{
static_assert(std::is_same_v<typename Derived::iterator_category, std::random_access_iterator_tag>,
"Iterator must allow random access");
return b - a > 0;
}
friend bool operator>(const wrapper_base& a, const wrapper_base& b)
{
static_assert(std::is_same_v<typename Derived::iterator_category, std::random_access_iterator_tag>,
"Iterator must allow random access");
return b < a;
}
friend bool operator>=(const wrapper_base& a, wrapper_base& b)
{
static_assert(std::is_same_v<typename Derived::iterator_category, std::random_access_iterator_tag>,
"Iterator must allow random access");
return !(a < b); // NOLINT
}
friend bool operator<=(const wrapper_base& a, const wrapper_base& b)
{
static_assert(std::is_same_v<typename Derived::iterator_category, std::random_access_iterator_tag>,
"Iterator must allow random access");
return !(a > b); // NOLINT
}
friend bool operator==(const wrapper_base& a, const wrapper_base& b)
{
return a.base() == b.base();
}
friend bool operator!=(const wrapper_base& a, const wrapper_base& b)
{
return !(a.base() == b.base()); // NOLINT
}
};
}
#endif //BLT_ITERATOR_ITER_COMMON

30
include/blt/iterator/iter_common.h
View File

@ -1,30 +0,0 @@
#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 <https://www.gnu.org/licenses/>.
*/
#ifndef BLT_ITERATOR_ITER_COMMON
#define BLT_ITERATOR_ITER_COMMON
#include <type_traits>
#include <iterator>
namespace blt
{
}
#endif //BLT_ITERATOR_ITER_COMMON

2
include/blt/iterator/iterator.h
View File

@ -21,7 +21,7 @@
#include <blt/std/types.h>
#include <blt/std/logging.h>
#include <blt/iterator/iter_common.h>
#include <blt/iterator/common.h>
#include <blt/iterator/zip.h>
#include <blt/meta/meta.h>
#include <blt/meta/iterator.h>

155
include/blt/iterator/zip.h
View File

@ -19,7 +19,7 @@
#ifndef BLT_ITERATOR_ZIP
#define BLT_ITERATOR_ZIP
#include <blt/iterator/iter_common.h>
#include <blt/iterator/common.h>
#include <blt/meta/meta.h>
#include <blt/meta/iterator.h>
#include <tuple>
@ -28,14 +28,11 @@ namespace blt
{
namespace iterator
{
template<typename Tag, typename... Iter>
class zip_wrapper;
template<typename... Iter>
class zip_wrapper<std::input_iterator_tag, Iter...>
class zip_wrapper : public wrapper_base<zip_wrapper<Iter...>>
{
public:
using iterator_category = std::input_iterator_tag;
using iterator_category = meta::lowest_iterator_category_t<Iter...>;
using value_type = std::tuple<meta::deref_return_t<Iter>...>;
using difference_type = blt::ptrdiff_t;
using pointer = value_type;
@ -49,99 +46,18 @@ namespace blt
return std::apply([](auto& ... i) { return std::tuple<meta::deref_return_t<Iter>...>{*i...}; }, iter);
}
friend bool operator==(const zip_wrapper& a, const zip_wrapper& b)
{
return a.iter == b.iter;
}
friend bool operator!=(const zip_wrapper& a, const zip_wrapper& b)
{
return !(a.iter == b.iter);
}
zip_wrapper& operator++()
{
std::apply([](auto& ... i) { ((++i), ...); }, iter);
return *this;
}
zip_wrapper operator++(int)
{
auto tmp = *this;
++*this;
return tmp;
}
auto raw_tuple()
{
return iter;
}
protected:
std::tuple<Iter...> iter;
};
template<typename... Iter>
class zip_wrapper<std::forward_iterator_tag, Iter...> : public zip_wrapper<std::input_iterator_tag, Iter...>
{
public:
using iterator_category = std::forward_iterator_tag;
using value_type = std::tuple<meta::deref_return_t<Iter>...>;
using difference_type = blt::ptrdiff_t;
using pointer = value_type;
using reference = value_type;
using zip_wrapper<std::input_iterator_tag, Iter...>::zip_wrapper;
};
template<typename... Iter>
class zip_wrapper<std::bidirectional_iterator_tag, Iter...> : public zip_wrapper<std::forward_iterator_tag, Iter...>
{
public:
using iterator_category = std::bidirectional_iterator_tag;
using value_type = std::tuple<meta::deref_return_t<Iter>...>;
using difference_type = blt::ptrdiff_t;
using pointer = value_type;
using reference = value_type;
public:
using zip_wrapper<std::forward_iterator_tag, Iter...>::zip_wrapper;
zip_wrapper& operator--()
{
std::apply([](auto& ... i) { ((--i), ...); }, this->iter);
return *this;
}
zip_wrapper operator--(int)
{
auto tmp = *this;
--*this;
return tmp;
}
};
template<typename... Iter>
class zip_wrapper<std::random_access_iterator_tag, Iter...> : public zip_wrapper<std::bidirectional_iterator_tag, Iter...>
{
public:
using iterator_category = std::random_access_iterator_tag;
using value_type = std::tuple<meta::deref_return_t<Iter>...>;
using difference_type = blt::ptrdiff_t;
using pointer = value_type;
using reference = value_type;
private:
template<typename T, T... n>
static blt::ptrdiff_t sub(const zip_wrapper& a, const zip_wrapper& b,
std::integer_sequence<T, n...>)
{
blt::ptrdiff_t min = std::numeric_limits<blt::ptrdiff_t>::max();
((min = std::min(min, std::get<n>(a.iter) - std::get<n>(b.iter))), ...);
return min;
}
public:
using zip_wrapper<std::bidirectional_iterator_tag, Iter...>::zip_wrapper;
zip_wrapper& operator+=(blt::ptrdiff_t n)
{
std::apply([n](auto& ... i) { ((i += n), ...); }, this->iter);
@ -154,54 +70,26 @@ namespace blt
return *this;
}
friend zip_wrapper operator+(const zip_wrapper& a, blt::ptrdiff_t n)
{
return std::apply([n](auto& ... i) { return zip_wrapper{(i + n)...}; }, a.iter);
}
friend zip_wrapper operator+(blt::ptrdiff_t n, const zip_wrapper& a)
{
return std::apply([n](auto& ... i) { return zip_wrapper{(i + n)...}; }, a.iter);
}
friend zip_wrapper operator-(const zip_wrapper& a, blt::ptrdiff_t n)
{
return std::apply([n](auto& ... i) { return zip_wrapper{(i - n)...}; }, a.iter);
}
friend zip_wrapper operator-(blt::ptrdiff_t n, const zip_wrapper& a)
{
return std::apply([n](auto& ... i) { return zip_wrapper{(i - n)...}; }, a.iter);
}
friend blt::ptrdiff_t operator-(const zip_wrapper& a, const zip_wrapper& b)
{
return sub(a, b, std::index_sequence_for<Iter...>());
}
auto operator[](blt::ptrdiff_t n) const
auto base()
{
return *(*this + n);
return iter;
}
friend bool operator<(const zip_wrapper& a, const zip_wrapper& b)
{
return b - a > 0;
}
protected:
std::tuple<Iter...> iter;
friend bool operator>(const zip_wrapper& a, const zip_wrapper& b)
template<typename T, T... n>
static blt::ptrdiff_t sub(const zip_wrapper& a, const zip_wrapper& b,
std::integer_sequence<T, n...>)
{
return b < a;
}
friend bool operator>=(const zip_wrapper& a, const zip_wrapper& b)
{
return !(a < b); // NOLINT
}
friend bool operator<=(const zip_wrapper& a, const zip_wrapper& b)
{
return !(a > b); // NOLINT
blt::ptrdiff_t min = std::numeric_limits<blt::ptrdiff_t>::max();
((min = std::min(min, std::get<n>(a.iter) - std::get<n>(b.iter))), ...);
return min;
}
};
@ -294,7 +182,8 @@ namespace blt
{
for (blt::size_t i = 0; i < n; i++)
{
if constexpr (check){
if constexpr (check)
{
if (begin == end)
break;
}
@ -341,7 +230,7 @@ namespace blt
m_begins(std::move(iterator_pairs.begin)...), m_ends(std::move(iterator_pairs.end)...)
{}
zip_iterator_storage(iterator::zip_wrapper<iterator_category, Iter...> begins, iterator::zip_wrapper<iterator_category, Iter...> ends):
zip_iterator_storage(iterator::zip_wrapper<Iter...> begins, iterator::zip_wrapper<Iter...> ends):
m_begins(std::move(begins)), m_ends(std::move(ends))
{}
@ -372,8 +261,8 @@ namespace blt
}
private:
iterator::zip_wrapper<iterator_category, Iter...> m_begins;
iterator::zip_wrapper<iterator_category, Iter...> m_ends;
iterator::zip_wrapper<Iter...> m_begins;
iterator::zip_wrapper<Iter...> m_ends;
};
template<typename... Iter>
@ -389,8 +278,8 @@ namespace blt
"reverse iteration is only supported on bidirectional or better iterators!");
}
zip_iterator_storage_rev(iterator::zip_wrapper<iterator_category, Iter...> begins,
iterator::zip_wrapper<iterator_category, Iter...> ends): m_begins(std::move(begins)), m_ends(std::move(ends))
zip_iterator_storage_rev(iterator::zip_wrapper<Iter...> begins,
iterator::zip_wrapper<Iter...> ends): m_begins(std::move(begins)), m_ends(std::move(ends))
{
static_assert((std::is_same_v<iterator_category, std::bidirectional_iterator_tag> ||
std::is_same_v<iterator_category, std::random_access_iterator_tag>),
@ -413,8 +302,8 @@ namespace blt
}
private:
std::reverse_iterator<iterator::zip_wrapper<iterator_category, Iter...>> m_begins;
std::reverse_iterator<iterator::zip_wrapper<iterator_category, Iter...>> m_ends;
std::reverse_iterator<iterator::zip_wrapper<Iter...>> m_begins;
std::reverse_iterator<iterator::zip_wrapper<Iter...>> m_ends;
};
/*

6
tests/iterator_tests.cpp
View File

@ -126,17 +126,17 @@ void test_pairs()
void test_zip()
{
blt::log_box_t box(std::cout, "Zip Tests", 25);
for (auto [a1, a2, a3] : blt::zip(array_1, array_2, array_3))
for (auto [a1, a2, a3] : blt::zip(array_1, array_2, list_1))
{
BLT_TRACE_STREAM << a1 << " : " << a2 << " : " << a3 << "\n";
}
BLT_TRACE("================================");
for (auto [a1, a2, a3] : blt::zip(array_1, array_2, array_3).take(3))
for (auto [a1, a2, a3] : blt::zip(array_1, array_2, list_1).take(3))
{
BLT_TRACE_STREAM << a1 << " : " << a2 << " : " << a3 << "\n";
}
BLT_TRACE("================================");
for (auto [a1, a2, a3] : blt::zip(array_1, array_2, array_3).take(3).rev())
for (auto [a1, a2, a3] : blt::zip(array_1, array_2, list_1).take(3).rev())
{
BLT_TRACE_STREAM << a1 << " : " << a2 << " : " << a3 << "\n";
}