BasesParserSLan/Src/BaseClass/Def.mqh

//+------------------------------------------------------------------+
//|                                                          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