Any.h

Go to the documentation of this file.

#pragma once
 
 
#include "objects/wrappers/AutoPtr.h"
#include "objects/wrappers/Optional.h"
#include <typeinfo>
 
NAMESPACE_SPH_BEGIN
 
class Any {
private:
    class AbstractHolder : public Polymorphic {
    public:
        virtual const std::type_info& getTypeInfo() const = 0;
        virtual AutoPtr<AbstractHolder> clone() const = 0;
    };
 
    template <typename Type>
    class Holder : public AbstractHolder {
        static_assert(!std::is_reference<Type>::value, "Cannot store references in Any");
 
    private:
        Type value;
 
    public:
        Holder(const Type& value)
            : value(value) {}
 
        Holder(Type&& value)
            : value(std::move(value)) {}
 
        virtual const std::type_info& getTypeInfo() const {
            return typeid(value);
        }
 
        virtual AutoPtr<AbstractHolder> clone() const {
            return makeAuto<Holder>(value);
        }
 
        Type& get() {
            return value;
        }
 
        const Type& get() const {
            return value;
        }
    };
 
    AutoPtr<AbstractHolder> data;
 
    template <typename Type>
    using HolderType = Holder<std::decay_t<Type>>;
 
    template <typename Type>
    HolderType<Type>* safeCast() {
        if (data) {
            return dynamic_cast<HolderType<Type>*>(&*data);
        } else {
            return nullptr;
        }
    }
 
    template <typename Type>
    const HolderType<Type>* safeCast() const {
        if (data) {
            return dynamic_cast<const HolderType<Type>*>(&*data);
        } else {
            return nullptr;
        }
    }
 
    template <typename Type>
    HolderType<Type>* cast() {
        SPH_ASSERT(data);
        return assert_cast<HolderType<Type>*>(&*data);
    }
 
    template <typename Type>
    const HolderType<Type>* cast() const {
        SPH_ASSERT(data);
        return assert_cast<const HolderType<Type>*>(&*data);
    }
 
 
public:
    Any() = default;
 
    Any(const Any& other) {
        *this = other;
    }
 
    Any(Any&& other) {
        *this = std::move(other);
    }
 
    template <typename Type, typename = std::enable_if_t<!std::is_same<Any, std::decay_t<Type>>::value>>
    Any(Type&& value) {
        *this = std::forward<Type>(value);
    }
 
    Any& operator=(const Any& other) {
        if (other.data) {
            data = other.data->clone();
        } else {
            data = nullptr;
        }
        return *this;
    }
 
    Any& operator=(Any&& other) {
        data = std::move(other.data);
        return *this;
    }
 
    template <typename Type, typename = std::enable_if_t<!std::is_same<Any, std::decay_t<Type>>::value>>
    Any& operator=(Type&& value) {
        data = makeAuto<HolderType<Type>>(std::forward<Type>(value));
        return *this;
    }
 
    template <typename Type>
    explicit operator const Type&() const {
        return cast<Type>()->get();
    }
 
    template <typename Type>
    explicit operator Type&() {
        return cast<Type>()->get();
    }
 
    bool hasValue() const {
        return bool(data);
    }
 
    template <typename Type>
    friend Optional<Type> anyCast(const Any& any);
 
    template <typename Type, typename = std::enable_if_t<!std::is_same<Any, std::decay_t<Type>>::value>>
    bool operator==(Type&& value) const {
        auto casted = safeCast<Type>();
        return casted && casted->get() == value;
    }
 
    template <typename Type, typename = std::enable_if_t<!std::is_same<Any, std::decay_t<Type>>::value>>
    bool operator!=(Type&& value) const {
        return !(*this == std::forward<Type>(value));
    }
};
 
template <typename Type>
Optional<Type> anyCast(const Any& any) {
    const Any::Holder<Type>* casted = any.safeCast<Type>();
    if (casted == nullptr) {
        // either nothing stored or different type
        return NOTHING;
    }
    return casted->get();
}
 
NAMESPACE_SPH_END