fb_json.h

Go to the documentation of this file.

// Copyright (c) Space-ng, inc. All rights reserved.
 
#pragma once
 
#include "sol3/cpp/filesystem.h"
 
#include <flatbuffers/base.h>
#include <flatbuffers/idl.h>
#include <fmt/format.h>
 
#include <fstream>
namespace sol3::core {
 
enum class JsonFormat { SINGLE_LINE = 0, MULTI_LINE = 1 };
 
void toJson(
    flatbuffers::Parser const& parser,
    uint8_t const* buffer,
    std::string& out_json);
std::string toJson(flatbuffers::Parser const& parser, uint8_t const* buffer);
flatbuffers::span<uint8_t const> bufferSpanFromJson(
    flatbuffers::Parser& parser, std::string const& json_str);
 
template <typename TMessage>
flatbuffers::Parser deserializeReflectionParser() {
  flatbuffers::Parser parser;
  parser.opts.strict_json = true;
  parser.opts.skip_unexpected_fields_in_json = false;
  parser.opts.output_default_scalars_in_json = true;
  parser.opts.indent_step = -1;
  parser.opts.size_prefixed = true;
  flatbuffers::span<uint8_t const> schema_data =
      TMessage::NativeTableType::GetSchemaData();
  parser.Deserialize(schema_data.data(), schema_data.size());
  return parser;
}
 
template <typename TMessage>
flatbuffers::Parser& reflectionParser(
    JsonFormat format = JsonFormat::SINGLE_LINE) {
  // thread local parser, populated with schema data, once per thread.
  // thread local so we can change single line to multi_line without being
  // surprised when emitting json from multiple threads.
  thread_local static flatbuffers::Parser s_parser =
      deserializeReflectionParser<TMessage>();
  if (format == JsonFormat::MULTI_LINE) {
    s_parser.opts.indent_step = 2;
  } else {
    s_parser.opts.indent_step = -1;
  }
  return s_parser;
}
 
template <typename TMessage>
void toJson(
    uint8_t const* buffer,
    std::string& out_json,
    JsonFormat format = JsonFormat::SINGLE_LINE) {
  toJson(reflectionParser<TMessage>(format), buffer, out_json);
}
 
template <typename TMessage>
std::string toJson(
    uint8_t const* buffer, JsonFormat format = JsonFormat::SINGLE_LINE) {
  return toJson(reflectionParser<TMessage>(format), buffer);
}
 
template <typename TMessage>
void toJson(
    TMessage const* table,
    std::string& out_json,
    JsonFormat format = JsonFormat::SINGLE_LINE) {
  out_json.clear();
  char const* error_str = flatbuffers::GenTextFromTable(
      reflectionParser<TMessage>(format),
      table,
      TMessage::GetFullyQualifiedName(),
      &out_json);
  if (error_str != nullptr) {
    out_json.clear();
    throw std::runtime_error(error_str);
  }
}
 
template <typename TMessage>
std::string toJson(
    TMessage const* table, JsonFormat format = JsonFormat::SINGLE_LINE) {
  std::string out_json;
  toJson<TMessage>(table, out_json, format);
  return out_json;
}
 
template <typename TMessageT>
void toJson(
    TMessageT const& object,
    std::string& out_json,
    JsonFormat format = JsonFormat::SINGLE_LINE) {
  using TableType = typename TMessageT::TableType;
  flatbuffers::FlatBufferBuilder builder;
  builder.FinishSizePrefixed(TableType::Pack(builder, &object));
  toJson(
      reflectionParser<TableType>(format),
      builder.GetBufferPointer(),
      out_json);
}
 
template <typename TMessageT>
std::string toJson(
    TMessageT const& object, JsonFormat format = JsonFormat::SINGLE_LINE) {
  std::string out_json;
  toJson<TMessageT>(object, out_json, format);
  return out_json;
}
 
template <typename TMessage>
TMessage const* fromJson(std::string const& json_str) {
  auto span = bufferSpanFromJson(reflectionParser<TMessage>(), json_str);
  return flatbuffers::GetSizePrefixedRoot<TMessage>(span.data());
}
 
template <typename TMessageT>
void fromJson(std::string const& json_str, TMessageT& out_message) {
  fromJson<typename TMessageT::TableType>(json_str)->UnPackTo(&out_message);
}
 
namespace impl {
std::string loadJsonFile(cpp::fs::path const& json_path);
}
 
template <typename TMessage>
TMessage const* fromJsonFile(cpp::fs::path const& json_path) {
  try {
    return fromJson<TMessage>(impl::loadJsonFile(json_path));
  } catch (std::runtime_error const& e) {
    throw std::runtime_error(
        fmt::format("Failed to parse json file: {}\n{}", json_path, e.what()));
  }
}
 
template <typename TMessageT>
void fromJsonFile(cpp::fs::path const& json_path, TMessageT& out_message) {
  fromJsonFile<typename TMessageT::TableType>(json_path)->UnPackTo(
      &out_message);
}
 
template <typename TMessageT>
void toJsonFile(
    cpp::fs::path const& json_path,
    TMessageT const& message,
    JsonFormat format = JsonFormat::SINGLE_LINE) {
  std::ofstream out_json(json_path);
  out_json << toJson(message, format);
}
 
template <typename TMessage>
void toJsonFile(
    cpp::fs::path const& json_path,
    TMessage const* message,
    JsonFormat format = JsonFormat::SINGLE_LINE) {
  std::ofstream out_json(json_path);
  out_json << toJson(message, format);
}
 
}  // namespace sol3::core