struct.hpp

Go to the documentation of this file.

/*
 * Copyright 2020 Robert Bosch GmbH
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
#pragma once
 
#include <map>          // for map<>
#include <memory>       // for shared_ptr<>
#include <string>       // for string
#include <type_traits>  // for enable_if_t<>, is_same<>
#include <utility>      // for move, forward<>, pair<>
#include <vector>       // for vector<>
 
#include <fable/schema/interface.hpp>  // for Base<>
 
namespace fable::schema {
 
template <typename S = Box>
using PropertyList = std::initializer_list<std::pair<std::string const, S>>;
 
template <typename T, typename S = Box>
using enable_if_property_list_t = std::enable_if_t<std::is_same_v<PropertyList<S>, T>>;
 
class Struct : public Base<Struct> {
 public:  // Constructors
  explicit Struct(std::string desc = "") : Base(JsonType::object, std::move(desc)) {}
 
  Struct(std::string desc, PropertyList<Box> props) : Base(JsonType::object, std::move(desc)) {
    set_properties(props);
  }
 
  Struct(PropertyList<Box> props) : Struct("", props) {}  // NOLINT
 
  // Inheriting constructors
  Struct(std::string desc, const Box& base, PropertyList<Box> props)
      : Struct(*base.template as<Struct>()) {
    desc_ = std::move(desc);
    set_properties(props);
  }
 
  Struct(const Box& base, PropertyList<Box> props) : Struct("", base, props) {}
 
 public:  // Special
  void set_property(const std::string& key, Box&& s);
 
  Struct property(const std::string& key, Box&& s) && {
    set_property(key, std::move(s));
    return std::move(*this);
  }
 
  void set_properties(PropertyList<Box> props);
 
  void set_properties_from(const Struct& s) { set_properties(s.properties_); }
 
  void set_properties_from(const Box& s) { set_properties_from(*s.template as<Struct>()); }
 
  template <typename T, typename = enable_if_confable_t<T>>
  void set_properties_from(const T* x) {
    set_properties_from(x->schema());
  }
 
  template <typename T>
  Struct properties_from(const T x) && {
    set_properties_from(x);
    return std::move(*this);
  }
 
  void set_require(std::initializer_list<std::string> init);
  Struct require(std::initializer_list<std::string> init) &&;
 
  void set_require_all();
  Struct require_all() &&;
 
  Struct additional_properties(bool v) && {
    additional_properties_ = v;
    return std::move(*this);
  }
 
  template <typename S, typename = enable_if_schema_t<S>>
  void set_additional_properties(const S& s) {
    additional_properties_ = true;
    additional_prototype_ = s.clone();
    additional_prototype_->reset_ptr();
  }
 
  template <typename S, typename = enable_if_schema_t<S>>
  Struct additional_properties(const S& s) && {
    set_additional_properties(s);
    return std::move(*this);
  }
 
  [[nodiscard]] bool additional_properties() const { return additional_properties_; }
 
  void reset_ptr() override;
 
 public:  // Overrides
  using Interface::to_json;
  [[nodiscard]] Json usage() const override;
  [[nodiscard]] Json json_schema() const override;
  bool validate(const Conf& c, std::optional<SchemaError>& err) const override;
  void to_json(Json& j) const override;
  void from_conf(const Conf& c) override;
 
  // NOTE: The following methods cannot be implemented because
  // Struct does not have an associated type:
  //
  //     Json serialize(const Type&) const;
  //     void serialize_into(Json&, const Type&) const;
  //     Type deserialize(const Conf&) const;
  //     void deserialize_into(const Conf&, Type&) const;
  //
  // This means that `Struct` cannot be used as a prototype schema
  // directly, for example with `optional`. Use `Confable` instead.
 
 private:
  void set_properties(const std::map<std::string, Box>& props);
 
 private:
  std::map<std::string, Box> properties_{};
  std::vector<std::string> properties_required_{};
  std::shared_ptr<Interface> additional_prototype_{};
  bool additional_properties_{false};
};
 
template <typename T, typename = enable_if_property_list_t<T>>
inline Struct make_schema(T&& props) {
  return Struct(std::forward<T>(props));
}
 
template <typename T, typename = enable_if_property_list_t<T>>
inline Struct make_schema(std::string desc, T&& props) {
  return Struct(std::move(desc), std::forward<T>(props));
}
 
template <typename T, typename = enable_if_property_list_t<T>>
inline Struct make_schema(std::string desc, const Box& base, T&& props) {
  return Struct(std::move(desc), base, std::forward<T>(props));
}
 
template <typename T, typename = enable_if_property_list_t<T>>
inline Struct make_schema(std::string desc, const Struct& base, T&& props) {
  return Struct(std::move(desc), base, std::forward<T>(props));
}
 
}  // namespace fable::schema