ExpressionChainBuilder.h

/*
  ==============================================================================
    DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 
    Copyright 2022- by sonible GmbH.
 
    This file is part of VCTR - Versatile Container Templates Reconceptualized.
 
    VCTR is free software: you can redistribute it and/or modify
    it under the terms of the GNU Lesser General Public License version 3
    only, as published by the Free Software Foundation.
 
    VCTR is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Lesser General Public License version 3 for more details.
 
    You should have received a copy of the GNU Lesser General Public License
    version 3 along with VCTR.  If not, see <https://www.gnu.org/licenses/>.
  ==============================================================================
*/
 
namespace vctr
{
 
namespace detail
{
template <is::stdTuple... ArgTuples>
class RuntimeArgChain
{
public:
    template <class... Args>
    requires (! (is::stdTuple<Args> || ...))
    constexpr RuntimeArgChain (Args... firstArgs)
        : chain {{ std::tuple (std::move (firstArgs)...) }}
    {}
 
    constexpr RuntimeArgChain()
    requires (sizeof... (ArgTuples) == 1)
        : chain {{ std::tuple<>() }}
    {}
 
    // TODO: This is a workaround for https://github.com/sonible/VCTR/issues/111 and should be replaced by a generic solution
    constexpr RuntimeArgChain()
    requires (sizeof... (ArgTuples) == 3)
        : chain {{ std::tuple<>() }, { std::tuple<>() }, { std::tuple<>() }}
    {}
 
    static constexpr size_t size() { return sizeof... (ArgTuples); }
 
    template <is::stdTuple... ArgTuplesToPrepend>
    constexpr RuntimeArgChain<ArgTuplesToPrepend..., ArgTuples...> prepend (RuntimeArgChain<ArgTuplesToPrepend...> chainToPrepend) const
    {
        return { std::tuple_cat (chainToPrepend.chain, chain) };
    }
 
    template <size_t idx>
    static constexpr bool hasValue()
    {
        return ! std::is_same_v<std::tuple<>, std::tuple_element_t<idx, decltype (chain)>>;
    }
 
    template <size_t idx>
    constexpr auto& get() const
    {
        return std::get<idx> (chain);
    }
 
private:
    template <is::stdTuple...> friend class RuntimeArgChain;
 
    constexpr RuntimeArgChain (std::tuple<ArgTuples...>&& newChain)
        : chain (std::move (newChain))
    {}
 
    std::tuple<ArgTuples...> chain;
};
 
template <class SrcChainer, template <size_t, class> class ExpressionToAdd>
struct ExpressionChainingHelper
{
    template <size_t extent, class SrcType>
    using NewExpressionChain = ExpressionToAdd<extent, typename SrcChainer::template Expression<extent, SrcType>>;
 
    template <class RuntimeArgs>
    using NewExpressionChainBuilder = ExpressionChainBuilderWithRuntimeArgs<NewExpressionChain, RuntimeArgs>;
};
} // namespace detail
 
template <auto constantValue>
struct Constant
{
    static constexpr auto value = constantValue;
};
 
template <const auto& range>
requires is::range<decltype (range)>
struct ConstantRangeStart
{
    static constexpr auto value = range.getStart();
};
 
template <const auto& range>
requires is::range<decltype (range)>
struct ConstantRangeEnd
{
    static constexpr auto value = range.getEnd();
};
 
 
struct DisabledConstant
{
    struct Value
    {
        template <is::realNumber T>
        constexpr operator T() const { return std::numeric_limits<T>::max(); }
 
        template <is::realNumber T>
        constexpr operator std::complex<T>() const { return { std::numeric_limits<T>::max(), std::numeric_limits<T>::max() }; }
    };
 
    static constexpr Value value {};
};
 
template <template <size_t, class...> class ExpressionType, class RuntimeArgs, class... AdditionalCompileTimeParameters>
struct ExpressionChainBuilderWithRuntimeArgs
{
    template <size_t extent, class SrcType>
    using Expression = ExpressionType<extent, SrcType, AdditionalCompileTimeParameters...>;
 
    RuntimeArgs runtimeArgs;
 
    constexpr ExpressionChainBuilderWithRuntimeArgs (RuntimeArgs&& rtArgs)
        : runtimeArgs (std::move (rtArgs))
    {}
 
    constexpr ExpressionChainBuilderWithRuntimeArgs() {}
 
    template <is::anyVctr Src>
    constexpr auto operator<< (const Src& src) const
    {
        auto expression = Expression<extentOf<Src>, const Src&> { src };
        expression.template iterateOverRuntimeArgChain<0> (runtimeArgs);
 
        if constexpr (is::reductionExpression<decltype (expression)>)
        {
            return ReductionExpression::reduce (expression);
        }
        else
        {
            return expression;
        }
    }
 
    template <is::anyVctr Src>
    constexpr auto operator<< (Src& src) const
    {
        auto expression = Expression<extentOf<Src>, const Src&> { src };
        expression.template iterateOverRuntimeArgChain<0> (runtimeArgs);
 
        if constexpr (is::reductionExpression<decltype (expression)>)
        {
            return ReductionExpression::reduce (expression);
        }
        else
        {
            return expression;
        }
    }
 
    template <is::anyVctr Src>
    constexpr auto operator<< (Src&& src) const
    {
        auto expression = Expression<extentOf<Src>, Src> { std::move (src) };
        expression.template iterateOverRuntimeArgChain<0> (runtimeArgs);
 
        if constexpr (is::reductionExpression<decltype (expression)>)
        {
            return ReductionExpression::reduce (expression);
        }
        else
        {
            return expression;
        }
    }
 
    template <is::expression SrcExpression>
    constexpr auto operator<< (SrcExpression&& e) const
    {
        auto expression = Expression<extentOf<SrcExpression>, SrcExpression> (std::forward<SrcExpression> (e));
        expression.template iterateOverRuntimeArgChain<0> (runtimeArgs);
 
        if constexpr (is::reductionExpression<decltype (expression)>)
        {
            return ReductionExpression::reduce (expression);
        }
        else
        {
            return expression;
        }
    }
 
    template <is::expressionChainBuilder SrcExpressionChainBuilder>
    constexpr auto operator<< (SrcExpressionChainBuilder srcExpressionChainBuilder) const
    {
        auto newRuntimeArgChain = srcExpressionChainBuilder.runtimeArgs.prepend (runtimeArgs);
 
        using ChainingHelper = detail::ExpressionChainingHelper<SrcExpressionChainBuilder, Expression>;
 
        return typename ChainingHelper::template NewExpressionChainBuilder<decltype(newRuntimeArgChain)> (std::move (newRuntimeArgChain));
    }
};
 
template <template <size_t, class...> class ExpressionType, class... AdditionalCompileTimeParameters>
using ExpressionChainBuilder = ExpressionChainBuilderWithRuntimeArgs<ExpressionType, detail::RuntimeArgChain<std::tuple<>>, AdditionalCompileTimeParameters...>;
 
template <template <size_t, class...> class ExpressionType, class... RuntimeArgs>
requires (sizeof... (RuntimeArgs) > 0)
constexpr auto makeExpressionChainBuilderWithRuntimeArgs (RuntimeArgs... runtimeArgs)
{
    return ExpressionChainBuilderWithRuntimeArgs<ExpressionType, detail::RuntimeArgChain<std::tuple<RuntimeArgs...>>> (detail::RuntimeArgChain<std::tuple<RuntimeArgs...>> (std::move (runtimeArgs)...));
}
 
template <template <size_t, class...> class ExpressionType, class ExpressionTemplateArg, class... RuntimeArgs>
requires (sizeof... (RuntimeArgs) > 0)
constexpr auto makeTemplateExpressionChainBuilderWithRuntimeArgs (RuntimeArgs... runtimeArgs)
{
    return ExpressionChainBuilderWithRuntimeArgs<ExpressionType, detail::RuntimeArgChain<std::tuple<RuntimeArgs...>>, ExpressionTemplateArg> (detail::RuntimeArgChain<std::tuple<RuntimeArgs...>> (std::move (runtimeArgs)...));
}
 
} // namespace vctr