Condition.h

Go to the documentation of this file.

#pragma once

// -- std includes
#include <functional>
#include <optional>
#include <regex>
#include <string_view>
#include <typeindex>

// -- MarlinBook includes
#include "marlinmt/book/EntryData.h"

namespace marlinmt {
  namespace book {
    // -- MarlinBook forward declaration
    struct EntryKey ;

    class Condition {

    public:
      using FilterFn_t = std::function< bool( const EntryKey & ) > ;

      Condition() ;

      ~Condition() = default ;

      explicit Condition( FilterFn_t filterFn ) ;
      Condition &operator=( const FilterFn_t &filterFn ) ;

      Condition( Condition && ) = default ;
      Condition &operator=( Condition && ) = default ;

      Condition( const Condition & ) = default ;
      Condition &operator=( const Condition & ) = default ;

      bool operator()( const EntryKey &key ) const { return _fiterFn( key ); }

      Condition operator&( const Condition &rhs ) const {
        return Condition( [lh = _fiterFn, rh = rhs]( const EntryKey &key ) {
          return lh( key ) && rh( key ) ;
        } ) ;
      }

      Condition operator|( const Condition &rhs ) const {
        return Condition( [lh = _fiterFn, rh = rhs]( const EntryKey &key ) {
          return lh( key ) || rh( key ) ;
        } ) ;
      }

      Condition operator!() const {
        return Condition( [fn = _fiterFn]( const EntryKey &key ) -> bool {
          return !fn( key ) ;
        } ) ;
      }

    private:
      FilterFn_t _fiterFn ;
    } ;

    class ConditionBuilder {
    public:
      operator Condition() const ; // NOLINT(hicpp-explicit-conversions, google-explicit-constructor)

      [[nodiscard]] Condition condition() const ;

      ConditionBuilder &setName( const std::string_view &name ) ;

      ConditionBuilder &setName( const std::basic_regex< char > &rgx ) ;

      ConditionBuilder &setPath( const std::string_view &path ) ;

      ConditionBuilder &setPath( const std::basic_regex< char > &rgx ) ;

      ConditionBuilder &setType( const std::type_index &type ) ;

      template < typename T >
      ConditionBuilder &setType() {
        return setType( std::type_index( typeid( T ) ) ) ;
      }

    private:
      std::optional< std::string > _name{} ;
      std::basic_regex< char > _rgxName{".*", std::regex::optimize} ;
      std::optional< std::string > _path{} ;
      std::basic_regex< char > _rgxPath{".*", std::regex::optimize} ;
      std::optional< std::type_index > _type{} ;
    } ;

  } // end namespace book
} // end namespace marlinmt