Data.h

Go to the documentation of this file.

#pragma once
 
#include "../Any.h"
#include "../Utils/Assert.h"
#include "Exceptions.h"
 
namespace Gorgon {
    
    namespace Scripting {
        
        class Type;
        
        class Data {
        public:
            
            static Data Invalid() { return {}; }
 
            Data() {}
 
            Data(const Data &other);
 
            Data(Data &&other);
 
            Data(const Type *type, const Any &data, bool isreference=false, bool isconstant=false);
 
            Data(const Type &type, const Any &data, bool isreference=false, bool isconstant=false) : Data(&type, data, isreference, isconstant) {
            }
            
            Data(const Type &type);
 
            Data &operator =(Data);
            
            bool IsNull() const;
            
            template <class T_>
            typename std::enable_if<!std::is_pointer<T_>::value, const typename std::remove_reference<T_>::type &>::type
            GetValue() const {
                if(isconstant) {
                    if(IsReference())
                        return *data.Get<typename std::remove_reference<const T_>::type*>();
                    else
                        return data.Get<typename std::remove_reference<const T_>::type>();
                }
                else {
                    if(IsReference())
                        return *data.Get<typename std::remove_const<typename std::remove_reference<T_>::type>::type*>();
                    else
                        return data.Get<typename std::remove_const<typename std::remove_reference<T_>::type>::type>();
                }                   
            }
            
            template <class T_>
            typename std::enable_if<std::is_pointer<T_>::value && std::is_const<typename std::remove_pointer<T_>::type>::value, T_>::type
            GetValue() const {
                if(isconstant) {
                    if(IsReference())
                        return data.Get<const typename std::remove_pointer<T_>::type *>();
                    else
                        throw CastException("Value", "Reference");
                }
                else {
                    if(IsReference())
                        return data.Get<typename std::remove_const<typename std::remove_pointer<T_>::type>::type*>();
                    else
                        throw CastException("Value", "Reference");
                }
            }
            
            template <class T_>
            typename std::enable_if<std::is_pointer<T_>::value && !std::is_const<typename std::remove_pointer<T_>::type>::value, T_>::type
            GetValue() const {
                if(isconstant) {
                    if(IsReference())
                        throw CastException("Const reference", "Reference");
                    else
                        throw CastException("Value", "Reference");
                }
                else {
                    if(IsReference())
                        return data.Get<typename std::remove_const<typename std::remove_pointer<T_>::type>::type*>();
                    else
                        throw CastException("Value", "Reference");
                }
            }
            
            template <class T_> 
            typename std::enable_if<std::is_pointer<T_>::value, T_>::type 
            ReferenceValue() const {
                ASSERT(type, "Type is not set", 1, 2);
                
                ASSERT(IsReference(), "The data contained is not a reference", 1, 10);
                
                return data.Get<typename std::remove_pointer<T_>::type *>();
            }
            
            template <class T_> 
            typename std::enable_if<!std::is_pointer<T_>::value, T_>::type 
            ReferenceValue() const {
                ASSERT(type, "Type is not set", 1, 2);
                
                ASSERT(IsReference(), "The data contained is not a reference", 1, 10);
                
                return *data.Get<typename std::remove_reference<T_>::type*>();
            }
            
            Any GetData() const {
                return data;
            }
            
            Data GetReference();
            
            Data DeReference();
            
            void SetParent(const Data data) {
                delete parent;
                parent=new Data(data);
            }
            
            void RemoveParent() {
                delete parent;
                parent=nullptr;
            }
            
            bool IsValid() const {
                return type != nullptr;
            }
            
            bool IsReference() const;
            
            bool IsConstant() const {
                return isconstant;
            }
            
            void MakeConstant();
            
            void Delete() const;
            
            bool operator==(const Data &r) const;
            
            const Type &GetType() const {
                ASSERT(type, "Type is not set", 1, 2);
                
                return *type;
            }
            
            std::string ToString() const;
 
            virtual ~Data();
            
        protected:
            Any   data;
            
            const Type *type = nullptr;
            
            bool isreference = false;
            
            bool isconstant = false;
            
            Data *parent = nullptr;
        private:
            
            void check();
        };
        
        
    }
}