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
#ifndef FABLE_SCHEMA_STRUCT_HPP_
#define FABLE_SCHEMA_STRUCT_HPP_

#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 {
namespace 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<PropertyList<S>, T>::value>;

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_.reset(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);
  }

  bool additional_properties() const { return additional_properties_; }

  void reset_ptr() override;

 public:  // Overrides
  using Interface::to_json;
  Json usage() const override;
  Json json_schema() const override;
  void validate(const Conf& c) const override;
  void to_json(Json& j) const override;
  void from_conf(const Conf& c) override;

 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 schema
}  // namespace fable

#endif  // FABLE_SCHEMA_STRUCT_HPP_