interface.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 <memory>       // for shared_ptr<>
#include <optional>     // for optional<>
#include <string>       // for string
#include <type_traits>  // for enable_if_t<>, is_base_of<>
#include <utility>      // for move
 
#include <fable/conf.hpp>       // for Conf
#include <fable/error.hpp>      // for SchemaError
#include <fable/fable_fwd.hpp>  // for Confable
#include <fable/json.hpp>       // for Json
 
namespace fable::schema {
 
class Interface {
 protected:
  Interface() = default;
  Interface(const Interface&) = default;
  Interface(Interface&&) noexcept = default;
  Interface& operator=(const Interface&) = default;
  Interface& operator=(Interface&&) noexcept = default;
 
 public:
  virtual ~Interface() noexcept = default;
 
  [[nodiscard]] virtual std::unique_ptr<Interface> clone() const = 0;
 
  [[nodiscard]] virtual bool is_variant() const { return false; }
 
  [[nodiscard]] virtual JsonType type() const = 0;
 
  [[nodiscard]] virtual std::string type_string() const = 0;
 
  [[nodiscard]] virtual bool is_required() const = 0;
 
  [[nodiscard]] virtual const std::string& description() const = 0;
 
  virtual void set_description(std::string s) = 0;
 
  [[nodiscard]] virtual Json usage() const = 0;
 
  [[nodiscard]] virtual Json json_schema() const = 0;
 
  virtual bool validate(const Conf& c, std::optional<SchemaError>& error) const = 0;
 
  virtual void validate_or_throw(const Conf& c) const final {
    if (auto err = fail(c); err) {
      throw std::move(*err);
    }
  }
 
  [[nodiscard]] virtual std::optional<SchemaError> fail(const Conf& c) const final {
    std::optional<SchemaError> err;
    validate(c, err);
    return err;
  }
 
  [[nodiscard]] virtual bool is_valid(const Conf& c) const final { return !fail(c); }
 
  [[nodiscard]] virtual Json to_json() const {
    Json j;
    to_json(j);
    return j;
  }
 
  virtual void to_json(Json&) const = 0;
 
  virtual void from_conf(const Conf&) = 0;
 
  virtual void reset_ptr() = 0;
};
 
template <typename S>
using enable_if_schema_t = std::enable_if_t<std::is_base_of_v<Interface, S>>;
 
// ------------------------------------------------------------------------- //
 
class Box final : public Interface {
 public:  // Constructors
  Box() = default;
  Box(const Box&) = default;
  Box(Box&&) noexcept = default;
  Box& operator=(const Box&) = default;
  Box& operator=(Box&&) noexcept = default;
  ~Box() noexcept override = default;
 
  Box(std::unique_ptr<Interface> i) : impl_(std::move(i)) { assert(impl_); }  // NOLINT
  Box(std::shared_ptr<Interface> i) : impl_(std::move(i)) { assert(impl_); }  // NOLINT
 
 public:  // Special
  [[nodiscard]] std::shared_ptr<Interface> get() { return impl_; }
 
  template <typename T>
  [[nodiscard]] std::shared_ptr<T> as() const {
    assert(impl_ != nullptr);
    auto downcast_ptr = std::dynamic_pointer_cast<T>(impl_);
    if (downcast_ptr == nullptr) {
      // If you can't figure out the type of this even from this error, set
      // a breakpoint here in gdb and run:
      //
      //     p dynamic_cast<Interface*>(impl_.get())
      //
      // That will give you something like:
      //
      //     $8 = (fable::schema::Interface *) 0x5555559dfd30 <
      //          vtable for fable::schema::FromConfable<
      //            (anonymous namespace)::NormalDistribution<double>, 0
      //          >
      //          +16>
      //
      // Which is much more specific, since the output of FromConfable and
      // Struct can be equivalent, for example.
      throw SchemaError{Conf{}, this->json_schema(),
                        "cannot dynamic_pointer_cast to type T, got nullptr"};
    }
    return downcast_ptr;
  }
 
  template <typename T>
  [[nodiscard]] std::shared_ptr<T> as_unsafe() const {
    return std::dynamic_pointer_cast<T>(impl_);
  }
 
  [[nodiscard]] Box reset_pointer() && {
    reset_ptr();
    return std::move(*this);
  }
 
 public:  // Overrides
  using Interface::to_json;
  [[nodiscard]] std::unique_ptr<Interface> clone() const override { return impl_->clone(); }
  [[nodiscard]] JsonType type() const override { return impl_->type(); }
  [[nodiscard]] std::string type_string() const override { return impl_->type_string(); }
  [[nodiscard]] bool is_required() const override { return impl_->is_required(); }
  [[nodiscard]] const std::string& description() const override { return impl_->description(); }
  void set_description(std::string s) override { return impl_->set_description(std::move(s)); }
  [[nodiscard]] Json usage() const override { return impl_->usage(); }
  [[nodiscard]] Json json_schema() const override { return impl_->json_schema(); };
  bool validate(const Conf& c, std::optional<SchemaError>& err) const override {
    return impl_->validate(c, err);
  }
  void to_json(Json& j) const override { impl_->to_json(j); }
  void from_conf(const Conf& c) override { impl_->from_conf(c); }
  void reset_ptr() override { impl_->reset_ptr(); }
 
  friend void to_json(Json& j, const Box& b) { b.impl_->to_json(j); }
 
 private:
  std::shared_ptr<Interface> impl_{nullptr};
};
 
// ------------------------------------------------------------------------- //
 
template <typename CRTP>
class Base : public Interface {
 protected:
  Base() = default;
  Base(const Base<CRTP>&) = default;
  Base(Base<CRTP>&&) noexcept = default;
  Base<CRTP>& operator=(const Base<CRTP>&) = default;
  Base<CRTP>& operator=(Base<CRTP>&&) noexcept = default;
 
  Base(JsonType t, std::string desc) : type_(t), desc_(std::move(desc)) {}
  explicit Base(JsonType t) : type_(t) {}
  explicit Base(std::string desc) : desc_(std::move(desc)) {}
 
 public:
  ~Base() noexcept override = default;
 
  [[nodiscard]] std::unique_ptr<Interface> clone() const override {
    return std::make_unique<CRTP>(static_cast<CRTP const&>(*this));
  }
  [[nodiscard]] operator Box() const { return Box{this->clone()}; }
 
  [[nodiscard]] JsonType type() const override { return type_; }
  [[nodiscard]] std::string type_string() const override { return to_string(type_); }
 
  [[nodiscard]] Json usage() const override {
    const auto* required = required_ ? "!" : "";
    if (desc_.empty()) {
      return type_string() + required;
    }
    return fmt::format("{}{} :: {}", type_string(), required, desc_);
  }
 
  [[nodiscard]] bool is_required() const override { return required_; }
  [[nodiscard]] CRTP require() && {
    required_ = true;
    return std::move(*dynamic_cast<CRTP*>(this));
  }
  [[nodiscard]] CRTP required(bool value) && {
    required_ = value;
    return std::move(*dynamic_cast<CRTP*>(this));
  }
 
  [[nodiscard]] CRTP reset_pointer() && {
    reset_ptr();
    return std::move(*dynamic_cast<CRTP*>(this));
  }
 
  [[nodiscard]] bool has_description() const { return !desc_.empty(); }
  void set_description(std::string s) override { desc_ = std::move(s); }
  [[nodiscard]] const std::string& description() const override { return desc_; }
  [[nodiscard]] CRTP description(std::string desc) && {
    desc_ = std::move(desc);
    return std::move(*dynamic_cast<CRTP*>(this));
  }
 
 protected:
  bool validate_type(const Conf& c, std::optional<SchemaError>& err) const {
    if (c->type() != type_) {
      if (c->type() == JsonType::number_unsigned && type_ == JsonType::number_integer) {
        return true;
      }
 
      return this->set_error(err, c, "require type {}, got {}", type_string(),
                             to_string(c->type()));
    }
    return true;
  }
 
  template <typename... Args>
  [[nodiscard]] SchemaError error(const Conf& c, std::string_view format, Args&&... args) const {
    return SchemaError{c, this->json_schema(), format, std::forward<Args>(args)...};
  }
 
  [[nodiscard]] SchemaError error(const ConfError& e) const {
    return SchemaError{e, this->json_schema()};
  }
 
  [[nodiscard]] SchemaError wrong_type(const Conf& c) const {
    return error(error::WrongType(c, type_));
  }
 
  template <typename... Args>
  bool set_error(std::optional<SchemaError>& err, const Conf& c, std::string_view format,
                 Args&&... args) const {
    err.emplace(this->error(c, format, std::forward<Args>(args)...));
    return false;
  }
 
  bool set_error(std::optional<SchemaError>& err, const ConfError& e) const {
    err.emplace(this->error(e));
    return false;
  }
 
  bool set_error(std::optional<SchemaError>& err, SchemaError&& e) const {
    err.emplace(std::move(e));
    return false;
  }
 
  bool set_wrong_type(std::optional<SchemaError>& err, const Conf& c) const {
    err.emplace(this->wrong_type(c));
    return false;
  }
 
  void augment_schema(Json& j) const {
    if (!desc_.empty()) {
      j["description"] = desc_;
    }
  }
 
 protected:
  JsonType type_{JsonType::null};
  bool required_{false};
  std::string desc_{};
};
 
// ------------------------------------------------------------------------- //
 
template <typename T>
using enable_if_confable_t = std::enable_if_t<std::is_base_of_v<Confable, T>>;
 
template <typename T>
using enable_if_not_confable_t = std::enable_if_t<!std::is_base_of_v<Confable, T>>;
 
template <typename T, typename S = std::string, std::enable_if_t<std::is_base_of_v<Confable, T>, int> = 0>
auto make_prototype(S&& desc = "");
 
template <typename T, typename S = std::string, std::enable_if_t<!std::is_base_of_v<Confable, T>, int> = 0>
auto make_prototype(S&& desc = "");
 
}  // namespace fable::schema