From c83f089e9c1e6ab5a0d36fc0c905d0b07c87a054 Mon Sep 17 00:00:00 2001 From: Brett Date: Wed, 25 Sep 2024 00:53:15 -0400 Subject: [PATCH] breaking change: enumerate is in its own file: std/iterator.h --- CMakeLists.txt | 5 +- include/blt/std/allocator.h | 1 + include/blt/std/iterator.h | 326 +++++++++++++++++++++++++++++++++++ include/blt/std/ranges.h | 283 ------------------------------ src/blt/parse/argparse.cpp | 1 + src/blt/parse/obj_loader.cpp | 1 + 6 files changed, 332 insertions(+), 285 deletions(-) create mode 100644 include/blt/std/iterator.h diff --git a/CMakeLists.txt b/CMakeLists.txt index 80e38d3..abb619a 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,6 +1,6 @@ cmake_minimum_required(VERSION 3.20) include(cmake/color.cmake) -set(BLT_VERSION 0.20.26) +set(BLT_VERSION 0.21.0) set(BLT_TEST_VERSION 0.0.1) set(BLT_TARGET BLT) @@ -69,7 +69,8 @@ if (${BUILD_FORMAT}) message(STATUS "Building ${Yellow}format${ColourReset} cxx files") file(GLOB_RECURSE FORMAT_FILES "${CMAKE_CURRENT_SOURCE_DIR}/src/blt/format/*.cpp") else () - set(FORMAT_FILES "") + set(FORMAT_FILES "" + include/blt/std/iterator.h) endif () if (EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/libraries/parallel-hashmap) diff --git a/include/blt/std/allocator.h b/include/blt/std/allocator.h index 64b641c..91e7e5d 100644 --- a/include/blt/std/allocator.h +++ b/include/blt/std/allocator.h @@ -22,6 +22,7 @@ #include #include #include + #include #include #include #include diff --git a/include/blt/std/iterator.h b/include/blt/std/iterator.h new file mode 100644 index 0000000..4d70916 --- /dev/null +++ b/include/blt/std/iterator.h @@ -0,0 +1,326 @@ +#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_H +#define BLT_ITERATOR_H + +#include +#include +#include +#include +#include + +namespace blt +{ + + template> + class enumerator; + + template> + class enumerator_rev; + + namespace iterator + { + template> + class enumerate_wrapper; + + template + struct enumerate_item + { + blt::size_t index; + T value; + }; + + template + class enumerate_iterator_base + { + public: + explicit enumerate_iterator_base(Iter iter, blt::size_t place = 0): iter(std::move(iter)), index(place) + {} + + enumerate_item> operator*() const + { + return {index, *this->iter}; + } + + friend bool operator==(const enumerate_iterator_base& a, const enumerate_iterator_base& b) + { + return a.iter == b.iter; + } + + friend bool operator!=(const enumerate_iterator_base& a, const enumerate_iterator_base& b) + { + return a.iter != b.iter; + } + + auto base() const + { + return iter; + } + + auto get_index() const + { + return index; + } + + protected: + Iter iter; + blt::size_t index; + }; + + template + class enumerate_forward_iterator : public enumerate_iterator_base + { + public: + using enumerate_iterator_base::enumerate_iterator_base; + + enumerate_forward_iterator& operator++() + { + ++this->iter; + ++this->index; + return *this; + } + + enumerate_forward_iterator operator++(int) + { + auto tmp = *this; + ++*this; + return tmp; + } + }; + + template + class enumerate_bidirectional_iterator : public enumerate_forward_iterator + { + public: + using enumerate_forward_iterator::enumerate_forward_iterator; + + enumerate_bidirectional_iterator& operator--() + { + --this->iter; + --this->index; + return *this; + } + + enumerate_bidirectional_iterator operator--(int) + { + auto tmp = *this; + --*this; + return tmp; + } + }; + + template + class enumerate_wrapper, std::void_t>> + : public enumerate_forward_iterator + { + public: + using iterator_category = std::forward_iterator_tag; + using value_type = enumerate_item>; + using difference_type = typename std::iterator_traits::difference_type; + using pointer = value_type; + using reference = value_type; + using iterator_type = Iter; + + using enumerate_forward_iterator::enumerate_forward_iterator; + }; + + template + class enumerate_wrapper, std::void_t>> + : public enumerate_bidirectional_iterator + { + public: + using iterator_category = typename std::iterator_traits::iterator_category; + using value_type = enumerate_item>; + using difference_type = typename std::iterator_traits::difference_type; + using pointer = value_type; + using reference = value_type; + using iterator_type = Iter; + + using enumerate_bidirectional_iterator::enumerate_bidirectional_iterator; + }; + + template + class enumerator_base + { + public: + explicit enumerator_base(Iter begin, Iter end): begin_(std::move(begin)), end_(std::move(end)) + {} + + explicit enumerator_base(IterWrapper begin, IterWrapper end): begin_(std::move(begin)), end_(std::move(end)) + {} + + auto begin() + { + return begin_; + } + + auto end() + { + return end_; + } + + protected: + IterWrapper begin_; + IterWrapper end_; + }; + + template + class enumerator_reversible : public enumerator_base + { + public: + explicit enumerator_reversible(Iter begin, Iter end, blt::size_t container_size): + enumerator_base{IterWrapper{enumerate_wrapper{std::move(begin), 0}}, + IterWrapper{enumerate_wrapper{std::move(end), container_size}}}, + container_size(container_size) + {} + + explicit enumerator_reversible(Iter begin, Iter end, blt::size_t begin_index, blt::size_t end_index, blt::size_t container_size): + enumerator_base(IterWrapper{enumerate_wrapper{std::move(begin), begin_index}}, + IterWrapper{enumerate_wrapper{std::move(end), end_index}}), + container_size(container_size) + {} + + auto rev() const + { + return enumerator_rev{this->end_.base(), this->begin_.base(), this->container_size, this->begin_.get_index(), + this->container_size}; + } + + protected: + blt::size_t container_size; + }; + + template + class enumerator_reversible_rev : public enumerator_reversible + { + public: + using enumerator_reversible::enumerator_reversible; + + auto rev() const + { + return enumerator{this->end_.base().base(), this->begin_.base().base(), this->end_.base().get_index(), + this->begin_.base().get_index(), this->container_size}; + } + }; + } + + template + class enumerator, std::void_t>> + : public iterator::enumerator_base> + { + public: + using iterator::enumerator_base>::enumerator_base; + }; + + template + class enumerator, std::void_t>> + : public iterator::enumerator_reversible> + { + public: + using iterator::enumerator_reversible>::enumerator_reversible; + + auto skip(blt::size_t offset) + { + + } + }; + + template + class enumerator, std::void_t>> + : public iterator::enumerator_reversible> + { + public: + using iterator::enumerator_reversible>::enumerator_reversible; + + auto skip(blt::size_t offset) + { + return enumerator{this->begin_.base() + offset, + this->end_.base(), + this->begin_.get_index() + offset, + this->end_.get_index(), + this->container_size}; + } + }; + + template + class enumerator_rev, std::void_t>> + : public iterator::enumerator_reversible_rev>> + { + public: + using iterator::enumerator_reversible_rev>>::enumerator_reversible_rev; + }; + + template + class enumerator_rev, std::void_t>> + : public iterator::enumerator_reversible_rev>> + { + public: + using iterator::enumerator_reversible_rev>>::enumerator_reversible_rev; + + auto skip(blt::size_t offset) + { + return enumerator_rev{this->begin_.base().base() - offset, + this->end_.base().base(), + this->begin_.base().get_index() - offset, + this->end_.base().get_index(), this->container_size}; + } + }; + + template + enumerator(Iter, Iter) -> enumerator; + + template + enumerator(Iter, Iter, blt::size_t) -> enumerator; + + template + enumerator(Iter, Iter, blt::size_t, blt::size_t) -> enumerator; + + template + static inline auto enumerate(const T& container) + { + return enumerator{container.begin(), container.end(), container.size()}; + } + + template + static inline auto enumerate(const T(& container)[size]) + { + return enumerator{&container[0], &container[size], size}; + } + + template + static inline auto enumerate(T(& container)[size]) + { + return enumerator{&container[0], &container[size], size}; + } + + template + static inline auto enumerate(T& container) + { + return enumerator{container.begin(), container.end(), container.size()}; + } + + template + static inline auto enumerate(T&& container) + { + return enumerator{container.begin(), container.end(), container.size()}; + } + +} + +#endif //BLT_ITERATOR_H diff --git a/include/blt/std/ranges.h b/include/blt/std/ranges.h index 8795579..f987b9e 100644 --- a/include/blt/std/ranges.h +++ b/include/blt/std/ranges.h @@ -19,291 +19,8 @@ namespace blt { - template> - class enumerate_wrapper; - - template> - class enumerator; - - template> - class enumerator_rev; - - template - struct enumerate_item - { - blt::size_t index; - T value; - }; - - template - class enumerate_iterator_base - { - public: - explicit enumerate_iterator_base(Iter iter, blt::size_t place = 0): iter(std::move(iter)), index(place) - {} - - enumerate_item> operator*() const - { - return {index, *this->iter}; - } - - friend bool operator==(const enumerate_iterator_base& a, const enumerate_iterator_base& b) - { - return a.iter == b.iter; - } - - friend bool operator!=(const enumerate_iterator_base& a, const enumerate_iterator_base& b) - { - return a.iter != b.iter; - } - - auto base() const - { - return iter; - } - - auto get_index() const - { - return index; - } - - protected: - Iter iter; - blt::size_t index; - }; - - template - class enumerate_forward_iterator : public enumerate_iterator_base - { - public: - using enumerate_iterator_base::enumerate_iterator_base; - - enumerate_forward_iterator& operator++() - { - ++this->iter; - ++this->index; - return *this; - } - - enumerate_forward_iterator operator++(int) - { - auto tmp = *this; - ++*this; - return tmp; - } - }; - - template - class enumerate_bidirectional_iterator : public enumerate_forward_iterator - { - public: - using enumerate_forward_iterator::enumerate_forward_iterator; - - enumerate_bidirectional_iterator& operator--() - { - --this->iter; - --this->index; - return *this; - } - - enumerate_bidirectional_iterator operator--(int) - { - auto tmp = *this; - --*this; - return tmp; - } - }; - - template - class enumerate_wrapper, std::void_t>> - : public enumerate_forward_iterator - { - public: - using iterator_category = std::forward_iterator_tag; - using value_type = enumerate_item>; - using difference_type = typename std::iterator_traits::difference_type; - using pointer = value_type; - using reference = value_type; - using iterator_type = Iter; - - using enumerate_forward_iterator::enumerate_forward_iterator; - }; - - template - class enumerate_wrapper, std::void_t>> - : public enumerate_bidirectional_iterator - { - public: - using iterator_category = typename std::iterator_traits::iterator_category; - using value_type = enumerate_item>; - using difference_type = typename std::iterator_traits::difference_type; - using pointer = value_type; - using reference = value_type; - using iterator_type = Iter; - - using enumerate_bidirectional_iterator::enumerate_bidirectional_iterator; - }; - - template - class enumerator_base - { - public: - explicit enumerator_base(Iter begin, Iter end): begin_(std::move(begin)), end_(std::move(end)) - {} - - explicit enumerator_base(IterWrapper begin, IterWrapper end): begin_(std::move(begin)), end_(std::move(end)) - {} - - auto begin() - { - return begin_; - } - - auto end() - { - return end_; - } - - protected: - IterWrapper begin_; - IterWrapper end_; - }; - - template - class enumerator_reversible : public enumerator_base - { - public: - explicit enumerator_reversible(Iter begin, Iter end, blt::size_t container_size): - enumerator_base{IterWrapper{enumerate_wrapper{std::move(begin), 0}}, - IterWrapper{enumerate_wrapper{std::move(end), container_size}}}, - container_size(container_size) - {} - - explicit enumerator_reversible(Iter begin, Iter end, blt::size_t begin_index, blt::size_t end_index, blt::size_t container_size): - enumerator_base(IterWrapper{enumerate_wrapper{std::move(begin), begin_index}}, - IterWrapper{enumerate_wrapper{std::move(end), end_index}}), - container_size(container_size) - {} - - auto rev() const - { - return enumerator_rev{this->end_.base(), this->begin_.base(), this->container_size, this->begin_.get_index(), - this->container_size}; - } - - protected: - blt::size_t container_size; - }; - - template - class enumerator_reversible_rev : public enumerator_reversible - { - public: - using enumerator_reversible::enumerator_reversible; - - auto rev() const - { - BLT_TRACE(this->end_.base().get_index()); - BLT_TRACE(this->begin_.base().get_index()); - return enumerator{this->end_.base().base(), this->begin_.base().base(), this->end_.base().get_index(), - this->begin_.base().get_index(), this->container_size}; - } - }; - - template - class enumerator, std::void_t>> - : public enumerator_base> - { - public: - using enumerator_base>::enumerator_base; - }; - - template - class enumerator, std::void_t>> - : public enumerator_reversible> - { - public: - using enumerator_reversible>::enumerator_reversible; - }; - - template - class enumerator, std::void_t>> - : public enumerator_reversible> - { - public: - using enumerator_reversible>::enumerator_reversible; - - auto skip(blt::size_t offset) - { - return enumerator{this->begin_.base() + offset, this->end_.base(), this->begin_.get_index() + offset, this->container_size, - this->container_size}; - } - }; - - template - class enumerator_rev, std::void_t>> - : public enumerator_reversible_rev>> - { - public: - using enumerator_reversible_rev>>::enumerator_reversible_rev; - }; - - template - class enumerator_rev, std::void_t>> - : public enumerator_reversible_rev>> - { - public: - using enumerator_reversible_rev>>::enumerator_reversible_rev; - - auto skip(blt::size_t offset) - { - return enumerator_rev{this->begin_.base().base() - offset, this->end_.base().base(), this->begin_.base().get_index() - offset, - this->container_size, this->container_size}; - } - }; - - template - enumerator(Iter, Iter) -> enumerator; - - template - enumerator(Iter, Iter, blt::size_t) -> enumerator; - - template - enumerator(Iter, Iter, blt::size_t, blt::size_t) -> enumerator; - - template - static inline auto enumerate(const T& container) - { - return enumerator{container.begin(), container.end(), container.size()}; - } - - template - static inline auto enumerate(const T(& container)[size]) - { - return enumerator{&container[0], &container[size], size}; - } - - template - static inline auto enumerate(T(& container)[size]) - { - return enumerator{&container[0], &container[size], size}; - } - - template - static inline auto enumerate(T& container) - { - return enumerator{container.begin(), container.end(), container.size()}; - } - - template - static inline auto enumerate(T&& container) - { - return enumerator{container.begin(), container.end(), container.size()}; - } - namespace itr { - template class itr_container { diff --git a/src/blt/parse/argparse.cpp b/src/blt/parse/argparse.cpp index d6c34cf..a467e2a 100644 --- a/src/blt/parse/argparse.cpp +++ b/src/blt/parse/argparse.cpp @@ -6,6 +6,7 @@ #include #include #include +#include #include #include "blt/std/utility.h" diff --git a/src/blt/parse/obj_loader.cpp b/src/blt/parse/obj_loader.cpp index d211be7..af5eb3d 100644 --- a/src/blt/parse/obj_loader.cpp +++ b/src/blt/parse/obj_loader.cpp @@ -21,6 +21,7 @@ #include #include #include +#include #include #include #include "blt/std/assert.h"