JsonObjExtractor.cpp

Go to the documentation of this file.

#include <sstream>

#include "JsonObjExtractor.hpp"

using namespace HCE::exception;

namespace HCE
{
  namespace utils
  {
    char JsonObjExtractor::objSeparator = '.';
    char JsonObjExtractor::arraySeparatorBegin = '[';
    char JsonObjExtractor::arraySeparatorEnd = ']';
    
    JsonObjExtractor::JsonObjExtractor():localObj(nullptr), localArray(nullptr) {}
    
    void JsonObjExtractor::commonParseObj(Poco::JSON::Object::Ptr obj, std::vector<Poco::Dynamic::Var> &varPath) throw (JsonObjectExeption)
    {
      int arrayIndex = 0;
      try
      {
        if(!obj.isNull())
        {
          for(unsigned int i = 0; i < varPath.size(); i++)
          {
            if(varPath[i].isInteger())
            {
              if(localArray.isNull())
              {
                throw JsonObjectExeption("JSON::Object> Node Not an Array");
              }
              arrayIndex = varPath[i].extract<int>();
              if(static_cast<unsigned int>(arrayIndex) >= localArray->size())
              {
                throw JsonObjectExeption("JSON::Object> Array Index out Of range");
              }
              if(localArray->isObject(arrayIndex))
              {
                localObj = localArray->getObject(arrayIndex);
                localArray = nullptr;
              }
              else if(localArray->isArray(arrayIndex))
              {
                localArray = localArray->getArray(arrayIndex);
                localObj = nullptr;
              }
              else if(!localArray->get(varPath[i].extract<int>()).isEmpty())
              {
                localVar = localArray->get(varPath[i].extract<int>());
                localArray = nullptr;
                localObj = nullptr;
              }
              else
              {
                clearLocalFields();
              }
            }
            else if(varPath[i].isString())
            {
              if(localObj.isNull())
              {
                throw JsonObjectExeption("JSON::Object> Node not an object");
              }
              if(localObj->isObject(varPath[i].extract<std::string>()))
              {
                localObj = localObj->getObject(varPath[i].extract<std::string>());
                localArray = nullptr;
              }
              else if(localObj->isArray(varPath[i].extract<std::string>()))
              {
                localArray = localObj->getArray(varPath[i].extract<std::string>());
                localObj = nullptr;
              }
              else if(!localObj->get(varPath[i].extract<std::string>()).isEmpty())
              {
                localVar = localObj->get(varPath[i].extract<std::string>());
                localArray = nullptr;
                localObj = nullptr;                
              }
              else
              {
                clearLocalFields();
              }
            }
            else
            {
              throw JsonObjectExeption("JSON::Object> Wrong vector type");
            }
          }
        }
      }
      catch(JsonObjectExeption &exp)
      {
        throw;
      }
      catch(std::exception &exp)
      {
      }
    }
    
    std::string JsonObjExtractor::toJsonPath(std::vector<Poco::Dynamic::Var> &varPath) throw (JsonObjectExeption)
    {
      std::string ret;
      std::stringstream intString;
      try
      {
        for(unsigned int i = 0; i < varPath.size(); i++)
        {
          if(varPath[i].isInteger())
          {
            if(i == 0)
            {
              throw JsonObjectExeption("JSON::Object> First element of varPath must be an string");
            }
            ret += arraySeparatorBegin;
            intString.str(std::string());
            intString.clear();
            intString << varPath[i].extract<int>();
            ret += intString.str();
            ret += arraySeparatorEnd;
          }
          else if(varPath[i].isString())
          {
            if(i > 0)
            {
              ret += objSeparator;
            }
            ret += (varPath[i].extract<std::string>());
          }
        }
      }
      catch(JsonObjectExeption &exp)
      {
        throw;
      }
      catch(std::exception &exp)
      {
      }
      return ret;
    }

    void JsonObjExtractor::generateMap(Poco::JSON::Object::Ptr obj, std::string &name)
    {
      globalMap.clear();
      generateMapByObj(obj, name);
    }
   
    void JsonObjExtractor::generateMapByObj(Poco::JSON::Object::Ptr obj, std::string &name)
    {
      if(!obj.isNull())
      {
        std::string localName;
        std::vector<std::string> localNames;
        obj->getNames(localNames);
        for(unsigned int i = 0; i < localNames.size(); i++)
        {
          localName = name;
          if(!localName.empty())
          {
            localName += objSeparator;
          }
          localName += localNames[i];
          if(obj->isObject(localNames[i]))
          {
            generateMapByObj(obj->getObject(localNames[i]), localName);
          }
          else if(obj->isArray(localNames[i]))
          {
            generateMapByArray(obj->getArray(localNames[i]), localName);
          }
          else if(!obj->isNull(localNames[i]))
          {
            Poco::Checksum crcCalc(Poco::Checksum::TYPE_CRC32);
            crcCalc.update(localName);
            globalMap.insert(std::pair<unsigned int, Poco::Dynamic::Var>(crcCalc.checksum(), obj->get(localNames[i])));
          }
        }
        if(!name.empty())
        {
          Poco::Dynamic::Var localVar(obj);
          Poco::Checksum crcCalc(Poco::Checksum::TYPE_CRC32);
          crcCalc.update(name);
          globalMap.insert(std::pair<unsigned int, Poco::Dynamic::Var>(crcCalc.checksum(), localVar));  
        }
      }
    }
    
    void JsonObjExtractor::generateMapByArray(Poco::JSON::Array::Ptr array, std::string &name)
    {    
      if(!array.isNull())
      {
        std::string localName;
        std::stringstream intString;
        for(unsigned int i = 0; i < array->size(); i++)
        {
          localName = name;
          localName += arraySeparatorBegin;
          intString.str(std::string());
          intString.clear();
          intString << i;
          localName += intString.str();
          localName += arraySeparatorEnd;
          if(array->isObject(i))
          {
            generateMapByObj(array->getObject(i), localName);
          }
          else if(array->isArray(i))
          {
            generateMapByArray(array->getArray(i), localName);
          }
          else if(!array->isNull(i))
          {
            Poco::Checksum crcCalc(Poco::Checksum::TYPE_CRC32);
            crcCalc.update(localName);
            globalMap.insert(std::pair<unsigned int, Poco::Dynamic::Var>(crcCalc.checksum(), array->get(i)));
          }          
        }
        if(!name.empty())
        {
          Poco::Dynamic::Var localVar(array);
          Poco::Checksum crcCalc(Poco::Checksum::TYPE_CRC32);
          crcCalc.update(name);
          globalMap.insert(std::pair<unsigned int, Poco::Dynamic::Var>(crcCalc.checksum(), localVar));          
        }        
      }      
    }
    
    void JsonObjExtractor::clearLocalFields()
    {
      localArray = nullptr;
      localObj = nullptr;                
      localVar.empty();
    }

    bool JsonObjExtractor::isKeyPresent(Poco::JSON::Object::Ptr obj, std::vector<Poco::Dynamic::Var> &varPath)
    {
      bool ret = false;
      if(obj.isNull())
      {
        Poco::Checksum crcCalc(Poco::Checksum::TYPE_CRC32);
        crcCalc.update(toJsonPath(varPath));
        if(globalMap.find(crcCalc.checksum()) != globalMap.end())
        {
          ret = true;
        }
      }
      else
      {
        commonParsePrepareObj(obj, varPath);
        if(!localVar.isEmpty() || !localObj.isNull() || !localArray.isNull())
        {
          ret = true;
        }
      }
      return ret;
    }
    
    JsonObjExtractor::~JsonObjExtractor() {}
  }
}