s4g_gc.h

См. документацию.

/*
Copyright © Vitaliy Buturlin, Evgeny Danilovich, 2017
license MIT see in LICENSE or
https://s4g.su/
*/

#ifndef __S4G_GC_H
#define __S4G_GC_H

#include "limits.h"
#include "s4g_types.h"
#include "s4g_main.h"

#define S4G_COND_TYPE1(s4gm, pVar,retval) if (!pVar){s4g_GenMsg(s4gm, S4G_MSG_LEVEL_ERROR, "variable is not init, api function [%s]",__FUNCTION__); return retval;}
#define S4G_COND_TYPE2(s4gm, pVar,retval) if (!pVar->m_pData){s4g_GenMsg(s4gm, S4G_MSG_LEVEL_ERROR, "variable is has not data, api function [%s]",__FUNCTION__);    return retval;}
#define S4G_COND_TYPE_12(s4gm, pVar,retval) S4G_COND_TYPE1(s4gm, pVar,retval) S4G_COND_TYPE2(s4gm, pVar,retval)



class s4g_GC
{
public:
    s4g_GC(s4g_Main * ptr);
    ~s4g_GC();

    void clear();

    void releaseEmptyPages();

    s4g_Table* getGtable(){ return m_pGtable; };

    s4g_Variable* getGvar(){ return m_pGvar; };

    s4g_Variable* createVarData();

    s4g_Data* createDataCopy(s4g_Data *pDataSrc, int typeData = S4G_GC_TYPE_DATA_FREE);

    s4g_Variable* createVarDataCopy(s4g_Variable *pVarSrc, int typeVar = S4G_GC_TYPE_VAR_FREE, int typeData = S4G_GC_TYPE_DATA_FREE, bool canCopyData = false);


    s4g_Variable* createVarNull(int typeVar = S4G_GC_TYPE_VAR_FREE);

    s4g_Variable* createVarPdata(s4g_pdata pdata, int typeData = S4G_GC_TYPE_VAR_FREE);
    
    s4g_Variable* createVarTableEmpty(int typeVar = S4G_GC_TYPE_VAR_FREE, int typeData = S4G_GC_TYPE_DATA_FREE);

    s4g_Variable* createVarTable(s4g_Table *pTable, int typeVar = S4G_GC_TYPE_VAR_FREE);

    s4g_Variable* createVarArrayEmpty(int typeVar = S4G_GC_TYPE_VAR_FREE, int typeData = S4G_GC_TYPE_DATA_FREE);

    s4g_Variable* createVarSfuncEmpty(int typeVar = S4G_GC_TYPE_VAR_FREE, int typeData = S4G_GC_TYPE_DATA_FREE);
    
    s4g_Variable* createVarSfunc(s4g_Sfunction *func, int typeVar = S4G_GC_TYPE_VAR_FREE);
    
    s4g_Variable* createVarInt(s4g_int num, int typeVar = S4G_GC_TYPE_VAR_FREE, int typeData = S4G_GC_TYPE_DATA_FREE);
    
    s4g_Variable* createVarUint(s4g_uint num, int typeVar = S4G_GC_TYPE_VAR_FREE, int typeData = S4G_GC_TYPE_DATA_FREE);
    
    s4g_Variable* createVarFloat(s4g_float num, int typeVar = S4G_GC_TYPE_VAR_FREE, int typeData = S4G_GC_TYPE_DATA_FREE);
    
    s4g_Variable* createVarBool(s4g_bool bf, int typeVar = S4G_GC_TYPE_VAR_FREE);
    
    s4g_Variable* createVarString(const char *szString, int typeVar = S4G_GC_TYPE_VAR_FREE, int typeData = S4G_GC_TYPE_DATA_FREE);
    
    s4g_Variable* createVarCfunc(s4g_c_function func, int typeVar = S4G_GC_TYPE_VAR_FREE);

    s4g_Variable* createVarClassEmpty(const char *szName, int typeVar = S4G_GC_TYPE_VAR_FREE, int typeData = S4G_GC_TYPE_DATA_FREE);

    s4g_Variable* createVarClassObjectEmpty(s4g_Variable *pVarClass, int typeVar = S4G_GC_TYPE_VAR_FREE, int typeData = S4G_GC_TYPE_DATA_FREE);
    

    s4g_Data* createDataInt(s4g_int num, int typeData = S4G_GC_TYPE_DATA_FREE);

    s4g_Data* createDataUint(s4g_uint num, int typeData = S4G_GC_TYPE_DATA_FREE);

    s4g_Data* createDataFloat(s4g_float num, int typeData = S4G_GC_TYPE_DATA_FREE);


    s4g_Variable* getVarNull();

    s4g_Variable* getVarBool(bool bf);


    const char* getVarName(s4g_Variable *pVar, char* szName=0);


    void assign(s4g_Variable *pVarDest, s4g_Variable *pVarSrc); 
    
    s4g_int getInt(s4g_Variable *pVar);

    s4g_uint getUint(s4g_Variable *pVar);

    s4g_float getFloat(s4g_Variable *pVar);

    const char* getStr(s4g_Variable *pVar);

    String* getStr2(s4g_Variable *pVar);

    s4g_Table* getTable(s4g_Variable *pVar);

    s4g_Array* getArray(s4g_Variable *pVar);

    s4g_Sfunction* getSfunc(s4g_Variable *pVar);

    s4g_c_function getCfunc(s4g_Variable *pVar);

    s4g_bool getBool(s4g_Variable *pVar);

    s4g_pdata getPdata(s4g_Variable *pVar);

    s4g_Class* getClass(s4g_Variable *pVar);

    s4g_ClassObject* getClassObject(s4g_Variable *pVar);

    /*//! возвращает юзердату объекта класса, если есть
    s4g_pdata* getClassObjectData(s4g_Variable *pVar);*/


    S4G_TYPE getType(s4g_Variable *pVar);


    s4g_OwnerVar* getContextOwner(ID id);

    s4g_OwnerVar* getDataOwner(ID id);

    
    ID createContext(s4g_Table **ppTable, S4G_CONTEXT_TYPE_WORK typeWork = S4G_CONTEXT_TYPE_WORK_ONLINE);   

    ID addContext(s4g_Table *pTable, S4G_CONTEXT_TYPE_WORK typeWork = S4G_CONTEXT_TYPE_WORK_ONLINE);

    void activatePrev(ID idLastContext);        
    
    ID deactivatePrev();                    

    void deleteTopContext(bool canClear);       
    
    void removeTableInContext(ID id);   

    void clearTopContext();
    
            
    bool add2ConstContext(const char *szName, s4g_Variable *pVar);
    
    s4g_Variable* getFromConstContext(const char *szName);
    
    ID existsInAccessibleContexts(const char *szName, s4g_Variable **ppVar);

    s4g_Variable* getVarFromContextByNum(ID idRelativeTopContext, ID idVar);

    
    void deleteData(s4g_Data *pData);

    void deleteVar(s4g_Variable *pVar);

    void collectGarbage();
    

    void fixationConstVarData();


    int getMemCountBusy();

    int getMemCountAllocated();

protected:
    friend class s4g_Main;
    s4g_Main* s4gm;

    void allocMemContexts(int iCount = S4G_ADD_MEM_CONTEXTS);

    void addConstContext();

    ID m_idVarNULL;     
    ID m_idVarTRUE;     
    ID m_idVarFALSE;    

    ID m_idDataNULL;    
    ID m_idDataTRUE;    
    ID m_idDataFALSE;   

    s4g_Table *m_pGtable;       
    s4g_Variable *m_pGvar;  


    s4g_Stack<s4g_Variable*, S4G_RESERVE_VALUE> m_aVars;

    s4g_Stack<s4g_Data*, S4G_RESERVE_DATA> m_aData; 

    s4g_Stack<s4g_Context*, S4G_RESERVE_CONTEXTS> m_aCurrContexts;

    int m_iCountCurrContexts = 0;   

    MemAlloc<s4g_Variable, S4G_RESERVE_VALUE_MEM> m_oMemVar;    

    MemAlloc<s4g_Data, S4G_RESERVE_DATA_MEM> m_oMemData;        

    MemAlloc<s4g_Context, S4G_RESERVE_CONTEXTS_MEM> m_oMemContext;  

    MemAlloc<String, S4G_RESERVE_STRING_MEM> m_oMemString;      

    MemAlloc<s4g_Sfunction, S4G_RESERVE_SFUNC_MEM> m_oMemSFunc; 

    MemAlloc<s4g_Table, S4G_RESERVE_TABLE_MEM> m_oMemTable;     

    MemAlloc<s4g_Array, S4G_RESERVE_TABLE_MEM> m_oMemArray;

    MemAlloc<s4g_Class, S4G_RESERVE_CLASS_MEM> m_oMemClass;

    MemAlloc<s4g_ClassObject, S4G_RESERVE_CLASS_OBJECT_MEM> m_oMemObjClass;


    ID m_idConstContext;

    ID m_idFixedData;   

    ID m_idFixedVars;   
};

#endif

//!@} gc