Make strong_number construct only from non-narrowing input

Author: kcat

alc/alu.cpp

@@ -2329,9 +2329,9 @@ template<> [[nodiscard]] auto SampleConv(f32 const val) noexcept -> i32
     return fastf2i(std::clamp(val*2147483648.0f, -2147483648.0f, 2147483520.0f));
 }
 template<> [[nodiscard]] auto SampleConv(f32 const val) noexcept -> i16
-{ return i16{gsl::narrow_cast<i16>(fastf2i(std::clamp(val*32768.0f, -32768.0f, 32767.0f)))}; }
+{ return i16{gsl::narrow_cast<i16::value_t>(fastf2i(std::clamp(val*32768.0f, -32768.0f, 32767.0f)))}; }
 template<> [[nodiscard]] auto SampleConv(f32 const val) noexcept -> i8
-{ return i8{gsl::narrow_cast<std::int8_t>(fastf2i(std::clamp(val*128.0f, -128.0f, 127.0f)))}; }
+{ return i8{gsl::narrow_cast<i8::value_t>(fastf2i(std::clamp(val*128.0f, -128.0f, 127.0f)))}; }
 
 /* Define unsigned output variations. */
 template<> [[nodiscard]] auto SampleConv(f32 const val) noexcept -> u32

alc/backends/wave.cpp

@@ -334,19 +334,19 @@ auto WaveBackend::reset() -> bool
         // 16-bit val, format type id (extensible: 0xFFFE)
         fwrite16le(0xFFFE_u16, mFile);
         // 16-bit val, channel count
-        fwrite16le(u16{channels}, mFile);
+        fwrite16le(u16::make_from(channels), mFile);
         // 32-bit val, frequency
         fwrite32le(mDevice->mSampleRate, mFile);
         // 32-bit val, bytes per second
         fwrite32le(mDevice->mSampleRate * channels * bytes, mFile);
         // 16-bit val, frame size
-        fwrite16le(u16{channels * bytes}, mFile);
+        fwrite16le(u16::make_from(channels * bytes), mFile);
         // 16-bit val, bits per sample
-        fwrite16le(u16{bytes * 8}, mFile);
+        fwrite16le(u16::make_from(bytes * 8), mFile);
         // 16-bit val, extra byte count
         fwrite16le(22_u16, mFile);
         // 16-bit val, valid bits per sample
-        fwrite16le(u16{bytes * 8}, mFile);
+        fwrite16le(u16::make_from(bytes * 8), mFile);
         // 32-bit val, channel mask
         fwrite32le(chanmask, mFile);
         // 16 byte GUID, sub-type format

common/alcomplex.cpp

@@ -52,8 +52,8 @@ struct BitReverser {
 
             if(idx < revidx)
             {
-                mData[ret_i][0] = u16{idx};
-                mData[ret_i][1] = u16{revidx};
+                mData[ret_i][0] = u16::make_from(idx);
+                mData[ret_i][1] = u16::make_from(revidx);
                 ++ret_i;
             }
         }

common/altypes.hpp

@@ -13,6 +13,8 @@
 #include "gsl/gsl"
 
 
+struct UInt;
+
 namespace al {
 
 /* A "weak number" is a standard number type. They are prone to implicit
@@ -131,14 +133,41 @@ class number_base {
     using value_t = T;
     T c_val;
 
-    template<weak_number U> force_inline constexpr explicit
-    number_base(U const &value) noexcept(not can_narrow<T, U>) : c_val{convert_to<T>(value)} { }
+    template<weak_number U> requires(not can_narrow<T, U>) force_inline constexpr explicit
+    number_base(U const &value) noexcept : c_val{convert_to<T>(value)} { }
+
+    force_inline constexpr explicit
+    number_base(ConstantNum<T> const &value) noexcept : c_val{value.c_val} { }
+
+    template<weak_number U> force_inline static constexpr
+    auto make_from(U const &value) noexcept(not can_narrow<T, U>) -> SelfType
+    {
+        /* Converting to a floating point type isn't checked here because it's
+         * nearly impossible to otherwise ensure a large enough integer or
+         * precise enough double will correctly fit in the target type. Since
+         * converting to floating point results in the nearest value instead of
+         * being modulo wrapped, this should be considered fine.
+         */
+        if constexpr(std::floating_point<T>)
+            return SelfType{static_cast<T>(value)};
+        else
+            return SelfType{convert_to<T>(value)};
+    }
+
+    [[nodiscard]] static constexpr
+    auto bit_pack(std::byte const hi, std::byte const lo) noexcept -> SelfType
+        requires(sizeof(SelfType) == 2)
+    {
+        auto const ret = static_cast<std::uint16_t>((to_integer<std::uint16_t>(hi)<<8)
+            | to_integer<std::uint16_t>(lo));
+        return std::bit_cast<SelfType>(ret);
+    }
 
     /* Copy assignment from another strong number type, only for types that
      * won't narrow.
      */
-    template<strong_number U> requires(not std::is_base_of_v<number_base, U>)
-    constexpr auto operator=(U const &rhs) & noexcept LIFETIMEBOUND -> number_base&
+    template<strong_number U> requires(not std::is_base_of_v<number_base, U>) constexpr
+    auto operator=(U const &rhs) & noexcept LIFETIMEBOUND -> number_base&
     {
         static_assert(not can_narrow<T, typename U::value_t>,
             "Invalid narrowing assignment; use .cast_to<U>() or .reinterpret_as<U>() to convert");
@@ -172,11 +201,8 @@ class number_base {
         noexcept(not can_narrow<typename U::value_t,T> or std::floating_point<typename U::value_t>)
         -> U
     {
-        /* Converting to a floating point type isn't checked here because it's
-         * nearly impossible to otherwise ensure a large enough integer or
-         * precise enough double will correctly fit in the target type. Since
-         * converting to floating point results in the nearest value instead of
-         * being modulo wrapped, this should be considered fine.
+        /* Like make_from, converting to a floating point type isn't checked
+         * here.
          */
         if constexpr(std::floating_point<typename U::value_t>)
             return U{static_cast<U::value_t>(c_val)};
@@ -190,6 +216,8 @@ class number_base {
     template<strong_number U> [[nodiscard]] constexpr
     auto reinterpret_as() const noexcept -> U { return U{static_cast<U::value_t>(c_val)}; }
 
+    [[nodiscard]] constexpr auto popcount() const noexcept -> UInt requires(std::integral<T>);
+
     /* Relevant values for the given type. Offered here as static methods
      * instead of through a separate templated structure.
      */
@@ -206,15 +234,6 @@ class number_base {
         requires std::numeric_limits<T>::has_signaling_NaN
     { return SelfType{std::numeric_limits<T>::signaling_NaN()}; }
 
-    [[nodiscard]] static constexpr
-    auto bit_pack(std::byte const hi, std::byte const lo) noexcept -> SelfType requires (sizeof(SelfType) == 2)
-    {
-        using unsigned_t = std::make_unsigned_t<T>;
-        auto ret = static_cast<unsigned_t>((to_integer<unsigned_t>(hi)<<8)
-            | to_integer<unsigned_t>(lo));
-        return std::bit_cast<SelfType>(ret);
-    }
-
     /* Prefix and postfix increment and decrement operators. Only valid for
      * integral types.
      */
@@ -314,13 +333,15 @@ class number_base {
     DECL_BINARY(&)
     DECL_BINARY(^)
 #undef DECL_BINARY
-    /* Binary ops >> and << between a strong number type and integer constant.
-     * The shift amount must fit into an u8 regardless of the left-side type.
+    /* Binary ops >> and << between a strong number type and weak integer.
+     * Unlike the other operations, these don't require the weak integer to be
+     * constant because the result type is always the same as the left-side
+     * operand.
      */
 #define DECL_BINARY(op)                                                       \
-    [[nodiscard]] force_inline friend constexpr                               \
-    auto operator op(SelfType const &lhs, ConstantNum<std::uint8_t> const &rhs) noexcept \
-    { return SelfType{static_cast<T>(lhs.c_val op rhs.c_val)}; }
+    template<std::unsigned_integral U> [[nodiscard]] force_inline friend      \
+    constexpr auto operator op(SelfType const &lhs, U const &rhs) noexcept    \
+    { return SelfType{static_cast<T>(lhs.c_val op rhs)}; }
     DECL_BINARY(>>)
     DECL_BINARY(<<)
 #undef DECL_BINARY
@@ -511,16 +532,30 @@ using usize = std::size_t;
 using f32 = float;
 using f64 = double;
 
+struct UInt : al::number_base<unsigned, UInt> { using number_base::number_base; using number_base::operator=; };
+template<typename CharT> struct al::formatter<UInt, CharT> : UInt::formatter<CharT> { };
+
+namespace al {
+
+template<weak_number T, typename SelfType>
+    requires(not std::is_const_v<T> and not std::is_volatile_v<T>) [[nodiscard]] constexpr
+auto number_base<T,SelfType>::popcount() const noexcept -> UInt requires(std::integral<T>)
+{
+    using unsigned_t = std::make_unsigned_t<T>;
+    return UInt{static_cast<unsigned>(std::popcount(static_cast<unsigned_t>(c_val)))};
+}
+
+} /* namespace al */
 
 [[nodiscard]] consteval
-auto operator ""_i8(unsigned long long const n) noexcept { return i8{n}; }
+auto operator ""_i8(unsigned long long const n) noexcept { return i8::make_from(n); }
 [[nodiscard]] consteval
-auto operator ""_u8(unsigned long long const n) noexcept { return u8{n}; }
+auto operator ""_u8(unsigned long long const n) noexcept { return u8::make_from(n); }
 
 [[nodiscard]] consteval
-auto operator ""_i16(unsigned long long const n) noexcept { return i16{n}; }
+auto operator ""_i16(unsigned long long const n) noexcept { return i16::make_from(n); }
 [[nodiscard]] consteval
-auto operator ""_u16(unsigned long long const n) noexcept { return u16{n}; }
+auto operator ""_u16(unsigned long long const n) noexcept { return u16::make_from(n); }
 
 [[nodiscard]] consteval
 auto operator ""_i32(unsigned long long const n) noexcept { return gsl::narrow<i32>(n); }

core/device.h

@@ -136,7 +136,7 @@ struct MixParams {
             {
                 if(AmbiMap[j].Index == inmix.AmbiMap[i].Index)
                 {
-                    idx = u8{j};
+                    idx = u8{static_cast<u8::value_t>(j)};
                     gain = AmbiMap[j].Scale * gainbase;
                     break;
                 }

core/hrtf.cpp

@@ -587,7 +587,10 @@ try {
             hrtf->mDelays.size()};
         std::ranges::transform(new_delays, (delays | std::views::join).begin(),
             [delay_scale](f32 const fdelay) -> u8
-        { return gsl::narrow_cast<u8>(float2int(fdelay*delay_scale + 0.5f)); });
+        {
+            return u8::make_from(al::saturate_cast<u8::value_t>(
+                float2int(fdelay*delay_scale + 0.5f)));
+        });
 
         /* Scale the IR size for the new sample rate and update the stored
          * sample rate.

core/hrtf_loader.cpp

@@ -165,7 +165,12 @@ auto readle(std::istream &data) -> T
 
     alignas(T) auto ret = std::array<char,sizeof(T)>{};
     if(!data.read(ret.data(), num_bits/8))
-        return gsl::narrow_cast<T>(EOF);
+    {
+        if constexpr(al::strong_number<T>)
+            return T{gsl::narrow_cast<typename T::value_t>(EOF)};
+        else
+            return gsl::narrow_cast<T>(EOF);
+    }
     if constexpr(std::endian::native == std::endian::big)
         std::reverse(ret.begin(), ret.end());
 

examples/allafplay.cpp

@@ -410,12 +410,12 @@ auto LafStream::readChunk() -> u32
     }
 
     mEnabledTracks = std::bit_cast<decltype(mEnabledTracks)>(enableTrackBits);
-    mNumEnabled = gsl::narrow<u32>(std::accumulate(mEnabledTracks.cbegin(),
-        mEnabledTracks.cend(), 0, [](int const val, u8 const in) -> int
-    { return val + std::popcount(in.c_val); }));
+    mNumEnabled = std::accumulate(mEnabledTracks.cbegin(), mEnabledTracks.cend(),
+        UInt{0u}, [](UInt const val, u8 const in) -> UInt
+    { return val + in.popcount(); }).c_val;
 
     /* Make sure enable bits aren't set for non-existent tracks. */
-    if(mNumEnabled > 0 && mEnabledTracks[((mNumTracks+7_uz)>>3) - 1] >= 1u<<(mNumTracks&7))
+    if(mNumEnabled > 0 && mEnabledTracks[((mNumTracks+7_uz)>>3) - 1] >= 1_u8<<(mNumTracks&7))
         throw std::runtime_error{"Invalid channel enable bits"};
 
     /* Each chunk is exactly one second long, with samples interleaved for each
@@ -453,18 +453,18 @@ auto LafStream::readChunk() -> u32
 auto LafStream::prepareTrack(usize const trackidx, usize const count) -> std::span<std::byte>
 {
     auto const todo = std::min(usize{mSampleRate}, count);
-    if((mEnabledTracks[trackidx>>3] & u8{1<<(trackidx&7)}) != 0)
+    if((mEnabledTracks[trackidx>>3] & (1_u8<<(trackidx&7))) != 0)
     {
         /* If the track is enabled, get the real index (skipping disabled
          * tracks), and deinterlace it into the mono line.
          */
         auto const idx = std::invoke([this,trackidx]() -> u32
         {
             auto const bits = std::span{mEnabledTracks}.first(trackidx>>3);
-            auto const res = std::accumulate(bits.begin(), bits.end(), 0_i32,
-                [](int const val, u8 const in) -> int { return val + std::popcount(in.c_val); })
-                + std::popcount((mEnabledTracks[trackidx>>3] & u8{(1u<<(trackidx&7))-1}).c_val);
-            return gsl::narrow_cast<u32>(res);
+            auto const res = std::accumulate(bits.begin(), bits.end(), UInt{0},
+                [](UInt const val, u8 const in) -> UInt { return val + in.popcount(); })
+                + (mEnabledTracks[trackidx>>3] & ((1_u8<<(trackidx&7))-1)).popcount();
+            return gsl::narrow_cast<u32>(res.c_val);
         });
 
         auto const step = usize{mNumEnabled};

utils/uhjdecoder.cpp

@@ -425,13 +425,13 @@ auto main(std::span<std::string_view> args) -> int
         // 16-bit val, format type id (extensible: 0xFFFE)
         fwrite16le(0xFFFE_u16, outfile);
         // 16-bit val, channel count
-        fwrite16le(u16{outchans}, outfile);
+        fwrite16le(u16::make_from(outchans), outfile);
         // 32-bit val, frequency
         fwrite32le(gsl::narrow<u32>(ininfo.samplerate), outfile);
         // 32-bit val, bytes per second
         fwrite32le(gsl::narrow<u32>(ininfo.samplerate)*outchans*u32{sizeof(f32)}, outfile);
         // 16-bit val, frame size
-        fwrite16le(u16{sizeof(f32)*outchans}, outfile);
+        fwrite16le(u16::make_from(sizeof(f32)*outchans), outfile);
         // 16-bit val, bits per sample
         fwrite16le(u16{sizeof(f32)*8}, outfile);
         // 16-bit val, extra byte count