staticif.hpp

#ifndef SIPLASPLAS_UTILITY_STATICIF_HPP
#define SIPLASPLAS_UTILITY_STATICIF_HPP

#include "meta.hpp"
#include "identity.hpp"
#include <utility>

namespace cpp
{

namespace detail
{

template<bool Condition>
class If
{
public:
    template<typename T>
    class ElseBypass
    {
    public:
        constexpr ElseBypass(T&& value) :
            _value{std::move(value)}
        {}

        template<typename Body>
        constexpr T Else(const Body&)
        {
            return std::move(_value);
        }

    private:
        T _value;
    };

    template<typename T>
    class ElseBypass<T&>
    {
    public:
        constexpr ElseBypass(T& value) :
            _value{&value}
        {}

        template<typename Body>
        constexpr T& Else(const Body&)
        {
            return static_cast<T&>(*this);
        }

        constexpr operator T&()
        {
            return *_value;
        }

        T& operator()()
        {
            return *_value;
        }

    private:
        T* _value;
    };

    template<typename Body, typename... Args>
    constexpr auto Then(const Body& body, Args&&... args) ->
        typename std::enable_if<
            !std::is_void<decltype(body(::cpp::Identity(), std::forward<Args>(args)...))>::value,
            ElseBypass<decltype(body(::cpp::Identity(), std::forward<Args>(args)...))>
        >::type
    {
        return body(::cpp::Identity(), std::forward<Args>(args)...);
    }

    template<typename Body, typename... Args>
    constexpr auto Then(const Body& body, Args&&... args) ->
        typename std::enable_if<
            std::is_void<decltype(body(::cpp::Identity(), std::forward<Args>(args)...))>::value,
            If&
        >::type
    {
        body(::cpp::Identity(), std::forward<Args>(args)...);
        return *this;
    }


    template<typename Body, typename... Args>
    constexpr void Else(const Body&, Args&&...)
    {
        /* NOTHING */
    }
};

template<>
class If<false>
{
public:
    constexpr If() = default;

    template<typename Body, typename... Args>
    constexpr If& Then(const Body&, Args&&...)
    {
        return *this;
    }

    template<typename Body, typename... Args>
    constexpr decltype(auto) Else(const Body& body, Args&&... args)
    {
        return body(Identity(), std::forward<Args>(args)...);
    }
};

}

template<bool Condition, typename ThenBody, typename... Args>
auto staticIf(const ThenBody& thenBody, Args&&... args)
{
    detail::If<Condition> if_;
    return if_.Then(thenBody, std::forward<Args>(args)...);
}

}

#endif // SIPLASPLAS_UTILITY_STATICIF_HPP