mem_rw_optional.h

#pragma once
 
#include "libmicroemu/internal/bus/mem_access_results.h"
#include "libmicroemu/types.h"
#include <cassert>
#include <type_traits>
 
namespace libmicroemu::internal {

template <unsigned Id, typename TCpuAccessor, typename TEndianessC> class MemRwOptional {
public:
  static constexpr bool kReadOnly = false;

  explicit MemRwOptional(u8 *const buf, const me_size_t buf_size, const me_adr_t vadr_offset)
      : buf_(buf), vadr_offset_(vadr_offset), buf_size_(buf_size) {}

  virtual ~MemRwOptional() = default;

  MemRwOptional(const MemRwOptional &r_src) = default;

  MemRwOptional &operator=(const MemRwOptional &r_src) = default;

  MemRwOptional(MemRwOptional &&r_src) = default;

  MemRwOptional &operator=(MemRwOptional &&r_src) = default;
 
  template <typename T> ReadResult<T> Read(TCpuAccessor &cpua, me_adr_t vadr) const {
    // clang-format off
    static_assert(
        std::is_same<T, u32>::value || 
        std::is_same<T, u16>::value ||
        std::is_same<T, u8>::value,  
        "Read only allows u32, u16 and u8");
    // clang-format on
    static_cast<void>(cpua);
 
    assert(buf_ != nullptr && buf_size_ != 0U);
 
    const me_adr_t padr = ConvertToPhysicalAdr(vadr);
    assert(IsPAdrInRange(padr) == true);
    T val = *reinterpret_cast<const T *>(&buf_[padr]);
    T cval = TEndianessC::template Convert<T>(val);
 
    return ReadResult<T>{cval, ReadStatusCode::kOk};
  }
 
  template <typename T> WriteResult<T> Write(TCpuAccessor &cpua, me_adr_t vadr, T value) const {
    // clang-format off
    static_assert(
        std::is_same<T, u32>::value || 
        std::is_same<T, u16>::value ||
        std::is_same<T, u8>::value,  
         "Write only allows u32, u16 and u8 types");
    // clang-format on
    static_cast<void>(cpua);
 
    assert(buf_ != nullptr && buf_size_ != 0U);
    const me_adr_t padr = ConvertToPhysicalAdr(vadr);
    assert(IsPAdrInRange(padr) == true);
 
    *reinterpret_cast<T *const>(&buf_[padr]) = value;
 
    return WriteResult<T>{WriteStatusCode::kOk};
  }
 
  bool IsVAdrInRange(me_adr_t vadr) const {
    // if no buffer was assigned always return that this memory has to valid access range
    if (buf_ == nullptr || buf_size_ == 0U) {
      return false;
    }
 
    const me_adr_t padr = ConvertToPhysicalAdr(vadr);
    if (IsPAdrInRange(padr) == false) {
      return false;
    }
    return true;
  }
 
private:
  u8 *const buf_{nullptr};
  const me_adr_t vadr_offset_{0U};
  const me_size_t buf_size_{0U};
 
  me_adr_t ConvertToPhysicalAdr(me_adr_t vadr) const { return vadr - vadr_offset_; }
  bool IsPAdrInRange(me_adr_t padr) const { return padr < buf_size_; }
};
 
} // namespace libmicroemu::internal