koros0111/BasesParserSLan
Watch
1
0
Fork
You've already forked BasesParserSLan
 0
forked from nique_372/BasesParserSLan
Code Pull requests Activity
BasesParserSLan/Src/BaseClass/Def.mqh
Nique_372 573509878e
2026-10-08 21:47:12 -05:00

251 lines
10 KiB
MQL5
RawPermalinkBlameHistory

//+------------------------------------------------------------------+
//| Def.mqh |
//| Copyright 2026, Niquel Mendoza. |
//| https://www.mql5.com/ |
//+------------------------------------------------------------------+
#ifndef TSNPARSERIN_CPP_DLL
#property copyright "Copyright 2026, Niquel Mendoza."
#property link "https://www.mql5.com/"
#property strict
#endif // TSNPARSERIN_CPP_DLL
#ifndef BASESPARSERSLAN_SRC_BASECLASS_DEF_MQH
#define BASESPARSERSLAN_SRC_BASECLASS_DEF_MQH
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
#ifndef TSNPARSERIN_CPP_DLL
#include <TSN\\PHash\\Main.mqh>
#include <TSN/Tables/H/FNV1A.mqh>
#endif // TSNPARSERIN_CPP_DLL
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
namespace TSN
{
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
#define TSN_SLF_RAW_FILE 0
#define TSN_SLF_RAW_EMBEBED 1
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
#define TSN_SLF_EXT_TYPE_FILE 0
#define TSN_SLF_EXT_TYPE_CACHE_FILE 1
#ifndef TSNPARSERIN_CPP_DLL
//+------------------------------------------------------------------+
//| Implementacion de hashers para el hash perfecto |
//+------------------------------------------------------------------+
class CSBLHasherGenUl
{
public:
CSBLHasherGenUl(void) {}
~CSBLHasherGenUl(void) {}
static __forceinline ulong Hash(const ulong v)
{
return v; // Hasher 0
}
};
#define SBL_HASH_ALG(_v, _seed) \
ulong h = (_v ^ _seed) * 0x9E3779B97F4A7C15;\
h ^= h >> 32;
//+------------------------------------------------------------------+
class CSBLHasherGenUl1
{
public:
CSBLHasherGenUl1(void) {}
~CSBLHasherGenUl1(void) {}
static __forceinline ulong Hash(const ulong v, const ushort seed)
{
SBL_HASH_ALG(v, seed)
return h; // Hasher 1
}
};
#endif // TSNPARSERIN_CPP_DLL
//+------------------------------------------------------------------+
//| Layout base |
//+------------------------------------------------------------------+
/*
---
Notas:
- cada [] = 1 slot = 64 bits = long
- el tipo de un slot tiene 5 bits.. asi que puede producir hasta 31 tipos diferentes
Tabla:
ARR: [tipo(5)|count(28)<<5|step(31)<<33]
OBJ: [tipo(5)|count(28)<<5|step(31)<<33][jit_try(32)|is_jit(1)<<31]
UINT: [tipo(5)] [64bit=ulong]
INT: [tipo(5)] [64bit=long] ... aplica lo mismo para uint
FLT: [tipo(5)] [64bit=double]
BOL: [tipo(5)|bool_value(1)<<5]
// para str\key "easy" recomenadado:
// aparte eso de is solo existe en key
// asi que len_start = 5 + (is_key) (si no es key usa los 28 completos si lo es enotnces aparit rde 6)
STR: [tipo(5)|is(1)<<5|len(27 o 28)<<(6 o 5)|start(31)<<33]
---
Nota que luego el layout de yaml, etc.. para otros elemtos como ustring, etc varia...
*/
//+------------------------------------------------------------------+
//| Mask \ Bits start |
//+------------------------------------------------------------------+
//--- General
#define TSN_SBL_BIT_START_ENDTYPE (5)
#define TSN_SBL_BIT_MASK_TYPE (0x1F)
//--- STRING
// el len empiza donde el type termina +1 por que reserva un bit
//
#define TSN_SBL_SLEN_KEY (1)
#define TSN_SBL_SLEN_STR (0)
#define TSN_SBL_BIT_STR_LEN(K) (TSN_SBL_BIT_START_ENDTYPE+(K))
// si
// k=1: osea +1 para key se queda como esta (1-1)
// k=0: +0 (str) entonces es 0
#define TSN_SBL_BIT_STR_MASK_LEN(K) (0x7FFFFFF | (1-K) << 27)
// inicio de str
#define TSN_SBL_BIT_STR_START (33)
// hash
// marca en bit 5
#define TSN_SBL_KEY_FLAG_HASH (1<<TSN_SBL_BIT_START_ENDTYPE)
#define TSN_SBL_KEY_HAS_IS_HASH(V) (((V)&TSN_SBL_KEY_FLAG_HASH)!=0)
#define TSN_SBL_KEY_HAS_ISN_HASH(V) (((V)&TSN_SBL_KEY_FLAG_HASH)==0)
// ofset + 1 para llegar al hash
#define TSN_SBL_KEY_OFF_HASH (1)
//--- Arrays\Obj numero de lementos (bit starts)
// numero de elementos
#define TSN_SBL_BIT_START_NUM_EL (TSN_SBL_BIT_START_ENDTYPE)
#define TSN_SBL_BIT_MASK_NUM_EL (0xFFFFFFF)
// step
#define TSN_SBL_BIT_START_NUM_C (33)
// 2do slot
// JIT
#define TSN_SBL_BIT_JIT_START_IS (63)
#define TSN_SBL_BIT_JIT_ATTEMPS_MASK (0x7FFFFFFFFFFFFFFF)
// lo mismo dado que como tal para validfez tien que ser menor a ese valor..
#define TSN_SBL_BIT_JIT_INV_VAL (TSN_SBL_BIT_JIT_ATTEMPS_MASK)
#define TSN_SBL_BIT_JIT_INITIAL_V (1)
//--- Bool
#define TSN_SBL_BIT_START_BOOL (TSN_SBL_BIT_START_ENDTYPE)
//--- Macros para el parseo solo ahi
//--- Masraca para obtener el inciio del elemento en la cinta..
// layot en curso
// [1bit=arr or obj][32bit=cinta_pos][33bit=padre pos]
#define TSN_SBL_PARSE_MASK_CINTAPOS_S (0xffffffff) // mascara de la posicon en la cinta
#define TSN_SBL_PARSE_MASK_OA_T (1)
#define TSN_SBL_PARSE_START_CINTAPOS (1)
//+------------------------------------------------------------------+
//| Helpers |
//+------------------------------------------------------------------+
//--- Libres (CNL requier value no pide algo fijo)
#define TSN_SBL_CNL_STR_START(V, T) T((V) >> TSN_SBL_BIT_STR_START)
#define TSN_SBL_CNL_STR_LEN(V, K, T) T(((V) >> TSN_SBL_BIT_STR_LEN(K)) & TSN_SBL_BIT_STR_MASK_LEN(K))
//---
// CNG = C Node Get (prefijo para btener desde un node..)
#define TSN_SBL_CNG_STR_START(IDX, T) TSN_SBL_CNL_STR_START(m_ctx.m_cinta[IDX], T)
#define TSN_SBL_CNG_STR_LEN(IDX, K, T) TSN_SBL_CNL_STR_LEN(m_ctx.m_cinta[IDX], K, T)
#define TSN_SBL_CNG_BOOL(IDX) (m_ctx.m_cinta[IDX] >> TSN_SBL_BIT_START_BOOL)
// JIT
#define TSN_SBL_CNG_OBJ_JIT(IDX) (m_ctx.m_cinta[IDX] >> TSN_SBL_BIT_JIT_START_IS)
#define TSN_SBL_CNG_OBJ_JIT_ATTMP(IDX) (m_ctx.m_cinta[IDX] & TSN_SBL_BIT_JIT_ATTEMPS_MASK)
//---
// CLS = Class
#define TSN_SBL_CLS_STR_START(IDX, T) T(m_cinta[IDX] >> TSN_SBL_BIT_STR_START)
#define TSN_SBL_CLS_STR_LEN(IDX, K, T) T((m_cinta[IDX] >> TSN_SBL_BIT_STR_LEN(K)) & TSN_SBL_BIT_STR_MASK_LEN(K))
#define TSN_SBL_CLS_BOOL(IDX) (m_cinta[IDX] >> TSN_SBL_BIT_START_BOOL)
// JIT
#define TSN_SBL_CLS_OBJ_JIT(IDX) (m_cinta[IDX] >> TSN_SBL_BIT_JIT_START_IS)
#define TSN_SBL_CLS_OBJ_JIT_ATTMP(IDX) (m_cinta[IDX] & TSN_SBL_BIT_JIT_ATTEMPS_MASK)
// AO = Array Object
#define TSN_SBL_CLS_AO_NUM_EL(IDX, T) T((m_cinta[IDX] >> TSN_SBL_BIT_START_NUM_EL) & TSN_SBL_BIT_MASK_NUM_EL)
#define TSN_SBL_CLS_AO_STEP(IDX, T) T(m_cinta[IDX] >> TSN_SBL_BIT_START_NUM_C)
//+------------------------------------------------------------------+
//| Tamaños clave |
//+------------------------------------------------------------------+
#define TSN_SBL_KEYSLOT_SIZE (2)
#define TSN_SBL_SLOT_OBJ_SIZE (2)
//--- 2 por si acaso.. (yaml quizas lo necesite)
#define TSN_SBL_SLOT_ARR_SIZE (2)
//+------------------------------------------------------------------+
//| Tipos base |
//+------------------------------------------------------------------+
#define TSN_SBL_BASE_TYPE_ARR 0
#define TSN_SBL_BASE_TYPE_OBJ 1
#define TSN_SBL_BASE_TYPE_UINT 2
#define TSN_SBL_BASE_TYPE_INT 3
#define TSN_SBL_BASE_TYPE_FLT 4
#define TSN_SBL_BASE_TYPE_BOL 5
#define TSN_SBL_BASE_TYPE_STR 6
//--- SOLO USADO EN MODO DOM (no es necesario que las clases hijas lo usen)
#define TSN_SBL_BASE_DOM_NULL 7
// key iria aqui abajo pero ya en nodo hijo lo implemenbta
//--- flags base
#define TSN_SBL_BASE_F_ARR (1 << TSN_SBL_BASE_TYPE_ARR)
#define TSN_SBL_BASE_F_OBJ (1 << TSN_SBL_BASE_TYPE_OBJ)
#define TSN_SBL_BASE_F_UINT (1 << TSN_SBL_BASE_TYPE_UINT)
#define TSN_SBL_BASE_F_INT (1 << TSN_SBL_BASE_TYPE_INT)
#define TSN_SBL_BASE_F_FLT (1 << TSN_SBL_BASE_TYPE_FLT)
#define TSN_SBL_BASE_F_BOL (1 << TSN_SBL_BASE_TYPE_BOL)
#define TSN_SBL_BASE_F_STR (1 << TSN_SBL_BASE_TYPE_STR)
//+------------------------------------------------------------------+
//| Constantes para JIT |
//+------------------------------------------------------------------+
// ADVERTENCIA
// Si los valores son invalidos (muy grandes o negativos) pueden ocasionar bugs o errores silencionos
// (por ejemplo un numero grande mas de 6 pueide corromper la cinta (esnuciando slots del costado), o por ejepmoklo un valor negativo en value tu hash
// puedfe hacer que el numero de buckets sea 0 o invalido... por lo cual en RunWValue array out range seguro)
// asi que con precuacion modifique estos valores cuidadosamente.. por algo los he escondido bien.. y no documento.. ais que si los encuntreas lee esto
//--- Valor recomendalbe entre 4-6 acceso quizas se pdoria considera ya un perfect hash
// maximo valor que toma < LONG_MAX > 0
// 1. Representa el numero minimo de accceso a cierto objeto para ya empezar el hashing
#ifndef TSN_NODEBASEREAD_MIN_JIT_ATTEMPS_TO_PHASH
#define TSN_NODEBASEREAD_MIN_JIT_ATTEMPS_TO_PHASH 5
#endif // TSN_NODEBASEREAD_MIN_JIT_ATTEMPS_TO_PHASH
//---
// Representa el numero minimo de par key-value que debera de tener un objeto para ser candidato al hshaing
// recomeindo rotar entre un valor de 4 a 3 pero no 0
#ifndef TSN_NODEBASEREAD_MIN_JIT_VALUES_TO_HASH
#define TSN_NODEBASEREAD_MIN_JIT_VALUES_TO_HASH 4
#endif // TSN_NODEBASEREAD_MIN_JIT_ATTEMPS_TO_PHASH
}
//+------------------------------------------------------------------+
#endif // BASESPARSERSLAN_SRC_BASECLASS_DEF_MQH
View git blameCopy permalink