SizeHint.h

#pragma once
 
#include <optional>
#include <limits>
#include <cmath>
 
namespace CXXIter {
 
    struct SizeHint {
        constexpr static size_t INFINITE = std::numeric_limits<size_t>::max();
 
        size_t lowerBound;
        std::optional<size_t> upperBound;
 
        constexpr size_t expectedResultSize(size_t min = 0) const { return std::min(min, upperBound.value_or(lowerBound)); }
 
        constexpr SizeHint(size_t lowerBound = 0, std::optional<size_t> upperBound = {}) : lowerBound(lowerBound), upperBound(upperBound) {}
 
        static constexpr std::optional<size_t> upperBoundMax(std::optional<size_t> upperBound1, std::optional<size_t> upperBound2) {
            if(!upperBound1.has_value() || !upperBound2.has_value()) { return {}; } // no upperbound is like Infinity -> higher
            return std::max(upperBound1.value(), upperBound2.value());
        }
        static constexpr std::optional<size_t> upperBoundMin(std::optional<size_t> upperBound1, std::optional<size_t> upperBound2) {
            if(!upperBound1.has_value()) { return upperBound2; }
            if(!upperBound2.has_value()) { return upperBound1; }
            return std::min(upperBound1.value(), upperBound2.value());
        }
        void subtract(size_t cnt) {
            lowerBound = (lowerBound > cnt) ? (lowerBound - cnt) : 0;
            if(upperBound) {
                upperBound = (upperBound.value() > cnt) ? (upperBound.value() - cnt) : 0;
            }
        }
        void add(const SizeHint& o) {
            lowerBound += o.lowerBound;
            if(upperBound.has_value() && o.upperBound.has_value()) {
                upperBound = upperBound.value() + o.upperBound.value();
            } else {
                upperBound = {};
            }
        }
    };
 
}