//+------------------------------------------------------------------+ //| 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 #include #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_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