universal_reference.hpp

#ifndef SIPLASPLAS_UTILITY_UNIVERSALREFERENCE_HPP
#define SIPLASPLAS_UTILITY_UNIVERSALREFERENCE_HPP

#include <type_traits>
#include <bitset>

namespace cpp
{

template<typename T,
    bool IsLvalueReference,
    bool IsConst
>
class UniversalReference
{
public:
    using ValueType = T;

    UniversalReference(const ValueType& lvalueRef) :
        _ref{&lvalueRef}
    {}

    const ValueType& get() const
    {
        return *_ref;
    }

private:
    const T* _ref;
};

template<typename T>
class UniversalReference<
    T,
    true,
    false
>
{
public:
    using ValueType = T;

    UniversalReference(ValueType& lvalueRef) :
        _ref{&lvalueRef}
    {}

    ValueType& get() const
    {
        return *_ref;
    }
private:
    T* _ref;
};

template<typename T>
class UniversalReference<
    T,
    false,
    false
>
{
public:
    using ValueType = T;

    UniversalReference(ValueType&& rvalueRef) :
        _object{std::move(rvalueRef)}
    {}

    ValueType& get()
    {
        return _object;
    }

    const ValueType& get() const
    {
        return _object;
    }

private:
    ValueType _object;
};

template<typename T>
auto universalReference(T&& value) ->
UniversalReference<
    std::decay_t<T>,
    std::is_lvalue_reference<T>::value,
    std::is_const<std::remove_reference_t<T>>::value
>
{
    return { std::forward<T>(value) };
}

}

#endif // SIPLASPLAS_UTILITY_UNIVERSALREFERENCE_HPP