concepts.h

#pragma once
 
#include "../concepts.h"
 
#include <type_traits>
 
namespace Ponca
{
    template <typename T>
    concept ProvidesScaleDerivative = (T::isScaleDer() && T::derDimension() > 0);
 
    template <typename T>
    concept ProvidesSpaceDerivative = (T::isSpaceDer() && T::derDimension() > 0);
 
    template <typename T>
    concept ProvidesDerivatives = (ProvidesScaleDerivative<T> || ProvidesSpaceDerivative<T>);
 
    template <typename K>
    concept KernelProvidesFirstOrderDerivative = K::isDValid;
 
    template <typename K>
    concept KernelProvidesSecondOrderDerivative = K::isDDValid;
    template <typename T>
    concept ProvidesComputeState = ProvidesCommonTypes<T> && requires(T t, const T ct) {
        { ct.isStable() } -> std::same_as<bool>;
        { ct.isReady() } -> std::same_as<bool>;
        { ct.getCurrentState() } -> std::same_as<FIT_RESULT>;
    };
    template <typename T>
    concept ProvidesBasketUnitBase = ProvidesCommonTypes<T> && ProvidesComputeState<T> && requires(T t, const T ct) {
        typename T::NeighborFilter;
        t.setNeighborFilter(typename T::NeighborFilter{});
        { ct.getNeighborFilter() } -> std::convertible_to<typename T::NeighborFilter>;
 
        { ct.getWeightSum() } -> std::same_as<typename T::Scalar>;
        { ct.getNumNeighbors() } -> std::integral;
    };
 
    template <typename T>
    concept ProvidesBasketDiffUnitBase = ProvidesBasketUnitBase<T> && requires(T t, const T ct) {
        { ct.isScaleDer() } -> std::same_as<bool>;
        { ct.isSpaceDer() } -> std::same_as<bool>;
        { ct.derDimension() } -> std::integral;
    };
 
    template <typename T>
    concept ProvidesSpaceDerivatives = T::isSpaceDer() && ProvidesCommonTypes<T>;
} // namespace Ponca