wrapping_uint.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: AGPL-3.0-or-later
/*
 * Project: RAVENNAKIT (RAVENNA / AES67 / ST2110-30 SDK)
 * Copyright (c) 2024-2025 Sound on Digital
 *
 * This file is part of RAVENNAKIT.
 *
 * RAVENNAKIT is dual-licensed:
 *   1) Under the terms of the GNU Affero General Public License as published by
 *      the Free Software Foundation, either version 3 of the License, or
 *      (at your option) any later version (the "AGPL License"); and
 *   2) Under a commercial license from Sound on Digital, for customers who
 *      cannot (or do not wish to) comply with the AGPL License terms.
 *
 * If you obtained this file under the AGPL License, you may redistribute it
 * and/or modify it under the terms of the AGPL License. See the LICENSE
 * file in the project root for details.
 *
 * For commercial licensing, support, and other inquiries, please visit:
 *
 *     https://ravennakit.com
 *
 */
 
#pragma once
 
#include <limits>
#include <type_traits>
#include <cstdint>
#include <optional>
 
namespace rav {

template<class T>
class WrappingUint {
    static_assert(std::is_integral_v<T>, "WrappingUint only supports integral types");
    static_assert(std::is_unsigned_v<T>, "WrappingUint only supports unsigned types");
 
  public:
    WrappingUint() = default;

    explicit WrappingUint(const T value) : value_(value) {}

    std::optional<T> update(const T value) {
        if (is_older_than(value, value_)) {
            return std::nullopt;  // Value too old
        }
 
        const auto diff = value - value_;
        value_ = value;
        return static_cast<T>(diff);
    }

    [[nodiscard]] explicit operator T() const {
        return value_;
    }

    [[nodiscard]] T value() const {
        return value_;
    }

    WrappingUint& operator=(const T value) {
        value_ = value;
        return *this;
    }

    WrappingUint& operator+=(const T value) {
        value_ += value;
        return *this;
    }

    WrappingUint& operator-=(const T value) {
        value_ -= value;
        return *this;
    }

    [[nodiscard]] WrappingUint operator+(const T value) const {
        return WrappingUint(value_ + value);
    }

    [[nodiscard]] WrappingUint operator-(const T value) const {
        return WrappingUint(value_ - value);
    }

    [[nodiscard]] bool operator==(T other) {
        return value_ == other;
    }

    [[nodiscard]] bool operator!=(T other) {
        return value_ != other;
    }

    friend bool operator==(const WrappingUint& lhs, const WrappingUint& rhs) {
        return lhs.value_ == rhs.value_;
    }

    friend bool operator!=(const WrappingUint& lhs, const WrappingUint& rhs) {
        return lhs.value_ != rhs.value_;
    }

    friend bool operator<(const WrappingUint& lhs, const WrappingUint& rhs) {
        return is_older_than(lhs.value_, rhs.value_);
    }

    friend bool operator<=(const WrappingUint& lhs, const WrappingUint& rhs) {
        return lhs < rhs || lhs == rhs;
    }

    friend bool operator>(const WrappingUint& lhs, const WrappingUint& rhs) {
        return !(lhs <= rhs);
    }

    friend bool operator>=(const WrappingUint& lhs, const WrappingUint& rhs) {
        return lhs > rhs || lhs == rhs;
    }

    [[nodiscard]] std::make_signed_t<T> diff(const WrappingUint& other) const {
        return diff(other.value_);
    }

    [[nodiscard]] std::make_signed_t<T> diff(T other) const {
        // 1 -> 0
        if (is_older_than(other, value_)) {
            return static_cast<std::make_signed_t<T>>(value_ - other) * -1;
        }
        return static_cast<std::make_signed_t<T>>(other - value_);
    }
 
  private:
    T value_ {};

    static bool is_older_than(T a, T b) {
        return !(a == b) && static_cast<T>(b - a) < std::numeric_limits<T>::max() / 2 + 1;
    }
};

using WrappingUint8 = WrappingUint<uint8_t>;

using WrappingUint16 = WrappingUint<uint16_t>;

using WrappingUint32 = WrappingUint<uint32_t>;

using WrappingUint64 = WrappingUint<uint64_t>;
 
}  // namespace rav