From 36d22d82aa202bb199967e9512281e9a53db42c9 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 21:33:14 +0200 Subject: Adding upstream version 115.7.0esr. Signed-off-by: Daniel Baumann --- mfbt/IntegerRange.h | 192 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 192 insertions(+) create mode 100644 mfbt/IntegerRange.h (limited to 'mfbt/IntegerRange.h') diff --git a/mfbt/IntegerRange.h b/mfbt/IntegerRange.h new file mode 100644 index 0000000000..4415031454 --- /dev/null +++ b/mfbt/IntegerRange.h @@ -0,0 +1,192 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +/* Iterator over ranges of integers */ + +#ifndef mozilla_IntegerRange_h +#define mozilla_IntegerRange_h + +#include "mozilla/Assertions.h" +#include "mozilla/ReverseIterator.h" + +#include +#include + +namespace mozilla { + +namespace detail { + +template +class IntegerIterator { + public: + // It is disputable whether these type definitions are correct, since + // operator* doesn't return a reference at all. Also, the iterator_category + // can be at most std::input_iterator_tag (rather than + // std::bidrectional_iterator_tag, as it might seem), because it is a stashing + // iterator. See also, e.g., + // https://stackoverflow.com/questions/50909701/what-should-be-iterator-category-for-a-stashing-iterator + using value_type = const IntTypeT; + using pointer = const value_type*; + using reference = const value_type&; + using difference_type = std::make_signed_t; + using iterator_category = std::input_iterator_tag; + + template + explicit IntegerIterator(IntType aCurrent) : mCurrent(aCurrent) {} + + template + explicit IntegerIterator(const IntegerIterator& aOther) + : mCurrent(aOther.mCurrent) {} + + // This intentionally returns a value rather than a reference, to make + // mozilla::ReverseIterator work with it. Still, std::reverse_iterator cannot + // be used with IntegerIterator because it still is a "stashing iterator". See + // Bug 1175485. + IntTypeT operator*() const { return mCurrent; } + + /* Increment and decrement operators */ + + IntegerIterator& operator++() { + ++mCurrent; + return *this; + } + IntegerIterator& operator--() { + --mCurrent; + return *this; + } + IntegerIterator operator++(int) { + auto ret = *this; + ++mCurrent; + return ret; + } + IntegerIterator operator--(int) { + auto ret = *this; + --mCurrent; + return ret; + } + + /* Comparison operators */ + + template + friend bool operator==(const IntegerIterator& aIter1, + const IntegerIterator& aIter2); + template + friend bool operator!=(const IntegerIterator& aIter1, + const IntegerIterator& aIter2); + template + friend bool operator<(const IntegerIterator& aIter1, + const IntegerIterator& aIter2); + template + friend bool operator<=(const IntegerIterator& aIter1, + const IntegerIterator& aIter2); + template + friend bool operator>(const IntegerIterator& aIter1, + const IntegerIterator& aIter2); + template + friend bool operator>=(const IntegerIterator& aIter1, + const IntegerIterator& aIter2); + + private: + IntTypeT mCurrent; +}; + +template +bool operator==(const IntegerIterator& aIter1, + const IntegerIterator& aIter2) { + return aIter1.mCurrent == aIter2.mCurrent; +} + +template +bool operator!=(const IntegerIterator& aIter1, + const IntegerIterator& aIter2) { + return aIter1.mCurrent != aIter2.mCurrent; +} + +template +bool operator<(const IntegerIterator& aIter1, + const IntegerIterator& aIter2) { + return aIter1.mCurrent < aIter2.mCurrent; +} + +template +bool operator<=(const IntegerIterator& aIter1, + const IntegerIterator& aIter2) { + return aIter1.mCurrent <= aIter2.mCurrent; +} + +template +bool operator>(const IntegerIterator& aIter1, + const IntegerIterator& aIter2) { + return aIter1.mCurrent > aIter2.mCurrent; +} + +template +bool operator>=(const IntegerIterator& aIter1, + const IntegerIterator& aIter2) { + return aIter1.mCurrent >= aIter2.mCurrent; +} + +template +class IntegerRange { + public: + typedef IntegerIterator iterator; + typedef IntegerIterator const_iterator; + typedef ReverseIterator> reverse_iterator; + typedef ReverseIterator> const_reverse_iterator; + + template + explicit IntegerRange(IntType aEnd) : mBegin(0), mEnd(aEnd) {} + + template + IntegerRange(IntType1 aBegin, IntType2 aEnd) : mBegin(aBegin), mEnd(aEnd) {} + + iterator begin() const { return iterator(mBegin); } + const_iterator cbegin() const { return begin(); } + iterator end() const { return iterator(mEnd); } + const_iterator cend() const { return end(); } + reverse_iterator rbegin() const { return reverse_iterator(iterator(mEnd)); } + const_reverse_iterator crbegin() const { return rbegin(); } + reverse_iterator rend() const { return reverse_iterator(iterator(mBegin)); } + const_reverse_iterator crend() const { return rend(); } + + private: + IntTypeT mBegin; + IntTypeT mEnd; +}; + +template > +struct GeqZero { + static bool isNonNegative(T t) { return t >= 0; } +}; + +template +struct GeqZero { + static bool isNonNegative(T t) { return true; } +}; + +} // namespace detail + +template +detail::IntegerRange IntegerRange(IntType aEnd) { + static_assert(std::is_integral_v, "value must be integral"); + MOZ_ASSERT(detail::GeqZero::isNonNegative(aEnd), + "Should never have negative value here"); + return detail::IntegerRange(aEnd); +} + +template +detail::IntegerRange IntegerRange(IntType1 aBegin, IntType2 aEnd) { + static_assert(std::is_integral_v && std::is_integral_v, + "values must both be integral"); + static_assert(std::is_signed_v == std::is_signed_v, + "signed/unsigned mismatch"); + MOZ_ASSERT(aEnd >= aBegin, "End value should be larger than begin value"); + return detail::IntegerRange(aBegin, aEnd); +} + +} // namespace mozilla + +#endif // mozilla_IntegerRange_h -- cgit v1.2.3