CXXIter.h

#pragma once
 
#include <utility>
#include <optional>
#include <concepts>
#include <functional>
#include <string>
#include <limits>
 
#include <unordered_map>
#include <vector>
#include <cmath>
 
#include "src/Common.h"
#include "src/Generator.h"
#include "src/sources/Concepts.h"
#include "src/sources/ContainerSources.h"
#include "src/sources/GeneratorSources.h"
#include "src/Collector.h"
#include "src/op/Alternater.h"
#include "src/op/Caster.h"
#include "src/op/Chainer.h"
#include "src/op/Chunked.h"
#include "src/op/ChunkedExact.h"
#include "src/op/Filter.h"
#include "src/op/FilterMap.h"
#include "src/op/FlagLast.h"
#include "src/op/FlatMap.h"
#include "src/op/GenerateFrom.h"
#include "src/op/GroupBy.h"
#include "src/op/InplaceModifier.h"
#include "src/op/Intersperser.h"
#include "src/op/Map.h"
#include "src/op/Reverse.h"
#include "src/op/SkipN.h"
#include "src/op/SkipWhile.h"
#include "src/op/Sorter.h"
#include "src/op/TakeN.h"
#include "src/op/TakeWhile.h"
#include "src/op/Unique.h"
#include "src/op/Zipper.h"
#include "src/Helpers.h"
 
 
namespace CXXIter {
 
// ################################################################################################
// SURFACE-API
// ################################################################################################
 
template<CXXIterIterator TSelf>
class IterApi {
public: // Associated types
    using Iterator = trait::Iterator<TSelf>;
    using Item = typename Iterator::Item;
    using ItemOwned = std::remove_cvref_t<Item>;
 
private:
    constexpr TSelf* self() { return static_cast<TSelf*>(this); }
    constexpr const TSelf* self() const { return static_cast<const TSelf*>(this); }
    static constexpr bool IS_REFERENCE = std::is_lvalue_reference_v<Item>;
 
public: // C++ Iterator API-Surface
 
    class iterator {
        friend class IterApi;
        TSelf& self;
        IterValue<Item> element;
 
        iterator(TSelf& self) : self(self) {}
        iterator(TSelf& self, IterValue<Item>&& element) : self(self), element(std::move(element)) {}
 
 
    public:
        iterator& operator++() {
            if(element.has_value()) {
                element = self.next();
            }
            return *this;
        }
 
        Item& operator*() { return element.value(); }
 
        bool operator!=(const iterator& o) {
            return (element.has_value() != o.element.has_value());
        }
    };
 
    iterator begin() { return {*self(), next()}; }
 
    iterator end() { return {*self()}; }
 
public: // CXXIter API-Surface
 
    constexpr SizeHint sizeHint() const {
        return Iterator::sizeHint(*self());
    }
 
    constexpr size_t size() const requires CXXIterExactSizeIterator<TSelf> {
        return trait::ExactSizeIterator<TSelf>::size(*self());
    }
 
    constexpr IterValue<Item> next() {
        return Iterator::next(*self());
    }
 
    constexpr void advanceBy(size_t n) {
        Iterator::advanceBy(*self(), n);
    }
 
    constexpr IterValue<Item> nextBack() requires CXXIterDoubleEndedIterator<TSelf> {
        return trait::DoubleEndedIterator<TSelf>::nextBack(*self());
    }
 
    // ###################
    // CONSUMERS
    // ###################
 
    template<typename TUseFn>
    constexpr void forEach(TUseFn useFn) {
        while(true) {
            auto item = Iterator::next(*self());
            if(!item.has_value()) [[unlikely]] { return; }
            useFn(std::forward<Item>( item.value() ));
        }
    }
 
    template<template <typename...> typename TTargetContainer, typename... TTargetContainerArgs>
    constexpr auto collect() {
        return Collector<TSelf, TTargetContainer, TTargetContainerArgs...>::template collect<Item, ItemOwned>(*self());
    }
 
    template<typename TTargetContainer>
    constexpr TTargetContainer collect() {
        TTargetContainer container;
        collectInto(container);
        return container;
    }
 
    template<typename TTargetContainer>
    constexpr void collectInto(TTargetContainer& container) {
        IntoCollector<TSelf, TTargetContainer>::collectInto(*self(), container);
    }
 
    template<typename TResult, std::invocable<TResult&, Item&&> FoldFn>
    constexpr TResult fold(TResult startValue, FoldFn foldFn) {
        TResult result = startValue;
        forEach([&result, &foldFn](Item&& item) { foldFn(result, std::forward<Item>(item)); });
        return result;
    }
 
    template<std::invocable<const ItemOwned&> TPredicateFn>
    requires std::same_as<std::invoke_result_t<TPredicateFn, const ItemOwned&>, bool>
    constexpr bool all(TPredicateFn predicateFn) {
        return !skipWhile(predicateFn).next().has_value();
    }
 
    constexpr bool all() requires requires(const ItemOwned& item) {
        {static_cast<bool>(item)};
    } {
        return all([](const auto& item) -> bool { return item; });
    }
 
    template<std::invocable<const ItemOwned&> TPredicateFn>
    constexpr bool any(TPredicateFn predicateFn) {
        return filter(predicateFn).next().has_value();
    }
 
    constexpr bool any() requires requires(const ItemOwned& item) {
        {static_cast<bool>(item)};
    } {
        return any([](const auto& item) -> bool { return item; });
    }
 
    constexpr std::optional<size_t> findIdx(const ItemOwned& searchItem)    requires requires(const ItemOwned& searchItem, const Item& item) {
        {searchItem == item} -> std::same_as<bool>;
    } {
        return findIdx([&searchItem](const ItemOwned& item) {
            return (searchItem == item);
        });
    }
 
 
    template<std::invocable<const ItemOwned&> TFindFn>
    constexpr std::optional<size_t> findIdx(TFindFn findFn) {
        size_t idx = 0;
        while(true) {
            auto item = Iterator::next(*self());
            if(!item.has_value()) [[unlikely]] { return {}; }
            if(findFn(item.value())) [[unlikely]] { return idx; }
            idx += 1;
        }
    }
 
    template<std::invocable<const ItemOwned&> TFindFn>
    constexpr IterValue<Item> find(TFindFn findFn) {
        return filter(findFn).next();
    }
 
    constexpr size_t count() {
        return fold((size_t)0, [](size_t& cnt, auto&&) { cnt += 1; });
    }
 
    template<std::invocable<const ItemOwned&> TPredicateFn>
    constexpr size_t count(TPredicateFn predicateFn) {
        return fold((size_t)0, [&predicateFn](size_t& cnt, auto&& item) {
            if(predicateFn(item)) { cnt += 1; }
        });
    }
 
    constexpr size_t count(const ItemOwned& countItem)
    requires requires(const ItemOwned& countItem, Item&& item) {
        {countItem == item};
    } {
        return fold((size_t)0, [&countItem](size_t& cnt, auto&& item) {
            if(item == countItem) { cnt += 1; }
        });
    }
 
 
    template<typename TResult = ItemOwned>
    requires requires(TResult res, Item item) { { res += item }; }
    constexpr TResult sum(TResult startValue = TResult()) {
        return fold(startValue, [](TResult& res, Item&& item) { res += item; });
    }
 
    std::string stringJoin(const std::string& separator) requires std::is_same_v<ItemOwned, std::string> {
        std::string result;
        forEach([&result, &separator](const std::string& item) {
            if(result.size() > 0) [[likely]] { result += separator + item; }
            else [[unlikely]] { result = item; }
        });
        return result;
    }
 
    template<StatisticNormalization NORM = StatisticNormalization::N, typename TResult = ItemOwned, typename TCount = ItemOwned>
    constexpr std::optional<TResult> mean(TResult sumStart = TResult()) {
        size_t cnt = 0;
        TResult result = fold(sumStart, [&cnt](TResult& res, Item&& item) {
            cnt += 1;
            res += item;
        });
        if(cnt > 0) {
            if constexpr(NORM == StatisticNormalization::N) {
                return result / static_cast<TCount>(cnt);
            } else {
                return result / static_cast<TCount>(cnt - 1);
            }
        }
        return {};
    }
 
    template<StatisticNormalization NORM = StatisticNormalization::N, typename TResult = ItemOwned, typename TCount = ItemOwned>
    constexpr std::optional<TResult> variance() {
        TResult sumSquare = TResult();
        TResult sum = TResult();
        size_t cnt = 0;
        forEach([&sumSquare, &sum, &cnt](Item&& item) {
            sum += item;
            sumSquare += (item * item);
            cnt += 1;
        });
        if(cnt >= 2) {
            if constexpr(NORM == StatisticNormalization::N) {
                TResult E1 = (sumSquare / static_cast<TCount>(cnt));
                TResult E2 = (sum / static_cast<TCount>(cnt));
                return E1 - (E2 * E2);
            } else {
                TResult E1 = (sum * sum / static_cast<TCount>(cnt));
                return (sumSquare - E1) / static_cast<TCount>(cnt - 1);
            }
        }
        return {};
    }
 
    template<StatisticNormalization NORM = StatisticNormalization::N, typename TResult = ItemOwned, typename TCount = ItemOwned>
    constexpr std::optional<TResult> stddev() {
        std::optional<TResult> result = variance<NORM, TResult, TCount>();
        if(result.has_value()) { return std::sqrt(result.value()); }
        return {};
    }
 
    constexpr IterValue<Item> min() {
        return minBy([](auto&& item) { return item; });
    }
 
    constexpr std::optional<size_t> minIdx() {
        return minIdxBy([](auto&& item) { return item; });
    }
 
    constexpr IterValue<Item> max() {
        return maxBy([](auto&& item) { return item; });
    }
 
    constexpr std::optional<size_t> maxIdx() {
        return maxIdxBy([](auto&& item) { return item; });
    }
 
    template<typename TCompValueExtractFn>
    requires requires(const std::invoke_result_t<TCompValueExtractFn, Item&&>& a, std::remove_cvref_t<decltype(a)> ownedA) {
        { a < a };
        { ownedA = ownedA };
    }
    constexpr IterValue<Item> minBy(TCompValueExtractFn compValueExtractFn) {
        IterValue<Item> result = Iterator::next(*self());
        if(!result.has_value()) { return {}; }
        auto resultValue = compValueExtractFn(std::forward<Item>(result.value()));
        forEach([&result, &resultValue, &compValueExtractFn](Item&& item) {
            auto itemValue = compValueExtractFn(std::forward<Item>(item));
            if(itemValue < resultValue) {
                result = item;
                resultValue = itemValue;
            }
        });
        return result;
    }
 
    template<typename TCompValueExtractFn>
    requires requires(const std::invoke_result_t<TCompValueExtractFn, Item&&>& a) {
        { a < a };
    }
    constexpr std::optional<size_t> minIdxBy(TCompValueExtractFn compValueExtractFn) {
        IterValue<Item> tmp = Iterator::next(*self());
        if(!tmp.has_value()) { return {}; }
        size_t iterationIdx = 1, minIdx = 0;
        auto minValue = compValueExtractFn(std::forward<Item>(tmp.value()));
        forEach([iterationIdx, &minIdx, &minValue, &compValueExtractFn](Item&& item) mutable {
            auto itemValue = compValueExtractFn(std::forward<Item>(item));
            if(itemValue < minValue) {
                minValue = itemValue;
                minIdx = iterationIdx;
            }
            iterationIdx += 1;
        });
        return minIdx;
    }
 
    template<typename TMaxValueExtractFn>
    requires requires(const std::invoke_result_t<TMaxValueExtractFn, Item&&>& a, std::remove_cvref_t<decltype(a)> ownedA) {
        { a > a };
        { ownedA = ownedA };
    }
    constexpr IterValue<Item> maxBy(TMaxValueExtractFn compValueExtractFn) {
        IterValue<Item> result = Iterator::next(*self());
        if(!result.has_value()) { return {}; }
        auto resultValue = compValueExtractFn(std::forward<Item>(result.value()));
        forEach([&result, &resultValue, &compValueExtractFn](Item&& item) {
            auto itemValue = compValueExtractFn(std::forward<Item>(item));
            if(itemValue > resultValue) {
                result = item;
                resultValue = itemValue;
            }
        });
        return result;
    }
 
    template<typename TMaxValueExtractFn>
    requires requires(const std::invoke_result_t<TMaxValueExtractFn, Item&&>& a, std::remove_cvref_t<decltype(a)> ownedA) {
        { a > a };
        { ownedA = ownedA };
    }
    constexpr std::optional<size_t> maxIdxBy(TMaxValueExtractFn compValueExtractFn) {
        IterValue<Item> tmp = Iterator::next(*self());
        if(!tmp.has_value()) { return {}; }
        size_t iterationIdx = 1, maxIdx = 0;
        auto maxValue = compValueExtractFn(std::forward<Item>(tmp.value()));
        forEach([iterationIdx, &maxIdx, &maxValue, &compValueExtractFn](Item&& item) mutable {
            auto itemValue = compValueExtractFn(std::forward<Item>(item));
            if(itemValue > maxValue) {
                maxValue = itemValue;
                maxIdx = iterationIdx;
            }
            iterationIdx += 1;
        });
        return maxIdx;
    }
 
    constexpr IterValue<Item> last() {
        IterValue<Item> tmp;
        forEach([&tmp](Item&& item) { tmp = item; });
        return tmp;
    }
 
    constexpr IterValue<Item> nth(size_t n) {
        return skip(n).next();
    }
 
 
    // ###################
    // CHAINERS
    // ###################
 
    template<typename TItemOutput>
    constexpr op::Caster<TSelf, TItemOutput> cast() {
        return op::Caster<TSelf, TItemOutput>(std::move(*self()));
    }
 
    constexpr auto copied() {
        return map([](const ItemOwned& item) -> ItemOwned {
            ItemOwned copy = item;
            return copy;
        });
 
    }
 
    constexpr auto indexed() {
        size_t idx = 0;
        return map([idx](Item&& item) mutable -> std::pair<size_t, Item> {
            return std::pair<size_t, Item>(idx++, std::forward<Item>(item));
        });
    }
 
    constexpr op::FlagLast<TSelf> flagLast() {
        return op::FlagLast<TSelf>(std::move(*self()));
    }
 
    template<std::invocable<const ItemOwned&> TFilterFn>
    constexpr op::Filter<TSelf, TFilterFn> filter(TFilterFn filterFn) {
        return op::Filter<TSelf, TFilterFn>(std::move(*self()), filterFn);
    }
 
    template<std::invocable<const ItemOwned&> TMapFn>
    requires util::is_hashable<std::invoke_result_t<TMapFn, const ItemOwned&>>
    constexpr op::Unique<TSelf, TMapFn> unique(TMapFn mapFn) {
        return op::Unique<TSelf, TMapFn>(std::move(*self()), mapFn);
    }
 
    constexpr auto unique() {
        return unique([](const auto& item) { return item; });
    }
 
    constexpr op::Reverse<TSelf> reverse() {
        return op::Reverse<TSelf>(std::move(*self()));
    }
 
    template<const size_t CHUNK_SIZE>
    constexpr op::Chunked<TSelf, CHUNK_SIZE> chunked() {
        return op::Chunked<TSelf, CHUNK_SIZE>(std::move(*self()));
    }
 
    template<const size_t CHUNK_SIZE, const size_t STEP_SIZE = CHUNK_SIZE>
    constexpr op::ChunkedExact<TSelf, CHUNK_SIZE, STEP_SIZE> chunkedExact() {
        return op::ChunkedExact<TSelf, CHUNK_SIZE, STEP_SIZE>(std::move(*self()));
    }
 
    template<std::invocable<Item&&> TMapFn>
    constexpr auto map(TMapFn mapFn) {
        using TMapFnResult = std::invoke_result_t<TMapFn, Item&&>;
        return op::Map<TSelf, TMapFn, TMapFnResult>(std::move(*self()), mapFn);
    }
 
    template<std::invocable<Item&&> TFlatMapFn>
    constexpr auto flatMap(TFlatMapFn mapFn) {
        using TFlatMapFnResult = std::invoke_result_t<TFlatMapFn, Item&&>;
        return op::FlatMap<TSelf, TFlatMapFn, TFlatMapFnResult>(std::move(*self()), mapFn);
    }
 
#ifdef CXXITER_HAS_COROUTINE
    template<GeneratorFromFunction<Item> TGeneratorFn>
    constexpr auto generateFrom(TGeneratorFn generatorFn) {
        using TGeneratorFnResult = std::invoke_result_t<TGeneratorFn, Item>;
        return op::GenerateFrom<TSelf, TGeneratorFn, TGeneratorFnResult>(std::move(*self()), generatorFn);
    }
#endif
 
    constexpr auto flatMap() {
        return flatMap([](Item&& item) { return item; });
    }
 
    template<std::invocable<Item&> TModifierFn>
    constexpr op::InplaceModifier<TSelf, TModifierFn> modify(TModifierFn modifierFn) {
        return op::InplaceModifier<TSelf, TModifierFn>(std::move(*self()), modifierFn);
    }
 
    template<std::invocable<ItemOwned&&> TFilterMapFn>
    requires util::is_optional<std::invoke_result_t<TFilterMapFn, ItemOwned&&>>
    constexpr auto filterMap(TFilterMapFn filterMapFn) {
        using TFilterMapFnResult = typename std::invoke_result_t<TFilterMapFn, ItemOwned&&>::value_type;
        return op::FilterMap<TSelf, TFilterMapFn, TFilterMapFnResult>(std::move(*self()), filterMapFn);
    }
 
    constexpr op::SkipN<TSelf> skip(size_t cnt) {
        return op::SkipN<TSelf>(std::move(*self()), cnt);
    }
 
    template<std::invocable<const Item&> TSkipPredicate>
    constexpr op::SkipWhile<TSelf, TSkipPredicate> skipWhile(TSkipPredicate skipPredicate) {
        return op::SkipWhile<TSelf, TSkipPredicate>(std::move(*self()), skipPredicate);
    }
 
    constexpr op::TakeN<TSelf> take(size_t cnt) {
        return op::TakeN<TSelf>(std::move(*self()), cnt);
    }
 
    template<std::invocable<const Item&> TTakePredicate>
    requires std::is_same_v<std::invoke_result_t<TTakePredicate, const Item&>, bool>
    constexpr auto takeWhile(TTakePredicate takePredicate) {
        return op::TakeWhile<TSelf, TTakePredicate>(std::move(*self()), takePredicate);
    }
 
    constexpr auto stepBy(size_t stepWidth) {
        //TODO: better SizeHints?
        size_t idx = 0;
        return filter([idx, stepWidth](const ItemOwned&) mutable {
            return (idx++ % stepWidth) == 0;
        });
    }
 
    template<typename TOtherIterator>
    constexpr op::Zipper<TSelf, std::pair, TOtherIterator> zip(TOtherIterator&& otherIterator) {
        return op::Zipper<TSelf, std::pair, TOtherIterator>(std::move(*self()), std::forward<TOtherIterator>(otherIterator));
    }
 
    template<typename... TOtherIterators>
    requires (CXXIterIterator<TOtherIterators> && ...)
            && (!std::disjunction_v< std::is_reference<typename trait::Iterator<TOtherIterators>::Item>... > && !IS_REFERENCE)
    constexpr op::Zipper<TSelf, std::tuple, TOtherIterators...> zipTuple(TOtherIterators&&... otherIterators) {
        return op::Zipper<TSelf, std::tuple, TOtherIterators...>(std::move(*self()), std::forward<TOtherIterators>(otherIterators)...);
    }
 
    template<typename TOtherIterator>
    requires std::is_same_v<Item, typename TOtherIterator::Item>
    constexpr op::Chainer<TSelf, TOtherIterator> chain(TOtherIterator&& otherIterator) {
        return op::Chainer<TSelf, TOtherIterator>(std::move(*self()), std::forward<TOtherIterator>(otherIterator));
    }
 
    template<typename... TOtherIterators>
    requires (CXXIterIterator<TOtherIterators> && ...)
            && (util::are_same_v<Item, typename TOtherIterators::Item...>)
    constexpr op::Alternater<TSelf, TOtherIterators...> alternate(TOtherIterators&&... otherIterators) {
        return op::Alternater<TSelf, TOtherIterators...>(std::move(*self()), std::forward<TOtherIterators>(otherIterators)...);
    }
 
    template<typename TOtherIterator>
    requires (std::is_same_v<Item, typename TOtherIterator::Item>)
    constexpr op::Intersperser<TSelf, TOtherIterator> intersperse(TOtherIterator&& otherIterator) {
        return op::Intersperser<TSelf, TOtherIterator>(std::move(*self()), std::forward<TOtherIterator>(otherIterator));
    }
 
    template<std::invocable<const Item&> TGroupIdentifierFn>
    requires util::is_hashable<std::invoke_result_t<TGroupIdentifierFn, const Item&>>
    constexpr auto groupBy(TGroupIdentifierFn groupIdentFn) {
        using TGroupIdent = std::remove_cvref_t<std::invoke_result_t<TGroupIdentifierFn, const ItemOwned&>>;
        return op::GroupBy<TSelf, TGroupIdentifierFn, TGroupIdent>(std::move(*self()), groupIdentFn);
    }
 
    template<bool STABLE, std::invocable<const ItemOwned&, const ItemOwned&> TCompareFn>
    constexpr auto sort(TCompareFn compareFn) {
        return op::Sorter<TSelf, TCompareFn, STABLE>(std::move(*self()), compareFn);
    }
 
    template<SortOrder ORDER = SortOrder::ASCENDING, bool STABLE = false>
    requires requires(const ItemOwned& a) { { a < a }; { a > a }; }
    constexpr auto sort() {
        return sort<STABLE>([](const ItemOwned& a, const ItemOwned& b) {
            if constexpr(ORDER == SortOrder::ASCENDING) {
                return (a < b);
            } else {
                return (a > b);
            }
        });
    }
 
    template<SortOrder ORDER = SortOrder::ASCENDING, bool STABLE = false, std::invocable<const ItemOwned&> TSortValueExtractFn>
    requires requires(const std::invoke_result_t<TSortValueExtractFn, const ItemOwned&>& a) {
        { a < a }; { a > a };
    }
    constexpr auto sortBy(TSortValueExtractFn sortValueExtractFn) {
        return sort<STABLE>([sortValueExtractFn](const ItemOwned& a, const ItemOwned& b) {
            if constexpr(ORDER == SortOrder::ASCENDING) {
                return (sortValueExtractFn(a) < sortValueExtractFn(b));
            } else {
                return (sortValueExtractFn(a) > sortValueExtractFn(b));
            }
        });
    }
};
 
 
 
// ################################################################################################
// ENTRY POINTS
// ################################################################################################
 
    template<typename TContainer>
    requires (!std::is_reference_v<TContainer> && !util::is_const_reference_v<TContainer> && concepts::SourceContainer<TContainer>)
    constexpr SrcMov<std::remove_cvref_t<TContainer>> from(TContainer&& container) {
        return SrcMov<std::remove_cvref_t<TContainer>>(std::forward<TContainer>(container));
    }
 
    template<typename TContainer>
    requires (!std::is_reference_v<TContainer> && !util::is_const_reference_v<TContainer> && concepts::SourceContainer<TContainer>)
    constexpr SrcRef<std::remove_cvref_t<TContainer>> from(TContainer& container) {
        return SrcRef<std::remove_cvref_t<TContainer>>(container);
    }
 
    template<typename TContainer>
    requires (!std::is_reference_v<TContainer> && !util::is_const_reference_v<TContainer> && concepts::SourceContainer<TContainer>)
    constexpr SrcCRef<std::remove_cvref_t<TContainer>> from(const TContainer& container) {
        return SrcCRef<std::remove_cvref_t<TContainer>>(container);
    }
 
 
    template<typename TItem>
    constexpr Empty<TItem> empty() { return Empty<TItem>(); }
 
    template<std::invocable<> TGeneratorFn>
    requires util::is_optional<std::invoke_result_t<TGeneratorFn>>
    constexpr auto fromFn(TGeneratorFn generatorFn) {
        using TGeneratorFnResult = typename std::invoke_result_t<TGeneratorFn>::value_type;
        return FunctionGenerator<TGeneratorFnResult, TGeneratorFn>(generatorFn);
    }
 
    #ifdef CXXITER_HAS_COROUTINE
    template<GeneratorFunction TGeneratorFn>
    auto generate(TGeneratorFn generatorFn) {
        using TGenerator = typename std::invoke_result_t<TGeneratorFn>;
        TGenerator generator = generatorFn();
        return CoroutineGenerator<TGenerator>(std::forward<TGenerator>(generator));
    }
    #endif
 
    template<typename TItem>
    constexpr Repeater<TItem> repeat(const TItem& item, std::optional<size_t> cnt = {}) {
        return Repeater<TItem>(item, cnt);
    }
 
    template<typename TValue>
    constexpr Range<TValue> range(TValue from, TValue to, TValue step = 1) {
        return Range<TValue>(from, to, step);
    }
}