flash/flash.hpp

#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 {

// Only used for C++ type safety, because otherwise a PSTR would be indistinguishable from a normal c-string
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