schema.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "core_types.hpp"
#include "data_value.hpp"
 
#include <map>
#include <optional>
#include <string>
#include <vector>
 
namespace assets {
 
struct TOAST_API TypeSwitchCase {
  std::string case_value;
  DataType type {DataType::null};
  std::optional<DataValue> default_value;
};
 
struct TOAST_API TypeSwitch {
  std::string field;    
  std::vector<TypeSwitchCase> cases;
};

struct TOAST_API SchemaField {
  std::string name;
  DataType type {DataType::null};
 
  bool is_array {false};
  std::string struct_type;
 
  std::optional<DataValue> default_value;
  std::string description;
 
  std::optional<double> min;
  std::optional<double> max;
 
  std::string asset_type;                   
  std::string node_type;                    
  std::vector<std::string> variants;        
  std::vector<std::string> enum_options;    
  std::optional<TypeSwitch> type_switch;    
 
  std::vector<SchemaField> children;
};

class TOAST_API Schema : public Asset {
public:
  explicit Schema(std::string_view json_content);
 
  [[nodiscard]]
  auto type() const -> std::string_view override {
    return "schema";
  }
 
  [[nodiscard]]
  auto title() const -> std::string_view {
    return m_title;
  }
 
  [[nodiscard]]
  auto isValid() const noexcept -> bool {
    return m_valid;
  }
 
  [[nodiscard]]
  auto fields() const -> const std::vector<SchemaField>& {
    return m_fields;
  }
 
  [[nodiscard]]
  auto hasDefinition(std::string_view name) const noexcept -> bool;
 
  [[nodiscard]]
  auto getDefinition(std::string_view name) const -> const std::vector<SchemaField>*;
 
  [[nodiscard]]
  auto definitions() const -> const std::map<std::string, std::vector<SchemaField>>& {
    return m_definitions;
  }

  [[nodiscard]]
  auto discriminatorOf(std::string_view definition) const -> std::string_view;
 
private:
  std::string m_title;
  bool m_valid {true};
  std::vector<SchemaField> m_fields;
  std::map<std::string, std::vector<SchemaField>> m_definitions;
  std::map<std::string, std::string> m_discriminators;

  static auto parseOneField(const std::string& name, const json_t& properties) -> SchemaField;

  static void parseFields(const json_t& properties, std::vector<SchemaField>& out);

  static auto parseDefault(DataType t, bool is_array, const json_t& j_value) -> DataValue;

  static auto toastTypeOf(const std::string& x_type) -> DataType;

  void resolveStructRefs(std::vector<SchemaField>& fields);
};
 
}