Add generic variable wrapper to either flash or ram

flash.hpp

@@ -1,9 +1,14 @@
 #pragma once
 
+#include <type_traits>
+
+#include <cassert>
 #include <cstddef>
 
 #include <avr/pgmspace.h>
 
+#include "../util/util.hpp"
+
 #define F(str) (reinterpret_cast<const ::detail::FlashString *>(PSTR(str)))
 #define GF(name, str) \
 	const char __##name[] PROGMEM = str; \
@@ -19,14 +24,96 @@ struct FlashString;
 namespace flash {
 
 template <typename T>
-static T load(const T &object)
+static inline T load(const T &object)
 {
-	auto buffer = T{};
+	T buffer;
-	auto rawBuffer = reinterpret_cast<std::byte *>(&buffer);
+	auto byteBuffer = reinterpret_cast<std::byte *>(&buffer);
 	for (auto i = std::size_t{0}; i < sizeof(T); ++i) {
-		rawBuffer[i] = static_cast<std::byte>(pgm_read_byte(&reinterpret_cast<const std::byte *>(&object)[i]));
+		byteBuffer[i] = static_cast<std::byte>(pgm_read_byte(&reinterpret_cast<const std::byte *>(&object)[i]));
 	}
 	return buffer;
 }
 
+template <typename T>
+struct [[gnu::progmem]] Wrapper
+{
+	using value_type = T;
+
+	inline T operator*() const
+	{
+		return load(value);
+	}
+
+	inline std::byte operator[](const std::size_t idx) const
+	{
+		const auto bytePtr = reinterpret_cast<const std::byte *>(&value);
+		return load(bytePtr[idx]);
+	}
+
+	const T value;
+};
+
+template <typename T>
+struct RamWrapper {
+	using value_type = T;
+
+	inline constexpr T &operator*()
+	{
+		return value;
+	}
+
+	inline constexpr const T &operator*() const
+	{
+		return value;
+	}
+
+	inline std::byte &operator[](const std::size_t idx)
+	{
+		const auto bytePtr = reinterpret_cast<std::byte *>(&value);
+		return bytePtr[idx];
+	}
+
+	inline const std::byte &operator[](const std::size_t idx) const
+	{
+		const auto bytePtr = reinterpret_cast<const std::byte *>(&value);
+		return bytePtr[idx];
+	}
+
+	T value;
+};
+
+template <typename WrapperT>
+struct is_flash_wrapper : std::false_type {
+};
+
+template <typename T>
+struct is_flash_wrapper<Wrapper<T>> : std::true_type {
+};
+
+template <typename WrapperT>
+static inline constexpr auto is_flash_wrapper_v = is_flash_wrapper<WrapperT>::value;
+
+template <typename WrapperT>
+struct is_ram_wrapper : std::false_type {
+};
+
+template <typename T>
+struct is_ram_wrapper<RamWrapper<T>> : std::true_type {
+};
+
+template <typename WrapperT>
+static inline constexpr auto is_ram_wrapper_v = is_ram_wrapper<WrapperT>::value;
+
+template <typename WrapperT, typename T>
+static inline decltype(auto) loadLike(const T &object)
+{
+	if constexpr (is_ram_wrapper_v<std::remove_cvref_t<WrapperT>>) {
+		return object;
+	} else if constexpr (is_flash_wrapper_v<std::remove_cvref_t<WrapperT>>) {
+		return load(object);
+	} else {
+		static_assert(util::always_false_v<T>, "Invalid wrapper type");
+	}
+}
+
 } // namespace flash