runtime: Use fable namespace for fable types

This has a few advantages:

1. Users know where types come from, which aids them
   in finding documentation and further information.
   It encourages them to use other facilities from the
   library.
   The fable types are not an implementation detail.

2. It allows selective header inclusion and use of forward
   declarations to cut down compile times.

Author: cassava

runtime/include/cloe/cloe_fwd.hpp

@@ -0,0 +1,102 @@
+/*
+ * Copyright 2023 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
+ */
+/**
+ * \file cloe/cloe_fwd.hpp
+ *
+ * This file provides forward declarations.
+ */
+
+#pragma once
+
+#include <chrono>      // for nanoseconds
+#include <functional>  // for function<>
+#include <memory>      // for unique_ptr<>, shared_ptr<>
+
+#include <spdlog/fwd.h> // for spdlog namespace
+#include <fable/fable_fwd.hpp> // for fable namespace
+
+namespace cloe {
+
+// from core/duration.hpp
+using Duration = std::chrono::nanoseconds;
+
+// from core/error.hpp
+class Error;
+class ConcludedError;
+
+// from core/logger.hpp
+using Logger = std::shared_ptr<spdlog::logger>;
+using LogLevel = spdlog::level::level_enum;
+
+// from entity.hpp
+class Entity;
+
+// from sync.hpp
+class Sync;
+
+// from handler.hpp
+class Request;
+class Response;
+enum class ContentType;
+enum class RequestMethod;
+enum class StatusCode;
+using Handler = std::function<void(const Request&, Response&)>;
+
+// from trigger.hpp
+class Trigger;
+using TriggerPtr = std::unique_ptr<Trigger>;
+class TriggerError;
+template <typename T>
+class TriggerFactory;
+class TriggerRegistrar;
+
+class Callback;
+enum class Source;
+
+class Event;
+using EventPtr = std::unique_ptr<Event>;
+using EventFactory = TriggerFactory<Event>;
+
+class Action;
+using ActionPtr = std::unique_ptr<Action>;
+using ActionFactory = TriggerFactory<Action>;
+
+// from registrar.hpp
+enum class HandlerType;
+class Registrar;
+
+// from model.hpp
+class Model;
+class ModelFactory;
+
+// from component.hpp
+class Component;
+class ComponentFactory;
+
+// from vehicle.hpp
+class Vehicle;
+
+// from controller.hpp
+class Controller;
+class ControllerFactory;
+
+// from simulator.hpp
+class Simulator;
+class SimulatorFactory;
+
+}  // namespace cloe

runtime/include/cloe/component.hpp

@@ -32,9 +32,10 @@
 #include <type_traits>  // for decay
 #include <utility>      // for move
 
+#include <fable/fable_fwd.hpp>  // for Json
+
 #include <cloe/model.hpp>  // for Model, ModelFactory
 #include <cloe/sync.hpp>   // for Sync
-#include <fable/enum.hpp>  // for ENUM_SERIALIZATION
 
 /**
  * This macro defines a ComponentFactory named xFactoryType and with the
@@ -59,7 +60,7 @@
       return std::make_unique<std::decay<decltype(*this)>::type>(*this);                      \
     }                                                                                         \
     std::unique_ptr<::cloe::Component> make(                                                  \
-        const ::cloe::Conf&, std::vector<std::shared_ptr<::cloe::Component>>) const override; \
+        const ::fable::Conf&, std::vector<std::shared_ptr<::cloe::Component>>) const override; \
                                                                                               \
    protected:                                                                                 \
     ::cloe::Schema schema_impl() override { return config_.schema(); }                        \
@@ -79,7 +80,7 @@
  */
 #define DEFINE_COMPONENT_FACTORY_MAKE(xFactoryType, xComponentType, xInputType)              \
   std::unique_ptr<::cloe::Component> xFactoryType::make(                                     \
-      const ::cloe::Conf& c, std::vector<std::shared_ptr<::cloe::Component>> comp) const {   \
+      const ::fable::Conf& c, std::vector<std::shared_ptr<::cloe::Component>> comp) const {   \
     decltype(config_) conf{config_};                                                         \
     assert(comp.size() == 1);                                                                \
     if (!c->is_null()) {                                                                     \
@@ -137,7 +138,7 @@ namespace cloe {
  *
  * - `uint64_t id() const`
  * - `T* as()`
- * - `Json active_state() const = 0`
+ * - `fable::Json active_state() const = 0`
  */
 class Component : public Model {
  public:
@@ -169,7 +170,7 @@ class Component : public Model {
   /**
    * Return the JSON representation of the component.
    */
-  virtual Json active_state() const = 0;
+  virtual fable::Json active_state() const = 0;
 
   /**
    * Clear any cache that may be accumulated during a step.
@@ -190,7 +191,7 @@ class Component : public Model {
   void abort() override {}
 
  protected:
-  friend void to_json(Json& j, const Component& c) {
+  friend void to_json(fable::Json& j, const Component& c) {
     j = c.active_state();
     j["id"] = c.id();
     j["name"] = c.name();
@@ -236,7 +237,7 @@ class ComponentFactory : public ModelFactory {
    *
    * - This method may throw Error.
    */
-  virtual std::unique_ptr<Component> make(const Conf& c,
+  virtual std::unique_ptr<Component> make(const fable::Conf& c,
                                           std::vector<std::shared_ptr<Component>>) const = 0;
 };
 

runtime/include/cloe/controller.hpp

@@ -53,7 +53,7 @@
       return std::make_unique<std::decay<decltype(*this)>::type>(*this);          \
     }                                                                             \
                                                                                   \
-    std::unique_ptr<::cloe::Controller> make(const ::cloe::Conf&) const override; \
+    std::unique_ptr<::cloe::Controller> make(const ::fable::Conf&) const override; \
                                                                                   \
    protected:                                                                     \
     ::cloe::Schema schema_impl() override { return config_.schema(); }            \
@@ -71,7 +71,7 @@
  *    xControllerType(const std::string&, const xConfigType&)
  */
 #define DEFINE_CONTROLLER_FACTORY_MAKE(xFactoryType, xControllerType)                   \
-  std::unique_ptr<::cloe::Controller> xFactoryType::make(const ::cloe::Conf& c) const { \
+  std::unique_ptr<::cloe::Controller> xFactoryType::make(const ::fable::Conf& c) const { \
     decltype(config_) conf{config_};                                                    \
     if (!c->is_null()) {                                                                \
       conf.from_conf(c);                                                                \
@@ -192,7 +192,7 @@ class ControllerFactory : public ModelFactory {
    *
    * - This method may throw Error.
    */
-  virtual std::unique_ptr<Controller> make(const Conf& c) const = 0;
+  virtual std::unique_ptr<Controller> make(const fable::Conf& c) const = 0;
 };
 
 }  // namespace cloe

runtime/include/cloe/entity.hpp

@@ -24,7 +24,8 @@
 
 #include <string>  // for string
 
-#include <cloe/core.hpp>  // for Json, Error, Logger
+#include <cloe/core.hpp>  // for Error, Logger
+#include <fable/json.hpp> // for Json
 
 namespace cloe {
 
@@ -99,11 +100,11 @@ class Entity {
   // Note: moving the definition from the inline into this declaration here
   // will result in cloe/trigger.hpp not compiling because:
   //
-  //   no matching function for call to 'to_json(Json, const Entity&)'
+  //   no matching function for call to 'to_json(fable::Json, const Entity&)'
   //
   // I have no idea why it works in many other instances, but not here. If you,
   // my dear reader, know why, please open a pull request!
-  friend void to_json(Json& j, const Entity& e);
+  friend void to_json(fable::Json& j, const Entity& e);
 
  protected:
   std::string name_;
@@ -113,7 +114,7 @@ class Entity {
 /**
  * Return JSON representation of an Entity.
  */
-inline void to_json(Json& j, const Entity& e) {
+inline void to_json(fable::Json& j, const Entity& e) {
   j["name"] = e.name();
   if (!e.desc_.empty()) {
     j["description"] = e.description();

runtime/include/cloe/handler.hpp

@@ -36,11 +36,12 @@
 #pragma once
 
 #include <functional>  // for function
-#include <map>         // for map, map<>::mapped_type
-#include <string>      // for string, basic_string
+#include <map>         // for map
+#include <string>      // for string
 #include <utility>     // for pair
 
-#include <cloe/core.hpp>  // for Confable, Json
+#include <fable/confable.hpp>  // for Confable
+#include <fable/json.hpp>      // for Json
 
 namespace cloe {
 
@@ -148,7 +149,7 @@ class Request {
   /**
    * Helper method that tries to convert the body to a JSON object.
    */
-  virtual Json as_json() const { return fable::parse_json(body()); }
+  virtual fable::Json as_json() const { return fable::parse_json(body()); }
 };
 
 /**
@@ -274,7 +275,7 @@ class Response {
    * - When NDEBUG is set, then the serialization of JSON to string does not
    *   pretty print.
    */
-  void set_body(const Json& js) {
+  void set_body(const fable::Json& js) {
 #ifdef NDEBUG
     this->set_body(js.dump(), ContentType::JSON);
 #else
@@ -285,28 +286,28 @@ class Response {
   /**
    * Write is an alias for `set_body(Json)`, for historical reasons.
    */
-  void write(const Json& js) { this->set_body(js); }
+  void write(const fable::Json& js) { this->set_body(js); }
 
   /**
    * Use bad_request when the method is correct, but the body content is not
    * correct.
    */
-  void bad_request(const Json& js) { this->error(StatusCode::BAD_REQUEST, js); }
+  void bad_request(const fable::Json& js) { this->error(StatusCode::BAD_REQUEST, js); }
 
   /**
    * Use not_found when the resource in question is not available.
    */
-  void not_found(const Json& js) { this->error(StatusCode::NOT_FOUND, js); }
+  void not_found(const fable::Json& js) { this->error(StatusCode::NOT_FOUND, js); }
 
   /**
    * Use not_allowed when the method (GET, POST, PUT, DELETE) is not allowed.
    *
    * Specify in `allow` which method is allowed:
    * ```
-   * r.not_allowed(RequestMethod::POST, Json{{"error", "try something else"}});
+   * r.not_allowed(RequestMethod::POST, fable::Json{{"error", "try something else"}});
    * ```
    */
-  void not_allowed(const RequestMethod& allow, const Json& js) {
+  void not_allowed(const RequestMethod& allow, const fable::Json& js) {
     this->set_status(StatusCode::NOT_ALLOWED);
     this->set_header("Allow", as_cstr(allow));
     this->set_body(js);
@@ -316,14 +317,14 @@ class Response {
    * Use not_implemented when the functionality represented by the endpoint
    * is not implemented yet.
    */
-  void not_implemented(const Json& js) { this->error(StatusCode::NOT_IMPLEMENTED, js); }
+  void not_implemented(const fable::Json& js) { this->error(StatusCode::NOT_IMPLEMENTED, js); }
 
   /**
    * Use server_error when an internal error occurred, such as a panic.
    */
-  void server_error(const Json& js) { this->error(StatusCode::SERVER_ERROR, js); }
+  void server_error(const fable::Json& js) { this->error(StatusCode::SERVER_ERROR, js); }
 
-  void error(StatusCode code, const Json& js) {
+  void error(StatusCode code, const fable::Json& js) {
     this->set_body(js);
     this->set_status(code);
   }
@@ -374,11 +375,11 @@ class Redirect {
  */
 class StaticJson {
  public:
-  StaticJson(Json j) : data_(j) {}  // NOLINT
+  StaticJson(fable::Json j) : data_(j) {}  // NOLINT
   void operator()(const cloe::Request&, cloe::Response& r) { r.write(data_); }
 
  private:
-  const Json data_;
+  const fable::Json data_;
 };
 
 /**
@@ -387,14 +388,14 @@ class StaticJson {
  * - It requires a pointer as input, as it assumes that the data will change.
  * - The type of the pointer must have the associated `to_json` function
  *   implemented. In other words, it must be directly convertible to a
- *   `cloe::Json`.
+ *   `fable::Json`.
  */
 template <typename T>
 class ToJson {
  public:
   explicit ToJson(const T* ptr) : ptr_(ptr) {}
   void operator()(const cloe::Request&, cloe::Response& r) {
-    Json j;
+    fable::Json j;
     to_json(j, *ptr_);
     r.set_body(j);
   }
@@ -417,12 +418,12 @@ class ToJson {
  */
 class FromConf {
  public:
-  explicit FromConf(Confable* ptr, bool query_map_as_json = true)
+  explicit FromConf(fable::Confable* ptr, bool query_map_as_json = true)
       : ptr_(ptr), convert_(query_map_as_json) {}
   void operator()(const cloe::Request& q, cloe::Response& r);
 
  private:
-  Confable* ptr_;
+  fable::Confable* ptr_;
   bool convert_;
 };
 

runtime/include/cloe/model.hpp

@@ -48,7 +48,9 @@
 
 #pragma once
 
-#include <cloe/core.hpp>    // for Duration, Error, Confable
+#include <fable/confable.hpp> // for Confable
+
+#include <cloe/core.hpp>    // for Duration, Error
 #include <cloe/entity.hpp>  // for Entity
 
 namespace cloe {
@@ -409,7 +411,7 @@ class Model : public Entity {
  * The ModelFactory class serves as a base class for all other factory classes
  * that make models.
  */
-class ModelFactory : public Entity, public Confable {
+class ModelFactory : public Entity, public fable::Confable {
  public:
   using Entity::Entity;
   virtual ~ModelFactory() = default;

runtime/include/cloe/registrar.hpp

@@ -28,6 +28,7 @@
 
 #include <cloe/handler.hpp>  // for Handler
 #include <cloe/trigger.hpp>  // for ActionFactory, EventFactory, Callback, ...
+#include <fable/json.hpp>    // for Json
 
 namespace cloe {
 
@@ -46,7 +47,7 @@ class DirectCallback : public Callback {
   bool empty() const { return triggers_.empty(); }
 
   void emplace(TriggerPtr&& t, const Sync&) override { triggers_.emplace_back(std::move(t)); }
-  void to_json(Json& j) const override { j = triggers_; }
+  void to_json(fable::Json& j) const override { j = triggers_; }
 
   void trigger(const Sync& sync, const Ctx&... args) {
     auto it = triggers_.begin();