Runtime.h

Go to the documentation of this file.

 
#pragma once
 
#include <ostream>
#include <string>
 
 
#include "Reflection.h"
#include "Data.h"
#include "Input.h"
#include "Instruction.h"
 
namespace Gorgon {
    
    namespace Scripting {
        
        class ReferenceCounter {
        public:
            
            void Register(const Data &data) {
                ASSERT(data.GetData().IsPointer(), "Reference keeping can only be performed for reference types, "
                "offender: "+data.GetType().GetName(), 1, 4);
                
                void *ptr=data.GetData().Pointer();
                
                //ignore register requests to nullptr
                if(ptr==nullptr) return;
                
                if(references[ptr]==0)
                    references[ptr]=1;
            }
            
            void Register(void *ptr) {
                //ignore register requests to nullptr
                if(ptr==nullptr) return;
                
                references[ptr];
            }
            
            void Increase(const Data &data) {
                ASSERT(data.GetData().IsPointer(), "Reference keeping can only be performed for reference types, "
                "offender: "+data.GetType().GetName(), 1, 4);
                
                void *ptr=data.GetData().Pointer();
                auto f=references.find(ptr);
                if(f==references.end()) return;
                
                f->second++;
            }
            
            void Increase(void *ptr) {
                auto f=references.find(ptr);
                if(f==references.end()) return;
                
                f->second++;
            }
            
            void Decrease(const Data &data) {
                ASSERT(data.GetData().IsPointer(), "Reference keeping can only be performed for reference types, "
                       "offender: "+data.GetType().GetName(), 1, 4);
 
                void *ptr=data.GetData().Pointer();
                auto f=references.find(ptr);
                if(f==references.end()) return;
 
                int &v=f->second;
                v--;
                if(v<=0) {
                    data.Delete();
                    references.erase(f);
                }
            }
            
            void Reset(const Data &data) {
                ASSERT(data.GetData().IsPointer(), "Reference keeping can only be performed for reference types, "
                       "offender: "+data.GetType().GetName(), 1, 4);
 
                void *ptr=data.GetData().Pointer();
                auto f=references.find(ptr);
                if(f==references.end()) return;
 
                int &v=f->second;
                v=0;
            }
            
            bool IsRegistered(const Data &data) const {
                if(!data.IsValid()) return false;
                
                ASSERT(data.GetData().IsPointer(), "Reference keeping can only be performed for reference types, "
                "offender: "+data.GetType().GetName(), 1, 4);
                
                void *ptr=data.GetData().Pointer();
                auto f=references.find(ptr);
                if(f==references.end()) return false;
                
                return true;
            }
            
            void Unregister(const Data &data) {
                ASSERT(data.GetData().IsPointer(), "Reference keeping can only be performed for reference types, "
                "offender: "+data.GetType().GetName(), 1, 4);
                
                void *ptr=data.GetData().Pointer();
                references.erase(ptr);
            }
            
            void GetRidOf(Data &data) {
                ASSERT(data.GetData().IsPointer(), "Reference keeping can only be performed for reference types, "
                "offender: "+data.GetType().GetName(), 1, 4);
                
                void *ptr=data.GetData().Pointer();
                auto f=references.find(ptr);
                if(f==references.end()) return;
                
                int &v=f->second;
                v++;
                data=Data::Invalid();
                v--;
            }
            
            void list() {
                for(auto it : references) {
                    std::cout<<it.first<<": "<<it.second<<std::endl;
                }
            }
 
        private:
            std::map<void*, int> references;
        };
        
        class Variable : public Data {
            friend class VirtualMachine;
        public:
            
            Variable(const std::string &name="", const Data &data=Data::Invalid()) : name(name), Data(data) { }
            
            Variable(const std::string &name, const Type &type, const Any &value) : 
            name(name), Data(type, value) {
            }
            
            
            Variable(const std::string &name, const Type &type) :
            name(name), Data(type) {
            }
            
            
            void Set(Any value) {
                isreference=false;
                isconstant=false;
                delete parent;
                parent=nullptr;
                
                data.Swap(value);
            }
            
            void Set(const Data &value) {
                Data::operator=(value);
            }
            
            void Set(const Type &type, Any value) {
                isreference=false;
                isconstant=false;
                delete parent;
                parent=nullptr;
                
                data.Swap(value);
                this->type=&type;
            }
            
            void SetReferenceable(const Data &value);
 
            std::string GetName() const {
                return name;
            }
            
            bool IsReferenceAssigned() const { return ref; }
 
        private:
            bool ref=false;
            std::string name;
        };
 
        struct ParameterTemplate {
            std::string name, help;
            std::vector<Value> options;
            Value defaultvalue;
            Value type;
            bool optional=false, reference=false, constant=false, variable=false;
 
            void *defvaldata=nullptr;
            void *optdata=nullptr;
            
            bool operator ==(const ParameterTemplate &) const {
                Utils::ASSERT_FALSE("This cannot occur");
                
                return false;
            }
        };
        
    }
}