SharedMemoryRepository.h

Go to the documentation of this file.

#ifndef LINTEL_SHAREDMEMORYREPOSITORY_H
#define LINTEL_SHAREDMEMORYREPOSITORY_H
 
#include <lintel/core/models/JsonSerializable.h>
 
#include <memory>
 
#include <boost/container/map.hpp>
#include <boost/container/vector.hpp>
 
#include "lintel/core/models/SharedMemorySegment.h"
#include "lintel/core/services/PersistableBean.h"
#include "lintel/core/utils/TypeName.h"
#include "lintel/features/base/services/SharedMemoryService.h"
#include "lintel/features/base/services/ShmConstructors.h"
 
namespace lintel {
enum SharedMemoryType { Map, Vector, Array, Object };
 
class SharedMemoryRepository : public JsonSerializable
{
private:
  std::shared_ptr<SharedMemorySegment> m_sharedMemorySegment;
  std::size_t m_sizeOfData;
  std::string m_sharedMemoryRepository;
  int32_t m_codeVersion;
  std::string m_uuid;
 
protected:
  template<typename TYPE> static constexpr bool isSerializable()
  {
    return std::is_base_of_v<JsonSerializable, TYPE> || std::is_same_v<shm::String, TYPE> || std::is_arithmetic_v<TYPE>;
  }
 
public:
  SharedMemoryRepository(std::shared_ptr<SharedMemorySegment> sharedMemorySegment,
    std::size_t sizeOfData,
    std::string_view sharedMemoryRepository,
    int32_t codeVersion,
    std::string uuid);
 
  [[nodiscard]] const std::shared_ptr<SharedMemorySegment> &getSharedMemorySegment() const;
 
  [[nodiscard]] std::size_t getSizeOfData() const;
 
  [[nodiscard]] const std::string &getSharedMemoryRepository() const;
 
  [[nodiscard]] int32_t getCodeVersion() const;
 
  [[nodiscard]] const std::string &getUuid() const;
 
  [[nodiscard]] virtual SharedMemoryType getType() const = 0;
 
  [[nodiscard]] std::string_view getTypeName() const
  {
    if (getType() == SharedMemoryType::Map) { return "Map"; }
    if (getType() == SharedMemoryType::Vector) { return "Vector"; }
    if (getType() == SharedMemoryType::Array) { return "Array"; }
    return "Object";
  }
 
protected:
  class ReadLockGuard
  {
  public:
    explicit ReadLockGuard(const SharedMemoryRepository &owner) : m_owner(owner) { m_owner.onAcquireReadLock(); }
 
    ~ReadLockGuard() { m_owner.onReleaseReadLock(); }
 
    ReadLockGuard(const ReadLockGuard &) = delete;
    ReadLockGuard &operator=(const ReadLockGuard &) = delete;
 
  private:
    const SharedMemoryRepository &m_owner;
  };
 
  virtual void onAcquireReadLock() const {}
 
  virtual void onReleaseReadLock() const {}
 
public:
  ~SharedMemoryRepository() override = default;
 
  virtual void onMigrate(int32_t currentActiveVersion) = 0;
};
 
template<typename DATA, typename DAO, std::size_t MaxSize>
class SharedMemoryArrayRepository : public SharedMemoryRepository
{
private:
  mutable std::array<DATA, MaxSize> *m_array;
  mutable std::size_t m_generation;
 
protected:
  std::shared_ptr<SharedMemoryService> m_sharedMemoryService;
 
  std::array<DATA, MaxSize> &getArray() const
  {
    const auto generation = m_sharedMemoryService->getGeneration();
    if (generation != m_generation) {
      m_array = &shm::constructArray<DATA, MaxSize>(
        *m_sharedMemoryService, getSharedMemorySegment(), getSharedMemoryRepository());
      m_generation = generation;
    }
    return *m_array;
  }
 
public:
  SharedMemoryArrayRepository(const std::shared_ptr<SharedMemoryService> &sharedMemoryService,
    const std::shared_ptr<SharedMemorySegment> &segment,
    int32_t codeVersion,
    std::string uuid)
    : SharedMemoryRepository(segment, sizeof(DATA), std::string(type_name<DATA>()), codeVersion, uuid),
      m_array(&shm::constructArray<DATA, MaxSize>(*sharedMemoryService, segment, getSharedMemoryRepository())),
      m_generation(sharedMemoryService->getGeneration()), m_sharedMemoryService(sharedMemoryService)
  {}
 
  [[nodiscard]] SharedMemoryType getType() const override { return SharedMemoryType::Array; }
 
  void serialize(rapidjson::Writer<rapidjson::StringBuffer> *writer) const override
  {
    ReadLockGuard guard(*this);
    writer->StartObject();
    writer->String("repository");
    writer->String("SharedMemoryArrayRepository");
    writer->String("array");
    writer->StartArray();
    for (const auto &iter : getArray()) {
      LOG_TRACE("serialize vector entry");
      if constexpr (std::is_base_of<JsonSerializable, DAO>()) {
        DAO dao(iter);
        dao.serialize(writer);
      } else if constexpr (std::is_same<shm::String, DATA>()) {
        writer->String(iter.c_str());
      }
    }
    writer->EndArray();
    writer->EndObject();
  }
 
  bool deserialize(const rapidjson::Value &obj) override { throw std::runtime_error("Unsupported operation"); }
};
 
template<typename DATA, typename DAO>
class SharedMemoryVectorRepository : public SharedMemoryRepository
{
private:
  using Vector = boost::container::vector<DATA,
    boost::interprocess::allocator<DATA, boost::interprocess::managed_mapped_file::segment_manager>>;
  mutable Vector *m_vector;
  mutable std::size_t m_generation;
 
protected:
  std::shared_ptr<SharedMemoryService> m_sharedMemoryService;
 
  [[nodiscard]] Vector &getVector() const
  {
    const auto generation = m_sharedMemoryService->getGeneration();
    if (generation != m_generation) {
      m_vector =
        &shm::constructVector<DATA>(*m_sharedMemoryService, getSharedMemorySegment(), getSharedMemoryRepository());
      m_generation = generation;
    }
    return *m_vector;
  }
 
public:
  SharedMemoryVectorRepository(const std::shared_ptr<SharedMemoryService> &sharedMemoryService,
    const std::shared_ptr<SharedMemorySegment> &segment,
    int32_t codeVersion,
    std::string uuid)
    : SharedMemoryRepository(segment, sizeof(DATA), std::string(type_name<DATA>()), codeVersion, uuid),
      m_vector(&shm::constructVector<DATA>(*sharedMemoryService, segment, getSharedMemoryRepository())),
      m_generation(sharedMemoryService->getGeneration()), m_sharedMemoryService(sharedMemoryService)
  {}
 
  [[nodiscard]] SharedMemoryType getType() const override { return SharedMemoryType::Vector; }
 
  void serialize(rapidjson::Writer<rapidjson::StringBuffer> *writer) const override
  {
    ReadLockGuard guard(*this);
    writer->StartObject();
    writer->String("repository");
    writer->String("SharedMemoryVectorRepository");
    writer->String("vector");
    writer->StartArray();
    for (const auto &iter : getVector()) {
      LOG_TRACE("serialize vector entry");
      if constexpr (std::is_base_of<JsonSerializable, DAO>()) {
        DAO dao(iter);
        dao.serialize(writer);
      } else if constexpr (std::is_same<shm::String, DATA>()) {
        writer->String(iter.c_str());
      }
    }
    writer->EndArray();
    writer->EndObject();
  }
 
  bool deserialize(const rapidjson::Value &obj) override { throw std::runtime_error("Unsupported operation"); }
};
 
template<typename KEY, typename VALUE, typename KeyDao, typename ValueDao>
class SharedMemoryMapRepository : public SharedMemoryRepository
{
private:
  using Map = boost::container::map<KEY,
    VALUE,
    std::less<KEY>,
    boost::interprocess::allocator<std::pair<const KEY, VALUE>,
      boost::interprocess::managed_mapped_file::segment_manager>>;
  mutable Map *m_map;
  mutable std::size_t m_generation;
 
protected:
  std::shared_ptr<SharedMemoryService> m_sharedMemoryService;
 
  [[nodiscard]] Map &getMap() const
  {
    const auto generation = m_sharedMemoryService->getGeneration();
    if (generation != m_generation) {
      m_map =
        &shm::constructMap<KEY, VALUE>(*m_sharedMemoryService, getSharedMemorySegment(), getSharedMemoryRepository());
      m_generation = generation;
    }
    return *m_map;
  }
 
public:
  SharedMemoryMapRepository(const std::shared_ptr<SharedMemoryService> &sharedMemoryService,
    const std::shared_ptr<SharedMemorySegment> &segment,
    int32_t codeVersion,
    std::string uuid,
    int32_t sizeOfData = sizeof(VALUE))
    : SharedMemoryRepository(segment, sizeOfData, std::string(type_name<VALUE>()), codeVersion, uuid),
      m_map(&shm::constructMap<KEY, VALUE>(*sharedMemoryService, segment, getSharedMemoryRepository())),
      m_generation(sharedMemoryService->getGeneration()), m_sharedMemoryService(sharedMemoryService)
  {
    static_assert(isSerializable<KeyDao>());
    static_assert(isSerializable<ValueDao>());
    LOG_TRACE("map loaded with size of {}", getMap().size());
  }
 
  [[nodiscard]] SharedMemoryType getType() const override { return SharedMemoryType::Map; }
 
  void serialize(rapidjson::Writer<rapidjson::StringBuffer> *writer) const override
  {
    ReadLockGuard guard(*this);
    writer->StartObject();
    writer->String("repository");
    writer->String("SharedMemoryMapRepository");
    writer->String("map");
    writer->StartArray();
    for (auto &iterator : getMap()) {
      const KEY &key = iterator.first;
      const VALUE &value = iterator.second;
      LOG_TRACE("serialize map entry");
      writer->StartObject();
      writer->String("key");
      if constexpr (std::is_base_of<JsonSerializable, KeyDao>()) {
        KeyDao dao(key);
        dao.serialize(writer);
      } else if constexpr (std::is_same<shm::String, KEY>()) {
        writer->String(key.c_str());
      }
      writer->String("value");
      if constexpr (std::is_base_of<JsonSerializable, ValueDao>()) {
        ValueDao dao(value);
        dao.serialize(writer);
      } else if constexpr (std::is_same<shm::String, VALUE>()) {
        writer->String(value.c_str());
      }
      writer->EndObject();
    }
    writer->EndArray();
    writer->EndObject();
  }
 
  bool deserialize(const rapidjson::Value &obj) override { throw std::runtime_error("Unsupported operation"); }
};
 
template<typename DATA, typename DAO>
class SharedMemoryObjectRepository : public SharedMemoryRepository
{
private:
  mutable DATA *m_data;
  mutable std::size_t m_generation;
 
protected:
  std::shared_ptr<SharedMemoryService> m_sharedMemoryService;
 
  DATA &getData() const
  {
    const auto generation = m_sharedMemoryService->getGeneration();
    if (generation != m_generation) {
      m_data =
        &shm::constructObject<DATA>(*m_sharedMemoryService, getSharedMemorySegment(), getSharedMemoryRepository());
      m_generation = generation;
    }
    return *m_data;
  }
 
public:
  SharedMemoryObjectRepository(const std::shared_ptr<SharedMemoryService> &sharedMemoryService,
    const std::shared_ptr<SharedMemorySegment> &segment,
    int32_t codeVersion,
    std::string uuid)
    : SharedMemoryRepository(segment, sizeof(DATA), std::string(type_name<DATA>()), codeVersion, uuid),
      m_data(&shm::constructObject<DATA>(*sharedMemoryService, segment, getSharedMemoryRepository())),
      m_generation(sharedMemoryService->getGeneration()), m_sharedMemoryService(sharedMemoryService)
  {}
 
  [[nodiscard]] SharedMemoryType getType() const override { return SharedMemoryType::Object; }
 
  void serialize(rapidjson::Writer<rapidjson::StringBuffer> *writer) const override
  {
    ReadLockGuard guard(*this);
    writer->StartObject();
    writer->String("repository");
    writer->String("SharedMemoryObjectRepository");
    writer->String("object");
    if constexpr (std::is_base_of<JsonSerializable, DAO>()) {
      DAO dao(getData());
      dao.serialize(writer);
    } else if constexpr (std::is_same<shm::String, DATA>()) {
      writer->String(getData().c_str());
    }
    writer->EndObject();
  }
 
  bool deserialize(const rapidjson::Value &obj) override { throw std::runtime_error("Unsupported operation"); }
};
 
}// namespace lintel
#endif// LINTEL_SHAREDMEMORYREPOSITORY_H