safe_int.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 "ravennakit/core/expected.hpp"
 
#include <limits>
 
namespace rav {
 
enum class SafeIntError { overflow, underflow, div_by_zero };

template<class T>
class SafeInt {
  public:
    static_assert(std::is_integral_v<T>, "T must be an integral type");
 
    SafeInt() = default;

    explicit SafeInt(T value) : value_ {value} {}

    T value() const {
        return value_.value();
    }

    [[nodiscard]] SafeIntError error() const {
        return value_.error();
    }

    tl::expected<T, SafeIntError> expected() const {
        return value_;
    }

    template<class U>
    SafeInt& operator+=(U b) {
        if (!value_) {
            return *this;
        }
        value_ = add(*value_, b);
        return *this;
    }

    template<class U>
    SafeInt operator+(U b) const {
        SafeInt r = *this;
        r += b;
        return r;
    }

    template<class U>
    SafeInt& operator-=(U b) {
        if (!value_) {
            return *this;
        }
        value_ = sub(*value_, b);
        return *this;
    }

    template<class U>
    SafeInt operator-(U b) const {
        SafeInt r = *this;
        r -= b;
        return r;
    }

    template<class U>
    SafeInt& operator*=(U b) {
        if (!value_) {
            return *this;
        }
        value_ = mul(*value_, b);
        return *this;
    }

    template<class U>
    SafeInt operator*(U b) const {
        SafeInt r = *this;
        r *= b;
        return r;
    }

    template<class U>
    SafeInt& operator/=(U b) {
        if (!value_) {
            return *this;
        }
        value_ = div(*value_, b);
        return *this;
    }

    template<class U>
    SafeInt operator/(U b) const {
        SafeInt r = *this;
        r /= b;
        return r;
    }

    template<class U>
    static tl::expected<T, SafeIntError> add(T a, U b) {
        if (b > 0 && a > std::numeric_limits<T>::max() - b) {
            return tl::unexpected(SafeIntError::overflow);
        }
        if (b < 0 && a < std::numeric_limits<T>::min() - b) {
            return tl::unexpected(SafeIntError::underflow);
        }
        return a + b;
    }

    template<class U>
    static tl::expected<T, SafeIntError> sub(T a, U b) {
        if (b < 0 && a > std::numeric_limits<T>::max() + b) {
            return tl::unexpected(SafeIntError::overflow);
        }
        if (b > 0 && a < std::numeric_limits<T>::min() + b) {
            return tl::unexpected(SafeIntError::underflow);
        }
        return a - b;
    }

    template<class U>
    static tl::expected<T, SafeIntError> mul(T a, U b) {
        // Handle zero cases early
        if (a == 0 || b == 0) {
            return T {0};
        }
 
        // Check for overflow or underflow before performing the multiplication
        if (a > 0) {
            if (b > 0) {
                if (a > std::numeric_limits<T>::max() / b) {
                    return tl::unexpected(SafeIntError::overflow);
                }
            } else {
                if (b < std::numeric_limits<T>::min() / a) {
                    return tl::unexpected(SafeIntError::underflow);
                }
            }
        } else {
            if (b > 0) {
                if (a < std::numeric_limits<T>::min() / b) {
                    return tl::unexpected(SafeIntError::underflow);
                }
            } else {
                if (a < std::numeric_limits<T>::max() / b) {
                    return tl::unexpected(SafeIntError::overflow);
                }
            }
        }
 
        return a * b;
    }

    template<class U>
    static tl::expected<T, SafeIntError> div(T a, U b) {
        // Check for division by zero
        if (b == 0) {
            return tl::unexpected(SafeIntError::div_by_zero);
        }
 
        // Check for overflow when dividing the smallest negative value by -1
        if constexpr (std::is_signed_v<T>) {
            if (a == std::numeric_limits<T>::min() && b == -1) {
                return tl::unexpected(SafeIntError::overflow);
            }
        }
 
        return a / b;
    }
 
  private:
    tl::expected<T, SafeIntError> value_ {};
};
 
// Convenience aliases
using SafeInt8 = SafeInt<int8_t>;
using SafeInt16 = SafeInt<int16_t>;
using SafeInt32 = SafeInt<int32_t>;
using SafeInt64 = SafeInt<int64_t>;
using SafeUint8 = SafeInt<uint8_t>;
using SafeUint16 = SafeInt<uint16_t>;
using SafeUint32 = SafeInt<uint32_t>;
using SafeUint64 = SafeInt<uint64_t>;
 
}  // namespace rav