simpleany.hpp

#ifndef SIPLASPLAS_TYPEERASURE_SIPLEANY_HPP
#define SIPLASPLAS_TYPEERASURE_SIPLEANY_HPP

#include "typeinfo.hpp"
#include "anystorage/deadpool.hpp"
#include "anystorage/nonowning.hpp"
#include "logger.hpp"
#include <siplasplas/utility/assert.hpp>
#include <cstdint>

namespace cpp
{

template<typename Storage>
class SimpleAny;

template<>
class SimpleAny<cpp::NonOwningStorage>;

template<>
class SimpleAny<cpp::ConstNonOwningStorage>;


template<typename LhsStorage, typename RhsStorage>
bool sameType(const SimpleAny<LhsStorage>& lhs, const SimpleAny<RhsStorage>& rhs)
{
    return lhs.typeInfo() == rhs.typeInfo();
}

template<>
class SimpleAny<ConstNonOwningStorage> : public ConstNonOwningStorage
{
public:
    struct EmptyTag {};

    SimpleAny() :
        ConstNonOwningStorage{nullptr},
        _typeInfo{cpp::typeerasure::TypeInfo::get<EmptyTag>()}
    {}

    bool empty() const
    {
        return hasType<EmptyTag>();
    }

    template<typename T>
    SimpleAny(const T& value) :
        ConstNonOwningStorage(&value),
        _typeInfo{cpp::typeerasure::TypeInfo::get<T>()}
    {}

    SimpleAny(const void* object, const cpp::typeerasure::TypeInfo& typeInfo) :
        ConstNonOwningStorage{object},
        _typeInfo{typeInfo}
    {}

    template<typename T>
    static SimpleAny create(const T& value)
    {
        return SimpleAny(value);
    }

    template<typename T>
    bool hasType() const
    {
        return cpp::typeerasure::TypeInfo::get<T>() == _typeInfo;
    }

    template<typename T>
    const std::decay_t<T>& get() const
    {
        SIPLASPLAS_ASSERT_FALSE(empty());
#ifdef SIPLASPLAS_TYPEERASURE_SIMPLEANY_TYPECHECKS
        SIPLASPLAS_ASSERT_TRUE(hasType<std::decay_t<T>>())("SimpleAny has type '{}', requested '{}' instead", typeInfo().typeName(), ctti::type_id<std::decay_t<T>>().name());
#endif
        return *reinterpret_cast<const std::decay_t<T>*>(ConstNonOwningStorage::storage(_typeInfo));
    }

    cpp::typeerasure::TypeInfo typeInfo() const
    {
        return _typeInfo;
    }

    template<typename T>
    SimpleAny& operator=(const T& value)
    {
        if(!hasType<T>())
        {
            _typeInfo = cpp::typeerasure::TypeInfo::get<T>();
            ConstNonOwningStorage::rebind(&value);
        }
        else
        {
            _typeInfo.copyAssign(ConstNonOwningStorage::storage(_typeInfo), &value);
        }

        return *this;
    }

    const ConstNonOwningStorage& getStorage() const
    {
        return *static_cast<const ConstNonOwningStorage*>(this);
    }

private:
    cpp::typeerasure::TypeInfo _typeInfo;
};

template<>
class SimpleAny<NonOwningStorage> : public NonOwningStorage
{
public:
    struct EmptyTag {};

    SimpleAny() :
        NonOwningStorage{nullptr},
        _typeInfo{cpp::typeerasure::TypeInfo::get<EmptyTag>()}
    {}

    bool empty() const
    {
        return hasType<EmptyTag>();
    }

    template<typename T>
    SimpleAny(T& value) :
        NonOwningStorage(const_cast<std::decay_t<T>*>(&value)),
        _typeInfo{cpp::typeerasure::TypeInfo::get<std::decay_t<T>>()}
    {}

    SimpleAny(void* object, const cpp::typeerasure::TypeInfo& typeInfo) :
        NonOwningStorage{object},
        _typeInfo{typeInfo}
    {}

    template<typename T>
    static SimpleAny create(const T& value)
    {
        return SimpleAny(value);
    }

    template<typename T>
    bool hasType() const
    {
        return cpp::typeerasure::TypeInfo::get<T>() == _typeInfo;
    }

    template<typename T>
    const std::decay_t<T>& get() const
    {
        SIPLASPLAS_ASSERT_FALSE(empty());
#ifdef SIPLASPLAS_TYPEERASURE_SIMPLEANY_TYPECHECKS
        SIPLASPLAS_ASSERT_TRUE(hasType<std::decay_t<T>>())("SimpleAny has type '{}', requested '{}' instead", typeInfo().typeName(), ctti::type_id<std::decay_t<T>>().name());
#endif
        return *reinterpret_cast<const std::decay_t<T>*>(NonOwningStorage::storage(_typeInfo));
    }

    template<typename T>
    std::decay_t<T>& get()
    {
        SIPLASPLAS_ASSERT_FALSE(empty());
#ifdef SIPLASPLAS_TYPEERASURE_SIMPLEANY_TYPECHECKS
        SIPLASPLAS_ASSERT_TRUE(hasType<std::decay_t<T>>())("SimpleAny has type '{}', requested '{}' instead", typeInfo().typeName(), ctti::type_id<std::decay_t<T>>().name());
#endif
        return *reinterpret_cast<std::decay_t<T>*>(NonOwningStorage::storage(_typeInfo));
    }

    cpp::typeerasure::TypeInfo typeInfo() const
    {
        return _typeInfo;
    }

    template<typename T>
    SimpleAny& operator=(T& value)
    {
        if(!hasType<T>())
        {
            _typeInfo = cpp::typeerasure::TypeInfo::get<T>();
            NonOwningStorage::rebind(&value);
        }
        else
        {
            _typeInfo.copyAssign(NonOwningStorage::storage(_typeInfo), &value);
        }

        return *this;
    }

    template<typename T>
    SimpleAny& operator=(T&& value)
    {
        if(!hasType<std::decay_t<T>>())
        {
            throw cpp::exception<std::runtime_error>(
                "Cannot assign an rvalue of type {} to an lvalue reference of type {}",
                ctti::type_id(value).name(),
                _typeInfo.typeName()
            );
        }
        else
        {
            get<std::decay_t<T>>() = std::move(value);
            return *this;
        }
    }

    const NonOwningStorage& getStorage() const
    {
        return *static_cast<const NonOwningStorage*>(this);
    }

private:
    cpp::typeerasure::TypeInfo _typeInfo;
};

template<typename Storage>
class SimpleAny : protected Storage
{
public:
    struct EmptyTag {};

    template<typename T, typename... Args>
    static SimpleAny create(Args&&... args)
    {
        return SimpleAny{meta::identity<T>(), std::forward<Args>(args)...};
    }

    SimpleAny() :
        _typeInfo{cpp::typeerasure::TypeInfo::get<EmptyTag>()}
    {}

    SimpleAny(const cpp::typeerasure::TypeInfo& typeInfo) :
        _typeInfo{typeInfo}
    {
        _typeInfo.defaultConstruct(Storage::storage(_typeInfo));
    }

    bool empty() const
    {
        return hasType<EmptyTag>();
    }

    template<typename T, typename = std::enable_if_t<
        !std::is_base_of<
            SimpleAny,
            std::decay_t<T>
        >::value
    >>
    SimpleAny(const T& value) :
        _typeInfo{cpp::typeerasure::TypeInfo::get<T>()}
    {
        SIPLASPLAS_ASSERT_TRUE(Storage::template objectFitsInStorage<T>());
        _typeInfo.copyConstruct(Storage::storage(_typeInfo), &value);
    }

    template<typename OtherStorage>
    SimpleAny(const SimpleAny<OtherStorage>& other) :
        _typeInfo{other.typeInfo()}
    {
        _typeInfo.copyConstruct(Storage::storage(_typeInfo), other.storage(other.typeInfo()));
    }

    template<typename OtherStorage>
    SimpleAny(SimpleAny<OtherStorage>&& other) :
        _typeInfo{other.typeInfo()}
    {
        _typeInfo.moveConstruct(Storage::storage(_typeInfo), other.storage(other.typeInfo()));
    }

    SimpleAny(const SimpleAny& other) :
        _typeInfo{other.typeInfo()}
    {
        _typeInfo.copyConstruct(Storage::storage(_typeInfo), other.storage(other.typeInfo()));
    }

    SimpleAny(SimpleAny&& other) :
        _typeInfo{other.typeInfo()}
    {
        _typeInfo.moveConstruct(Storage::storage(_typeInfo), other.storage(other.typeInfo()));
    }

    template<typename T>
    bool hasType() const
    {
        return cpp::typeerasure::TypeInfo::get<T>() == _typeInfo;
    }

    template<typename T>
    const std::decay_t<T>& get() const
    {
        SIPLASPLAS_ASSERT_FALSE(empty());
#ifdef SIPLASPLAS_TYPEERASURE_SIMPLEANY_TYPECHECKS
        SIPLASPLAS_ASSERT_TRUE(hasType<std::decay_t<T>>())("SimpleAny has type '{}', requested '{}' instead", typeInfo().typeName(), ctti::type_id<std::decay_t<T>>().name());
#endif
        if(_typeInfo.isPointer())
        {
            return **reinterpret_cast<const std::decay_t<T>* const *>(Storage::storage(_typeInfo));
        }
        else
        {
            return *reinterpret_cast<const std::decay_t<T>*>(Storage::storage(_typeInfo));
        }
    }

    template<typename T>
    std::decay_t<T>& get()
    {
        SIPLASPLAS_ASSERT_FALSE(empty());
#ifdef SIPLASPLAS_TYPEERASURE_SIMPLEANY_TYPECHECKS
        SIPLASPLAS_ASSERT_TRUE(hasType<std::decay_t<T>>())("SimpleAny has type '{}', requested '{}' instead", typeInfo().typeName(), ctti::type_id<std::decay_t<T>>().name());
#endif
        if(_typeInfo.isPointer())
        {
            return **reinterpret_cast<std::decay_t<T>**>(Storage::storage(_typeInfo));
        }
        else
        {
            return *reinterpret_cast<std::decay_t<T>*>(Storage::storage(_typeInfo));
        }
    }

    cpp::typeerasure::TypeInfo typeInfo() const
    {
        return _typeInfo;
    }

    cpp::SimpleAny<cpp::NonOwningStorage> getReference()
    {
        return {Storage::storage(_typeInfo), _typeInfo};
    }

    cpp::SimpleAny<cpp::ConstNonOwningStorage> getReference() const
    {
        return {Storage::storage(_typeInfo), _typeInfo};
    }

    template<typename T>
    SimpleAny& operator=(const T& value)
    {
        if(!hasType<T>())
        {
            _typeInfo.destroy(Storage::storage(_typeInfo));
            _typeInfo = cpp::typeerasure::TypeInfo::get<T>();
            SIPLASPLAS_ASSERT_TRUE(Storage::template objectFitsInStorage<T>());
            _typeInfo.copyConstruct(Storage::storage(_typeInfo), &value);
        }
        else
        {
            _typeInfo.copyAssign(Storage::storage(_typeInfo), &value);
        }

        return *this;
    }

    SimpleAny& operator=(const SimpleAny& other)
    {
        if(!sameType(*this, other))
        {
            _typeInfo.destroy(Storage::storage(_typeInfo));
            _typeInfo = other._typeInfo;
            _typeInfo.copyConstruct(Storage::storage(_typeInfo), other.storage(other.typeInfo()));
        }
        else
        {
            _typeInfo.copyAssign(Storage::storage(_typeInfo), other.storage(other.typeInfo()));
        }

        return *this;
    }

    SimpleAny& operator=(SimpleAny&& other)
    {
        if(!sameType(*this, other))
        {
            _typeInfo.destroy(Storage::storage(_typeInfo));
            _typeInfo = other._typeInfo;
            _typeInfo.moveConstruct(Storage::storage(_typeInfo), other.storage(other.typeInfo()));
        }
        else
        {
            _typeInfo.moveAssign(Storage::storage(_typeInfo), other.storage(other.typeInfo()));
        }

        return *this;
    }

    ~SimpleAny()
    {
        _typeInfo.destroy(Storage::storage(_typeInfo));
    }

    const Storage& getStorage() const
    {
        return *static_cast<const Storage*>(this);
    }

private:
    cpp::typeerasure::TypeInfo _typeInfo;

    template<typename T, typename... Args>
    SimpleAny(meta::identity<T>, Args&&... args) :
        _typeInfo{cpp::typeerasure::TypeInfo::get<T>()}
    {
        SIPLASPLAS_ASSERT_TRUE(Storage::template objectFitsInStorage<T>());
        features::Constructible::apply<T>(Storage::storage(_typeInfo), std::forward<Args>(args)...);
    }
};


using SimpleAny8  = SimpleAny<DeadPoolStorage<8>>;

using SimpleAny16 = SimpleAny<DeadPoolStorage<16>>;

using SimpleAny32 = SimpleAny<DeadPoolStorage<32>>;

using SimpleAny64 = SimpleAny<DeadPoolStorage<64>>;

using ConstReferenceSimpleAny = SimpleAny<ConstNonOwningStorage>;

using ReferenceSimpleAny = SimpleAny<NonOwningStorage>;


}

#endif // SIPLASPLAS_TYPEERASURE_SIPLEANY_HPP