Range.h

Go to the documentation of this file.

/****
 * Sming Framework Project - Open Source framework for high efficiency native ESP8266 development.
 * Created 2015 by Skurydin Alexey
 * http://github.com/SmingHub/Sming
 * All files of the Sming Core are provided under the LGPL v3 license.
 *
 * Range.h
 *
 ****/
 
#pragma once
 
#include <WString.h>
#include <limits>
#include <esp_systemapi.h>
 
template <typename T> struct TRange {
    T min{};
    T max{};
 
    class Iterator
    {
    public:
        using value_type = T;
        using difference_type = std::ptrdiff_t;
        using pointer = T*;
        using reference = T&;
        using iterator_category = std::random_access_iterator_tag;
 
        Iterator(T value) : value(value)
        {
        }
 
        T operator*() const
        {
            return value;
        }
 
        bool operator==(const Iterator& other) const
        {
            return value == other.value;
        }
 
        bool operator!=(const Iterator& other) const
        {
            return !(*this == other);
        }
 
        Iterator operator++(int)
        {
            Iterator ret(value);
            ++*this;
            return ret;
        }
 
        Iterator& operator++()
        {
            ++value;
            return *this;
        }
 
    private:
        T value;
    };
 
    constexpr TRange() = default;
 
    constexpr TRange(T min, T max) : min(min), max(max)
    {
    }
 
    constexpr TRange(T count) : min(0), max(count - 1)
    {
    }
 
    template <typename V> constexpr bool contains(V value) const
    {
        return (value >= min) && (value <= max);
    }
 
    template <typename Q> bool contains(const TRange<Q>& value) const
    {
        return contains(value.min) && contains(value.max);
    }
 
    template <typename V> constexpr T clip(V value) const
    {
        return (value < min) ? min : (value > max) ? max : T(value);
    }
 
    T random() const
    {
        uint64_t n = 1 + max - min;
        if(n == 0) {
            return 0;
        }
        T value = os_random();
        if(n > std::numeric_limits<uint32_t>::max()) {
            value |= uint64_t(os_random()) << 32;
        }
        return min + value % n;
    }
 
    Iterator begin() const
    {
        return Iterator{min};
    }
 
    Iterator end() const
    {
        return Iterator{T(max + 1)};
    }
 
    String toString() const
    {
        String s;
        s += min;
        s += ", ";
        s += max;
        return s;
    }
 
    operator String() const
    {
        return toString();
    }
};
 
template <typename T> inline String toString(TRange<T> range)
{
    return range.toString();
}