Any.h

Go to the documentation of this file.

 
 
#pragma once
 
#include <cstring>
#include <cstdlib>
#include <stdexcept>
#include <typeinfo>
#include <algorithm>
#include <typeinfo>
#include "Utils/Assert.h"
#include "TMP.h"
 
 
 
namespace Gorgon {
 
    class Any {
    public:
        Any() : content(nullptr),type(nullptr) { }
        
        Any(const TMP::RTTS &typeinterface, void *data) {
            type=typeinterface.Duplicate();
            content=type->Clone(data);
        }
        
        Any(void *data, const TMP::RTTS &typeinterface) {
            type=typeinterface.Duplicate();
            content=type->Clone(data);
        }
        
        template <class T_>
        Any(const T_ &data) {
            using Type = typename std::decay<T_>::type;
            static_assert(!std::is_same<typename std::decay<typename std::remove_reference<T_>::type>::type, Any>::value,
                          "Something is wrong in here");
 
            type=new TMP::RTT<Type>;
            content=type->Clone(&data);
        }
 
        Any(const Any &any) {
            if(any.content) {
                type=any.type->Duplicate();
                content=type->Clone(any.content);
            }
            else {
                content=nullptr;
                type=nullptr;
            }
        }
 
 
        Any(Any &&any) : content(nullptr), type(nullptr) {
            Swap(any);
        }
        
        TMP::RTTI &TypeInfo() const {
            ASSERT(type, "Any is not set");
            
            return *type;
        }
        
        TMP::RTTS *TypeServices() const {
            return type;
        }
 
        
        Any &operator =(const Any &any) {
            Clear();
            
            if(any.type) {
                type=any.type->Duplicate();
                content=type->Clone(any.content);
            }
            else {
                type=nullptr;
                content=nullptr;
            }
 
            return *this;
        }
        
        Any &operator =(Any &&any) {
            Clear();
            
            Swap(any);
 
            return *this;
        }
 
        template<class T_>
        Any &operator =(const T_ &value) {
            static_assert(!std::is_same<typename std::decay<typename std::remove_reference<T_>::type>::type, Any>::value,
                          "Something is wrong in here");
            Set(value);
            
            return *this;
        }
 
 
        void Swap(Any &other) {
            using std::swap;
            
            swap(type, other.type);
            swap(content, other.content);
        }
 
        template <class T_>
        void Set(const T_ &data) {
            Clear();
 
            using Type = typename std::decay<T_>::type;
            
            type=new TMP::RTT<Type>;
            content=type->Clone(&data);
        }
 
        template <class T_>
        void Set(T_ &&data) {
            Clear();
 
 
            using Type = typename std::decay<T_>::type;
            
            type=new TMP::RTT<Type>;
            Type *n=new Type(std::move(data));
            content=n;
        }
 
        
        void Clear() {
            if(content) {
                type->Delete(content);
                delete type;
                type=nullptr;
                content=nullptr;
            }
        }
        
        void *GetRaw() const {
            return content;
        }
        
        void SetRaw(void *data) {
            if(content) type->Delete(content);
            
            content=type->Clone(data);
        }
        
        void SetRaw(TMP::RTTS *type, void *data) {
            Clear();
            
            this->type=type->Duplicate();
            content=type->Clone(data);
        }
        
        template<class T_>
        void Set(const T_ &data, TMP::RTTS *type) {
            Clear();
            
            this->type=type->Duplicate();
            content=type->Clone(&data);
        }
        
        void AssumeRaw(TMP::RTTS &type, void *data) {
            Clear();
            
            this->type=type.Duplicate();
            content=data;
        }
        
        void *Disown() {
            auto ret=content;
            
            delete type;
            type=nullptr;
            content=nullptr;
            
            return ret;
        }
        
        void SetType(const TMP::RTTS &type) {
            if(this->type) delete this->type;
            this->type=type.Duplicate();
        }
        
        template <class T_>
        T_ &Get() {
#ifndef GORGON_FAST_ANY
            if(!type || !content) {
                throw std::runtime_error("Any storage is empty");
            }
            
            ASSERT(type->IsSameType(typeid(T_)),
                "Type mismatch, orginal: "+type->Name()+", target: "+Utils::GetTypeName<T_>()
            );
#endif
 
            return *static_cast<T_*>(content);
        }
        
        std::string GetTypeName() const {
            if(!type) return "";
            
            return Utils::demangle(type->TypeInfo().name());
        }
 
        template <class T_>
        const T_ &Get() const {
#ifndef GORGON_FAST_ANY
            if(!type || !content) {
                throw std::runtime_error("Any storage is empty");
            }
            
            ASSERT(type->IsSameType(typeid(T_)),
                "Type mismatch, orginal: "+type->Name()+", target: "+Utils::GetTypeName<T_>()
            );
#endif
 
            return *static_cast<T_*>(content);
        }
 
 
        template <class T_>
        T_ UnsafeGet() const {
#ifndef GORGON_FAST_ANY
            if(!type || !content) {
                throw std::runtime_error("Any storage is empty");
            }
#endif
 
            return *static_cast<T_*>(content);
        }
 
        template <class T_>
        bool TypeCheck() const {
            return type->IsSameType(typeid(T_));
        }
        
        bool IsSameType(const Any &other) const {
            return type->IsSameType(other.type->TypeInfo());
        }
        
        bool IsPointer() const {
            return type->IsPointer();
        }
 
        void *Pointer() const {
            return *reinterpret_cast<void**>(content);
        }
 
        
        template <class T_>
        bool operator ==(const T_ &content) const  {
#ifndef GORGON_FAST_ANY
            if(!type || !this->content) {
                throw std::runtime_error("Any storage is empty");
            }
            
            ASSERT(type->IsSameType(typeid(T_)),
                "Type mismatch, orginal: "+type->Name()+", target: "+Utils::GetTypeName<T_>()
            );
#endif
 
            return *static_cast<T_*>(this->content)==content;
        }
 
        bool operator ==(const Any &content) const  {
            if(!content.content && !this->content) {
                return true;
            }
            else if(!content.content || !this->content) {
                return false;
            }
            
#ifndef GORGON_FAST_ANY
            ASSERT(type->TypeInfo() != content.type->TypeInfo(),
                "Type mismatch, left: "+type->Name()+", right: "+content.type->Name()
            );
#endif
 
            return memcmp(this->content, content.content, type->GetSize())==0;
        }
 
        template <class T_>
        bool operator !=(const T_ &content) const  {
            return !operator==(content);
        }
 
        bool operator !=(const Any &content) const  {
            return !operator==(content);
        }
 
        bool IsSet() const  {
            return content!=nullptr;
        }
 
        ~Any() {
            Clear();
        }
 
    protected:
        void *content;
        TMP::RTTS *type;
    };
    
 
    struct CopyFreeAny {
        virtual ~CopyFreeAny() {}
 
        template<class T_>
        T_ &GetData() const {
            return *reinterpret_cast<T_*>(data);
        }
 
        void *data;
    };
 
    template<class T_>
    struct CopyFreeAny_impl : public CopyFreeAny {
        CopyFreeAny_impl(T_ data) : mydata(std::move(data)) {
            this->data = &mydata;
        }
 
        CopyFreeAny_impl(const CopyFreeAny_impl &) = delete;
 
        CopyFreeAny_impl(CopyFreeAny_impl &&other) {
            mydata = std::move(other.data);
        }
 
        CopyFreeAny_impl &operator =(CopyFreeAny_impl &&other) {
            mydata = std::move(other.data);
 
            return *this;
        }
 
        CopyFreeAny_impl &operator =(const CopyFreeAny_impl &other) = delete;
 
        virtual ~CopyFreeAny_impl() {}
 
        T_ mydata;
    };
 
    template<class T_>
    CopyFreeAny &MakeCopyFreeAny(T_ data) {
        return *new CopyFreeAny_impl<T_>(std::move(data));
    }
 
 
}