trigger.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 unique_ptr<>, shared_ptr<>
#include <string>   // for string
#include <utility>  // for move
#include <vector>   // for vector<>
 
#include <cloe/core.hpp>     // for Duration, Error
#include <cloe/entity.hpp>   // for Entity
#include <fable/enum.hpp>    // for ENUM_SERIALIZATION
#include <fable/json.hpp>    // for Json
#include <fable/schema.hpp>  // for Schema
 
namespace cloe {
 
// Forward declarations:
class Sync;  // from cloe/sync.hpp
 
// Forward declarations for Trigger:
class Event;
using EventPtr = std::unique_ptr<Event>;
using EventPtrs = std::vector<EventPtr>;
class Action;
using ActionPtr = std::unique_ptr<Action>;
using ActionPtrs = std::vector<ActionPtr>;
class Trigger;
using TriggerPtr = std::unique_ptr<Trigger>;
using TriggerPtrs = std::vector<TriggerPtr>;
 
class TriggerError : public Error {
 public:
  using Error::Error;
  virtual ~TriggerError() noexcept = default;
};
 
class TriggerInvalid : public TriggerError {
 public:
  TriggerInvalid(const Conf& c, const std::string& what) : TriggerError(what), conf_(c) {}
  virtual ~TriggerInvalid() noexcept = default;
 
  const Conf& conf() const { return conf_; }
 
 private:
  Conf conf_;
};
 
struct InlineSchema {
 public:
  explicit InlineSchema(bool enabled) : required_(!enabled) {}
 
  explicit InlineSchema(std::string desc) : required_(false), desc_(std::move(desc)) {}
 
  InlineSchema(std::string desc, fable::JsonType type, bool required = true);
 
  InlineSchema(std::string desc, std::string format, bool required = true)
      : type_(fable::JsonType::string)
      , required_(required)
      , usage_(std::move(format))
      , desc_(std::move(desc)) {}
 
  const std::string& description() const { return desc_; }
 
  fable::JsonType type() const { return type_; }
 
  bool is_enabled() const { return !(required_ && type_ == fable::JsonType::null); }
 
  bool is_required() const { return required_; }
 
  std::string usage(const std::string& name) const;
 
 private:
  fable::JsonType type_{JsonType::null};
  bool required_{true};
  std::string usage_{};
  std::string desc_{};
};
 
struct TriggerSchema {
 public:
  TriggerSchema(std::string name, std::string desc)
      : name_(std::move(name)), schema_(std::move(desc)), inline_(true) {}
 
  TriggerSchema(std::string name, std::string desc, fable::schema::PropertyList<> props)
      : name_(std::move(name)), schema_(std::move(desc), std::move(props)), inline_(false) {}
 
  TriggerSchema(std::string name, std::string desc, Schema s)
      : name_(std::move(name)), schema_(std::move(s)), inline_(false) {
    schema_.set_description(std::move(desc));
  }
 
  TriggerSchema(std::string name, std::string desc, InlineSchema usage,
                fable::schema::PropertyList<> props)
      : name_(std::move(name))
      , schema_(std::move(desc), std::move(props))
      , inline_(std::move(usage)) {}
 
  TriggerSchema(std::string name, std::string desc, InlineSchema usage, Schema init)
      : name_(std::move(name)), schema_(std::move(init)), inline_(std::move(usage)) {
    schema_.set_description(std::move(desc));
  }
 
  const std::string& name() const { return name_; }
  const std::string& description() const { return schema_.description(); }
  std::string usage_inline() const { return inline_.usage(name_); }
  fable::Json usage() const { return schema_.usage(); }
  fable::Json json_schema() const;
 
 private:
  std::string name_;
  fable::Schema schema_;
  InlineSchema inline_;
};
 
template <typename T>
class TriggerFactory : public Entity {
 public:
  using Entity::Entity;
  virtual ~TriggerFactory() noexcept = default;
 
  virtual TriggerSchema schema() const { return TriggerSchema{this->name(), this->description()}; }
 
  virtual fable::Json json_schema() const { return this->schema().json_schema(); }
 
  virtual std::unique_ptr<T> make(const Conf& c) const = 0;
 
  virtual std::unique_ptr<T> make(const std::string& s) const {
    if (s.empty()) {
      // If the string is empty, then we can probably just assume that a Conf
      // with nothing inside is as good as if it were the only one. Some
      // information does go lost this way though.
      auto c = Conf{
          {"name", this->name()},
      };
      return this->make(c);
    } else {
      throw TriggerInvalid(fable::Conf{fable::Json{s}},
                           "cannot create " + this->name() + " from '" + s + "'");
    }
  }
};
 
enum class Source {
  FILESYSTEM,
 
  NETWORK,
 
  MODEL,
 
  TRIGGER,
 
  INSTANCE,
 
  LUA,
};
 
// clang-format off
ENUM_SERIALIZATION(Source, ({
  {Source::FILESYSTEM, "filesystem"},
  {Source::NETWORK, "network"},
  {Source::MODEL, "model"},
  {Source::TRIGGER, "trigger"},
  {Source::INSTANCE, "instance"},
  {Source::LUA, "lua"},
}))
// clang-format on
 
 
inline bool source_is_transient(Source s) {
  return (s != Source::FILESYSTEM && s != Source::NETWORK && s != Source::LUA);
}
 
class Trigger {
 public:
  Trigger(const std::string& label, Source s, EventPtr&& e, ActionPtr&& a);
  TriggerPtr clone() const;
 
  const std::string& label() const { return label_; }
  Source source() const { return source_; }
  Duration since() const { return since_; }
  void set_since(Duration t) { since_ = t; }
  const Event& event() const { return *event_; }
  Event& event() { return *event_; }
  const Action& action() const { return *action_; }
  Action& action() { return *action_; }
 
  bool is_significant() const;
  bool is_transient() const { return source_is_transient(source_) || is_conceal(); }
  bool is_conceal() const { return conceal_; }
  void set_conceal(bool value = true);
  bool is_sticky() const { return sticky_; }
  void set_sticky(bool value = true);
 
  friend void to_json(fable::Json& j, const Trigger& t);
 
 private:
  std::string label_;
  Source source_;
  EventPtr event_;
  ActionPtr action_;
  Duration since_{0};
  bool conceal_{false};
  bool sticky_{false};
};
 
class TriggerRegistrar {
 public:
  explicit TriggerRegistrar(Source s) : source_(s) {}
  virtual ~TriggerRegistrar() noexcept = default;
 
  virtual ActionPtr make_action(const Conf& c) const = 0;
  virtual EventPtr make_event(const Conf& c) const = 0;
  virtual TriggerPtr make_trigger(const Conf& c) const = 0;
 
  virtual void insert_trigger(const Conf& c) = 0;
  virtual void insert_trigger(TriggerPtr&& t) = 0;
 
  void insert_trigger(const std::string& label, EventPtr&& e, ActionPtr&& a);
 
 protected:
  Source source_;
};
 
class Event : public Entity {
 public:
  using Entity::Entity;
  virtual ~Event() noexcept = default;
 
  virtual EventPtr clone() const = 0;
 
  virtual void to_json(fable::Json&) const = 0;
  friend void to_json(fable::Json& j, const Event& e);
 
 protected:
  Logger logger() const { return logger::get("cloe/event/" + name()); }
};
 
using EventFactory = TriggerFactory<Event>;
using EventFactoryPtr = std::unique_ptr<EventFactory>;
 
enum class CallbackResult {
  Ok,
 
  Unpin,
};
 
using CallbackExecuter = std::function<CallbackResult(TriggerPtr&&, const Sync&)>;
 
class Callback {
 public:
  virtual ~Callback() noexcept = default;
 
  void set_executer(CallbackExecuter exe) { executer_ = exe; }
 
  virtual void emplace(TriggerPtr&& t, const Sync& s) = 0;
 
  virtual void to_json(fable::Json& j) const = 0;
  friend void to_json(fable::Json& j, const Callback& c) { c.to_json(j); }
 
 protected:
  CallbackResult execute(TriggerPtr&& t, const Sync& s);
 
 private:
  CallbackExecuter executer_;
};
 
class AliasCallback : public Callback {
 public:
  explicit AliasCallback(std::shared_ptr<Callback> owner) : owner_(owner) {}
  virtual ~AliasCallback() noexcept = default;
 
  void emplace(TriggerPtr&& t, const Sync& s) override { owner_->emplace(std::move(t), s); }
 
  void to_json(fable::Json&) const override {}
 
 private:
  std::shared_ptr<Callback> owner_;
};
 
class Action : public Entity {
 public:
  using Entity::Entity;
  virtual ~Action() noexcept = default;
 
  virtual ActionPtr clone() const = 0;
 
  virtual CallbackResult operator()(const Sync&, TriggerRegistrar&) = 0;
 
  virtual bool is_significant() const { return true; }
 
  virtual void to_json(fable::Json& j) const = 0;
  friend void to_json(fable::Json& j, const Action& a);
 
 protected:
  Logger logger() const { return logger::get("cloe/action/" + name()); }
};
 
using ActionFactory = TriggerFactory<Action>;
using ActionFactoryPtr = std::unique_ptr<ActionFactory>;
 
}  // namespace cloe