confable.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_CONFABLE_HPP_
#define FABLE_CONFABLE_HPP_

#include <memory>  // for unique_ptr<>

#include <fable/json.hpp>    // for Json
#include <fable/conf.hpp>    // for Conf

#define CONFABLE_FRIENDS(xType)                                           \
  using ::fable::Confable::to_json;                                       \
  friend void to_json(::fable::Json& j, const xType& t) { t.to_json(j); } \
  friend void from_json(const ::fable::Json& j, xType& t) { t.from_conf(::fable::Conf{j}); }

#define CONFABLE_SCHEMA(xType) \
  CONFABLE_FRIENDS(xType)      \
  ::fable::Schema schema_impl() override

namespace fable {

class Schema;

class Confable {
 public:
  Confable() noexcept;
  Confable(const Confable&) noexcept;
  Confable(Confable&&) noexcept;

  Confable& operator=(const Confable& other) noexcept;
  Confable& operator=(Confable&& other) noexcept;

  virtual ~Confable() noexcept;

  virtual void reset_schema();

  Schema& schema();

  const Schema& schema() const;

  virtual void validate(const Conf& c) const;

  virtual void from_conf(const Conf& c);

  virtual void to_json(Json& j) const;

  Json to_json() const;

 protected:
  virtual Schema schema_impl();

 private:
  mutable std::unique_ptr<Schema> schema_;
};

}  // namespace fable

namespace nlohmann {

template <>
struct adl_serializer<fable::Confable> {
  static void to_json(json& j, const fable::Confable& c) { c.to_json(j); }
  static void from_json(const json& j, fable::Confable& c) { c.from_conf(fable::Conf{j}); }
};

}  // namespace nlohmann

#endif  // FABLE_CONFABLE_HPP_