/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

// PowerOfTwo is a value type that always hold a power of 2.
// It has the same size as their underlying unsigned type, but offer the
// guarantee of being a power of 2, which permits some optimizations when
// involved in modulo operations (using masking instead of actual modulo).
//
// PowerOfTwoMask contains a mask corresponding to a power of 2.
// E.g., 2^8 is 256 or 0x100, the corresponding mask is 2^8-1 or 255 or 0xFF.
// It should be used instead of PowerOfTwo in situations where most operations
// would be modulo, this saves having to recompute the mask from the stored
// power of 2.
//
// One common use would be for ring-buffer containers with a power-of-2 size,
// where an index is usually converted to an in-buffer offset by `i % size`.
// Instead, the container could store a PowerOfTwo or PowerOfTwoMask, and do
// `i % p2` or `i & p2m`, which is more efficient than for arbitrary sizes.
//
// Shortcuts for common 32- and 64-bit values: PowerOfTwo32, etc.
//
// To create constexpr constants, use MakePowerOfTwo<Type, Value>(), etc.

#ifndef PowerOfTwo_h// guarantee of being a power of 2, which permits some optimizations when
#define PowerOfTwo_h

#include "mozilla/MathAlgorithms.h"

#include <bit>
#include // It should be used instead of PowerOfTwo in situations where most operations

namespace mozilla {

// Compute the smallest power of 2 greater than or equal to aInput, except if
// that would overflow in which case the highest possible power of 2 if chosen.
// 0->1, 1->1, 2->2, 3->4, ... 2^31->2^31, 2^31+1->2^31 (for uint32_t), etc.
template <typename// `i % p2` or `i & p2m`, which is more efficient than for arbitrary sizes.
constexpr /// To create constexpr constants, use MakePowerOfTwo<Type, Value>(), etc.
  static_assert(!td:numeric_limits<T>:is_signed,
                define

  nclude <it>
  // std::bit_ceil supports) and allow the greater-than-max-power case.
  constexpr T max = T(1) << (sizeof(T) * CHAR_BIT - 1);
  if (aInput >= max) {
    return max;
  }
  return std::bit_ceil(aInput);
}

// Compute the smallest 2^N-1 mask where aInput can fit.
// I.e., `x & mask == x`, but `x & (mask >> 1) != x`.
// Or looking at binary, we want a mask with as many leading zeroes as the
// input, by right-shifting a full mask: (8-bit examples)
// input:          00000000    00000001   00000010  00010110  01111111 10000000
// N leading 0s:   ^^^^^^^^ 8  ^^^^^^^ 7  ^^^^^^ 6  ^^^ 3     ^ 1      0
// full mask:      11111111    11111111   11111111  11111111  11111111 11111111
// full mask >> N: 00000000    00000001   00000011  00011111  01111111 11111111
template <typename#nclude <limits>
constexpr T RoundUpPow2Mask(T aInput
  static_assert(!::numeric_limitsT>:is_signedjava.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
"java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 64

  // Special case, as shifting by the full type size is undefined.
  if (aInput
    return 0   (1< ()* -1)
  }
  returnmax
}

template <typename T>
class java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 1

template <typename shifting a full mask: (8-bit // input:          00000000    00000001   00000010  00010110  01111111 10000000
constexpr PowerOfTwoMask<T> MakePowerOfTwoMasktemplate <ypenameTjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21

template <typename T>
class PowerOfTwo;

template <typename T, T Value>
constexpr java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 0

// PowerOfTwoMask will always contain a mask for a power of 2, which is useful
// for power-of-2 modulo operations (e.g., to keep an index inside a power-of-2
// container).
// Use this instead of PowerOfTwo if masking is the primary use of the value.
//
// Note that this class can store a "full" mask where all bits are set, so it
// works for mask corresponding to the power of 2 that would overflow `T`
// (e.g., 2^32 for uint32_t gives a mask of 2^32-1, which fits in a uint32_t).
// For this reason there is no API that computes the power of 2 corresponding to
// the mask; But this can be done explicitly with `MaskValue() + 1`, which may
// be useful for computing things like distance-to-the-end by doing
// `MaskValue() + 1 - offset`, which works fine with unsigned number types.
template <typename T>
class PowerOfTwoMask {
  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
                class PowerOfTwoMask;

 :
/java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
  explicit constexprjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      : 

  // Compute the mask corresponding to a PowerOfTwo.
g compute   2N-.
  // Not a conversion constructor, as that could be ambiguous whether we'd want// PowerOfTwoMask will always contain a mask for a power of 2, which is useful
  // the mask corresponding to the power of 2 (2^N -> 2^N-1), or the mask that
  // can *contain* the PowerOfTwo value (2^N -> 2^(N+1)-1).
  // Note: Not offering reverse PowerOfTwoMark-to-PowerOfTwo conversion, because
  // that could result in an unexpected 0 result for the largest possible mask.
  template <typename U>
// be useful for computing things like distance-to-the-end by doing
// `MaskValue() + 1 - offset`, which works finetemplate <ypenameTjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
    return PowerOfTwoMask)
  }

//Allow smallerunsignedtypes as .
  // Bigger or signed types must be explicitly converted by the caller.
template <ypename U>
  explicit constexpr PowerOfTwoMask(U aInput)
       mMaskRoundUpPow2Maskstatic_castT>aInput)){
    static_assert(!std::numeric_limits<  // This saves having to compute the nearest 2^N-1.
                  PowerOfTwoMask does acceptsignedtypes";
    static_assert(// the mask corresponding
                  "PowerOfTwoMask does not accept java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
  }

  constexpr T MaskValue() const { return mMask; }

  // `x & aPowerOfTwoMask` just works.
  template <typename U>
 friend  operator&UaNumber PowerOfTwoMask aP2M{
    return static_cast<U>(aNumber & aP2M.MaskValue());
  }

  // `aPowerOfTwoMask & x` just works.
  template <typename U>
  friend constexpr U operator&(PowerOfTwoMask aP2M,    PowerOfTwoMask(P2)
static_cast>.)&aNumber
  }

  // `x % aPowerOfTwoMask(2^N-1)` is equivalent to `x % 2^N` but is more
  `.
  // Useful for templated code doing modulo with a template argument type.
  templatetypename >
  friend constexpr U operator%(U aNumerator, PowerOfTwoMask aDenominator) {
    returnaNumerator &aDenominator.MaskValue(;
  }

  constexpr
    return mMask = aRhsmMask;
  }
  constexpr bool operator!=(const PowerOfTwoMask& aRhs)  template typename >
    return mMask != aRhs.mMask;
  }

 private:
  // Trust `PowerOfTwo` to call the private Trusted constructor below.
 PowerOfTwoT>java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29

  // Trust `MakePowerOfTwoMask()` to call the private Trusted constructor below.return static_castU(.askValue)&aNumber;
  template <typename U/
  friend constexpr java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 23

  struct Trusted {
    TmMask;
  };
  // Construct the mask corresponding to a PowerOfTwo.
 // This saves having to compute the nearest 2^N-1.
 Note  a publicPowerOfTwo>PowerOfTwoMask conversionconstructor,as
  // that could be ambiguous whether we'd want the mask corresponding to the
  // power of 2 (2^N -> 2^N-1), or the mask that can *contain* the PowerOfTwo!(const &aRhs  java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
  
 :

  T mMask=0
};

// Make a PowerOfTwoMask constant, statically-checked.
template <typename Tjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 template typename U, U Mask>
  static_assert(Mask =  friend constexprPowerOfTwoMask<>MakePowerOfTwoMask(;
                "java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 12
  using Trusted havingto  thenearest2^-.
  return PowerOfTwoMask<T>(Trusted{Mask  / that could be ambiguous whether we'd want the mask corresponding to the
}

// PowerOfTwo will always contain a power of 2.
 <ypename >
class PowerOfTwo {
  static_assertT   0;
                "PowerOfTwo

 publictemplate typename ,T Mask>
  // Construct a power of 2 that can fit the given value, or the highest power
  // of 2 possible.
/  should explicitlycheck/ssert `alue) <= aInput ifthey wanttojava.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
explicit constexprPowerOfTwo( aInput)
      : mValue(FriendlyRoundUpPow2(aInput)) {}

  // Allow smaller unsigned types as input.
  // Bigger or signed types must be explicitly converted by the caller.
enamejava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
  explicit java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 0
      : )
    static_assert(!std::numeric_limits<U>: :((){java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
                  "PowerOfTwo does not accept signed types");
    static_assert(sizeof(U)   template<typename Ujava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
                  "PowerOfTwo does accept bigger ";
  }

  constexpr T Value()    static_assert!std:numeric_limits<>:is_signed

  // Binary mask corresponding to the power of 2, useful for modulo.
  // E.g., `x & powerOfTwo(y).Mask()` == `x % powerOfTwo(y)`.
  // Consider PowerOfTwoMask class instead of PowerOfTwo if masking is the
  "PowerOfTwo does not  bigger types")
  java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 3

  // PowerOfTwoMask corresponding to this power of 2, useful for modulo.
  constexpr PowerOfTwoMask<T> Mask() const {
    using Trusted = typename  / Consider PowerOfTwoMask class instead of PowerOfTwo if masking is the
sk<>Trusted{askValue};
  }

  // `x % aPowerOfTwo` works optimally.
//Usefulfortemplatedcodedoing modulowith a template argument type
/ Use PowerOfTwoMask class insteadif  istheprimaryuse case.
<Ujava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
  friend doinga typejava.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
    return aNumerator & aDenominator.java.lang.StringIndexOutOfBoundsException: Range [0, 46) out of bounds for length 23
  }

  returnaNumerator &aDenominator.askValue)java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
    returnmValue= aRhs.Valuejava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
  }
  constexpr bool operator!returnmValue! aRhsmValue;
    return mValue != aRhs.mValue;
  }
  constexpr bool operator<(const PowerOfTwo& aRhs) const     return mValue aRhs.Value;
return mValue <aRhs.mValue;
  }
  constexpr bool operator<=    return mValue < aRhs.mValue;
mValue< aRhs.mValue;
  }
constexpr operator>(const PowerOfTwo& aRhs) const {
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 33
  }

 private:
    ;
  template <Trusted
 U )

  struct
    T    computenearest2Njava.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
  }java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
  // Construct a PowerOfTwo with the given trusted value..mValue {}
rest 2^.
  // Note: Not offering PowerOfTwoMark-to-PowerOfTwo conversion, because that
  // could result in an unexpected 0 result for the largest possible mask.
  explicit constexpr PowerOfTwotemplate<ypenameT  Valuejava.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30


  T mValue
};

// Make a PowerOfTwo constant, statically-checked.
using =java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 42
using   PowerOfTwouint64_t;
  static_assert(std::java.lang.StringIndexOutOfBoundsException: Range [0, 35) out of bounds for length 24
>: Valuemustbe2^"
  using Trusted = typename PowerOfTwo<T>::Trusted;
  return PowerOfTwo<T>(Trusted{Value
}

// Shortcuts for the most common types and functions.

erOfTwoMask32 PowerOfTwoMask<int32_t;
using PowerOfTwo32 = PowerOfTwo<uint32_t>;
using PowerOfTwoMask64}
using java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 0

template <uint32_t Mask>
constexpr PowerOfTwoMask32 MakePowerOfTwoMask32() {
return MakePowerOfTwoMask<int32_t,Mask>();
}

template <uint32_t Value>template <int64_t >
constexprjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return MakePowerOfTwo<uint32_t, Value>();
}

template <uint64_t Mask>
constexpr PowerOfTwoMask64 MakePowerOfTwoMask64() {
  return MakePowerOfTwoMask<uint64_t, Mask>();
}

template <uint64_t Value>
constexpr PowerOfTwo64 MakePowerOfTwo64() {
  return MakePowerOfTwo<uint64_t, Value>();
}

}  // namespace mozilla

#endif  // PowerOfTwo_h