registrar.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 <list>     // for list<>
#include <memory>   // for unique_ptr<>
#include <string>   // for string
#include <utility>  // for move
 
#include <sol/table.hpp>
#include <cloe/cloe_fwd.hpp> // for DataBroker
#include <cloe/handler.hpp>  // for Handler
#include <cloe/trigger.hpp>  // for ActionFactory, EventFactory, Callback, ...
#include <fable/json.hpp>    // for Json
 
namespace cloe {
 
template <typename E, typename... Ctx>
class DirectCallback : public Callback {
 public:
  size_t size() const { return triggers_.size(); }
  bool empty() const { return triggers_.empty(); }
 
  void emplace(TriggerPtr&& t, const Sync&) override { triggers_.emplace_back(std::move(t)); }
  void to_json(fable::Json& j) const override { j = triggers_; }
 
  void trigger(const Sync& sync, const Ctx&... args) {
    auto it = triggers_.begin();
    while (it != triggers_.end()) {
      auto& condition = dynamic_cast<E&>((*it)->event());
      if (condition(sync, args...)) {
        if ((*it)->is_sticky()) {
          auto result = this->execute((*it)->clone(), sync);
          if (result == CallbackResult::Unpin) {
            it = triggers_.erase(it);
          }
        } else {
          // Remove from trigger list and advance.
          this->execute(std::move(*it), sync);
          it = triggers_.erase(it);
          continue;
        }
      }
      ++it;
    }
  }
 
 private:
  std::list<TriggerPtr> triggers_;
};
 
template <typename E, typename... Ctx>
using DirectCallbackPtr = std::shared_ptr<DirectCallback<E, Ctx...>>;
 
enum class HandlerType {
  STATIC,
 
  DYNAMIC,
 
  BUFFERED,
};
 
class Registrar {
 public:
  virtual ~Registrar() noexcept = default;
 
  virtual void register_static_handler(const std::string& endpoint, Handler) = 0;
 
  virtual void register_api_handler(const std::string& endpoint, HandlerType, Handler) = 0;
 
  virtual std::unique_ptr<Registrar> with_api_prefix(const std::string& prefix) const = 0;
 
  virtual std::unique_ptr<Registrar> with_static_prefix(const std::string& prefix) const = 0;
 
  virtual std::unique_ptr<Registrar> with_trigger_prefix(const std::string& prefix) const = 0;
 
  virtual void register_action(std::unique_ptr<ActionFactory>&&) = 0;
 
  virtual DataBroker& data_broker() const = 0;
 
  template <typename F, typename... Ctx>
  void register_action(Ctx&&... ctx) {
    register_action(std::make_unique<F>(std::forward<Ctx>(ctx)...));
  }
 
  virtual void register_event(std::unique_ptr<EventFactory>&& f, std::shared_ptr<Callback> c) = 0;
 
  virtual sol::table register_lua_table() = 0;
 
  template <typename F, typename... Ctx>
  DirectCallbackPtr<typename F::EventType, Ctx...> register_event(std::unique_ptr<F>&& f) {
    auto callback = std::make_shared<DirectCallback<typename F::EventType, Ctx...>>();
    this->register_event(std::move(f), callback);
    return callback;
  }
 
  template <typename F, typename... Ctx, typename... Args>
  DirectCallbackPtr<typename F::EventType, Ctx...> register_event(Args... args) {
    auto callback = std::make_shared<DirectCallback<typename F::EventType, Ctx...>>();
    this->register_event(std::make_unique<F>(args...), callback);
    return callback;
  }
};
 
}  // namespace cloe