BLI_serialize.hh

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2023 Blender Authors
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */
 
#pragma once

 
#include <iosfwd>
 
#include "BLI_map.hh"
#include "BLI_string_ref.hh"
#include "BLI_vector.hh"
 
namespace blender::io::serialize {

enum class eValueType {
  String,
  Int,
  Array,
  Null,
  Boolean,
  Double,
  Dictionary,
  Enum,
};
 
class Value;
class StringValue;
class DictionaryValue;
template<typename T, eValueType V> class PrimitiveValue;
using IntValue = PrimitiveValue<int64_t, eValueType::Int>;
using DoubleValue = PrimitiveValue<double, eValueType::Double>;
using BooleanValue = PrimitiveValue<bool, eValueType::Boolean>;
using EnumValue = PrimitiveValue<int, eValueType::Enum>;
class ArrayValue;

class Value {
 private:
  eValueType type_;
 
 protected:
  Value() = delete;
  explicit Value(eValueType type) : type_(type) {}
 
 public:
  virtual ~Value() = default;
  eValueType type() const
  {
    return type_;
  }

  const StringValue *as_string_value() const;

  const IntValue *as_int_value() const;

  const DoubleValue *as_double_value() const;

  const BooleanValue *as_boolean_value() const;

  const EnumValue *as_enum_value() const;

  const ArrayValue *as_array_value() const;

  const DictionaryValue *as_dictionary_value() const;
};

template<
    typename T,
    eValueType V>
class PrimitiveValue : public Value {
 private:
  T inner_value_{};
 
 public:
  explicit PrimitiveValue(const T value) : Value(V), inner_value_(value) {}
 
  const T value() const
  {
    return inner_value_;
  }
};
 
class NullValue : public Value {
 public:
  NullValue() : Value(eValueType::Null) {}
};
 
class StringValue : public Value {
 private:
  std::string string_;
 
 public:
  StringValue(std::string string) : Value(eValueType::String), string_(std::move(string)) {}
 
  const std::string &value() const
  {
    return string_;
  }
};
 
class ArrayValue : public Value {
  Vector<std::shared_ptr<Value>> values_;
 
 public:
  ArrayValue() : Value(eValueType::Array) {}
 
  void append(std::shared_ptr<Value> value);
  void append_bool(bool value);
  void append_int(int value);
  void append_double(double value);
  void append_str(std::string value);
  void append_null();
  std::shared_ptr<DictionaryValue> append_dict();
  std::shared_ptr<ArrayValue> append_array();
 
  Span<std::shared_ptr<Value>> elements() const
  {
    return values_;
  }
};

class DictionaryValue : public Value {
 public:
  using Item = std::pair<std::string, std::shared_ptr<Value>>;
  using Lookup = Map<std::string, std::shared_ptr<Value>>;
 
 private:
  Vector<Item> values_;
 
 public:
  DictionaryValue() : Value(eValueType::Dictionary) {}

  Lookup create_lookup() const;
 
  const std::shared_ptr<Value> *lookup(const StringRef key) const;
  std::optional<StringRefNull> lookup_str(const StringRef key) const;
  std::optional<int64_t> lookup_int(const StringRef key) const;
  std::optional<double> lookup_double(const StringRef key) const;
  const DictionaryValue *lookup_dict(const StringRef key) const;
  const ArrayValue *lookup_array(const StringRef key) const;
  Span<Item> elements() const
  {
    return values_;
  }
 
  void append(std::string key, std::shared_ptr<Value> value);
  void append_int(std::string key, int64_t value);
  void append_double(std::string key, double value);
  void append_str(std::string key, std::string value);
  std::shared_ptr<DictionaryValue> append_dict(std::string key);
  std::shared_ptr<ArrayValue> append_array(std::string key);
};

class Formatter {
 public:
  virtual ~Formatter() = default;

  virtual void serialize(std::ostream &os, const Value &value) = 0;

  virtual std::unique_ptr<Value> deserialize(std::istream &is) = 0;
};

class JsonFormatter : public Formatter {
 public:
  int8_t indentation_len = 0;
 
 public:
  void serialize(std::ostream &os, const Value &value) override;
  std::unique_ptr<Value> deserialize(std::istream &is) override;
};
 
void write_json_file(StringRef path, const Value &value);
std::shared_ptr<Value> read_json_file(StringRef path);
 
}  // namespace blender::io::serialize