| //+------------------------------------------------------------------+
|
| //| JsonNode.mqh |
|
| //| Copyright 2026, Niquel Mendoza. |
|
| //| https://www.mql5.com/ |
|
| //+------------------------------------------------------------------+
|
| #property copyright "Copyright 2026, Niquel Mendoza."
|
| #property link "https://www.mql5.com/"
|
| #property strict
|
|
|
| #ifndef JSONPARSERBYLEO_SRC_JSONNODE_MQH
|
| #define JSONPARSERBYLEO_SRC_JSONNODE_MQH
|
|
|
| //+------------------------------------------------------------------+
|
| //| |
|
| //+------------------------------------------------------------------+
|
| #include "JsonAsm.mqh"
|
| #include "JsonDomSerializer.mqh"
|
|
|
| //---
|
| #include <TSN\\MQLArticles\\Utils\\EnumReg.mqh>
|
|
|
| //+------------------------------------------------------------------+
|
| //| |
|
| //+------------------------------------------------------------------+
|
| namespace TSN
|
| {
|
| // Layour de los demas en repo base
|
| // Layout cinta:
|
| // NULL 1 pos [tipo(4)]
|
|
|
| //+------------------------------------------------------------------+
|
| //| |
|
| //+------------------------------------------------------------------+
|
| #define CJsonIteratorArray TSN::CNodeBaseIteradorArray<TSN::CJsonParser, TSN::CJsonNode>
|
| #define CJsonIteratorArrayFast TSN::CNodeBaseIteradorArrayFast<TSN::CJsonParser, TSN::CJsonNode>
|
| #define CJsonIteratorObj TSN::CNodeBaseIteratorObj<TSN::CJsonParser, TSN::CJsonNode>
|
|
|
| //+------------------------------------------------------------------+
|
| //| |
|
| //+------------------------------------------------------------------+
|
| struct CJsonNode : CNodeSFLBase<CJsonParser, ENUM_JSON_VTYPE, CJsonNode>
|
| {
|
| public:
|
| //---
|
| CJsonNode()
|
| : CNodeSFLBase<CJsonParser, ENUM_JSON_VTYPE, CJsonNode>(NULL, -1, -1, -1) {}
|
| //--- Resuelve m_node_pos una unica vez aqui (igual que YML_NODE_RPOS en YAML)
|
| CJsonNode(CJsonParser* _ctx, const int _idx, const int _end)
|
| : CNodeSFLBase<CJsonParser, ENUM_JSON_VTYPE, CJsonNode>(_ctx, _idx, _end, NODEBASEF_RES_BASE(_ctx, _idx)) {}
|
|
|
| CJsonNode(CJsonParser* _ctx, const int _idx)
|
| : CNodeSFLBase<CJsonParser, ENUM_JSON_VTYPE, CJsonNode>(_ctx, _idx, _idx + _ctx.GetStep(_idx), NODEBASEF_RES_BASE(_ctx, _idx)) {}
|
|
|
| // Exclusivo de copia (Aqui NO RESUELVE NADA NI GET STE NI NADA) (constructor de clonacion)
|
| CJsonNode(CJsonParser* _ctx, const int _idx, const int _end, const int _node_pos)
|
| : CNodeSFLBase<CJsonParser, ENUM_JSON_VTYPE, CJsonNode>(_ctx, _idx, _end, _node_pos) {}
|
|
|
|
|
| //--- Acceso
|
| CJsonNode operator[](const string& key);
|
| //CJsonNode At(const int index) const;
|
|
|
|
|
| //--- Array
|
| template <typename T>
|
| int ToArray(T& out_arr[]) const;
|
| // Exist?
|
| template <typename T>
|
| bool ExistInArray(const uint flags, const T val) const;
|
| bool ExistInArrayStr(const string& val) const;
|
|
|
| //--- String
|
| string ToString(const string def = "") const;
|
| int ToStringUArray(uchar& data[]) const;
|
| string ToStringNoEscape(const string def = "") const;
|
| int ToStringUArrayNoEscape(uchar& data[]) const;
|
| int StrLenRaw() const;
|
| __forceinline bool CompareStrWith(const string& str) const; // Compara sin pagar el costo de copias.. directo al buffer.
|
|
|
| //-- to bytes (asume hex string)
|
| int HexToBytes(uchar& buf[]) const;
|
|
|
| // Interpolacion
|
| template <typename TInterpolate>
|
| string Interpolate(const TInterpolate& cs, const string def) const;
|
|
|
| //---
|
| string ComplexToString(bool clean) const;
|
| int ComplexToData(uchar& data[], bool clean, int dst_start = 0, bool ajustar_arr = true) const;
|
|
|
| //--- Int
|
| long ToInt(const long def) const;
|
| bool ToIntSafe(long& val) const;
|
|
|
| //--- Double
|
| double ToDouble(const double def) const;
|
| bool ToDoubleSafe(double& val) const;
|
|
|
| //--- MqlParam
|
| bool ToMqlParam(MqlParam& param, const string stype) const;
|
| bool ToMqlParam(MqlParam& param, const ENUM_DATATYPE type) const;
|
|
|
|
|
| //--- Is
|
| __forceinline bool IsNull() const;
|
|
|
| //--- Navegacion raw
|
| static const CJsonNode EMPTY_NODE;
|
| static void OnMute(CNodeSFLBase<CJsonParser, ENUM_JSON_VTYPE, CJsonNode>& node);
|
| };
|
|
|
| //+------------------------------------------------------------------+
|
| //| |
|
| //+------------------------------------------------------------------+
|
| const CJsonNode CJsonNode::EMPTY_NODE;
|
|
|
| //+------------------------------------------------------------------+
|
| //| |
|
| //+------------------------------------------------------------------+
|
| static void CJsonNode::OnMute(CNodeSFLBase<CJsonParser, ENUM_JSON_VTYPE, CJsonNode> &node)
|
| {
|
| node.RecalcNodePos(); // Posicion...
|
| node.m_end = node.m_idx + node.m_ctx.GetStep(node.m_idx); // Calculamos el fin...
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| To MqlParam |
|
| //+------------------------------------------------------------------+
|
| __forceinline bool CJsonNode::ToMqlParam(MqlParam& param, const string stype) const
|
| {
|
| const ENUM_DATATYPE type = CEnumRegBasis::GetVal<ENUM_DATATYPE>(stype, WRONG_VALUE);
|
| return type == WRONG_VALUE ? false : ToMqlParam(param, type);
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| bool CJsonNode::ToMqlParam(MqlParam& param, const ENUM_DATATYPE type) const
|
| {
|
| //---
|
| // Si no es un tipo de data valido salimos
|
| if(NODEBASE_IS_NOT_VALID_F || !CJsonParser::s_dtype_is_valid[uchar(m_ctx.m_cinta[m_idx] & TSN_SBL_BIT_MASK_TYPE)])
|
| return false;
|
|
|
| //---
|
| param.type = type;
|
|
|
| //---
|
| switch(type)
|
| {
|
| case TYPE_BOOL:
|
| param.integer_value = ToBool(false);
|
| break;
|
| case TYPE_CHAR:
|
| param.integer_value = char(ToInt(0));
|
| break;
|
| case TYPE_UCHAR:
|
| param.integer_value = uchar(ToInt(0));
|
| break;
|
| case TYPE_SHORT:
|
| param.integer_value = short(ToInt(0));
|
| break;
|
| case TYPE_USHORT:
|
| param.integer_value = ushort(ToInt(0));
|
| break;
|
| case TYPE_COLOR:
|
| param.integer_value = long(color(ToString("")));
|
| break;
|
| case TYPE_INT:
|
| param.integer_value = int(ToInt(0));
|
| break;
|
| case TYPE_UINT:
|
| param.integer_value = uint(ToInt(0));
|
| break;
|
| case TYPE_DATETIME:
|
| param.integer_value = long(datetime(ToString("")));
|
| break;
|
| case TYPE_LONG:
|
| case TYPE_ULONG:
|
| param.integer_value = long(ToInt(0));
|
| break;
|
| case TYPE_FLOAT:
|
| param.double_value = float(ToInt(0));
|
| break;
|
| case TYPE_DOUBLE:
|
| param.double_value = double(ToInt(0));
|
| break;
|
| case TYPE_STRING:
|
| param.string_value = ToString("");
|
| break;
|
| default:
|
| param.string_value = ToString("");
|
| break;
|
| }
|
|
|
| //---
|
| return true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| |
|
| //+------------------------------------------------------------------+
|
| string CJsonNode::ComplexToString(bool clean) 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 "";
|
|
|
| //---
|
| const int start = int(m_ctx.m_cinta[m_idx + 1] & 0xFFFFFFFF);
|
| const int end = int(m_ctx.m_cinta[m_idx + 1] >> TSN_JSON_BIT_END_T);
|
| return clean ? m_ctx.CleanNode(start, end) : CharArrayToString(m_ctx.m_raw, start, (end - start) + 1);
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| |
|
| //+------------------------------------------------------------------+
|
| int CJsonNode::ComplexToData(uchar &data[], bool clean, int dst_start = 0, bool ajustar_arr = true) 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;
|
|
|
| //---
|
| const int start = int(m_ctx.m_cinta[m_idx + 1] & 0xFFFFFFFF);
|
| const int end = int(m_ctx.m_cinta[m_idx + 1] >> TSN_JSON_BIT_END_T);
|
| return clean ? m_ctx.CleanNode(start, end, data, dst_start, ajustar_arr) :
|
| ArrayCopy(data, m_ctx.m_raw, dst_start, start, (end - start) + 1);
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| |
|
| //+------------------------------------------------------------------+
|
| CJsonNode CJsonNode::operator[](const string& key)
|
| {
|
| //---
|
| if(NODEBASE_IS_NOT_VALID_F || int(m_ctx.m_cinta[m_idx] & TSN_SBL_BIT_MASK_TYPE) != JSON_VTYPE_OBJ)
|
| return 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.PerfectHashComputeHash(key, m_node_pos);
|
| if(val_pos == -1)
|
| {
|
| return EMPTY_NODE;
|
| }
|
| else
|
| {
|
| val_pos++; // Luego de key
|
| return CJsonNode(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 + 2;
|
| while(cur < m_end)
|
| {
|
| if(int(m_ctx.m_cinta[cur] & TSN_SBL_BIT_MASK_TYPE) != JSON_VTYPE_KEY)
|
| {
|
| cur += m_ctx.GetStep(cur);
|
| continue;
|
| }
|
| if(m_ctx.KeysEqual(key, cur))
|
| {
|
| const int val_pos = cur + 1;
|
| return CJsonNode(m_ctx, val_pos, val_pos + m_ctx.GetStep(val_pos));
|
| }
|
|
|
| //---
|
| cur++; // salta KEY
|
| cur += m_ctx.GetStep(cur); // salta VAL
|
| }
|
| return EMPTY_NODE;
|
| }
|
|
|
| //--- m_node_pos ya viene resuelto desde el constructor
|
| int val_pos = m_ctx.PerfectHashComputeHash(key, m_node_pos);
|
| if(val_pos == -1)
|
| {
|
| return EMPTY_NODE;
|
| }
|
| else
|
| {
|
| val_pos++; // Luego de key
|
| return CJsonNode(m_ctx, val_pos, val_pos + m_ctx.GetStep(val_pos));
|
| }
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| String |
|
| //+------------------------------------------------------------------+
|
| string CJsonNode::ToString(const string def = "") const
|
| {
|
| //---
|
| if(NODEBASE_IS_NOT_VALID_F)
|
| return def;
|
|
|
| //---
|
| switch(int(m_ctx.m_cinta[m_idx] & TSN_SBL_BIT_MASK_TYPE))
|
| {
|
| case JSON_VTYPE_INTEGER:
|
| return string(m_ctx.m_cinta[m_idx + 1]);
|
| case JSON_VTYPE_REAL:
|
| {
|
| TsnBitInterprete un;
|
| un.long_value = m_ctx.m_cinta[m_idx + 1];
|
| return string(un.double_value);
|
| }
|
| case JSON_VTYPE_BOOLEAN:
|
| return ((m_ctx.m_cinta[m_idx] >> TSN_SBL_BIT_START_ENDTYPE) & 1) != 0 ? "true" : "false";
|
| case JSON_VTYPE_STRING:
|
| {
|
| const int start = int(m_ctx.m_cinta[m_idx] >> TSN_SBL_BIT_STR_START);
|
| const int slen = int((m_ctx.m_cinta[m_idx] >> TSN_SBL_BIT_STR_LEN) & TSN_SBL_BIT_STR_MASK_LEN);
|
| return m_ctx.Unescape(start, start + slen - 1);
|
| }
|
| }
|
|
|
| return def;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| template <typename TInterpolate>
|
| string CJsonNode::Interpolate(const TInterpolate& cs, const string def) const
|
| {
|
| //---
|
| if(NODEBASE_IS_NOT_VALID_F || int(m_ctx.m_cinta[m_idx] & TSN_SBL_BIT_MASK_TYPE) != JSON_VTYPE_STRING)
|
| return def;
|
|
|
| //---
|
| const int start = int(m_ctx.m_cinta[m_idx] >> TSN_SBL_BIT_STR_START);
|
| const int slen = int((m_ctx.m_cinta[m_idx] >> TSN_SBL_BIT_STR_LEN) & TSN_SBL_BIT_STR_MASK_LEN);
|
| return cs.Interpolate(m_ctx.m_raw, start, start + slen - 1, def);
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| string CJsonNode::ToStringNoEscape(const string def = "") const
|
| {
|
| //---
|
| if(NODEBASE_IS_NOT_VALID_F || int(m_ctx.m_cinta[m_idx] & TSN_SBL_BIT_MASK_TYPE) != JSON_VTYPE_STRING)
|
| return def;
|
|
|
| //---
|
| const int start = int(m_ctx.m_cinta[m_idx] >> TSN_SBL_BIT_STR_START);
|
| const int slen = int((m_ctx.m_cinta[m_idx] >> TSN_SBL_BIT_STR_LEN) & TSN_SBL_BIT_STR_MASK_LEN);
|
| return CharArrayToString(m_ctx.m_raw, start, slen);
|
|
|
| //---
|
| return def;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| int CJsonNode::ToStringUArray(uchar & data[]) const
|
| {
|
| //---
|
| if(NODEBASE_IS_NOT_VALID_F || int(m_ctx.m_cinta[m_idx] & TSN_SBL_BIT_MASK_TYPE) != JSON_VTYPE_STRING)
|
| return 0;
|
|
|
| //---
|
| const int start = int(m_ctx.m_cinta[m_idx] >> TSN_SBL_BIT_STR_START);
|
| const int slen = int((m_ctx.m_cinta[m_idx] >> TSN_SBL_BIT_STR_LEN) & TSN_SBL_BIT_STR_MASK_LEN);
|
| return m_ctx.Unescape(start, start + slen - 1, data);
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| int CJsonNode::ToStringUArrayNoEscape(uchar &data[]) const
|
| {
|
| //---
|
| if(NODEBASE_IS_NOT_VALID_F || int(m_ctx.m_cinta[m_idx] & TSN_SBL_BIT_MASK_TYPE) != JSON_VTYPE_STRING)
|
| return 0;
|
|
|
| //---
|
| const int start = int(m_ctx.m_cinta[m_idx] >> TSN_SBL_BIT_STR_START);
|
| const int slen = int((m_ctx.m_cinta[m_idx] >> TSN_SBL_BIT_STR_LEN) & TSN_SBL_BIT_STR_MASK_LEN);
|
| return ArrayCopy(data, m_ctx.m_raw, 0, start, slen);
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| int CJsonNode::StrLenRaw(void) const
|
| {
|
| //---
|
| if(NODEBASE_IS_NOT_VALID_F || int(m_ctx.m_cinta[m_idx] & TSN_SBL_BIT_MASK_TYPE) != JSON_VTYPE_STRING)
|
| return 0;
|
|
|
| //---
|
| return int((m_ctx.m_cinta[m_idx] >> TSN_SBL_BIT_STR_LEN) & TSN_SBL_BIT_STR_MASK_LEN);
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| __forceinline bool CJsonNode::CompareStrWith(const string &str) const
|
| {
|
| if(NODEBASE_IS_NOT_VALID_F || int(m_ctx.m_cinta[m_idx] & TSN_SBL_BIT_MASK_TYPE) != JSON_VTYPE_STRING)
|
| return false;
|
| return m_ctx.StrEquals(str, m_idx);
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| int CJsonNode::HexToBytes(uchar &buf[]) const
|
| {
|
| if(NODEBASE_IS_NOT_VALID_F || (m_ctx.m_cinta[m_idx]&TSN_SBL_BIT_MASK_TYPE) != JSON_VTYPE_STRING)
|
| return 0;
|
| // ahora si en value
|
| // tenemos que recortar por la parte alta
|
|
|
| //---
|
| const int start = int(m_ctx.m_cinta[m_idx] >> TSN_SBL_BIT_STR_START);
|
| const int slen = int((m_ctx.m_cinta[m_idx] >> TSN_SBL_BIT_START_ENDTYPE) & TSN_SBL_BIT_STR_MASK_LEN);
|
|
|
| //---
|
| const int sob = slen & 1; // % 2 (vemos si hay sobrante o si es multiplo de dos exacto)
|
| int exact_len = slen - sob;
|
| ArrayResize(buf, (slen >> 1) + (sob << 1));
|
| int w = 0;
|
|
|
| //---
|
| exact_len += start; // para que peuda empzar bien..
|
| int i = start;
|
| //---
|
| for(i; i < exact_len; i += 2)
|
| buf[w++] = g_arr_valid_hex_chars[m_ctx.m_raw[i]] | g_arr_valid_hex_chars[m_ctx.m_raw[i + 1]] << 4;
|
| if(sob) // solo rellenmaso alto (la parte alta la inteprntamos como 0)
|
| buf[w++] = m_ctx.m_raw[i];
|
| //---
|
| return w;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Arrays |
|
| //+------------------------------------------------------------------+
|
| template <typename T>
|
| int CJsonNode::ToArray(T &out_arr[]) const
|
| {
|
| //---
|
| if(NODEBASE_IS_NOT_VALID_F || int(m_ctx.m_cinta[m_idx] & TSN_SBL_BIT_MASK_TYPE) != JSON_VTYPE_ARR)
|
| return 0;
|
|
|
| //---
|
| const int count = int((m_ctx.m_cinta[m_idx] >> TSN_SBL_BIT_START_NUM_EL) & TSN_SBL_BIT_MASK_NUM_EL);
|
| ArrayResize(out_arr, count);
|
|
|
| //---
|
| int cur = m_idx + 2;
|
| int k = 0;
|
|
|
| //---
|
| switch(int(m_ctx.m_cinta[cur] & TSN_SBL_BIT_MASK_TYPE))
|
| {
|
| case JSON_VTYPE_INTEGER:
|
| {
|
| while(cur < m_end)
|
| {
|
| out_arr[k++] = T(m_ctx.m_cinta[cur + 1]);
|
| cur += 2;
|
| }
|
| return count;
|
| }
|
| case JSON_VTYPE_REAL:
|
| {
|
| while(cur < m_end)
|
| {
|
| TsnBitInterprete bit;
|
| bit.long_value = m_ctx.m_cinta[cur + 1];
|
| out_arr[k++] = T(bit.double_value);
|
| cur += 2;
|
| }
|
| return count;
|
| }
|
| case JSON_VTYPE_BOOLEAN:
|
| {
|
| while(cur < m_end)
|
| {
|
| out_arr[k++] = T((m_ctx.m_cinta[cur] >> TSN_SBL_BIT_START_ENDTYPE) & 1);
|
| cur++;
|
| }
|
| return count;
|
| }
|
| case JSON_VTYPE_STRING:
|
| {
|
| 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_arr[k++] = T(m_ctx.Unescape(start, start + slen - 1));
|
| cur++;
|
| }
|
| return count;
|
| }
|
| }
|
|
|
| //---
|
| return 0;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| template <typename T>
|
| bool CJsonNode::ExistInArray(const uint flags, const T val) const
|
| {
|
| //---
|
| if(NODEBASE_IS_NOT_VALID_F || int(m_ctx.m_cinta[m_idx] & TSN_SBL_BIT_MASK_TYPE) != JSON_VTYPE_ARR)
|
| return false;
|
|
|
| //---
|
| int cur = m_idx + 2;
|
| while(cur < m_end)
|
| {
|
| //---
|
| const uint ct = 1U << uint(m_ctx.m_cinta[cur] & TSN_SBL_BIT_MASK_TYPE);
|
| if((ct & flags) == 0)
|
| {
|
| cur += m_ctx.GetStep(cur);
|
| continue;
|
| }
|
|
|
| //---
|
| switch(ct)
|
| {
|
| case JSON_VTYPE_INTEGER:
|
| {
|
| if(m_ctx.m_cinta[cur + 1] == T(val))
|
| return true;
|
| break;
|
| }
|
| case JSON_VTYPE_REAL:
|
| {
|
| bit.long_value = m_ctx.m_cinta[cur + 1];
|
| if(bit.double_value == T(val))
|
| return true;
|
| break;
|
| }
|
| case JSON_VTYPE_BOOLEAN:
|
| {
|
| if(val == T((m_ctx.m_cinta[cur] >> TSN_SBL_BIT_START_ENDTYPE) & 1))
|
| return true;
|
| break;
|
| }
|
| case JSON_VTYPE_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);
|
| if(val == T(m_ctx.Unescape(start, start + slen - 1)))
|
| return true;
|
| break;
|
| }
|
| case JSON_VTYPE_NULL:
|
| {
|
| return true;
|
| }
|
| }
|
|
|
| //---
|
| cur += m_ctx.GetStep(cur);
|
| }
|
|
|
| //---
|
| return false;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| bool CJsonNode::ExistInArrayStr(const string& val) const
|
| {
|
| //---
|
| if(NODEBASE_IS_NOT_VALID_F || int(m_ctx.m_cinta[m_idx] & TSN_SBL_BIT_MASK_TYPE) != JSON_VTYPE_ARR)
|
| return false;
|
|
|
| //---
|
| int cur = m_idx + 2;
|
| while(cur < m_end)
|
| {
|
| //---
|
| const int ct = int(m_ctx.m_cinta[cur] & TSN_SBL_BIT_MASK_TYPE);
|
| if(ct != JSON_VTYPE_STRING)
|
| {
|
| cur += m_ctx.GetStep(cur);
|
| continue;
|
| }
|
|
|
| //---
|
| 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);
|
| if(val == m_ctx.Unescape(start, start + slen - 1))
|
| return true;
|
|
|
| //---
|
| cur += m_ctx.GetStep(cur);
|
| }
|
|
|
| //---
|
| return false;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| ToInt |
|
| //+------------------------------------------------------------------+
|
| long CJsonNode::ToInt(const long 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];
|
| case TSN_SBL_BASE_TYPE_FLT:
|
| {
|
| TsnBitInterprete un;
|
| un.long_value = m_ctx.m_cinta[m_idx + 1];
|
| return long(un.double_value);
|
| }
|
| case TSN_SBL_BASE_TYPE_BOL:
|
| return long((m_ctx.m_cinta[m_idx] >> TSN_SBL_BIT_START_ENDTYPE) & 1);
|
| case TSN_SBL_BASE_TYPE_STR:
|
| {
|
| const int start = int(m_ctx.m_cinta[m_idx] >> TSN_SBL_BIT_STR_START);
|
| const int slen = int((m_ctx.m_cinta[m_idx] >> TSN_SBL_BIT_STR_LEN) & TSN_SBL_BIT_STR_MASK_LEN);
|
| return long(CharArrayToString(m_ctx.m_raw, start, slen));
|
| }
|
| }
|
| return def;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| bool CJsonNode::ToIntSafe(long & 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];
|
| return true;
|
| case TSN_SBL_BASE_TYPE_FLT:
|
| {
|
| TsnBitInterprete un;
|
| un.long_value = m_ctx.m_cinta[m_idx + 1];
|
| val = long(un.double_value);
|
| return true;
|
| }
|
| case TSN_SBL_BASE_TYPE_BOL:
|
| val = long((m_ctx.m_cinta[m_idx] >> TSN_SBL_BIT_START_ENDTYPE) & 1);
|
| return true;
|
| case TSN_SBL_BASE_TYPE_STR:
|
| {
|
| const int start = int(m_ctx.m_cinta[m_idx] >> TSN_SBL_BIT_STR_START);
|
| const int slen = int((m_ctx.m_cinta[m_idx] >> TSN_SBL_BIT_STR_LEN) & TSN_SBL_BIT_STR_MASK_LEN);
|
| val = long(CharArrayToString(m_ctx.m_raw, start, slen));
|
| return true;
|
| }
|
| }
|
|
|
| return false;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| ToDouble |
|
| //+------------------------------------------------------------------+
|
| double CJsonNode::ToDouble(const double 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 double(m_ctx.m_cinta[m_idx + 1]);
|
| case TSN_SBL_BASE_TYPE_FLT:
|
| {
|
| TsnBitInterprete un;
|
| un.long_value = m_ctx.m_cinta[m_idx + 1];
|
| return un.double_value;
|
| }
|
| case TSN_SBL_BASE_TYPE_BOL:
|
| return double((m_ctx.m_cinta[m_idx] >> TSN_SBL_BIT_START_ENDTYPE) & 1);
|
| case TSN_SBL_BASE_TYPE_STR:
|
| {
|
| const int start = int(m_ctx.m_cinta[m_idx] >> TSN_SBL_BIT_STR_START);
|
| const int slen = int((m_ctx.m_cinta[m_idx] >> TSN_SBL_BIT_STR_LEN) & TSN_SBL_BIT_STR_MASK_LEN);
|
| return double(CharArrayToString(m_ctx.m_raw, start, slen));
|
| }
|
| }
|
|
|
| return def;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| bool CJsonNode::ToDoubleSafe(double & 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 = double(m_ctx.m_cinta[m_idx + 1]);
|
| return true;
|
| case TSN_SBL_BASE_TYPE_FLT:
|
| {
|
| TsnBitInterprete un;
|
| un.long_value = m_ctx.m_cinta[m_idx + 1];
|
| val = un.double_value;
|
| return true;
|
| }
|
| case TSN_SBL_BASE_TYPE_BOL:
|
| val = double((m_ctx.m_cinta[m_idx] >> TSN_SBL_BIT_START_ENDTYPE) & 1);
|
| return true;
|
| case TSN_SBL_BASE_TYPE_STR:
|
| {
|
| const int start = int(m_ctx.m_cinta[m_idx] >> TSN_SBL_BIT_STR_START);
|
| const int slen = int((m_ctx.m_cinta[m_idx] >> TSN_SBL_BIT_STR_LEN) & TSN_SBL_BIT_STR_MASK_LEN);
|
| val = double(CharArrayToString(m_ctx.m_raw, start, slen));
|
| return true;
|
| }
|
| }
|
|
|
| return false;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Is |
|
| //+------------------------------------------------------------------+
|
| __forceinline bool CJsonNode::IsNull() const
|
| {
|
| return NODEBASE_IS_VALID && int(m_ctx.m_cinta[m_idx] & TSN_SBL_BIT_MASK_TYPE) == JSON_VTYPE_NULL;
|
| }
|
| }
|
| //+------------------------------------------------------------------+
|
| #endif // JSONPARSERBYLEO_SRC_JSONNODE_MQH
|
