inputHistoryFactory.hpp

Go to the documentation of this file.

#pragma once
 
#include "inputHistory.hpp"
#include "inputHistoryNone.hpp"
#include "inputHistoryRaw.hpp"
#include "inputHistoryTrie.hpp"
#include <jaffarCommon/exceptions.hpp>
#include <jaffarCommon/json.hpp>
 
namespace jaffarPlus
{
 
namespace inputHistory
{
 
__INLINE__ std::string getType(const nlohmann::json& config) { return jaffarCommon::json::getString(config, "Type"); }
 
__INLINE__ std::shared_ptr<void> createSharedBacking(const nlohmann::json& config, const uint32_t numShards)
{
  if (getType(config) == "Trie") return std::make_shared<SequenceInputTrie>(numShards);
  return nullptr;
}
 
__INLINE__ size_t getSharedBackingMaxMemoryBytes(const std::shared_ptr<void>& backing)
{
  if (backing == nullptr) return 0;
  return static_cast<SequenceInputTrie*>(backing.get())->getMaxMemoryBytes();
}
 
__INLINE__ size_t getSharedBackingApproxMemoryBytes(const std::shared_ptr<void>& backing)
{
  if (backing == nullptr) return 0;
  return static_cast<SequenceInputTrie*>(backing.get())->getApproxMemoryBytes();
}
 
__INLINE__ bool isSharedBackingExhausted(const std::shared_ptr<void>& backing)
{
  if (backing == nullptr) return false;
  return static_cast<SequenceInputTrie*>(backing.get())->isExhausted();
}
 
__INLINE__ std::unique_ptr<InputHistory> create(const nlohmann::json& config, const uint32_t maxInputIndex, const uint32_t numShards, const uint32_t shardId,
                                                const std::shared_ptr<void>& backing)
{
  // Strictly consume the config: pop the recognized keys, then reject any leftover (unknown) key.
  auto                          cfg  = config;
  const auto                    type = jaffarCommon::json::popString(cfg, "Type");
  std::unique_ptr<InputHistory> result;
  if (type == "None")
    result = std::make_unique<InputHistoryNone>();
  else if (type == "Raw")
    result = std::make_unique<InputHistoryRaw>(maxInputIndex, jaffarCommon::json::popNumber<uint32_t>(cfg, "Max Size"));
  else if (type == "Trie")
    result = std::make_unique<InputHistoryTrie>(static_cast<SequenceInputTrie*>(backing.get()), shardId, numShards - 1, maxInputIndex,
                                                jaffarCommon::json::popNumber<uint32_t>(cfg, "Max Size"));
  else
    JAFFAR_THROW_LOGIC("Unrecognized 'Store Input History' Type: '%s' (expected None, Raw or Trie)", type.c_str());
  jaffarCommon::json::checkEmpty(cfg, "Runner Configuration > Store Input History");
  return result;
}
 
} // namespace inputHistory
 
} // namespace jaffarPlus