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

#include <memory>   // for unique_ptr<>, shared_ptr<>
#include <string>   // for string
#include <utility>  // for move
#include <vector>   // for vector<>

#include <cloe/core.hpp>    // for Schema, Json, Duration, Error
#include <cloe/entity.hpp>  // for Entity
#include <fable/enum.hpp>   // for ENUM_SERIALIZATION

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, JsonType type, bool required = true);

  InlineSchema(std::string&& desc, std::string&& format, bool required = true)
      : type_(JsonType::string)
      , required_(required)
      , usage_(std::move(format))
      , desc_(std::move(desc)) {}

  const std::string& description() const { return desc_; }

  JsonType type() const { return type_; }

  bool is_enabled() const { return !(required_ && type_ == JsonType::null); }

  bool is_required() const { return required_; }

  std::string usage(const std::string& name) const;

 private:
  JsonType type_{JsonType::null};
  bool required_{true};
  std::string usage_{};
  std::string desc_{};
};

struct TriggerSchema {
 public:
  TriggerSchema(const std::string& name, const std::string& desc)
      : name_(name), schema_(std::string(desc)), inline_(true) {}

  TriggerSchema(const std::string& name, const std::string& desc,
                fable::schema::PropertyList<> props)
      : name_(name), schema_(std::string(desc), props), inline_(false) {}

  TriggerSchema(const std::string& name, const std::string& desc, Schema&& s)
      : name_(name), schema_(std::move(s)), inline_(false) {
    schema_.set_description(desc);
  }

  TriggerSchema(const std::string& name, const std::string& desc, InlineSchema&& usage,
                fable::schema::PropertyList<> props)
      : name_(name), schema_(std::string(desc), props), inline_(std::move(usage)) {}

  TriggerSchema(const std::string& name, const std::string& desc, InlineSchema&& usage,
                Schema&& init)
      : name_(name), schema_(std::move(init)), inline_(std::move(usage)) {
    schema_.set_description(desc);
  }

  TriggerSchema(const std::string& name, const std::string& desc, InlineSchema&& usage,
                const Schema& init)
      : name_(name), schema_(init), inline_(std::move(usage)) {
    schema_.set_description(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_); }
  Json usage() const { return schema_.usage(); }
  Json json_schema() const;

 private:
  std::string name_;
  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 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(Conf{Json{s}}, "cannot create " + this->name() + " from '" + s + "'");
    }
  }
};

enum class Source {
  FILESYSTEM,

  NETWORK,

  MODEL,

  TRIGGER,

  INSTANCE,
};

// clang-format off
ENUM_SERIALIZATION(Source, ({
  {Source::FILESYSTEM, "filesystem"},
  {Source::NETWORK, "network"},
  {Source::MODEL, "model"},
  {Source::TRIGGER, "trigger"},
  {Source::INSTANCE, "instance"},
}))
// clang-format on


inline bool source_is_transient(Source s) {
  return (s != Source::FILESYSTEM && s != Source::NETWORK);
}

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(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(Json&) const = 0;
  friend void to_json(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>;

using CallbackExecuter = std::function<void(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(Json& j) const = 0;
  friend void to_json(Json& j, const Callback& c) { c.to_json(j); }

 protected:
  void 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(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 void operator()(const Sync&, TriggerRegistrar&) = 0;

  virtual bool is_significant() const { return true; }

  virtual void to_json(Json& j) const = 0;
  friend void to_json(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
#endif  // CLOE_TRIGGER_HPP_