numericCast.h

//
// Copyright 2024 Pixar
//
// Licensed under the Apache License, Version 2.0 (the "Apache License")
// with the following modification; you may not use this file except in
// compliance with the Apache License and the following modification to it:
// Section 6. Trademarks. is deleted and replaced with:
//
// 6. Trademarks. This License does not grant permission to use the trade
//    names, trademarks, service marks, or product names of the Licensor
//    and its affiliates, except as required to comply with Section 4(c) of
//    the License and to reproduce the content of the NOTICE file.
//
// You may obtain a copy of the Apache License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the Apache License with the above modification is
// distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied. See the Apache License for the specific
// language governing permissions and limitations under the Apache License.
//
#ifndef PXR_BASE_GF_NUMERIC_CAST_H
#define PXR_BASE_GF_NUMERIC_CAST_H
 
#include "pxr/pxr.h"
 
#include "pxr/base/gf/traits.h"
 
#include <cmath>
#include <limits>
#include <optional>
#include <type_traits>
 
PXR_NAMESPACE_OPEN_SCOPE
 
template <class T, class U>
constexpr bool
GfIntegerCompareLess(T t, U u) noexcept
{
    static_assert(std::is_integral_v<T> && std::is_integral_v<U>);
 
    if constexpr (std::is_signed_v<T> == std::is_signed_v<U>) {
        return t < u;
    }
    else if constexpr (std::is_signed_v<T>) {
        return t < 0 || std::make_unsigned_t<T>(t) < u;
    }
    else {
        return u >= 0 && t < std::make_unsigned_t<U>(u);
    }
}
 
enum GfNumericCastFailureType {
    GfNumericCastPosOverflow,  
    GfNumericCastNegOverflow,  
    GfNumericCastNaN           
};
 
template <class To, class From>
std::optional<To>
GfNumericCast(From from, GfNumericCastFailureType *failType = nullptr)
{
    static_assert(GfIsArithmetic<From>::value &&
                  GfIsArithmetic<To>::value);
 
    using FromLimits = std::numeric_limits<From>;
    using ToLimits = std::numeric_limits<To>;
 
    auto setFail = [&failType](GfNumericCastFailureType ft) {
        if (failType) {
            *failType = ft;
        };
    };
 
    // int -> int.
    if constexpr (std::is_integral_v<From> &&
                  std::is_integral_v<To>) {
        // Range check integer to integer.
        if (GfIntegerCompareLess(from, ToLimits::min())) {
            setFail(GfNumericCastNegOverflow);
            return {};
        }
        if (GfIntegerCompareLess(ToLimits::max(), from)) {
            setFail(GfNumericCastPosOverflow);
            return {};
        }
        // In-range.
        return static_cast<To>(from);
    }
    // float -> int.
    else if constexpr (GfIsFloatingPoint<From>::value &&
                       std::is_integral_v<To>) {
        // If the floating point value is NaN we cannot convert.
        if (std::isnan(from)) {
            setFail(GfNumericCastNaN);
            return {};
        }
        // If the floating point value is an infinity we cannot convert.
        if (std::isinf(from)) {
            setFail(std::signbit(static_cast<double>(from))
                    ? GfNumericCastNegOverflow
                    : GfNumericCastPosOverflow);
            return {};
        }
        // Otherwise the floating point value must be (when truncated) in the
        // range for the To type.  We do this by mapping the low/high values for
        // To into From, then displacing these away from zero by 1 to account
        // for the truncation, then checking against this range.  Note this
        // works okay for GfHalf whose max is ~65,000 when converting to
        // int32_t, say.  In that case we get a range like (-inf, inf), meaning
        // that all finite halfs are in-range.
        From low = static_cast<From>(ToLimits::lowest()) - static_cast<From>(1);
        From high = static_cast<From>(ToLimits::max()) + static_cast<From>(1);
        
        if (from <= low) {
            setFail(GfNumericCastNegOverflow);
            return {};
        }
        if (from >= high) {
            setFail(GfNumericCastPosOverflow);
            return {};
        }
        // The value is in-range.
        return static_cast<To>(from);
    }
    // float -> float, or float -> int.
    else {
        (void)setFail; // hush compiler.
        
        // No range checking, following boost::numeric_cast.
        return static_cast<To>(from);
    }
}
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif // PXR_BASE_GF_NUMERIC_CAST_H