anyarg.hpp

#ifndef SIPLASPLAS_TYPEERASURE_ANYARG_HPP
#define SIPLASPLAS_TYPEERASURE_ANYARG_HPP

#include "simpleany.hpp"
#include <siplasplas/utility/universal_reference.hpp>

namespace cpp
{

class AnyArg
{
public:
    template<typename T, typename = std::enable_if_t<
        !std::is_same<std::decay_t<T>, cpp::ConstReferenceSimpleAny>::value &&
        !std::is_same<std::decay_t<T>, cpp::ReferenceSimpleAny>::value
    >>
    AnyArg(T&& value) :
        _universalRef{cpp::universalReference(std::forward<T>(value))}
    {
        _typeProperties[0] = std::is_lvalue_reference<T>::value;
        _typeProperties[1] = std::is_const<std::remove_reference_t<T>>::value;
        _typeProperties[2] = false;
    }

    AnyArg(const cpp::ReferenceSimpleAny& reference) :
        _universalRef{cpp::SimpleAny32::create<cpp::ReferenceSimpleAny>(reference)}
    {
        _typeProperties[0] = true;
        _typeProperties[1] = false;
        _typeProperties[2] = true;
    }

    AnyArg(const cpp::ConstReferenceSimpleAny& reference) :
        _universalRef{cpp::SimpleAny32::create<cpp::ConstReferenceSimpleAny>(reference)}
    {
        _typeProperties[0] = true;
        _typeProperties[1] = true;
        _typeProperties[2] = true;
    }

    template<typename T>
    const T& get() const
    {
        if(isReferenceAny())
        {
            if(isConst())
            {
                return _universalRef.get<cpp::ConstReferenceSimpleAny>().get<T>();
            }
            else
            {
                return _universalRef.get<cpp::ReferenceSimpleAny>().get<T>();
            }
        }
        else
        {
            if(isRvalue())
            {
                return _universalRef.get<cpp::UniversalReference<std::decay_t<T>, false, false>>().get();
            }
            else if(isConst())
            {
                return _universalRef.get<cpp::UniversalReference<std::decay_t<T>, true, true>>().get();
            }
            else
            {
                return _universalRef.get<cpp::UniversalReference<std::decay_t<T>, true, false>>().get();
            }
        }
    }

    template<typename T>
    T& get()
    {
        if(isReferenceAny())
        {
            if(isConst())
            {
                return const_cast<T&>(_universalRef.get<cpp::ConstReferenceSimpleAny>().get<T>());
            }
            else
            {
                return _universalRef.get<cpp::ReferenceSimpleAny>().get<T>();
            }
        }
        else
        {
            if(isRvalue())
            {
                return _universalRef.get<cpp::UniversalReference<std::decay_t<T>, false, false>>().get();
            }
            else if(isConst())
            {
                throw std::runtime_error{"Cannot get a non-const reference to a const argument"};
            }
            else
            {
                return _universalRef.get<cpp::UniversalReference<std::decay_t<T>, true, false>>().get();
            }
        }
    }

    bool isRvalue() const
    {
        return !_typeProperties[0];
    }

    bool isLvalue() const
    {
        return _typeProperties[0];
    }

    bool isConst() const
    {
        return _typeProperties[1];
    }

private:
    cpp::SimpleAny32 _universalRef;
    std::bitset<3> _typeProperties;

    bool isReferenceAny() const
    {
        return _typeProperties[2];
    }
};

}

#endif // SIPLASPLAS_TYPEERASURE_ANYARG_HPP