Any.hpp

 
//
// TGUI - Texus' Graphical User Interface
// Copyright (C) 2012-2022 Bruno Van de Velde (vdv_b@tgui.eu)
//
// This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software.
//
// Permission is granted to anyone to use this software for any purpose,
// including commercial applications, and to alter it and redistribute it freely,
// subject to the following restrictions:
//
// 1. The origin of this software must not be misrepresented;
// you must not claim that you wrote the original software.
// If you use this software in a product, an acknowledgment
// in the product documentation would be appreciated but is not required.
//
// 2. Altered source versions must be plainly marked as such,
// and must not be misrepresented as being the original software.
//
// 3. This notice may not be removed or altered from any source distribution.
//
 
// Code based on http://codereview.stackexchange.com/questions/20058/c11-any-class
 
#ifndef TGUI_ANY_HPP
#define TGUI_ANY_HPP
 
#include <TGUI/Config.hpp>
#include <type_traits>
#include <utility>
#include <typeinfo>
 
#if TGUI_COMPILED_WITH_CPP_VER >= 17
 #include <any>
#endif
 
namespace tgui
{
#if TGUI_COMPILED_WITH_CPP_VER >= 17
 using Any = std::any;
 
 template<typename T>
 T AnyCast(const Any& obj)
 {
 return std::any_cast<T>(obj);
 }
#else
 struct Any
 {
 template<class T>
 using StorageType = typename std::decay<T>::type;
 
 bool is_null() const
 {
 return ptr == nullptr;
 }
 
 bool not_null() const
 {
 return ptr != nullptr;
 }
 
 template<typename U>
 Any(U&& value)
 : ptr{new Derived<StorageType<U>>(std::forward<U>(value))}
 {
 }
 
 template<class U>
 bool is() const
 {
 typedef StorageType<U> T;
 return (dynamic_cast<Derived<T>*>(ptr) != nullptr);
 }
 
 template<class U>
 StorageType<U>& as() const
 {
 typedef StorageType<U> T;
 auto derived = dynamic_cast<Derived<T>*>(ptr);
 if (!derived)
 throw std::bad_cast();
 
 return derived->value;
 }
 
 template<class U>
 operator U()
 {
 return as<StorageType<U>>();
 }
 
 Any()
 : ptr(nullptr)
 {
 }
 
 Any(const Any& that)
 : ptr(that.clone())
 {
 }
 
 Any(Any&& that) noexcept
 : ptr(that.ptr)
 {
 that.ptr = nullptr;
 }
 
 Any& operator=(const Any& a)
 {
 if (ptr == a.ptr)
 return *this;
 
 auto old_ptr = ptr;
 
 ptr = a.clone();
 
 if (old_ptr)
 delete old_ptr;
 
 return *this;
 }
 
 Any& operator=(Any&& a) noexcept
 {
 if (ptr == a.ptr)
 return *this;
 
 std::swap(ptr, a.ptr);
 
 return *this;
 }
 
 ~Any()
 {
 delete ptr;
 }
 
 private:
 struct Base
 {
 virtual ~Base() {}
 virtual Base* clone() const = 0;
 };
 
 template<typename T>
 struct Derived : Base
 {
 template<typename U>
 Derived(U&& val) :
 value(std::forward<U>(val))
 {
 }
 
 Base* clone() const override
 {
 return new Derived<T>(value);
 }
 
 T value;
 };
 
 Base* clone() const
 {
 if (ptr)
 return ptr->clone();
 else
 return nullptr;
 }
 
 Base* ptr;
 };
 
 template<typename T>
 T AnyCast(const Any& obj)
 {
 return obj.as<T>();
 }
#endif
}
 
#endif // TGUI_ANY_HPP