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(const 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;
  58 };
  59
  60 CJSONVariantParserHandler::CJSONVariantParserHandler(CVariant& parsedObject)
  61   : m_parsedObject(parsedObject),
  62     m_parse(),
  63     m_key(),
  64     m_status(PARSE_STATUS::Variable)
  65 { }
  66
  67 bool CJSONVariantParserHandler::Null()
  68 {
  69   PushObject(CVariant::ConstNullVariant);
  70   PopObject();
  71
  72   return true;
  73 }
  74
  75 bool CJSONVariantParserHandler::Bool(bool b)
  76 {
  77   return Primitive(b);
  78 }
  79
  80 bool CJSONVariantParserHandler::Int(int i)
  81 {
  82   return Primitive(i);
  83 }
  84
  85 bool CJSONVariantParserHandler::Uint(unsigned u)
  86 {
  87   return Primitive(u);
  88 }
  89
  90 bool CJSONVariantParserHandler::Int64(int64_t i)
  91 {
  92   return Primitive(i);
  93 }
  94
  95 bool CJSONVariantParserHandler::Uint64(uint64_t u)
  96 {
  97   return Primitive(u);
  98 }
  99
 100 bool CJSONVariantParserHandler::Double(double d)
 101 {
 102   return Primitive(d);
 103 }
 104
 105 bool CJSONVariantParserHandler::RawNumber(const char* str, rapidjson::SizeType length, bool copy)
 106 {
 107   return Primitive(str, length);
 108 }
 109
 110 bool CJSONVariantParserHandler::String(const char* str, rapidjson::SizeType length, bool copy)
 111 {
 112   return Primitive(str, length);
 113 }
 114
 115 bool CJSONVariantParserHandler::StartObject()
 116 {
 117   PushObject(CVariant::VariantTypeObject);
 118
 119   return true;
 120 }
 121
 122 bool CJSONVariantParserHandler::Key(const char* str, rapidjson::SizeType length, bool copy)
 123 {
 124   m_key = std::string(str, 0, length);
 125
 126   return true;
 127 }
 128
 129 bool CJSONVariantParserHandler::EndObject(rapidjson::SizeType memberCount)
 130 {
 131   PopObject();
 132
 133   return true;
 134 }
 135
 136 bool CJSONVariantParserHandler::StartArray()
 137 {
 138   PushObject(CVariant::VariantTypeArray);
 139
 140   return true;
 141 }
 142
 143 bool CJSONVariantParserHandler::EndArray(rapidjson::SizeType elementCount)
 144 {
 145   PopObject();
 146
 147   return true;
 148 }
 149
 150 void CJSONVariantParserHandler::PushObject(const CVariant& variant)
 151 {
 152   if (m_status == PARSE_STATUS::Object)
 153   {
 154     (*m_parse[m_parse.size() - 1])[m_key] = variant;
 155     m_parse.push_back(&(*m_parse[m_parse.size() - 1])[m_key]);
 156   }
 157   else if (m_status == PARSE_STATUS::Array)
 158   {
 159     CVariant *temp = m_parse[m_parse.size() - 1];
 160     temp->push_back(variant);
 161     m_parse.push_back(&(*temp)[temp->size() - 1]);
 162   }
 163   else if (m_parse.empty())
 164   {
 165     m_root = variant;
 166     m_parse.push_back(&m_root);
 167   }
 168
 169   if (variant.isObject())
 170     m_status = PARSE_STATUS::Object;
 171   else if (variant.isArray())
 172     m_status = PARSE_STATUS::Array;
 173   else
 174     m_status = PARSE_STATUS::Variable;
 175 }
 176
 177 void CJSONVariantParserHandler::PopObject()
 178 {
 179   CVariant *variant = m_parse[m_parse.size() - 1];
 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 }