Selection.h

Go to the documentation of this file.

#ifndef NSL_SELECTIONS_H
#define NSL_SELECTIONS_H

// our headers
#include "NSL/matchers.h"

// c++ headers
#include <type_traits>

namespace NSL {

class Selection {
  // Generic definition of logical operators that takes uses perfect forwarding for both arguments
  template <typename T, typename U,
            std::enable_if_t<std::is_base_of<Selection, std::remove_reference_t<T>>::value, bool> = true,
            std::enable_if_t<std::is_base_of<Selection, std::remove_reference_t<U>>::value, bool> = true>
  friend inline Selection operator&&(T &&lhs, U &&rhs) {
    Selection result;
    result.m_matcher = std::make_shared<andMatcher>(std::forward<decltype(lhs.m_matcher)>(lhs.m_matcher),
                                                    std::forward<decltype(rhs.m_matcher)>(rhs.m_matcher));
    return result;
  }

  template <typename T, typename U,
            std::enable_if_t<std::is_base_of<Selection, std::remove_reference_t<T>>::value, bool> = true,
            std::enable_if_t<std::is_base_of<Selection, std::remove_reference_t<U>>::value, bool> = true>
  friend inline Selection operator||(T &&lhs, U &&rhs) {
    Selection result;
    result.m_matcher = std::make_shared<orMatcher>(std::forward<decltype(lhs.m_matcher)>(lhs.m_matcher),
                                                   std::forward<decltype(rhs.m_matcher)>(rhs.m_matcher));

    return result;
  }

  template <typename T, std::enable_if_t<std::is_base_of<Selection, std::remove_reference_t<T>>::value, bool> = true>
  friend inline Selection operator!(T &&lhs) {
    Selection result;
    result.m_matcher = std::make_shared<notMatcher>(std::forward<decltype(lhs.m_matcher)>(lhs.m_matcher));

    return result;
  }

public:
  template <class Hook, std::enable_if_t<std::is_convertible<Hook, matcher::hookType>::value, bool> = true>
  Selection &AddPreHook(Hook &&preHook) {
    m_matcher->AddPreHook(std::forward<decltype(preHook)>(preHook));
    return *this;
  }

  template <class Hook, std::enable_if_t<std::is_convertible<Hook, matcher::hookType>::value, bool> = true>
  Selection &AddPostHook(Hook &&preHook, PostHookCondition condition = PostHookCondition::OnSuccess) {
    m_matcher->AddPostHook(std::forward<decltype(preHook)>(preHook), condition);
    return *this;
  }

  virtual bool operator()(Event &ev) { return (*m_matcher)(ev); };

  template <typename T, std::enable_if_t<std::is_base_of<Selection, std::remove_reference_t<T>>::value, bool> = true>
  Selection &operator&=(T &&rhs) {
    m_matcher = std::make_shared<andMatcher>(m_matcher, std::forward<decltype(rhs.m_matcher)>(rhs.m_matcher));

    return *this;
  };

  template <typename T, std::enable_if_t<std::is_base_of<Selection, std::remove_reference_t<T>>::value, bool> = true>
  Selection &operator|=(T &&rhs) {
    m_matcher = std::make_shared<orMatcher>(m_matcher, std::forward<decltype(rhs.m_matcher)>(rhs.m_matcher));

    return *this;
  };

protected:
  RefCMatcher m_matcher = std::make_shared<boolMatcher>([](Event &ev) { return true; });
};

} // namespace Selections

#endif