Add generic variable wrapper to either flash or ram

flash.hpp

@@ -1,8 +1,18 @@
 #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; \
+	const auto *name = reinterpret_cast<const ::detail::FlashString *>(__##name)
 
 namespace detail {
 
@@ -10,3 +20,100 @@ namespace detail {
 struct FlashString;
 
 } // namespace detail
+
+namespace flash {
+
+template <typename T>
+static inline T load(const T &object)
+{
+	T buffer;
+	auto byteBuffer = reinterpret_cast<std::byte *>(&buffer);
+	for (auto i = std::size_t{0}; i < sizeof(T); ++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