matchers.h

Go to the documentation of this file.

#ifndef NSL_MATCHERS_H
#define NSL_MATCHERS_H

// NAIA headers
#include <Chain/Event.h>

// c++ headers
#include <functional>
#include <memory>

using Event = NAIA::Event;

namespace NSL {

enum class PostHookCondition { OnSuccess, OnFailure, Always };

class matcher {
public:
  using funcType = std::function<bool(Event &)>;
  using hookType = std::function<void(Event &)>;

  virtual bool operator()(Event &ev) {
    // run pre-hooks
    std::for_each(begin(m_preHooks), end(m_preHooks), [&ev](const auto &hook) { hook(ev); });

    // check the condition
    bool result = check(ev);

    // run post-hooks
    std::for_each(begin(m_postHooks), end(m_postHooks), [&ev, result](const auto &hook_pair) {
      if (hook_pair.second == PostHookCondition::Always ||
          (hook_pair.second == PostHookCondition::OnSuccess && result) ||
          (hook_pair.second == PostHookCondition::OnFailure && !result)) {
        hook_pair.first(ev);
      }
    });

    return result;
  };

  virtual void AddPreHook(const hookType &hook) { m_preHooks.push_back(hook); }
  virtual void AddPreHook(hookType &&hook) { m_preHooks.push_back(hook); }

  virtual void AddPostHook(const hookType &hook, PostHookCondition condition) {
    m_postHooks.emplace_back(hook, condition);
  }
  virtual void AddPostHook(hookType &&hook, PostHookCondition condition) { m_postHooks.emplace_back(hook, condition); }

private:
  virtual bool check(Event &ev) = 0;

  std::vector<hookType> m_preHooks{};
  std::vector<std::pair<hookType, PostHookCondition>> m_postHooks{};
};

using RefCMatcher = std::shared_ptr<matcher>;

class boolMatcher : public matcher {
public:
  explicit boolMatcher(funcType match) : m_match{std::move(match)} {};
  ~boolMatcher() = default;

private:
  bool check(Event &ev) override { return m_match(ev); }

private:
  funcType m_match;
};

class andMatcher : public matcher {
public:
  andMatcher(RefCMatcher lhs, RefCMatcher rhs) : m_lhs{std::move(lhs)}, m_rhs{std::move(rhs)} {};

private:
  bool check(Event &ev) override { return (*m_lhs)(ev) && (*m_rhs)(ev); };

protected:
  RefCMatcher m_lhs;
  RefCMatcher m_rhs;
};

class orMatcher : public matcher {
public:
  orMatcher(RefCMatcher lhs, RefCMatcher rhs) : m_lhs{std::move(lhs)}, m_rhs{std::move(rhs)} {};

private:
  bool check(Event &ev) override { return (*m_lhs)(ev) || (*m_rhs)(ev); };

protected:
  RefCMatcher m_lhs;
  RefCMatcher m_rhs;
};

class notMatcher : public matcher {
public:
  explicit notMatcher(RefCMatcher lhs) : m_lhs{std::move(lhs)} {};

private:
  bool check(Event &ev) override { return !(*m_lhs)(ev); };

protected:
  RefCMatcher m_lhs;
};

} // namespace NSL

#endif