15664438210/BasesParserSLan
Watch
1
0
Fork
You've already forked BasesParserSLan
 0
forked from nique_372/BasesParserSLan
Code Pull requests Activity
BasesParserSLan/Src/NodeBase.mqh
Nique_372 7f06f76f61 Pointer corrections
2026-07-26 17:15:14 -05:00

1058 lines
34 KiB
MQL5
Raw Permalink Blame History

//+------------------------------------------------------------------+
//| NodeBase.mqh |
//| Copyright 2026, Niquel Mendoza. |
//| https://www.mql5.com/ |
//+------------------------------------------------------------------+
#property copyright "Copyright 2026, Niquel Mendoza."
#property link "https://www.mql5.com/"
#property strict
#ifndef BASESPARSERSLAN_SRC_NODEBASE_MQH
#define BASESPARSERSLAN_SRC_NODEBASE_MQH
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
#include "DomImp.mqh"
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
namespace TSN
{
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
#define NODEBASEF_RES_BASE(_ctx_, _idx_) ((_ctx_ != NULL && int(_ctx_.m_cinta[_idx_] & TSN_SBL_BIT_MASK_TYPE) == TSN_SBL_BASE_TYPE_OBJ) ? _ctx_.FindNodePos(_idx_) : -1)
#define NODEBASEF_RES m_node_pos = NODEBASEF_RES_BASE(m_ctx, m_idx);
#define NODEBASE_IS_NOT_VALID_F (m_ctx == NULL)
#define NODEBASE_IS_VALID (m_ctx != NULL)
#define NODEBASE_IS_NOT_VALID_FULL (m_ctx == NULL || m_idx < 1 || m_end < 1)
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
template <typename TCtx, typename TOut>
struct CNodeBaseIteradorArray;
template <typename TCtx, typename TOut>
struct CNodeBaseIteratorObj;
template <typename TCtx, typename TOut>
struct CNodeBaseIteratorArrayFast;
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
template <typename TCtx, typename TType, typename TOut>
struct CNodeSFLBase
{
//---
TCtx* m_ctx;
int m_idx;
int m_end;
int m_node_pos;
//---
CNodeSFLBase(TCtx* ctx, const int idx, const int end, const int node_pos)
: m_ctx(ctx), m_idx(idx), m_end(end), m_node_pos(node_pos) {}
//--- Acceso
TOut Get(const ulong hash_fnv1a_64); // obtener por hash
TOut At(const int index) const; // obtener por hash
TOut AtHomegeneo(const int index) const;
TOut AtObj(const int index) const; // Obtiene el valor...
TOut Query(const string& path);
//--- Keys
bool HasKey(const string &key) const;
int GetKeys(string &out[]) const;
int KeyToPosition(const string &key) const;
string AtObjKey(const int index) const;
string AtObjKeyHomogeneo(const int index) const;
// Array exist
template <typename T>
bool ExistInArrayHomogeneo(const T val) const;
//---
__forceinline void RecalcNodePos() { NODEBASEF_RES }
//--- Tipo
__forceinline TType GetType() const { return TType(m_ctx.m_cinta[m_idx] & 0xF); }
__forceinline uint GetFlag() const { return 1 << uint(m_ctx.m_cinta[m_idx] & TSN_SBL_BIT_MASK_TYPE); }
__forceinline string TypeToMqlStr() const { return TCtx::s_dtype_to_str[int(m_ctx.m_cinta[m_idx] & TSN_SBL_BIT_MASK_TYPE)]; }
//--- Bool
bool ToBool(const bool def) const;
bool ToBoolSafe(bool& val) const;
//--- To
template <typename TValue>
__forceinline TValue GetAs() { return TValue(&this); }
//--- Is
__forceinline bool IsValid() const;
__forceinline bool IsInvalid() const;
__forceinline bool IsArray() const;
__forceinline bool IsObject() const;
__forceinline bool IsValidDataType() const;
//--- Size (arr u obj)
int Size() const;
__forceinline bool InRange(const int index) const;
bool InRangeSafe(const int index) const;
//--- JIT
bool NodeHashing();
__forceinline bool ObjectIsJit() const;
__forceinline int ObjectAttempCount() const;
//--- Mov raw
bool MoveToNextToken(const bool solo_en_el_bloque_actual = true);
bool MoveNextPositionsThis(const int posiciones, const bool solo_en_el_bloque_actual = true);
TOut MoveNextPositions(const int posiciones, const bool solo_en_el_bloque_actual = true);
//--- Dom
bool ToDom(CDomNodeBase* root, CDomNodeManager* manager);
//--- Iteradores
CNodeBaseIteradorArray<TCtx, TOut> BeginArr() const;
CNodeBaseIteradorArrayFast<TCtx, TOut> BeginArrHomogeneo() const;
CNodeBaseIteratorObj<TCtx, TOut> BeginObj() const;
};
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
template <typename TCtx, typename TType, typename TOut>
TOut CNodeSFLBase::Query(const string &path)
{
//---
if(NODEBASE_IS_NOT_VALID_F ||
((1 << int(m_ctx.m_cinta[m_idx] & TSN_SBL_BIT_MASK_TYPE)) & (TSN_SBL_BASE_F_OBJ | TSN_SBL_BASE_F_ARR)) == 0)
return TOut::EMPTY_NODE;
//---
if(path == "")
return TOut(m_ctx, m_idx, m_end, m_node_pos); // clonamos
//---
if(path[0] != '/')
return TOut::EMPTY_NODE;
//---
TOut curr(m_ctx, m_idx, m_end, m_node_pos);
const int l = StringLen(path);
int p = 1;
//---
while(true)
{
const uchar t = (uchar)curr.GetType();
if(t == TSN_SBL_BASE_TYPE_OBJ)
{
//--- Calcula y va escapando el key hash...y avanza p
const ulong khash = TCtx::EscapePointer(path, p, l);
// Ahora mismo en final o /
//---
curr = curr.Get(khash);
if(curr.IsInvalid())
return TOut::EMPTY_NODE;
}
else
if(t == TSN_SBL_BASE_TYPE_ARR)
{
//---
uchar ch = (uchar)path[p] ^ '0';
int last_index = -1;
//---
if(ch < 10)
{
last_index = 0;
while(true)
{
//---
last_index = (last_index << 3) + (last_index << 1) + ch;
p++;
if(p >= l)
break;
//---
ch = (uchar)path[p];
// p luego del /
if(ch == '/')
{
p++;
break;
}
//--
ch ^= '0';
}
}
//---
if(!curr.InRangeSafe(last_index))
return TOut::EMPTY_NODE;
//-- Accedemos
curr = curr.At(last_index);
}
else
{
// No se puede
return TOut::EMPTY_NODE;
}
//---
if(p >= l)
return curr;
}
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
template <typename TCtx, typename TType, typename TOut>
TOut CNodeSFLBase::Get(const ulong hash_fnv1a_64)
{
//---
if(NODEBASE_IS_NOT_VALID_F || int(m_ctx.m_cinta[m_idx] & TSN_SBL_BIT_MASK_TYPE) != TSN_SBL_BASE_TYPE_OBJ)
return TOut::EMPTY_NODE;
//--- Iterar pares KEY+VAL
// Print("Call");
if(((m_ctx.m_cinta[m_idx] >> TSN_SBL_BIT_START_IS_HASING) & TSN_SBL_BIT_MASK_IS_HASHSING) == 0)
{
//Print("No esta hasheado buscando o(n)");
//---
int c = int(m_ctx.m_cinta[m_idx] >> TSN_SBL_BIT_START_NUM_C_HASH) & TSN_SBL_BIT_MASK_NUM_C_HASH;
//Print("Contador actual: ", c);
if(c >= TSN_NODEBASEREAD_MIN_JIT_ATTEMPS_TO_PHASH) // Veriricamos si supero
{
if(NodeHashing())
{
//Print("Hasheado");
//--- Obtenemos posicion
int val_pos = m_ctx.PerfectHashAcces(hash_fnv1a_64, m_node_pos);
if(val_pos == -1)
{
return TOut::EMPTY_NODE;
}
else
{
val_pos++; // Luego de key
return TOut(m_ctx, val_pos, val_pos + m_ctx.GetStep(val_pos));
}
}
//Print("No se pudo hashear");
// Si llega aqui es por que fallo.. en ese caso reiniciamos los intetnos..
//---
c = 0;
const long mask = long(TSN_SBL_BIT_MASK_NUM_C_HASH) << TSN_SBL_BIT_START_NUM_C_HASH; // máscara de 3 bits en pos 5
m_ctx.m_cinta[m_idx] = (m_ctx.m_cinta[m_idx] & ~mask) | (c << TSN_SBL_BIT_START_NUM_C_HASH);
}
else
{
// Aun no.. solo aumentamos y modificamos..
c++;
const long mask = long(TSN_SBL_BIT_MASK_NUM_C_HASH) << TSN_SBL_BIT_START_NUM_C_HASH; // máscara de 3 bits en pos 5
m_ctx.m_cinta[m_idx] = (m_ctx.m_cinta[m_idx] & ~mask) | (c << TSN_SBL_BIT_START_NUM_C_HASH);
}
//--- Linear probing.. de siempre...
int cur = m_idx + TCtx::s_slots_size_arrobj;
while(cur < m_end)
{
if(int(m_ctx.m_cinta[cur] & TSN_SBL_BIT_MASK_TYPE) != TSN_SBL_BASE_TYPE_KEY)
{
cur += m_ctx.GetStep(cur);
continue;
}
if(m_ctx.KeysEqual(hash_fnv1a_64, cur))
{
const int val_pos = cur + 1;
return TOut(m_ctx, val_pos, val_pos + m_ctx.GetStep(val_pos));
}
//---
cur++; // salta KEY
cur += m_ctx.GetStep(cur); // salta VAL
}
return TOut::EMPTY_NODE;
}
//--- m_node_pos ya viene resuelto desde el constructor
int val_pos = m_ctx.PerfectHashAcces(hash_fnv1a_64, m_node_pos);
if(val_pos == -1)
{
return TOut::EMPTY_NODE;
}
else
{
val_pos++; // Luego de key
return TOut(m_ctx, val_pos, val_pos + m_ctx.GetStep(val_pos));
}
}
//+------------------------------------------------------------------+
//| AtHomegeneo — acceso por indice en ARR con step fijo |
//+------------------------------------------------------------------+
template <typename TCtx, typename TType, typename TOut>
TOut CNodeSFLBase::AtHomegeneo(const int index) const
{
//---
if(NODEBASE_IS_NOT_VALID_F || int(m_ctx.m_cinta[m_idx] & TSN_SBL_BIT_MASK_TYPE) != TSN_SBL_BASE_TYPE_ARR)
return TOut::EMPTY_NODE;
//---
const int first = m_idx + TCtx::s_slots_size_arrobj;
const int step = m_ctx.GetStep(first);
const int cur = first + index * step;
return TOut(m_ctx, cur, cur + step);
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
template <typename TCtx, typename TType, typename TOut>
TOut CNodeSFLBase::AtObj(const int index) const
{
//---
if(NODEBASE_IS_NOT_VALID_F || int(m_ctx.m_cinta[m_idx] & TSN_SBL_BIT_MASK_TYPE) != TSN_SBL_BASE_TYPE_OBJ)
return TOut::EMPTY_NODE;
//---
int cur = 0;
if(((m_ctx.m_cinta[m_idx] >> TSN_SBL_BIT_START_IS_HASING)&TSN_SBL_BIT_MASK_IS_HASHSING) != 0)
{
cur = m_ctx.m_tables[m_node_pos].pos_arr[index] + 1;// Ahora mismo apunta a key saltos al valor..
}
else
{
cur = m_idx + TCtx::s_slots_size_arrobj;
// Ahora mismo apunta a key..
for(int k = 0; k < index; k++)
{
cur++; // Salta key
cur += m_ctx.GetStep(cur);
}
}
//---
return TOut(m_ctx, cur, cur + m_ctx.GetStep(cur));
}
//+------------------------------------------------------------------+
//| At — acceso por indice en ARR |
//+------------------------------------------------------------------+
template <typename TCtx, typename TType, typename TOut>
TOut CNodeSFLBase::At(const int index) const
{
//---
if(NODEBASE_IS_NOT_VALID_F || int(m_ctx.m_cinta[m_idx] & TSN_SBL_BIT_MASK_TYPE) != TSN_SBL_BASE_TYPE_ARR)
return TOut::EMPTY_NODE;
//---
int cur = m_idx + TCtx::s_slots_size_arrobj;
for(int k = 0; k < index; k++)
cur += m_ctx.GetStep(cur);
//---
return TOut(m_ctx, cur, cur + m_ctx.GetStep(cur));
}
//+------------------------------------------------------------------+
//| AtObjKey — key string del par en posicion index dentro de OBJ |
//+------------------------------------------------------------------+
template <typename TCtx, typename TType, typename TOut>
string CNodeSFLBase::AtObjKey(const int index) const
{
//---
if(NODEBASE_IS_NOT_VALID_F || int(m_ctx.m_cinta[m_idx] & TSN_SBL_BIT_MASK_TYPE) != TSN_SBL_BASE_TYPE_OBJ)
return "";
//---
int cur = 0;
if(((m_ctx.m_cinta[m_idx] >> TSN_SBL_BIT_START_IS_HASING)&TSN_SBL_BIT_MASK_IS_HASHSING) != 0)
{
//--- Objeto ya hasheado, m_node_pos ya viene resuelto desde el constructor.
// Usamos pos_arr en vez de recorrer linealmente (esta funcion no fuerza el JIT, solo lo aprovecha).
cur = m_ctx.m_tables[m_node_pos].pos_arr[index];
}
else
{
cur = m_idx + TCtx::s_slots_size_arrobj;
for(int k = 0; k < index; k++)
{
cur++; // salta KEY (1 pos)
cur += m_ctx.GetStep(cur); // salta VAL
}
}
//--- TSN_SBL_BIT_STR_MASK_LEN
// KEY ocupa 1 pos: [tipo(4)|len(28low)|start(32high)] (igual que STRING)
const int start = int(m_ctx.m_cinta[cur] >> TSN_SBL_BIT_STR_START);
const int slen = int((m_ctx.m_cinta[cur] >> TSN_SBL_BIT_STR_LEN) & TSN_SBL_BIT_STR_MASK_LEN);
return CharArrayToString(m_ctx.m_raw, start, slen);
}
//+------------------------------------------------------------------+
//| AtObjKeyHomogeneo — igual pero asume step fijo del VAL |
//+------------------------------------------------------------------+
template <typename TCtx, typename TType, typename TOut>
string CNodeSFLBase::AtObjKeyHomogeneo(const int index) const
{
//---
if(NODEBASE_IS_NOT_VALID_F || int(m_ctx.m_cinta[m_idx] & TSN_SBL_BIT_MASK_TYPE) != TSN_SBL_BASE_TYPE_OBJ)
return "";
//--- step fijo = 1(KEY) + step(primer VAL)
const int first_val = m_idx + TCtx::s_slots_size_arrobj + 1;
const int val_step = m_ctx.GetStep(first_val);
const int pair_step = 1 + val_step; // key+val
const int key_pos = (m_idx + TCtx::s_slots_size_arrobj) + index * pair_step;
//--- KEY ocupa 1 pos: [tipo(4)|len(28low)|start(32high)] (igual que STRING)
const int start = int(m_ctx.m_cinta[key_pos] >> TSN_SBL_BIT_STR_START);
const int slen = int((m_ctx.m_cinta[key_pos] >> TSN_SBL_BIT_STR_LEN) & TSN_SBL_BIT_STR_MASK_LEN);
return CharArrayToString(m_ctx.m_raw, start, slen);
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
template <typename TCtx, typename TType, typename TOut>
int CNodeSFLBase::KeyToPosition(const string &key) const
{
//---
if(NODEBASE_IS_NOT_VALID_F || int(m_ctx.m_cinta[m_idx] & TSN_SBL_BIT_MASK_TYPE) != TSN_SBL_BASE_TYPE_OBJ)
return -1;
//---
if(((m_ctx.m_cinta[m_idx] >> TSN_SBL_BIT_START_IS_HASING)&TSN_SBL_BIT_MASK_IS_HASHSING) != 0)
{
//--- Ya hasheado, m_node_pos ya viene resuelto desde el constructor
return m_ctx.PerfectHashComputeHashIndex(key, m_node_pos);
}
else
{
int cur = m_idx + TCtx::s_slots_size_arrobj;
int k = 0;
while(cur < m_end)
{
if(int(m_ctx.m_cinta[cur] & TSN_SBL_BIT_MASK_TYPE) != TSN_SBL_BASE_TYPE_KEY)
{
cur += m_ctx.GetStep(cur);
continue;
}
if(m_ctx.KeysEqual(key, cur))
return k;
//---
cur++; // salta KEY
cur += m_ctx.GetStep(cur); // salta VAL
k++;
}
return -1;
}
}
//+------------------------------------------------------------------+
//| GetKeys — vacia todas las keys del objeto a un array de strings |
//+------------------------------------------------------------------+
template <typename TCtx, typename TType, typename TOut>
int CNodeSFLBase::GetKeys(string &out[]) const
{
//---
if(NODEBASE_IS_NOT_VALID_F || int(m_ctx.m_cinta[m_idx] & TSN_SBL_BIT_MASK_TYPE) != TSN_SBL_BASE_TYPE_OBJ)
return 0;
//---
if(((m_ctx.m_cinta[m_idx] >> TSN_SBL_BIT_START_IS_HASING)&TSN_SBL_BIT_MASK_IS_HASHSING) != 0)
{
//--- Ya hasheado, m_node_pos ya viene resuelto desde el constructor
const int count = m_ctx.m_tables[m_node_pos].table_size;
ArrayResize(out, count);
for(int i = 0; i < count; i++)
{
const int cur = m_ctx.m_tables[m_node_pos].pos_arr[i];
const int start = int(m_ctx.m_cinta[cur] >> TSN_SBL_BIT_STR_START);
const int slen = int((m_ctx.m_cinta[cur] >> TSN_SBL_BIT_STR_LEN) & TSN_SBL_BIT_STR_MASK_LEN);
out[i] = CharArrayToString(m_ctx.m_raw, start, slen);
}
return count;
}
else
{
//---
const int count = int((m_ctx.m_cinta[m_idx] >> TSN_SBL_BIT_START_NUM_EL) & TSN_SBL_BIT_MASK_NUM_EL);
ArrayResize(out, count);
//---
int i = 0;
int cur = m_idx + TCtx::s_slots_size_arrobj;
while(cur < m_end)
{
const int start = int(m_ctx.m_cinta[cur] >> TSN_SBL_BIT_STR_START);
const int slen = int((m_ctx.m_cinta[cur] >> TSN_SBL_BIT_STR_LEN) & TSN_SBL_BIT_STR_MASK_LEN);
out[i++] = CharArrayToString(m_ctx.m_raw, start, slen);
//---
cur++; // salta KEY
cur += m_ctx.GetStep(cur); // salta VAL
}
//---
return count;
}
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
template <typename TCtx, typename TType, typename TOut>
bool CNodeSFLBase::HasKey(const string &key) const
{
//---
if(NODEBASE_IS_NOT_VALID_F || int(m_ctx.m_cinta[m_idx] & TSN_SBL_BIT_MASK_TYPE) != TSN_SBL_BASE_TYPE_OBJ)
return false;
//--- Iterar pares KEY+VAL
if(((m_ctx.m_cinta[m_idx] >> TSN_SBL_BIT_START_IS_HASING)&TSN_SBL_BIT_MASK_IS_HASHSING) == 0)
{
//--- Linear probing.. de siempre...
int cur = m_idx + TCtx::s_slots_size_arrobj;
while(cur < m_end)
{
if(int(m_ctx.m_cinta[cur] & TSN_SBL_BIT_MASK_TYPE) != TSN_SBL_BASE_TYPE_KEY)
{
cur += m_ctx.GetStep(cur);
continue;
}
if(m_ctx.KeysEqual(key, cur))
{
return true;
}
//---
cur++; // salta KEY
cur += m_ctx.GetStep(cur); // salta VAL
}
return false;
}
//---
return m_ctx.PerfectHashComputeHash(key, m_node_pos) != -1;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
template <typename TCtx, typename TType, typename TOut>
bool CNodeSFLBase::ToDom(CDomNodeBase* root, CDomNodeManager* manager)
{
//---
if(NODEBASE_IS_NOT_VALID_F || ((1 << int(m_ctx.m_cinta[m_idx] & TSN_SBL_BIT_MASK_TYPE)) &
(TSN_SBL_BASE_F_OBJ | TSN_SBL_BASE_F_ARR)) == 0)
return false;
m_ctx.SerializeToDom(root, manager, m_idx, m_end);
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+}
template <typename TCtx, typename TType, typename TOut>
bool CNodeSFLBase::NodeHashing(void)
{
//---
if(NODEBASE_IS_NOT_VALID_F || (m_ctx.m_cinta[m_idx] & TSN_SBL_BIT_MASK_TYPE) != TSN_SBL_BASE_TYPE_OBJ)
return false;
//---
if(m_ctx.NodeHashing(m_idx, int((m_ctx.m_cinta[m_idx] >> TSN_SBL_BIT_START_NUM_EL) & TSN_SBL_BIT_MASK_NUM_EL),
m_end, m_node_pos))
{
m_ctx.m_cinta[m_idx] = m_ctx.m_cinta[m_idx] | (long(1) << TSN_SBL_BIT_START_IS_HASING);
return true;
}
else
{
return false;
}
}
//+------------------------------------------------------------------+
//| Jit instrocpeccion |
//+------------------------------------------------------------------+
template <typename TCtx, typename TType, typename TOut>
__forceinline bool CNodeSFLBase::ObjectIsJit(void) const
{
return NODEBASE_IS_NOT_VALID_F || ((m_ctx.m_cinta[m_idx] & TSN_SBL_BIT_MASK_TYPE) != TSN_SBL_BASE_TYPE_OBJ) ? false
: ((m_ctx.m_cinta[m_idx] >> TSN_SBL_BIT_START_IS_HASING) & TSN_SBL_BIT_MASK_IS_HASHSING) != 0;
}
//+------------------------------------------------------------------+
template <typename TCtx, typename TType, typename TOut>
__forceinline int CNodeSFLBase::ObjectAttempCount(void) const
{
return NODEBASE_IS_NOT_VALID_F || ((m_ctx.m_cinta[m_idx] & TSN_SBL_BIT_MASK_TYPE) != TSN_SBL_BASE_TYPE_OBJ) ? 0
: int(m_ctx.m_cinta[m_idx] >> TSN_SBL_BIT_START_NUM_C_HASH) & TSN_SBL_BIT_MASK_NUM_C_HASH;
}
//+------------------------------------------------------------------+
//| Size |
//+------------------------------------------------------------------+
template <typename TCtx, typename TType, typename TOut>
int CNodeSFLBase::Size() const
{
//---
if(NODEBASE_IS_NOT_VALID_F || ((1 << int(m_ctx.m_cinta[m_idx] & TSN_SBL_BIT_MASK_TYPE)) & (TSN_SBL_BASE_F_OBJ | TSN_SBL_BASE_F_ARR)) == 0)
return 0;
//---
return int((m_ctx.m_cinta[m_idx] >> TSN_SBL_BIT_START_NUM_EL) & TSN_SBL_BIT_MASK_NUM_EL);
}
//+------------------------------------------------------------------+
template <typename TCtx, typename TType, typename TOut>
__forceinline bool CNodeSFLBase::InRange(const int index) const
{
const int t = int((m_ctx.m_cinta[m_idx] >> TSN_SBL_BIT_START_NUM_EL) & TSN_SBL_BIT_MASK_NUM_EL);
return index >= 0 && index < t;
}
//+------------------------------------------------------------------+
template <typename TCtx, typename TType, typename TOut>
bool CNodeSFLBase::InRangeSafe(const int index) const
{
//---
if(NODEBASE_IS_NOT_VALID_F || ((1 << int(m_ctx.m_cinta[m_idx] & TSN_SBL_BIT_MASK_TYPE)) & (TSN_SBL_BASE_F_OBJ | TSN_SBL_BASE_F_ARR)) == 0)
return false;
//---
const int t = int((m_ctx.m_cinta[m_idx] >> TSN_SBL_BIT_START_NUM_EL) & TSN_SBL_BIT_MASK_NUM_EL);
return index >= 0 && index < t;
}
//+------------------------------------------------------------------+
//| ToBool |
//+------------------------------------------------------------------+
template <typename TCtx, typename TType, typename TOut>
bool CNodeSFLBase::ToBool(const bool def) const
{
//---
if(NODEBASE_IS_NOT_VALID_F)
return def;
//---
switch(int(m_ctx.m_cinta[m_idx] & TSN_SBL_BIT_MASK_TYPE))
{
case TSN_SBL_BASE_TYPE_INT:
{
return m_ctx.m_cinta[m_idx + 1] != 0;
}
case TSN_SBL_BASE_TYPE_FLT:
{
static BitInterpreter un;
return un.double_value != 0.0;
}
case TSN_SBL_BASE_TYPE_BOL:
return ((m_ctx.m_cinta[m_idx] >> TSN_SBL_BIT_START_BOOL) & 1) != 0;
}
//---
return def;
}
//+------------------------------------------------------------------+
template <typename TCtx, typename TType, typename TOut>
bool CNodeSFLBase::ToBoolSafe(bool & val) const
{
//---
if(NODEBASE_IS_NOT_VALID_F)
return false;
//---
switch(int(m_ctx.m_cinta[m_idx] & TSN_SBL_BIT_MASK_TYPE))
{
case TSN_SBL_BASE_TYPE_INT:
{
val = m_ctx.m_cinta[m_idx + 1] != 0;
return true;
}
case TSN_SBL_BASE_TYPE_FLT:
{
static BitInterpreter un;
val = un.double_value != 0.0;
return true;
}
case TSN_SBL_BASE_TYPE_BOL:
val = ((m_ctx.m_cinta[m_idx] >> TSN_SBL_BIT_START_BOOL) & 1) != 0;
return true;
}
return false;
}
//+------------------------------------------------------------------+
//| Is |
//+------------------------------------------------------------------+
template <typename TCtx, typename TType, typename TOut>
__forceinline bool CNodeSFLBase::IsValid() const { return m_ctx != NULL && m_idx >= 0 && m_end >= 0; }
template <typename TCtx, typename TType, typename TOut>
__forceinline bool CNodeSFLBase::IsInvalid() const { return NODEBASE_IS_NOT_VALID_FULL; }
//+------------------------------------------------------------------+
template <typename TCtx, typename TType, typename TOut>
__forceinline bool CNodeSFLBase::IsArray() const
{
return NODEBASE_IS_VALID && int(m_ctx.m_cinta[m_idx] & TSN_SBL_BIT_MASK_TYPE) == TSN_SBL_BASE_TYPE_ARR;
}
//+------------------------------------------------------------------+
template <typename TCtx, typename TType, typename TOut>
__forceinline bool CNodeSFLBase::IsObject() const
{
return NODEBASE_IS_VALID && int(m_ctx.m_cinta[m_idx] & TSN_SBL_BIT_MASK_TYPE) == TSN_SBL_BASE_TYPE_OBJ;
}
//+------------------------------------------------------------------+
template <typename TCtx, typename TType, typename TOut>
__forceinline bool CNodeSFLBase::IsValidDataType(void) const
{
return NODEBASE_IS_VALID && TCtx::s_dtype_is_valid[uchar(m_ctx.m_cinta[m_idx] & TSN_SBL_BIT_MASK_TYPE)];
}
//+------------------------------------------------------------------+
//| Navegacion raw |
//+------------------------------------------------------------------+
template <typename TCtx, typename TType, typename TOut>
bool CNodeSFLBase::MoveToNextToken(const bool solo_en_el_bloque_actual = true)
{
//---
if(NODEBASE_IS_NOT_VALID_F)
return false;
//---
const int next_pos = m_idx + m_ctx.GetStep(m_idx);
const int final_pos = next_pos + m_ctx.GetStep(next_pos);
//---
if(next_pos >= (solo_en_el_bloque_actual ? m_end : m_ctx.m_cinta_pos))
return false;
//---
m_idx = next_pos;
m_end = final_pos;
//---
NODEBASEF_RES
//---
return true;
}
//+------------------------------------------------------------------+
template <typename TCtx, typename TType, typename TOut>
bool CNodeSFLBase::MoveNextPositionsThis(const int posiciones, const bool solo_en_el_bloque_actual = true)
{
//---
if(NODEBASE_IS_NOT_VALID_F)
return false;
//---
const int next_pos = m_idx + posiciones;
const int final_pos = solo_en_el_bloque_actual ? m_end : next_pos + m_ctx.GetStep(next_pos);
//---
if(next_pos >= (solo_en_el_bloque_actual ? m_end : m_ctx.m_cinta_pos))
return false;
//---
m_idx = next_pos;
m_end = final_pos;
//---
NODEBASEF_RES
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
template <typename TCtx, typename TType, typename TOut>
template <typename T>
bool CNodeSFLBase::ExistInArrayHomogeneo(const T val) const
{
//---
if(NODEBASE_IS_NOT_VALID_F || int(m_ctx.m_cinta[m_idx] & TSN_SBL_BIT_MASK_TYPE) != TSN_SBL_BASE_TYPE_ARR)
return false;
//---
int cur = m_idx + TCtx::s_slots_size_arrobj;
//---
switch(int(m_ctx.m_cinta[cur] & TSN_SBL_BIT_MASK_TYPE))
{
case TSN_SBL_BASE_TYPE_INT:
{
while(cur < m_end)
{
if(val == T(m_ctx.m_cinta[cur + 1]))
return true;
cur += 2;
}
return false;
}
case TSN_SBL_BASE_TYPE_FLT:
{
while(cur < m_end)
{
static BitInterpreter bit;
bit.long_value = m_ctx.m_cinta[cur + 1];
if(val == T(bit.double_value))
return true;
//---
cur += 2;
}
return false;
}
case TSN_SBL_BASE_TYPE_BOL:
{
while(cur < m_end)
{
if(val == T((m_ctx.m_cinta[cur] >> TSN_SBL_BIT_START_ENDTYPE) & 1))
return true;
cur++;
}
return false;
}
}
//---
return false;
}
//+------------------------------------------------------------------+
//| Navegacion raw |
//+------------------------------------------------------------------+
template <typename TCtx, typename TType, typename TOut>
TOut CNodeSFLBase::MoveNextPositions(const int posiciones, const bool solo_en_el_bloque_actual = true)
{
//---
if(NODEBASE_IS_NOT_VALID_F)
return TOut::EMPTY_NODE;
//---
const int next_pos = m_idx + posiciones;
const int final_pos = solo_en_el_bloque_actual ? m_end : next_pos + m_ctx.GetStep(next_pos);
//---
if(next_pos >= (solo_en_el_bloque_actual ? m_end : m_ctx.m_cinta_pos))
return TOut::EMPTY_NODE;
//---
// llamamos a la version con 3 (nodepos se calcula ahi mismo)
return TOut(m_ctx, next_pos, final_pos);
}
//+------------------------------------------------------------------+
//| Iterador de arrays fast |
//+------------------------------------------------------------------+
template <typename TCtx, typename TOut>
struct CNodeBaseIteradorArrayFast
{
TCtx* const m_ctx;
int m_cur;
const int m_end;
const int m_step;
//---
CNodeBaseIteradorArrayFast(TCtx* ctx, const int cur, const int end, const int step)
: m_ctx(ctx), m_cur(cur), m_end(end), m_step(step) {}
//---
CNodeBaseIteradorArrayFast()
: m_ctx(NULL), m_cur(0), m_end(0), m_step(0) {}
//---
__forceinline bool IsValid() { return m_cur < m_end; }
__forceinline void Kill() { m_cur = m_end; }
//---
void Next()
{
if(m_cur >= m_end)
return;
m_cur += m_step;
}
//---
TOut Val()
{
if(m_cur >= m_end)
return TOut::EMPTY_NODE;
const int fin = m_cur + m_step;
return TOut(m_ctx, m_cur, fin);
}
static const CNodeBaseIteradorArrayFast EMPTY_ITERATOR_ARR_FAST;
};
template <typename TCtx, typename TOut>
const CNodeBaseIteradorArrayFast<TCtx, TOut> CNodeBaseIteradorArrayFast::EMPTY_ITERATOR_ARR_FAST;
//+------------------------------------------------------------------+
//| Iterador de arrays |
//+------------------------------------------------------------------+
template <typename TCtx, typename TOut>
struct CNodeBaseIteradorArray
{
TCtx* const m_ctx;
int m_cur;
const int m_end;
//---
CNodeBaseIteradorArray(TCtx* ctx, const int cur, const int end)
: m_ctx(ctx), m_cur(cur), m_end(end) {}
//---
CNodeBaseIteradorArray()
: m_ctx(NULL), m_cur(0), m_end(0) {}
//---
__forceinline bool IsValid() { return m_cur < m_end; }
__forceinline void Kill() { m_cur = m_end; }
//---
void Next()
{
if(m_cur >= m_end)
return;
m_cur += m_ctx.GetStep(m_cur);
}
//---
TOut Val()
{
if(m_cur >= m_end)
return TOut::EMPTY_NODE;
const int fin = m_cur + m_ctx.GetStep(m_cur);
return TOut(m_ctx, m_cur, fin);
}
static const CNodeBaseIteradorArray EMPTY_ITERATOR_ARR;
};
template <typename TCtx, typename TOut>
const CNodeBaseIteradorArray<TCtx, TOut> CNodeBaseIteradorArray::EMPTY_ITERATOR_ARR;
//+------------------------------------------------------------------+
//| Iterador de objetos |
//+------------------------------------------------------------------+
template <typename TCtx, typename TOut>
struct CNodeBaseIteratorObj
{
TCtx* const m_ctx;
int m_cur;
const int m_end;
//---
CNodeBaseIteratorObj(TCtx* ctx, const int cur, const int end)
: m_ctx(ctx), m_cur(cur), m_end(end) {}
//---
CNodeBaseIteratorObj()
: m_ctx(NULL), m_cur(0), m_end(0) {}
//---
__forceinline bool IsValid() { return m_cur < m_end; }
__forceinline void Kill() { m_cur = m_end; }
//---
void Next()
{
if(m_cur >= m_end)
return;
m_cur++; // salta KEY (2 pos)
m_cur += m_ctx.GetStep(m_cur); // salta VAL
}
//---
string Key()
{
if(m_cur >= m_end)
return "";
//--- KEY ocupa 1 pos: [tipo(4)|len(28low)|start(32high)] (igual que STRING)
const int s = int(m_ctx.m_cinta[m_cur] >> TSN_SBL_BIT_STR_START);
const int slen = int((m_ctx.m_cinta[m_cur] >> TSN_SBL_BIT_STR_LEN) & TSN_SBL_BIT_STR_MASK_LEN);
return CharArrayToString(m_ctx.m_raw, s, slen);
}
//---
TOut Val()
{
if(m_cur >= m_end)
return TOut::EMPTY_NODE;
const int pos = m_cur + 1;
const int fin = pos + m_ctx.GetStep(pos);
return TOut(m_ctx, pos, fin);
}
static const CNodeBaseIteratorObj EMPTY_ITERATOR_OBJ;
};
template <typename TCtx, typename TOut>
const CNodeBaseIteratorObj<TCtx, TOut> CNodeBaseIteratorObj::EMPTY_ITERATOR_OBJ;
//+------------------------------------------------------------------+
//| BeginArr / BeginObj |
//+------------------------------------------------------------------+
template <typename TCtx, typename TType, typename TOut>
CNodeBaseIteradorArray<TCtx, TOut> CNodeSFLBase::BeginArr() const
{
if(int(m_ctx.m_cinta[m_idx] & TSN_SBL_BIT_MASK_TYPE) != TSN_SBL_BASE_TYPE_ARR)
return CNodeBaseIteradorArray<TCtx, TOut>::EMPTY_ITERATOR_ARR;
return CNodeBaseIteradorArray<TCtx, TOut>(m_ctx, m_idx + TCtx::s_slots_size_arrobj, m_end);
}
//+------------------------------------------------------------------+
template <typename TCtx, typename TType, typename TOut>
CNodeBaseIteradorArrayFast<TCtx, TOut> CNodeSFLBase::BeginArrHomogeneo() const
{
if(int(m_ctx.m_cinta[m_idx] & TSN_SBL_BIT_MASK_TYPE) != TSN_SBL_BASE_TYPE_ARR)
return CNodeBaseIteradorArrayFast<TCtx, TOut>::EMPTY_ITERATOR_ARR_FAST;
const int s = m_idx + TCtx::s_slots_size_arrobj;
return CNodeBaseIteradorArrayFast<TCtx, TOut>(m_ctx, s, m_end, m_ctx.GetStep(s));
}
//+------------------------------------------------------------------+
template <typename TCtx, typename TType, typename TOut>
CNodeBaseIteratorObj<TCtx, TOut> CNodeSFLBase::BeginObj() const
{
if(int(m_ctx.m_cinta[m_idx] & TSN_SBL_BIT_MASK_TYPE) != TSN_SBL_BASE_TYPE_OBJ)
return CNodeBaseIteratorObj<TCtx, TOut>::EMPTY_ITERATOR_OBJ;
return CNodeBaseIteratorObj<TCtx, TOut>(m_ctx, m_idx + TCtx::s_slots_size_arrobj, m_end);
}
}
//+------------------------------------------------------------------+
#endif // BASESPARSERSLAN_SRC_NODEBASE_MQH
View git blame Copy permalink