chromium/third_party/abseil-cpp/absl/random/internal/traits.h

// Copyright 2017 The Abseil Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#ifndef ABSL_RANDOM_INTERNAL_TRAITS_H_
#define ABSL_RANDOM_INTERNAL_TRAITS_H_

#include <cstdint>
#include <limits>
#include <type_traits>

#include "absl/base/config.h"
#include "absl/numeric/bits.h"
#include "absl/numeric/int128.h"

namespace absl {
ABSL_NAMESPACE_BEGIN
namespace random_internal {

// random_internal::is_widening_convertible<A, B>
//
// Returns whether a type A is widening-convertible to a type B.
//
// A is widening-convertible to B means:
//   A a = <any number>;
//   B b = a;
//   A c = b;
//   EXPECT_EQ(a, c);
template <typename A, typename B>
class is_widening_convertible { … };

template <typename T>
struct IsIntegral : std::is_integral<T> { … };
template <>
struct IsIntegral<absl::int128> : std::true_type { … };
template <>
struct IsIntegral<absl::uint128> : std::true_type { … };

template <typename T>
struct MakeUnsigned : std::make_unsigned<T> { … };
template <>
struct MakeUnsigned<absl::int128> { … };
template <>
struct MakeUnsigned<absl::uint128> { … };

template <typename T>
struct IsUnsigned : std::is_unsigned<T> { … };
template <>
struct IsUnsigned<absl::int128> : std::false_type { … };
template <>
struct IsUnsigned<absl::uint128> : std::true_type { … };

// unsigned_bits<N>::type returns the unsigned int type with the indicated
// number of bits.
template <size_t N>
struct unsigned_bits;

template <>
struct unsigned_bits<8> { … };
template <>
struct unsigned_bits<16> { … };
template <>
struct unsigned_bits<32> { … };
template <>
struct unsigned_bits<64> { … };

template <>
struct unsigned_bits<128> { … };

// 256-bit wrapper for wide multiplications.
struct U256 { … };
template <>
struct unsigned_bits<256> { … };

template <typename IntType>
struct make_unsigned_bits { … };

template <typename T>
int BitWidth(T v) { … }

}  // namespace random_internal
ABSL_NAMESPACE_END
}  // namespace absl

#endif  // ABSL_RANDOM_INTERNAL_TRAITS_H_