json_helper.h

#ifndef JSON_HELPER_H_
#define JSON_HELPER_H_

#include <iostream>
#include <string>
#include <picojson.h>
#include <vector>

using std::vector;

namespace csci3081 {

class JsonHelper {
public:

  /********************** Querying functions **************************/
  static const picojson::value& GetValue(const picojson::object& obj, std::string key) {
    if (!JsonHelper::ContainsKey(obj, key)) {
      throw std::logic_error("Trying to get the picojson::value from key that does not exist: " + key);
    }
    return obj.find(key)->second;
  }
  
  static const picojson::object& GetObject(const picojson::object& obj, std::string key) {
    if (!JsonHelper::ContainsKey(obj, key)) {
      throw std::logic_error("Trying to get the picojson::object from key that does not exist: " + key);
    }
      return GetValue(obj, key).get<picojson::object>();
  }
  
  static const picojson::array& GetArray(const picojson::object& obj, std::string key) {
    if (!JsonHelper::ContainsKey(obj, key)) {
      throw std::logic_error("Trying to get the picojson::array from key that does not exist: " + key);
    }
      return GetValue(obj, key).get<picojson::array>();
  }
  
  static std::string GetString(const picojson::object& obj, std::string key) {
    if (!JsonHelper::ContainsKey(obj, key)) {
      throw std::logic_error("Trying to get the string from key that does not exist: " + key);
    }
      return GetValue(obj, key).get<std::string>();
  }
  
  static double GetDouble(const picojson::object& obj, std::string key) {
    if (!JsonHelper::ContainsKey(obj, key)) {
      throw std::logic_error("Trying to get the double from key that does not exist: " + key);
    }
    return GetValue(obj, key).get<double>();
  }

  static std::vector<float> GetStdFloatVector(const picojson::object& obj, std::string key) {
    if (!JsonHelper::ContainsKey(obj, key)) {
      throw std::logic_error("Trying to get the std::vector<float> from key that does not exist: " + key);
    }
    std::vector<float> vec;
    picojson::array arr = GetArray(obj, key);
    for (int i = 0; i < arr.size(); i++) {
      vec.push_back(arr[i].get<double>());
    }
    return vec;
  }
  
  static bool ContainsKey(const picojson::object& obj, std::string key) {
    return obj.find(key) != obj.end();
  }

  /********************** Creation functions **************************/
  
  static picojson::object CreateJsonNotification() {
    picojson::object obj;
    AddStringToJsonObject(obj, "type", "notify");
    return obj;
  }

  static picojson::object CreateJsonObject() {
    return picojson::object();
  }

  static picojson::value ConvertPicojsonObjectToValue(picojson::object& obj) {
    return picojson::value(obj);
  }

  static void AddValueToJsonObject(picojson::object& obj, std::string key, picojson::value val) {
    obj[key] = val;
  }

  static void AddObjectToJsonObject(picojson::object& obj, std::string key, picojson::object& val) {
    obj[key] = JsonHelper::ConvertPicojsonObjectToValue(val);
  }

  static void AddStringToJsonObject(picojson::object& obj, std::string key, std::string val) {
    obj[key] = picojson::value(val);
  }

  static void AddFloatToJsonObject(picojson::object& obj, std::string key, float num) {
    obj[key] = picojson::value(num);
  }

  static void AddStdFloatVectorToJsonObject(picojson::object& obj, std::string key, std::vector<float> vec) {
    picojson::array arr = CreateJsonArrayFromVector(vec);
    obj[key] = picojson::value(arr);
  }

  static picojson::array CreateJsonArrayFromVector(std::vector<float> vec) {
    picojson::array arr;
    for (auto num : vec) {
      arr.push_back(picojson::value(num));
    }
    return arr;
  }

  static void AddStdVectorVectorFloatToJsonObject(picojson::object& obj, 
                                                 std::string key, std::vector<std::vector<float>> array) {
    obj[key] = EncodeArray(array);
  }

  static picojson::value EncodeArray(const vector<vector<float>> arr) { //todo discard some precision by converting to strings?
    vector<picojson::value> result;
    for(vector<float> subarr : arr) {
      vector<picojson::value> subarr_encode;
      for(float val : subarr) {
        subarr_encode.push_back(picojson::value(val));
      }
      result.push_back(picojson::value(subarr_encode));
    }
    return picojson::value(result);
  }


  /********************** Printing functions **************************/
  
  static void PrintArray(const picojson::array& arr) {
    std::cout << "Printing Array:" << std::endl << std::endl;
    int i = 0;
    for (auto key : arr) {
      std::cout << "Array item: " << i++ << std::endl;
      std::cout << "    " << key << std::endl;
    }
  }
  
  static void PrintKeyValues(const picojson::object& obj, std::string prefix = "  ") {
    std::cout << "PrintKeyValues ---------" << std::endl;
      for (picojson::object::const_iterator it = obj.begin(); it != obj.end(); it++) {
        std::cout << prefix << it->first << ": " << it->second << std::endl;
      }
    std::cout << "End PrintKeyValues ---------" << std::endl;
  }
  
  static void Print(const picojson::object& obj, std::string prefix = "  ") {
    picojson::value val(obj);
    std::cout << prefix << val.serialize() << std::endl;
  }
  
  static void PrintEntityDetails(const picojson::object& val) {
    std::cout << "\n------JSON:------" << std::endl;
    JsonHelper::Print(val);

    std::cout << "------Key Values:------" << std::endl;
    JsonHelper::PrintKeyValues(val);

    std::cout << "------Entity Type:------" << std::endl;
    std::string type = JsonHelper::GetString(val, "type");
    std::cout << "  " << type << std::endl;

    std::cout << "------Contains Key:------" << std::endl;
    std::cout << "  Contains type: " << JsonHelper::ContainsKey(val, "type") << std::endl;
    std::cout << "  Contains otherKey: " << JsonHelper::ContainsKey(val, "otherKey") << std::endl;
    std::cout << "  Contains position: " << JsonHelper::ContainsKey(val, "position") << std::endl;

    std::cout << "------Position array:------" << std::endl;
    if (JsonHelper::ContainsKey(val, "position")) {
      const picojson::array& position = JsonHelper::GetArray(val, "position");
      for (int f = 0; f < position.size(); f++) {
        std::cout << "  position[" << f << "]: " << position[f] << std::endl;
      }
    }
    std::cout << std::endl;
  }
};

}  // namespace csci3081
#endif