46   template <typename T> std::vector<T> ConsumeBytes(size_t num_bytes);
47   template <typename T>
48   std::vector<T> ConsumeBytesWithTerminator(size_t num_bytes, T terminator = 0);
49   template <typename T> std::vector<T> ConsumeRemainingBytes();
59   template <typename T> T ConsumeIntegral();
60   template <typename T> T ConsumeIntegralInRange(T min, T max);
63   template <typename T> T ConsumeFloatingPoint();
64   template <typename T> T ConsumeFloatingPointInRange(T min, T max);
67   template <typename T> T ConsumeProbability();
72   template <typename T> T ConsumeEnum();
75   template <typename T, size_t size> T PickValueInArray(const T (&array)[size]);
76   template <typename T, size_t size>
77   T PickValueInArray(const std::array<T, size> &array);
78   template <typename T> T PickValueInArray(std::initializer_list<const T> list);
94   template <typename T>
95   std::vector<T> ConsumeBytes(size_t size, size_t num_bytes);
107 template <typename T>
108 std::vector<T> FuzzedDataProvider::ConsumeBytes(size_t num_bytes) {  in ConsumeBytes()
110   return ConsumeBytes<T>(num_bytes, num_bytes);  in ConsumeBytes()
117 template <typename T>
118 std::vector<T> FuzzedDataProvider::ConsumeBytesWithTerminator(size_t num_bytes,  in ConsumeBytesWithTerminator()
119                                                               T terminator) {  in ConsumeBytesWithTerminator()
121   std::vector<T> result = ConsumeBytes<T>(num_bytes + 1, num_bytes);  in ConsumeBytesWithTerminator()
127 template <typename T>
128 std::vector<T> FuzzedDataProvider::ConsumeRemainingBytes() {  in ConsumeRemainingBytes()
129   return ConsumeBytes<T>(remaining_bytes_);  in ConsumeRemainingBytes()
194 template <typename T> T FuzzedDataProvider::ConsumeIntegral() {  in ConsumeIntegral()
195   return ConsumeIntegralInRange(std::numeric_limits<T>::min(),  in ConsumeIntegral()
196                                 std::numeric_limits<T>::max());  in ConsumeIntegral()
203 template <typename T>
204 T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) {  in ConsumeIntegralInRange()
205   static_assert(std::is_integral<T>::value, "An integral type is required.");  in ConsumeIntegralInRange()
206   static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type.");  in ConsumeIntegralInRange()
216   while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 &&  in ConsumeIntegralInRange()
233   return static_cast<T>(static_cast<uint64_t>(min) + result);  in ConsumeIntegralInRange()
239 template <typename T> T FuzzedDataProvider::ConsumeFloatingPoint() {  in ConsumeFloatingPoint()
240   return ConsumeFloatingPointInRange<T>(std::numeric_limits<T>::lowest(),  in ConsumeFloatingPoint()
241                                         std::numeric_limits<T>::max());  in ConsumeFloatingPoint()
247 template <typename T>
248 T FuzzedDataProvider::ConsumeFloatingPointInRange(T min, T max) {  in ConsumeFloatingPointInRange()
252   T range = .0;  in ConsumeFloatingPointInRange()
253   T result = min;  in ConsumeFloatingPointInRange()
254   constexpr T zero(.0);  in ConsumeFloatingPointInRange()
255   if (max > zero && min < zero && max > min + std::numeric_limits<T>::max()) {  in ConsumeFloatingPointInRange()
267   return result + range * ConsumeProbability<T>();  in ConsumeFloatingPointInRange()
272 template <typename T> T FuzzedDataProvider::ConsumeProbability() {  in ConsumeProbability()
273   static_assert(std::is_floating_point<T>::value,  in ConsumeProbability()
279       typename std::conditional<(sizeof(T) <= sizeof(uint32_t)), uint32_t,  in ConsumeProbability()
282   T result = static_cast<T>(ConsumeIntegral<IntegralType>());  in ConsumeProbability()
283   result /= static_cast<T>(std::numeric_limits<IntegralType>::max());  in ConsumeProbability()
295 template <typename T> T FuzzedDataProvider::ConsumeEnum() {  in ConsumeEnum()
296   static_assert(std::is_enum<T>::value, "|T| must be an enum type.");  in ConsumeEnum()
297   return static_cast<T>(  in ConsumeEnum()
298       ConsumeIntegralInRange<uint32_t>(0, static_cast<uint32_t>(T::kMaxValue)));  in ConsumeEnum()
302 template <typename T, size_t size>
303 T FuzzedDataProvider::PickValueInArray(const T (&array)[size]) {  in PickValueInArray()
308 template <typename T, size_t size>
309 T FuzzedDataProvider::PickValueInArray(const std::array<T, size> &array) {  in PickValueInArray()  argument
314 template <typename T>
315 T FuzzedDataProvider::PickValueInArray(std::initializer_list<const T> list) {  in PickValueInArray()
351 template <typename T>
352 std::vector<T> FuzzedDataProvider::ConsumeBytes(size_t size, size_t num_bytes) {  in ConsumeBytes()
353   static_assert(sizeof(T) == sizeof(uint8_t), "Incompatible data type.");  in ConsumeBytes()
361   std::vector<T> result(size);  in ConsumeBytes()