pipe.hpp

Go to the documentation of this file.

 
 
#pragma once
 
// --- Core Includes ---
#include "includes/kratos_parameters.h"
#include "includes/define.h" // KRATOS_TRY, KRATOS_CATCH
 
// --- STL Includes ---
#include <type_traits> // std::true_type, std::false_type
#include <utility> // std::move
 
 
namespace Kratos {
 
 
 
namespace Pipes {
 
 
template <class TInput, class TOutput>
struct Traits
{
    using InputType = TInput;
 
    using OutputType = TOutput;
}; // struct Traits
 
 
template <class TPipe>
using IsPipe = std::integral_constant<bool,
    // Has operator() with the following signature: OutputType operator()(InputType) const
    std::is_same_v<decltype(std::declval<const TPipe>().operator()(std::declval<typename TPipe::InputType>())), typename TPipe::OutputType>
 
    // Has non-void InputType
    && !std::is_same_v<typename TPipe::InputType,void>
 
    // Has non-void OutputType
    && !std::is_same_v<typename TPipe::OutputType,void>
>;
 
 
template <class TInput, class TPipe, std::enable_if_t<IsPipe<TPipe>::value && std::is_convertible_v<TInput,typename TPipe::InputType>, bool> = true>
typename TPipe::OutputType operator>>(TInput&& rInput, const TPipe& rPipe);
 
 
namespace Detail{
 
// Forward declare Factory because it needs to be a friend of CompoundPipe.
template <class>
class Factory;
 
} // namespace Detail
 
 
template <class TInputPipe, class TOutputPipe>
class CompoundPipe : public Traits<typename TInputPipe::InputType, typename TOutputPipe::OutputType>
{
public:
    using InputPipe = TInputPipe;
 
    using OutputPipe = TOutputPipe;
 
    CompoundPipe();
 
    CompoundPipe(CompoundPipe&& rOther) noexcept = default;
 
    CompoundPipe(const CompoundPipe& rOther) = default;
 
    template <class TInPipe = TInputPipe, class TOutPipe = TOutputPipe>
    CompoundPipe(const Parameters& rParameters,
                 std::enable_if_t<std::is_constructible_v<TInPipe,Parameters>
                     && std::is_constructible_v<TOutPipe,Parameters>>* = 0);
 
    CompoundPipe(TInputPipe&& rInputPipe, TOutputPipe&& rOutputPipe) noexcept;
 
    CompoundPipe(const TInputPipe& rInputPipe, const TOutputPipe& rOutputPipe);
 
    typename CompoundPipe::OutputType operator()(typename CompoundPipe::InputType Input) const;
 
    static Parameters GetDefaultParameters() noexcept;
 
private:
    template <class>
    friend class Detail::Factory;
 
    TInputPipe mInputPipe;
 
    TOutputPipe mOutputPipe;
}; // class CompoundPipe
 
 
template <class TInputPipe,
          class TOutputPipe,
          std::enable_if_t<
            IsPipe<TInputPipe>::value && IsPipe<TOutputPipe>::value,
            bool> = true
          >
CompoundPipe<TInputPipe,TOutputPipe> operator|(TInputPipe&& rInputPipe, TOutputPipe&& rOutputPipe);
 
 
template <class TInputPipe,
          class TOutputPipe,
          std::enable_if_t<
            IsPipe<TInputPipe>::value && IsPipe<TOutputPipe>::value,
            bool> = true
          >
CompoundPipe<TInputPipe,TOutputPipe> operator|(const TInputPipe& rInputPipe, const TOutputPipe& rOutputPipe);
 
 
template <class TPipe>
class SingleSegmentPipeline : public Traits<typename TPipe::InputType,typename TPipe::OutputType>
{
public:
    SingleSegmentPipeline() = default;
 
    SingleSegmentPipeline(SingleSegmentPipeline&& rOther) noexcept = default;
 
    SingleSegmentPipeline(const SingleSegmentPipeline& rOther) = default;
 
    SingleSegmentPipeline(const Parameters& rParameters);
 
    typename TPipe::OutputType operator()(typename TPipe::InputType input) const;
 
    static Parameters GetDefaultParameters();
 
private:
    TPipe mPipe;
}; // class SingleSegmentPipeline
 
 
template <class ...TPipes>
using Pipeline = decltype((... | std::declval<TPipes>()));
 
 
 
 
} // namespace Pipes
} // namespace Kratos
 
// Include definitions
#include "wrapp/pipes/impl/pipe_impl.hpp"