except.hpp

Go to the documentation of this file.

/*
 * libfxd - a fixed-point library for C++
 *
 * Copyright 2023 Daniel K. O.
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef LIBFXD_EXCEPT_HPP
#define LIBFXD_EXCEPT_HPP
 
#include <concepts>
#include <cstdlib>
#include <stdexcept>
 
#include "concepts.hpp"
#include "error.hpp"
 
#include "detail/safe.hpp"
#include "detail/safe-div.hpp"
#include "detail/safe-mul.hpp"
 
 
namespace fxd::except {
 
 
    [[noreturn]]
    inline
    void
    except(error e)
    {
        switch (e) {
            case error::underflow:
                throw std::underflow_error{"underflow"};
            case error::overflow:
                throw std::overflow_error{"overflow"};
            case error::not_a_number:
                throw std::invalid_argument{"not a number"};
            default:
                throw std::logic_error{"unknown error"};
        }
    }
 
 
#define WRAP(expr)                              \
    do {                                        \
        auto result = detail::safe::expr;       \
        if (!result)                            \
            except(result.error());             \
        return *result;                         \
    } while (false)
 
 
    template<fixed_point Fxd,
             std::integral I>
    constexpr
    Fxd
    from_raw(I val)
    {
        WRAP(from_raw<Fxd>(val));
    }
 
 
    template<fixed_point Dst,
             std::convertible_to<Dst> Src>
    constexpr
    Dst
    make_fixed(Src src)
    {
        WRAP(make_fixed<Dst>(src));
    }
 
 
    template<int Int, int Frac,
             typename Raw = detail::select_int_t<Int + Frac>,
             std::convertible_to<fixed<Int, Frac, Raw>> Src>
    constexpr
    fixed<Int, Frac, Raw>
    make_fixed(Src src)
    {
        using Dst = fixed<Int, Frac, Raw>;
        return except::make_fixed<Dst>(src);
    }
 
 
    template<int Int, int Frac,
             typename Raw = detail::select_uint_t<Int + Frac>,
             std::convertible_to<fixed<Int, Frac, Raw>> Src>
    constexpr
    fixed<Int, Frac, Raw>
    make_ufixed(Src src)
    {
        using Dst = fixed<Int, Frac, Raw>;
        return except::make_fixed<Dst>(src);
    }
 
 
    template<fixed_point Dst,
             fixed_point Src>
    constexpr
    Dst
    fixed_cast(Src src)
    {
        WRAP(fixed_cast<Dst>(src));
    }
 
 
    template<int Int, int Frac,
             typename Raw = detail::select_int_t<Int + Frac>,
             fixed_point Src>
    constexpr
    fixed<Int, Frac, Raw>
    fixed_cast(Src src)
    {
        using Dst = fixed<Int, Frac, Raw>;
        return except::fixed_cast<Dst>(src);
    }
 
 
    template<int Int, int Frac,
             typename Raw = detail::select_uint_t<Int + Frac>,
             fixed_point Src>
    constexpr
    fixed<Int, Frac, Raw>
    ufixed_cast(Src src)
    {
        using Dst = fixed<Int, Frac, Raw>;
        return except::fixed_cast<Dst>(src);
    }
 
 
    template<std::integral I,
             fixed_point Fxd>
    I
    to_int(Fxd f)
    {
        WRAP(to_int<I>(f));
    }
 
 
    template<fixed_point Fxd>
    constexpr
    detail::select_int_for<Fxd::int_bits, typename Fxd::raw_type>
    to_int(Fxd f)
    {
        using I = detail::select_int_for<Fxd::int_bits, typename Fxd::raw_type>;
        return except::to_int<I>(f);
    }
 
 
    template<fixed_point Dst,
             std::convertible_to<Dst> Src>
    constexpr
    Dst&
    assign(Dst& dst,
           Src src)
    {
        return dst = except::make_fixed<Dst>(src);
    }
 
 
    template<fixed_point Fxd>
    constexpr
    Fxd&
    pre_inc(Fxd& f)
    {
        auto result = detail::safe::incremented(f);
        if (!result)
            except(result.error());
        return f = *result;
    }
 
 
    template<fixed_point Fxd>
    constexpr
    Fxd
    post_inc(Fxd& f)
    {
        Fxd old_f = f;
        except::pre_inc(f);
        return old_f;
    }
 
 
    template<fixed_point Fxd>
    constexpr
    Fxd&
    pre_dec(Fxd& f)
    {
        auto result = detail::safe::decremented(f);
        if (!result)
            except(result.error());
        return f = *result;
    }
 
 
    template<fixed_point Fxd>
    constexpr
    Fxd
    post_dec(Fxd& f)
    {
        Fxd old_f = f;
        except::pre_dec(f);
        return old_f;
    }
 
 
    template<fixed_point Fxd>
    constexpr
    Fxd
    negate(Fxd f)
    {
        WRAP(negate(f));
    }
 
 
    template<fixed_point Fxd>
    constexpr
    Fxd
    add(Fxd a,
        Fxd b)
    {
        WRAP(add(a, b));
    }
 
 
    template<fixed_point Fxd>
    constexpr
    Fxd
    sub(Fxd a,
        Fxd b)
    {
        WRAP(sub(a, b));
    }
 
 
    namespace down {
 
        template<fixed_point Fxd>
        constexpr
        Fxd
        div(Fxd a,
            Fxd b)
        {
            WRAP(down::div(a, b));
        }
 
 
        template<fixed_point Fxd>
        constexpr
        Fxd
        mul(Fxd a,
            Fxd b)
        {
            WRAP(down::mul(a, b));
        }
 
    } // namespace down
 
 
    namespace up {
 
        template<fixed_point Fxd>
        constexpr
        Fxd
        div(Fxd a,
            Fxd b)
        {
            WRAP(up::div(a, b));
        }
 
 
        template<fixed_point Fxd>
        constexpr
        Fxd
        mul(Fxd a,
            Fxd b)
        {
            WRAP(up::mul(a, b));
        }
 
    } // namespace up
 
 
    inline
    namespace zero {
 
        template<fixed_point Fxd>
        constexpr
        Fxd
        div(Fxd a,
            Fxd b)
        {
            WRAP(zero::div(a, b));
        }
 
 
        template<fixed_point Fxd>
        constexpr
        Fxd
        mul(Fxd a,
            Fxd b)
        {
            WRAP(zero::mul(a, b));
        }
 
    } // namespace zero
 
 
    template<fixed_point Fxd>
    constexpr
    Fxd
    abs(Fxd f)
    {
        WRAP(abs(f));
    }
 
 
#undef WRAP
 
 
} // namespace fxd::except
 
 
#endif