interface.hpp

#pragma once
 
#include <cstdint>
#include <cstring>
 
#include "libxr_def.hpp"
#include "libxr_mem.hpp"
#include "libxr_type.hpp"
 
namespace LibXR
{
 
static constexpr uint16_t LIBXR_DATABASE_VERSION = 3;
 
class Database
{
 public:
  class KeyBase
  {
   public:
    const char* name_;  
    RawData raw_data_;  
 
    KeyBase(const char* name, RawData raw_data) : name_(name), raw_data_(raw_data) {}
  };
 
  template <typename Data>
  class Key : public KeyBase
  {
   public:
    Data data_;           
    Database& database_;  
 
    Key(Database& database, const char* name, Data init_value)
        : KeyBase(name, RawData(data_)), database_(database)
    {
      ErrorCode status = database.Get(*this);
      if (status != ErrorCode::OK)
      {
        data_ = init_value;
        if (status == ErrorCode::NOT_FOUND)
        {
          REQUIRE(database.Add(*this) == ErrorCode::OK);
        }
      }
    }
 
    Key(Database& database, const char* name)
        : KeyBase(name, RawData(data_)), database_(database)
    {
      ErrorCode status = database.Get(*this);
      if (status != ErrorCode::OK)
      {
        Memory::FastSet(&data_, 0, sizeof(Data));
        if (status == ErrorCode::NOT_FOUND)
        {
          REQUIRE(database.Add(*this) == ErrorCode::OK);
        }
      }
    }
 
    Key(const Key& other) = delete;
 
    Key(Key&& other) = delete;
 
    Key& operator=(const Key& other) = delete;
 
    Key& operator=(Key&& other) = delete;
 
    operator Data() { return data_; }
 
    ErrorCode Save() { return database_.Set(*this, this->raw_data_); }
 
    ErrorCode Set(Data data)
    {
      data_ = data;
      return Save();
    }
 
    ErrorCode Load() { return database_.Get(*this); }
 
    ErrorCode operator=(Data data) { return Set(data); }  // NOLINT
  };
 
 private:
  virtual ErrorCode Get(KeyBase& key) = 0;
 
  virtual ErrorCode Set(KeyBase& key, RawData data) = 0;
 
  virtual ErrorCode Add(KeyBase& key) = 0;
};
 
}  // namespace LibXR