Validator.h

Go to the documentation of this file.

#pragma once

// -- std headers
#include <type_traits>
#include <limits>
#include <cmath>
#include <functional>

namespace marlinmt {
  
  template <typename T>
  using ValidatorFunctionT = std::function<bool(const T &)> ;
  
  namespace validator {

    template <typename T>
    constexpr ValidatorFunctionT<T> notInfinity() {
      static_assert( std::numeric_limits<T>::has_infinity, "Infinity not defined for this type" ) ;
      return [] (const T &value) { 
        return not std::isinf(value) ;
      };
    } 
    
    template <typename T>
    constexpr ValidatorFunctionT<std::vector<T>> forEach( ValidatorFunctionT<T> func ) {
      return [func=std::move(func)] (const std::vector<T> &value) {
        return ( value.end() == std::find_if_not(value.begin(), value.end(), func ) ) ;
      };
    } 
    
    template <typename T>
    constexpr ValidatorFunctionT<T> greater( T limit ) {
      return  [limit=std::move(limit)] (const T &value) { 
        return value > limit ;
      };
    }
    
    template <typename T>
    constexpr ValidatorFunctionT<T> greaterEqual( T limit ) {
      return  [limit=std::move(limit)] (const T &value) { 
        return value >= limit ;
      };
    }
    
    template <typename T>
    constexpr ValidatorFunctionT<T> less( T limit ) {
      return  [limit=std::move(limit)] (const T &value) { 
        return value < limit ;
      };
    }
    
    template <typename T>
    constexpr ValidatorFunctionT<T> lessEqual( T limit ) {
      return  [limit=std::move(limit)] (const T &value) { 
        return value <= limit ;
      };
    }
    
    template <typename T>
    constexpr ValidatorFunctionT<T> inRange( T low, T high ) {
      return  [low=std::move(low),high=std::move(high)] (const T &value) { 
        return !(value < low) && !(high < value) ;
      };
    } 
    
    template <typename T>
    constexpr ValidatorFunctionT<T> sizeModulo( std::size_t mod ) {
      return  [mod] (const T &value) { 
        return (value.size() % mod) != 0 ;
      };
    } 
    
    template <typename T>
    constexpr inline  ValidatorFunctionT<T> expectSize( std::size_t s ) {
      return  [s] (const T &value) { 
        return (value.size() == s) ;
      };
    }
    
    template <typename T>
    constexpr inline  ValidatorFunctionT<T> notEmpty() {
      return  [] (const T &value) { 
        return not value.empty() ;
      };
    }
    
    template <typename T>
    constexpr ValidatorFunctionT<T> combineOr( ValidatorFunctionT<T> lhs, ValidatorFunctionT<T> rhs ) {
      return [lhs=std::move(lhs),rhs=std::move(rhs)]( const T &value ) {
        return ( lhs(value) || rhs(value) ) ; 
      } ;
    }
    
    template <typename T>
    constexpr ValidatorFunctionT<T> combineAnd( ValidatorFunctionT<T> lhs, ValidatorFunctionT<T> rhs ) {
      return [lhs=std::move(lhs),rhs=std::move(rhs)]( const T &value ) {
        return ( lhs(value) && rhs(value) ) ; 
      } ;
    }
    
    template <typename T>
    constexpr ValidatorFunctionT<T> constraints( std::set<T> cnsts ) {
      return [cnsts=std::move(cnsts)]( const T &value ) {
        return cnsts.find( value ) != cnsts.end() ; 
      } ;
    }

  }
  
} // end namespace marlinmt