xbmc/utils/JSONVariantParser.cpp

   1 /*
   2  *  Copyright (C) 2005-2018 Team Kodi
   3  *  This file is part of Kodi - https://kodi.tv
   4  *
   5  *  SPDX-License-Identifier: GPL-2.0-or-later
   6  *  See LICENSES/README.md for more information.
   7  */
   8
   9 #include "JSONVariantParser.h"
  10
  11 #include <rapidjson/reader.h>
  12
  13 class CJSONVariantParserHandler
  14 {
  15 public:
  16   explicit CJSONVariantParserHandler(CVariant& parsedObject);
  17
  18   bool Null();
  19   bool Bool(bool b);
  20   bool Int(int i);
  21   bool Uint(unsigned u);
  22   bool Int64(int64_t i);
  23   bool Uint64(uint64_t u);
  24   bool Double(double d);
  25   bool RawNumber(const char* str, rapidjson::SizeType length, bool copy);
  26   bool String(const char* str, rapidjson::SizeType length, bool copy);
  27   bool StartObject();
  28   bool Key(const char* str, rapidjson::SizeType length, bool copy);
  29   bool EndObject(rapidjson::SizeType memberCount);
  30   bool StartArray();
  31   bool EndArray(rapidjson::SizeType elementCount);
  32
  33 private:
  34   template <typename... TArgs>
  35   bool Primitive(TArgs... args)
  36   {
  37     PushObject(CVariant(std::forward<TArgs>(args)...));
  38     PopObject();
  39
  40     return true;
  41   }
  42
  43   void PushObject(CVariant variant);
  44   void PopObject();
  45
  46   CVariant& m_parsedObject;
  47   std::vector<CVariant *> m_parse;
  48   std::string m_key;
  49   CVariant m_root;
  50
  51   enum class PARSE_STATUS
  52   {
  53     Variable,
  54     Array,
  55     Object
  56   };
  57   PARSE_STATUS m_status = PARSE_STATUS::Variable;
  58 };
  59
  60 CJSONVariantParserHandler::CJSONVariantParserHandler(CVariant& parsedObject)
  61   : m_parsedObject(parsedObject), m_parse(), m_key()
  62 { }
  63
  64 bool CJSONVariantParserHandler::Null()
  65 {
  66   PushObject(CVariant::ConstNullVariant);
  67   PopObject();
  68
  69   return true;
  70 }
  71
  72 bool CJSONVariantParserHandler::Bool(bool b)
  73 {
  74   return Primitive(b);
  75 }
  76
  77 bool CJSONVariantParserHandler::Int(int i)
  78 {
  79   return Primitive(i);
  80 }
  81
  82 bool CJSONVariantParserHandler::Uint(unsigned u)
  83 {
  84   return Primitive(u);
  85 }
  86
  87 bool CJSONVariantParserHandler::Int64(int64_t i)
  88 {
  89   return Primitive(i);
  90 }
  91
  92 bool CJSONVariantParserHandler::Uint64(uint64_t u)
  93 {
  94   return Primitive(u);
  95 }
  96
  97 bool CJSONVariantParserHandler::Double(double d)
  98 {
  99   return Primitive(d);
 100 }
 101
 102 bool CJSONVariantParserHandler::RawNumber(const char* str, rapidjson::SizeType length, bool copy)
 103 {
 104   return Primitive(str, length);
 105 }
 106
 107 bool CJSONVariantParserHandler::String(const char* str, rapidjson::SizeType length, bool copy)
 108 {
 109   return Primitive(str, length);
 110 }
 111
 112 bool CJSONVariantParserHandler::StartObject()
 113 {
 114   PushObject(CVariant::VariantTypeObject);
 115
 116   return true;
 117 }
 118
 119 bool CJSONVariantParserHandler::Key(const char* str, rapidjson::SizeType length, bool copy)
 120 {
 121   m_key = std::string(str, 0, length);
 122
 123   return true;
 124 }
 125
 126 bool CJSONVariantParserHandler::EndObject(rapidjson::SizeType memberCount)
 127 {
 128   PopObject();
 129
 130   return true;
 131 }
 132
 133 bool CJSONVariantParserHandler::StartArray()
 134 {
 135   PushObject(CVariant::VariantTypeArray);
 136
 137   return true;
 138 }
 139
 140 bool CJSONVariantParserHandler::EndArray(rapidjson::SizeType elementCount)
 141 {
 142   PopObject();
 143
 144   return true;
 145 }
 146
 147 void CJSONVariantParserHandler::PushObject(CVariant variant)
 148 {
 149   const auto variant_type = variant.type();
 150
 151   if (m_status == PARSE_STATUS::Object)
 152   {
 153     (*m_parse.back())[m_key] = std::move(variant);
 154     m_parse.push_back(&((*m_parse.back())[m_key]));
 155   }
 156   else if (m_status == PARSE_STATUS::Array)
 157   {
 158     CVariant *temp = m_parse[m_parse.size() - 1];
 159     temp->push_back(std::move(variant));
 160     m_parse.push_back(&(*temp)[temp->size() - 1]);
 161   }
 162   else if (m_parse.empty())
 163   {
 164     m_root = std::move(variant);
 165     m_parse.push_back(&m_root);
 166   }
 167
 168   if (variant_type == CVariant::VariantTypeObject)
 169     m_status = PARSE_STATUS::Object;
 170   else if (variant_type == CVariant::VariantTypeArray)
 171     m_status = PARSE_STATUS::Array;
 172   else
 173     m_status = PARSE_STATUS::Variable;
 174 }
 175
 176 void CJSONVariantParserHandler::PopObject()
 177 {
 178   assert(!m_parse.empty());
 179   CVariant* variant = m_parse.back();
 180   m_parse.pop_back();
 181
 182   if (!m_parse.empty())
 183   {
 184     variant = m_parse[m_parse.size() - 1];
 185     if (variant->isObject())
 186       m_status = PARSE_STATUS::Object;
 187     else if (variant->isArray())
 188       m_status = PARSE_STATUS::Array;
 189     else
 190       m_status = PARSE_STATUS::Variable;
 191   }
 192   else
 193   {
 194     m_parsedObject = *variant;
 195     m_status = PARSE_STATUS::Variable;
 196   }
 197 }
 198
 199 bool CJSONVariantParser::Parse(const char* json, CVariant& data)
 200 {
 201   if (json == nullptr)
 202     return false;
 203
 204   rapidjson::Reader reader;
 205   rapidjson::StringStream stringStream(json);
 206
 207   CJSONVariantParserHandler handler(data);
 208   // use kParseIterativeFlag to eliminate possible stack overflow
 209   // from json parsing via reentrant calls
 210   if (reader.Parse<rapidjson::kParseIterativeFlag>(stringStream, handler))
 211     return true;
 212
 213   return false;
 214 }
 215
 216 bool CJSONVariantParser::Parse(const std::string& json, CVariant& data)
 217 {
 218   return Parse(json.c_str(), data);
 219 }