src/tint/utils/bytes/decoder.h - dawn.git - Git at Google

 // Copyright 2023 The Dawn & Tint Authors
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are met:
 //
 // 1. Redistributions of source code must retain the above copyright notice, this
 //    list of conditions and the following disclaimer.
 //
 // 2. Redistributions in binary form must reproduce the above copyright notice,
 //    this list of conditions and the following disclaimer in the documentation
 //    and/or other materials provided with the distribution.
 //
 // 3. Neither the name of the copyright holder nor the names of its
 //    contributors may be used to endorse or promote products derived from
 //    this software without specific prior written permission.
 //
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 // AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 // DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
 // FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 // SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 // CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 // OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 #ifndef SRC_TINT_UTILS_BYTES_DECODER_H_
 #define SRC_TINT_UTILS_BYTES_DECODER_H_

 #include <bitset>
 #include <climits>
 #include <optional>
 #include <string>
 #include <tuple>
 #include <unordered_map>
 #include <unordered_set>
 #include <utility>
 #include <vector>

 #include "src/tint/utils/bytes/reader.h"
 #include "src/tint/utils/reflection/reflection.h"

 namespace tint::bytes {

 template <typename T, typename = void>
 struct Decoder;

 /// Decodes T from @p reader.
 /// @param reader the byte reader
 /// @param args additional arguments used by Decoder<T>::Decode()
 /// @returns the decoded object
 template <typename T, typename... ARGS>
 Result<T> Decode(Reader& reader, ARGS&&... args) {
     return Decoder<T>::Decode(reader, std::forward<ARGS>(args)...);
 }

 /// Decoder specialization for integer types
 template <typename T>
 struct Decoder<T, std::enable_if_t<std::is_integral_v<T>>> {
     /// Decode decodes the integer type from @p reader.
     /// @param reader the reader to decode from
     /// @param endianness the endianness of the integer
     /// @returns the decoded integer type, or an error if the stream is too short.
     static Result<T> Decode(Reader& reader, Endianness endianness = Endianness::kLittle) {
         return reader.Int<T>(endianness);
     }
 };

 /// Decoder specialization for floating point types
 template <typename T>
 struct Decoder<T, std::enable_if_t<std::is_floating_point_v<T>>> {
     /// Decode decodes the floating point type from @p reader.
     /// @param reader the reader to decode from
     /// @returns the decoded floating point type, or an error if the stream is too short.
     static Result<T> Decode(Reader& reader) { return reader.Float<T>(); }
 };

 /// Decoder specialization for a uint16_t length prefixed string.
 template <>
 struct Decoder<std::string, void> {
     /// Decode decodes the string from @p reader.
     /// @param reader the reader to decode from
     /// @returns the decoded string, or an error if the stream is too short.
     static Result<std::string> Decode(Reader& reader) {
         auto len = reader.Int<uint16_t>();
         if (len != Success) {
             return len.Failure();
         }
         return reader.String(len.Get());
     }
 };

 /// Decoder specialization for bool types
 template <>
 struct Decoder<bool, void> {
     /// Decode decodes the boolean from @p reader.
     /// @param reader the reader to decode from
     /// @returns the decoded boolean, or an error if the stream is too short.
     static Result<bool> Decode(Reader& reader) { return reader.Bool(); }
 };

 /// Decoder specialization for types that use TINT_REFLECT
 template <typename T>
 struct Decoder<T, std::enable_if_t<HasReflection<T>>> {
     /// Decode decodes the reflected type from @p reader.
     /// @param reader the reader to decode from
     /// @returns the decoded reflected type, or an error if the stream is too short.
     static Result<T> Decode(Reader& reader) {
         T object{};
         diag::List errs;
         ForeachField(object, [&](auto& field) {  //
             auto value = bytes::Decode<std::decay_t<decltype(field)>>(reader);
             if (value == Success) {
                 field = value.Get();
             } else {
                 errs.Add(value.Failure().reason);
             }
         });
         if (errs.empty()) {
             return object;
         }
         return Failure{errs};
     }
 };

 /// Decoder specialization for std::unordered_map
 template <typename K, typename V>
 struct Decoder<std::unordered_map<K, V>, void> {
     /// Decode decodes the map from @p reader.
     /// @param reader the reader to decode from
     /// @returns the decoded map, or an error if the stream is too short.
     static Result<std::unordered_map<K, V>> Decode(Reader& reader) {
         std::unordered_map<K, V> out;

         while (!reader.IsEOF()) {
             auto stop = bytes::Decode<bool>(reader);
             if (stop != Success) {
                 return stop.Failure();
             }
             if (stop.Get()) {
                 break;
             }
             auto key = bytes::Decode<K>(reader);
             if (key != Success) {
                 return key.Failure();
             }
             auto val = bytes::Decode<V>(reader);
             if (val != Success) {
                 return val.Failure();
             }
             out.emplace(std::move(key.Get()), std::move(val.Get()));
         }

         return out;
     }
 };

 /// Decoder specialization for std::unordered_set
 template <typename V>
 struct Decoder<std::unordered_set<V>, void> {
     /// Decode decodes the set from @p reader.
     /// @param reader the reader to decode from
     /// @returns the decoded set, or an error if the stream is too short.
     static Result<std::unordered_set<V>> Decode(Reader& reader) {
         std::unordered_set<V> out;

         while (!reader.IsEOF()) {
             auto stop = bytes::Decode<bool>(reader);
             if (stop != Success) {
                 return stop.Failure();
             }
             if (stop.Get()) {
                 break;
             }
             auto val = bytes::Decode<V>(reader);
             if (val != Success) {
                 return val.Failure();
             }
             out.emplace(std::move(val.Get()));
         }

         return out;
     }
 };

 /// Decoder specialization for std::vector
 template <typename V>
 struct Decoder<std::vector<V>, void> {
     /// Decode decodes the vector from @p reader.
     /// @param reader the reader to decode from
     /// @returns the decoded vector, or an error if the stream is too short.
     static Result<std::vector<V>> Decode(Reader& reader) {
         std::vector<V> out;

         while (!reader.IsEOF()) {
             auto stop = bytes::Decode<bool>(reader);
             if (stop != Success) {
                 return stop.Failure();
             }
             if (stop.Get()) {
                 break;
             }
             auto val = bytes::Decode<V>(reader);
             if (val != Success) {
                 return val.Failure();
             }
             out.emplace_back(std::move(val.Get()));
         }

         return out;
     }
 };

 /// Decoder specialization for std::optional
 template <typename T>
 struct Decoder<std::optional<T>, void> {
     /// Decode decodes the optional from @p reader.
     /// @param reader the reader to decode from
     /// @returns the decoded optional, or an error if the stream is too short.
     static Result<std::optional<T>> Decode(Reader& reader) {
         auto has_value = bytes::Decode<bool>(reader);
         if (has_value != Success) {
             return has_value.Failure();
         }
         if (!has_value.Get()) {
             return std::optional<T>{std::nullopt};
         }
         auto value = bytes::Decode<T>(reader);
         if (value != Success) {
             return value.Failure();
         }
         return std::optional<T>{value.Get()};
     }
 };

 /// Decoder specialization for std::bitset
 template <std::size_t N>
 struct Decoder<std::bitset<N>, void> {
     /// Decode decodes the bitset from @p reader.
     /// @param reader the reader to decode from
     /// @returns the decoded bitset, or an error if the stream is too short.
     static Result<std::bitset<N>> Decode(Reader& reader) {
         Vector<std::byte, 32> vec;
         vec.Resize((N + CHAR_BIT - 1) / CHAR_BIT);

         if (auto len = reader.Read(&vec[0], vec.Length()); len != vec.Length()) {
             return Failure{"EOF"};
         }

         std::bitset<N> out;
         for (std::size_t i = 0; i < N; i++) {
             std::size_t w = i / CHAR_BIT;
             std::size_t b = i - (w * CHAR_BIT);
             out[i] = ((vec[w] >> b) & std::byte{1}) != std::byte{0};
         }
         return out;
     }
 };

 /// Decoder specialization for std::tuple
 template <typename FIRST, typename... OTHERS>
 struct Decoder<std::tuple<FIRST, OTHERS...>, void> {
     /// Decode decodes the tuple from @p reader.
     /// @param reader the reader to decode from
     /// @returns the decoded tuple, or an error if the stream is too short.
     static Result<std::tuple<FIRST, OTHERS...>> Decode(Reader& reader) {
         auto first = bytes::Decode<FIRST>(reader);
         if (first != Success) {
             return first.Failure();
         }
         if constexpr (sizeof...(OTHERS) > 0) {
             auto others = bytes::Decode<std::tuple<OTHERS...>>(reader);
             if (others != Success) {
                 return others.Failure();
             }
             return std::tuple_cat(std::tuple<FIRST>(first.Get()), others.Get());
         } else {
             return std::tuple<FIRST>(first.Get());
         }
     }
 };

 /// Decoder specialization for enum types that have a range defined with TINT_REFLECT_ENUM_RANGE
 template <typename T>
 struct Decoder<T, std::void_t<decltype(tint::EnumRange<T>::kMax)>> {
     /// Decode decodes the enum type from @p reader.
     /// @param reader the reader to decode from
     /// @param endianness the endianness of the enum
     /// @returns the decoded enum type, or an error if the stream is too short.
     static Result<T> Decode(Reader& reader, Endianness endianness = Endianness::kLittle) {
         using Range = tint::EnumRange<T>;
         using U = std::underlying_type_t<T>;
         auto value = reader.Int<U>(endianness);
         if (value != Success) {
             return value.Failure();
         }
         static constexpr U kMin = static_cast<U>(Range::kMin);
         static constexpr U kMax = static_cast<U>(Range::kMax);
         if (value.Get() < kMin || value.Get() > kMax) {
             return Failure{"value " + std::to_string(value.Get()) + " out of range for enum"};
         }
         return static_cast<T>(value.Get());
     }
 };

 }  // namespace tint::bytes

 #endif  // SRC_TINT_UTILS_BYTES_DECODER_H_
	// Copyright 2023 The Dawn & Tint Authors
	//
	// Redistribution and use in source and binary forms, with or without
	// modification, are permitted provided that the following conditions are met:
	//
	// 1. Redistributions of source code must retain the above copyright notice, this
	// list of conditions and the following disclaimer.
	//
	// 2. Redistributions in binary form must reproduce the above copyright notice,
	// this list of conditions and the following disclaimer in the documentation
	// and/or other materials provided with the distribution.
	//
	// 3. Neither the name of the copyright holder nor the names of its
	// contributors may be used to endorse or promote products derived from
	// this software without specific prior written permission.
	//
	// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
	// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
	// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
	// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
	// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
	// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
	// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

	#ifndef SRC_TINT_UTILS_BYTES_DECODER_H_
	#define SRC_TINT_UTILS_BYTES_DECODER_H_

	#include <bitset>
	#include <climits>
	#include <optional>
	#include <string>
	#include <tuple>
	#include <unordered_map>
	#include <unordered_set>
	#include <utility>
	#include <vector>

	#include "src/tint/utils/bytes/reader.h"
	#include "src/tint/utils/reflection/reflection.h"

	namespace tint::bytes {

	template <typename T, typename = void>
	struct Decoder;

	/// Decodes T from @p reader.
	/// @param reader the byte reader
	/// @param args additional arguments used by Decoder<T>::Decode()
	/// @returns the decoded object
	template <typename T, typename... ARGS>
	Result<T> Decode(Reader& reader, ARGS&&... args) {
	return Decoder<T>::Decode(reader, std::forward<ARGS>(args)...);
	}

	/// Decoder specialization for integer types
	template <typename T>
	struct Decoder<T, std::enable_if_t<std::is_integral_v<T>>> {
	/// Decode decodes the integer type from @p reader.
	/// @param reader the reader to decode from
	/// @param endianness the endianness of the integer
	/// @returns the decoded integer type, or an error if the stream is too short.
	static Result<T> Decode(Reader& reader, Endianness endianness = Endianness::kLittle) {
	return reader.Int<T>(endianness);
	}
	};

	/// Decoder specialization for floating point types
	template <typename T>
	struct Decoder<T, std::enable_if_t<std::is_floating_point_v<T>>> {
	/// Decode decodes the floating point type from @p reader.
	/// @param reader the reader to decode from
	/// @returns the decoded floating point type, or an error if the stream is too short.
	static Result<T> Decode(Reader& reader) { return reader.Float<T>(); }
	};

	/// Decoder specialization for a uint16_t length prefixed string.
	template <>
	struct Decoder<std::string, void> {
	/// Decode decodes the string from @p reader.
	/// @param reader the reader to decode from
	/// @returns the decoded string, or an error if the stream is too short.
	static Result<std::string> Decode(Reader& reader) {
	auto len = reader.Int<uint16_t>();
	if (len != Success) {
	return len.Failure();
	}
	return reader.String(len.Get());
	}
	};

	/// Decoder specialization for bool types
	template <>
	struct Decoder<bool, void> {
	/// Decode decodes the boolean from @p reader.
	/// @param reader the reader to decode from
	/// @returns the decoded boolean, or an error if the stream is too short.
	static Result<bool> Decode(Reader& reader) { return reader.Bool(); }
	};

	/// Decoder specialization for types that use TINT_REFLECT
	template <typename T>
	struct Decoder<T, std::enable_if_t<HasReflection<T>>> {
	/// Decode decodes the reflected type from @p reader.
	/// @param reader the reader to decode from
	/// @returns the decoded reflected type, or an error if the stream is too short.
	static Result<T> Decode(Reader& reader) {
	T object{};
	diag::List errs;
	ForeachField(object, [&](auto& field) { //
	auto value = bytes::Decode<std::decay_t<decltype(field)>>(reader);
	if (value == Success) {
	field = value.Get();
	} else {
	errs.Add(value.Failure().reason);
	}
	});
	if (errs.empty()) {
	return object;
	}
	return Failure{errs};
	}
	};

	/// Decoder specialization for std::unordered_map
	template <typename K, typename V>
	struct Decoder<std::unordered_map<K, V>, void> {
	/// Decode decodes the map from @p reader.
	/// @param reader the reader to decode from
	/// @returns the decoded map, or an error if the stream is too short.
	static Result<std::unordered_map<K, V>> Decode(Reader& reader) {
	std::unordered_map<K, V> out;

	while (!reader.IsEOF()) {
	auto stop = bytes::Decode<bool>(reader);
	if (stop != Success) {
	return stop.Failure();
	}
	if (stop.Get()) {
	break;
	}
	auto key = bytes::Decode<K>(reader);
	if (key != Success) {
	return key.Failure();
	}
	auto val = bytes::Decode<V>(reader);
	if (val != Success) {
	return val.Failure();
	}
	out.emplace(std::move(key.Get()), std::move(val.Get()));
	}

	return out;
	}
	};

	/// Decoder specialization for std::unordered_set
	template <typename V>
	struct Decoder<std::unordered_set<V>, void> {
	/// Decode decodes the set from @p reader.
	/// @param reader the reader to decode from
	/// @returns the decoded set, or an error if the stream is too short.
	static Result<std::unordered_set<V>> Decode(Reader& reader) {
	std::unordered_set<V> out;

	while (!reader.IsEOF()) {
	auto stop = bytes::Decode<bool>(reader);
	if (stop != Success) {
	return stop.Failure();
	}
	if (stop.Get()) {
	break;
	}
	auto val = bytes::Decode<V>(reader);
	if (val != Success) {
	return val.Failure();
	}
	out.emplace(std::move(val.Get()));
	}

	return out;
	}
	};

	/// Decoder specialization for std::vector
	template <typename V>
	struct Decoder<std::vector<V>, void> {
	/// Decode decodes the vector from @p reader.
	/// @param reader the reader to decode from
	/// @returns the decoded vector, or an error if the stream is too short.
	static Result<std::vector<V>> Decode(Reader& reader) {
	std::vector<V> out;

	while (!reader.IsEOF()) {
	auto stop = bytes::Decode<bool>(reader);
	if (stop != Success) {
	return stop.Failure();
	}
	if (stop.Get()) {
	break;
	}
	auto val = bytes::Decode<V>(reader);
	if (val != Success) {
	return val.Failure();
	}
	out.emplace_back(std::move(val.Get()));
	}

	return out;
	}
	};

	/// Decoder specialization for std::optional
	template <typename T>
	struct Decoder<std::optional<T>, void> {
	/// Decode decodes the optional from @p reader.
	/// @param reader the reader to decode from
	/// @returns the decoded optional, or an error if the stream is too short.
	static Result<std::optional<T>> Decode(Reader& reader) {
	auto has_value = bytes::Decode<bool>(reader);
	if (has_value != Success) {
	return has_value.Failure();
	}
	if (!has_value.Get()) {
	return std::optional<T>{std::nullopt};
	}
	auto value = bytes::Decode<T>(reader);
	if (value != Success) {
	return value.Failure();
	}
	return std::optional<T>{value.Get()};
	}
	};

	/// Decoder specialization for std::bitset
	template <std::size_t N>
	struct Decoder<std::bitset<N>, void> {
	/// Decode decodes the bitset from @p reader.
	/// @param reader the reader to decode from
	/// @returns the decoded bitset, or an error if the stream is too short.
	static Result<std::bitset<N>> Decode(Reader& reader) {
	Vector<std::byte, 32> vec;
	vec.Resize((N + CHAR_BIT - 1) / CHAR_BIT);

	if (auto len = reader.Read(&vec[0], vec.Length()); len != vec.Length()) {
	return Failure{"EOF"};
	}

	std::bitset<N> out;
	for (std::size_t i = 0; i < N; i++) {
	std::size_t w = i / CHAR_BIT;
	std::size_t b = i - (w * CHAR_BIT);
	out[i] = ((vec[w] >> b) & std::byte{1}) != std::byte{0};
	}
	return out;
	}
	};

	/// Decoder specialization for std::tuple
	template <typename FIRST, typename... OTHERS>
	struct Decoder<std::tuple<FIRST, OTHERS...>, void> {
	/// Decode decodes the tuple from @p reader.
	/// @param reader the reader to decode from
	/// @returns the decoded tuple, or an error if the stream is too short.
	static Result<std::tuple<FIRST, OTHERS...>> Decode(Reader& reader) {
	auto first = bytes::Decode<FIRST>(reader);
	if (first != Success) {
	return first.Failure();
	}
	if constexpr (sizeof...(OTHERS) > 0) {
	auto others = bytes::Decode<std::tuple<OTHERS...>>(reader);
	if (others != Success) {
	return others.Failure();
	}
	return std::tuple_cat(std::tuple<FIRST>(first.Get()), others.Get());
	} else {
	return std::tuple<FIRST>(first.Get());
	}
	}
	};

	/// Decoder specialization for enum types that have a range defined with TINT_REFLECT_ENUM_RANGE
	template <typename T>
	struct Decoder<T, std::void_t<decltype(tint::EnumRange<T>::kMax)>> {
	/// Decode decodes the enum type from @p reader.
	/// @param reader the reader to decode from
	/// @param endianness the endianness of the enum
	/// @returns the decoded enum type, or an error if the stream is too short.
	static Result<T> Decode(Reader& reader, Endianness endianness = Endianness::kLittle) {
	using Range = tint::EnumRange<T>;
	using U = std::underlying_type_t<T>;
	auto value = reader.Int<U>(endianness);
	if (value != Success) {
	return value.Failure();
	}
	static constexpr U kMin = static_cast<U>(Range::kMin);
	static constexpr U kMax = static_cast<U>(Range::kMax);
	if (value.Get() < kMin \|\| value.Get() > kMax) {
	return Failure{"value " + std::to_string(value.Get()) + " out of range for enum"};
	}
	return static_cast<T>(value.Get());
	}
	};

	} // namespace tint::bytes

	#endif // SRC_TINT_UTILS_BYTES_DECODER_H_