EnumIterator.h

Go to the documentation of this file.

/*
 * Copyright (C) 1996-2023 The Squid Software Foundation and contributors
 *
 * Squid software is distributed under GPLv2+ license and includes
 * contributions from numerous individuals and organizations.
 * Please see the COPYING and CONTRIBUTORS files for details.
 */
 
#ifndef SQUID_SRC_BASE_ENUMITERATOR_H
#define SQUID_SRC_BASE_ENUMITERATOR_H
 
#include <iterator>
#include <type_traits>
 
template <typename EnumType>
class EnumIteratorBase
{
protected:
    typedef typename std::underlying_type<EnumType>::type iterator_type;
 
public:
    using iterator_category = std::bidirectional_iterator_tag;
    using value_type = EnumType;
    using difference_type = std::ptrdiff_t;
    using pointer = EnumType *;
    using reference = EnumType &;
 
    explicit EnumIteratorBase(EnumType e) : current(static_cast<iterator_type>(e)) {}
 
    bool operator==(const EnumIteratorBase &i) const {
        return current == i.current;
    }
 
    bool operator!=(const EnumIteratorBase &i) const {
        return current != i.current;
    }
 
    EnumType operator*() const {
        return static_cast<EnumType>(current);
    }
protected:
    iterator_type current;
};
 
template <typename EnumType>
class EnumIterator : public EnumIteratorBase<EnumType>
{
public:
    explicit EnumIterator(EnumType e) : EnumIteratorBase<EnumType>(e) {}
 
    EnumIterator& operator++() {
        ++ EnumIteratorBase<EnumType>::current;
        return *this;
    }
 
    EnumIterator& operator++(int) {
        EnumIterator rv(*this);
        ++ EnumIteratorBase<EnumType>::current;
        return rv;
    }
 
    EnumIterator& operator--() {
        -- EnumIteratorBase<EnumType>::current;
        return *this;
    }
 
    EnumIterator& operator--(int) {
        EnumIterator rv(*this);
        -- EnumIteratorBase<EnumType>::current;
        return rv;
    }
};
 
template <typename EnumType>
class ReverseEnumIterator : public EnumIteratorBase<EnumType>
{
public:
    explicit ReverseEnumIterator(EnumType e) : EnumIteratorBase<EnumType>(e) {}
 
    // prefix increment
    ReverseEnumIterator& operator++() {
        -- EnumIteratorBase<EnumType>::current;
        return *this;
    }
 
    // postfix increment
    ReverseEnumIterator& operator++(int) {
        ReverseEnumIterator rv(*this);
        -- EnumIteratorBase<EnumType>::current;
        return rv;
    }
 
    // prefix decrement
    ReverseEnumIterator& operator--() {
        ++ EnumIteratorBase<EnumType>::current;
        return *this;
    }
 
    // postfix decrement
    ReverseEnumIterator& operator--(int) {
        ReverseEnumIterator rv(*this);
        ++ EnumIteratorBase<EnumType>::current;
        return rv;
    }
};
 
template <typename EnumType>
class EnumRangeT
{
public:
    typedef EnumIterator<EnumType> iterator;
    typedef ReverseEnumIterator<EnumType> reverse_iterator;
    EnumRangeT(EnumType first, EnumType one_past_last) : begin_(first), end_(one_past_last) { }
    iterator begin() const { return iterator(begin_);}
    iterator end() const { return iterator(end_);}
    reverse_iterator rbegin() const { return ++reverse_iterator(end_); }
    reverse_iterator rend() const { return ++reverse_iterator(begin_); }
private:
    EnumType begin_;
    EnumType end_;
};
 
template <typename EnumType>
EnumRangeT<EnumType> EnumRange(EnumType begin, EnumType one_past_end)
{
    return EnumRangeT<EnumType>(begin,one_past_end);
}
 
template <typename EnumType>
class WholeEnum : public EnumRangeT<EnumType>
{
public:
    WholeEnum() : EnumRangeT<EnumType>(EnumType::enumBegin_, EnumType::enumEnd_) {}
};
 
template <auto First, auto Last, class F>
constexpr void
ConstexprForEnum(F &&f)
{
    using enumType = decltype(First);
    using underlyingType = typename std::underlying_type<enumType>::type;
    // std::integral_constant trick makes f(First) argument a constexpr
    f(std::integral_constant<enumType, First>()); // including when First is Last
    if constexpr (First < Last)
        ConstexprForEnum<enumType(static_cast<underlyingType>(First) + 1), Last>(f);
}
 
#endif /* SQUID_SRC_BASE_ENUMITERATOR_H */