CryptoByLeo/Src/RSPParser/Node.mqh

//+------------------------------------------------------------------+
//|                                                         Node.mqh |
//|                                   Copyright 2026, Niquel Mendoza |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2026, Niquel Mendoza"
#property link      "https://www.mql5.com"
#property strict

#ifndef CRYPTOBYLEO_RSPPARSER_NODE_MQH
#define CRYPTOBYLEO_RSPPARSER_NODE_MQH

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
#include "RSP.mqh"
#include <TSN/MQLArticles/Utils/StructBytesCre.mqh>

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
namespace TSN
{
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
#define RSPDATA_TRIPLET_KEYVALUEMETA (3)
#define RSPDATA_IS_VALID     (m_ctx!=NULL)
#define RSPDATA_IS_NOT_VALID (m_ctx==NULL)
#define RSPDATA_IS_VALID_F   (RSPDATA_IS_VALID && m_idx!=-1)
#define RSPDATA_IS_VAL_TO_REVISE (((m_ctx.m_cinta[m_idx-1] >> RSPDATA_BITSTART_ISVAL_CLEAN) & RSPDATA_MASK_META_IS) == 0)

//--- forward
class CRSPIteradorBase;

template <typename TNumHashes, typename TBaseHash>
class CRSPIteratorHash;

//--- trim right
#define RSPNODE_CORRECT_R_WSPACES \
  if(RSPDATA_IS_VAL_TO_REVISE)\
   {\
    int i = (start + slen) - 1;\
    while(i >= start && m_ctx.m_raw[i] < 33)\
     {\
      i--;\
     }\
    slen = (i - start) + 1;\
    m_ctx.m_cinta[m_idx] =  long(RSPDATA_TYPE_PLAIN_VALUE)\
                    | long(slen) << TSN_SBL_BIT_STR_LEN\
                    | long(start) << TSN_SBL_BIT_STR_START;\
    m_ctx.m_cinta[m_idx - 1] |= RSPDATA_BITSTART_ISVAL_CLEAN_F;\
   }

//---

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
struct CRSPNode
 {
  CRSPParser*        m_ctx;
  int                m_idx;

  //----
                     CRSPNode(const int _idx, CRSPParser* _ctx) : m_idx(_idx), m_ctx(_ctx) {}
                     CRSPNode() : m_idx(-1), m_ctx(NULL)  {}


  //---
  __forceinline int  RootSize() const { return m_ctx.m_root_values; }

  //---
  // Navega en el root
  CRSPNode           operator[](const string& key);
  CRSPNode           At(const int index) const;
  string             AtKey(const int index);

  //---
  bool               HasKey(const string& key);

  //---
  __forceinline ENUM_RSPDATA_TYPE GetType() const { return ENUM_RSPDATA_TYPE(m_ctx.m_cinta[m_idx] & TSN_SBL_BIT_MASK_TYPE);     }
  __forceinline uint GetFlag()  const { return 1 << uint(m_ctx.m_cinta[m_idx] & TSN_SBL_BIT_MASK_TYPE);                         }

  //--- Value
  CRSPNode            Value() const;

  //-- to str
  string             ToString(const string def = "") const;
  int                ToStringUArray(uchar& data[]) const;
  __forceinline int  StrLenRaw() const;
  __forceinline int  StrStart() const;
  __forceinline bool CompareStrWith(const string& str) const;

  //-- to bytes (asume hex string)
  int                HexToBytes(uchar& buf[]) const;

  //--- Is
  __forceinline bool IsValid()   const { return RSPDATA_IS_VALID_F;  }
  __forceinline bool IsInvalid() const { return !RSPDATA_IS_VALID_F; }

  //--- Meta
  __forceinline bool MetaIsCor() const         { return ((m_ctx.m_cinta[m_idx] >> TSN_SBL_BIT_START_ENDTYPE) & RSPDATA_MASK_META_IS) != 0;    }
  __forceinline bool MetaCleanedKey() const    { return ((m_ctx.m_cinta[m_idx] >> RSPDATA_BITSTART_ISKEY_CLEAN) & RSPDATA_MASK_META_IS) != 0; }
  __forceinline bool MetaCleanedValue() const  { return ((m_ctx.m_cinta[m_idx] >> RSPDATA_BITSTART_ISVAL_CLEAN) & RSPDATA_MASK_META_IS) != 0; }

  //---
  template <typename TNumHashes, typename THashBase>
  TSN::CRSPIteratorHash<TNumHashes, THashBase> MakeHashIterator(const string& keys[]) const
   {
    if(RSPDATA_IS_NOT_VALID)
      return CRSPIteratorHash<TNumHashes, THashBase>::EMPTY;
    return CRSPIteratorHash<TNumHashes, THashBase>(keys, m_ctx, m_idx);
   }

  //---
  template <typename THashBase>
  CRSPIteradorBase*  MakeInteligentIterador(const string& keys[]) const;

  //---
  static const CRSPNode    EMPTY_NODE;

  //---
  bool               MoveNextPositionsThis(const int posiciones);
  CRSPNode           MoveNextPositions(const int posiciones) const;

  //---
  static bool        BytesEq(const uchar& a[], const uchar& b[]);
 };

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
const CRSPNode CRSPNode::EMPTY_NODE;

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
CRSPNode CRSPNode::operator[](const string& key)
 {
//---
  if(RSPDATA_IS_NOT_VALID)
    return CRSPNode::EMPTY_NODE;
//---
  int cur = 0;
  while(cur < m_ctx.m_cinta_pos)
   {
    if(m_ctx.KeysEqual(key, cur)) // + 1 para estar en META
      return CRSPNode(cur + 1, m_ctx);
    cur += RSPDATA_TRIPLET_KEYVALUEMETA;
   }
  return CRSPNode::EMPTY_NODE;
 }

//+------------------------------------------------------------------+
bool CRSPNode::HasKey(const string &key)
 {
//---
  if(RSPDATA_IS_NOT_VALID)
    return false;
//---
  int cur = 0;
  while(cur < m_ctx.m_cinta_pos)
   {
    if(m_ctx.KeysEqual(key, cur)) // + 1 para estar en META
      return true;
    cur += RSPDATA_TRIPLET_KEYVALUEMETA;
   }
  return false;
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
CRSPNode CRSPNode::At(const int index) const
 {
//---
  if(RSPDATA_IS_NOT_VALID ||  index < 0 || index >= m_ctx.m_cinta_pos)
    return CRSPNode::EMPTY_NODE;
//--- devuelve META
  return CRSPNode((index * RSPDATA_TRIPLET_KEYVALUEMETA) + 1, m_ctx);
 }
//+------------------------------------------------------------------+
string CRSPNode::AtKey(const int index)
 {
//---
  if(RSPDATA_IS_NOT_VALID ||  index < 0 || index >= m_ctx.m_cinta_pos)
    return "";
//--- devuelve string
  const int base = (index * RSPDATA_TRIPLET_KEYVALUEMETA);
//---
  const int start = int(m_ctx.m_cinta[base] >> TSN_SBL_BIT_STR_START);
  int slen = int((m_ctx.m_cinta[base] >> TSN_SBL_BIT_START_ENDTYPE) & TSN_SBL_BIT_STR_MASK_LEN);
//---
  m_ctx.VerifyCleanKey(base, start, slen);
//---
  return CharArrayToString(m_ctx.m_raw, start, slen);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
CRSPNode CRSPNode::Value(void) const
 {
//---
  if(RSPDATA_IS_NOT_VALID)
    return CRSPNode::EMPTY_NODE;
// si estamos en META  +1 = value
  return CRSPNode(m_idx + 1, m_ctx);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
string CRSPNode::ToString(const string def = "") const
 {
  if(RSPDATA_IS_NOT_VALID || (m_ctx.m_cinta[m_idx]&TSN_SBL_BIT_MASK_TYPE) != RSPDATA_TYPE_PLAIN_VALUE)
    return def;
// ahora si en value
// tenemos que recortar por la parte alta

//---
  const int start = TSN_SBL_CNG_STR_START(m_idx);;
  int slen = TSN_SBL_CNG_STR_LEN(m_idx);
//---
  RSPNODE_CORRECT_R_WSPACES
//---
  return CharArrayToString(m_ctx.m_raw, start, slen);
 }

//+------------------------------------------------------------------+
int CRSPNode::ToStringUArray(uchar &data[]) const
 {
  if(RSPDATA_IS_NOT_VALID || (m_ctx.m_cinta[m_idx]&TSN_SBL_BIT_MASK_TYPE) != RSPDATA_TYPE_PLAIN_VALUE)
    return 0;
// ahora si en value
// tenemos que recortar por la parte alta

//---
  const int start = TSN_SBL_CNG_STR_START(m_idx);;
  int slen = TSN_SBL_CNG_STR_LEN(m_idx);

//---
  RSPNODE_CORRECT_R_WSPACES
//---
  return ArrayCopy(data, m_ctx.m_raw, 0, start, slen);
 }

//+------------------------------------------------------------------+
// interpretna un mensaje multiplo de 2 len como una cadena de bytes LE
// Si no hay caracters NO HEX se intemapn como FF (invalidos) nota eso
// osea que
// "kkkk" da buf[] = {0xff, 0xff}
int CRSPNode::HexToBytes(uchar &buf[]) const
 {
  if(RSPDATA_IS_NOT_VALID || (m_ctx.m_cinta[m_idx]&TSN_SBL_BIT_MASK_TYPE) != RSPDATA_TYPE_PLAIN_VALUE)
    return 0;
// ahora si en value
// tenemos que recortar por la parte alta

//---
  const int start = TSN_SBL_CNG_STR_START(m_idx);;
  int slen = TSN_SBL_CNG_STR_LEN(m_idx);

//---
  RSPNODE_CORRECT_R_WSPACES

//---
  return CHexUtils::HexToBytes(m_ctx.m_raw, start, slen, buf);
 }


//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
__forceinline int CRSPNode::StrLenRaw(void) const
 {
  if(RSPDATA_IS_NOT_VALID || (m_ctx.m_cinta[m_idx]&TSN_SBL_BIT_MASK_TYPE) != RSPDATA_TYPE_PLAIN_VALUE)
    return 0;
  return TSN_SBL_CNG_STR_LEN(m_idx);
 }

//+------------------------------------------------------------------+
__forceinline int CRSPNode::StrStart(void) const
 {
  if(RSPDATA_IS_NOT_VALID || (m_ctx.m_cinta[m_idx]&TSN_SBL_BIT_MASK_TYPE) != RSPDATA_TYPE_PLAIN_VALUE)
    return 0;
  return TSN_SBL_CNG_STR_START(m_idx);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool CRSPNode::MoveNextPositionsThis(const int posiciones)
 {
  if(RSPDATA_IS_NOT_VALID)
    return false;
  const int next_pos = m_idx + posiciones;
  if(next_pos >= m_ctx.m_cinta_pos)
    return false;
  m_idx = next_pos;
  return true;
 }

//+------------------------------------------------------------------+
CRSPNode CRSPNode::MoveNextPositions(const int posiciones) const
 {
  if(RSPDATA_IS_NOT_VALID)
    return CRSPNode::EMPTY_NODE;
  const int next_pos = m_idx + posiciones;
  if(next_pos >= m_ctx.m_cinta_pos)
    return CRSPNode::EMPTY_NODE;
  return CRSPNode(next_pos, m_ctx);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
static bool CRSPNode::BytesEq(const uchar &a[], const uchar &b[])
 {
  const int ta = ArraySize(a);
  if(ta != ArraySize(b))
    return false;
  for(int i = 0; i < ta; i++)
   {
    if(a[i] != b[i])
      return false;
   }
  return true;
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
CRSPNode CRSPParser::GetRoot(void)
 {
  if(m_cinta_pos == 0)
    return CRSPNode::EMPTY_NODE;
  return CRSPNode(0, &this);
 }
}
#endif // CRYPTOBYLEO_RSPPARSER_NODE_MQH