peak_common_any.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <peak_common/detail/peak_common_defines.hpp>
#include <peak_common/exceptions/peak_common_exceptions.hpp>
 
#include <type_traits>
#include <memory>
#include <string>
 
namespace peak
{
namespace common
{

class Any
{
    struct Placeholder
    {
        virtual ~Placeholder() = default;
 
        PEAK_COMMON_NO_DISCARD virtual const std::type_info& Type() const = 0;
        PEAK_COMMON_NO_DISCARD virtual std::unique_ptr<Placeholder> Clone() const = 0;
    };
 
    template <typename T>
    struct Holder : public Placeholder
    {
        T value;
 
        explicit Holder(const T& val)
            : value(val)
        {}
 
        explicit Holder(T&& val)
            : value(std::move(val))
        {}
 
        PEAK_COMMON_NO_DISCARD const std::type_info& Type() const override
        {
            return typeid(T);
        }
 
        PEAK_COMMON_NO_DISCARD std::unique_ptr<Placeholder> Clone() const override
        {
            return std::make_unique<Holder<T>>(value);
        }
    };
 
    std::unique_ptr<Placeholder> m_content;
 
public:
    Any() = default;

    template <typename T>
    explicit Any(const T& value)
        : m_content(std::make_unique<Holder<typename std::decay_t<T>>>(value))
    {}

    template <typename T>
    explicit Any(T&& value
        ,
        typename std::enable_if<!std::is_same<Any, typename std::decay<T>::type>::value>::type* = nullptr
        )
        : m_content(std::make_unique<Holder<typename std::decay_t<T>>>(std::forward<T>(value)))
    {}

    Any(const Any& other)
        : m_content(other.m_content ? other.m_content->Clone() : nullptr)
    {}

    Any(Any&& other) noexcept = default;

    Any& operator=(const Any& other)
    {
        if (this != &other)
        {
            m_content = other.m_content ? other.m_content->Clone() : nullptr;
        }
        return *this;
    }

    Any& operator=(Any&& other) noexcept = default;

    void Reset()
    {
        m_content.reset();
    }

    PEAK_COMMON_NO_DISCARD const std::type_info& GetType() const
    {
        return m_content ? m_content->Type() : typeid(void);
    }

    template <typename T>
    T& AnyCast()
    {
        using namespace std::string_literals;
 
        if (typeid(T) != GetType())
        {
            throw InvalidCastException(
                "Casting from "s + typeid(T).name() + " to the given type " + GetType().name() + " is not supported!");
        }
        return static_cast<Holder<T>*>(m_content.get())->value;
    }

    template <typename T>
    PEAK_COMMON_NO_DISCARD const T& AnyCast() const
    {
        using namespace std::string_literals;
 
        if (typeid(T) != GetType())
        {
            throw InvalidCastException(
                "Casting from "s + typeid(T).name() + " to the given type " + GetType().name() + " is not supported!");
        }
        return static_cast<const Holder<T>*>(m_content.get())->value;
    }

    PEAK_COMMON_NO_DISCARD bool HasValue() const
    {
        return m_content != nullptr;
    }
};
 
} // namespace common 
} // namespace peak