fims_json.hpp

Go to the documentation of this file.

#ifndef FIMS_JSON_HPP
#define FIMS_JSON_HPP
 
#include <cctype>
#include <cstdio>
#include <iostream>
#include <fstream>
#include <map>
#include <sstream>
#include <string>
#include <algorithm>
#include <vector>
 
namespace fims {
class JsonValue;
 
using JsonObject = std::map<std::string, JsonValue>;
 
using JsonArray = std::vector<JsonValue>;
 
enum JsonValueType {
  Null = 0, 
  Number,   
  String,   
  Bool,     
  Object,   
  JArray    
};
 
class JsonValue {
 public:
  JsonValue() : type(JsonValueType::Null) {}
 
  JsonValue(int num) : type(JsonValueType::Number), number(num) {}
 
  JsonValue(double num) : type(JsonValueType::Number), number(num) {}
 
  JsonValue(const std::string& str) : type(JsonValueType::String), str(str) {}
 
  JsonValue(bool b) : type(JsonValueType::Bool), boolean(b) {}
 
  JsonValue(const JsonObject& obj) : type(JsonValueType::Object), object(obj) {}
 
  JsonValue(const JsonArray& arr) : type(JsonValueType::JArray), array(arr) {}
 
  JsonValueType GetType() const { return type; }
 
  int GetInt() const { return static_cast<int>(number); }
 
  double GetDouble() const { return number; }
 
  const std::string& GetString() const { return str; }
 
  bool GetBool() const { return boolean; }
 
  JsonObject& GetObject() { return object; }
 
  JsonArray& GetArray() { return array; }
 
 private:
  JsonValueType type; 
  double number;      
  std::string str;    
  bool boolean;       
  JsonObject object;  
  JsonArray array;    
};
 
class JsonParser {
 public:
  JsonValue Parse(const std::string& json);
  void WriteToFile(const std::string& filename, JsonValue jsonValue);
  void Show(JsonValue jsonValue);
 
  static std::string removeWhitespace(const std::string& input) {
    std::string result;
    result.reserve(input.size());
    bool inQuotes = false;
    bool escaped = false;
    for (char current : input) {
      if (inQuotes) {
        result += current;
        if (escaped) {
          escaped = false;
        } else if (current == '\\') {
          escaped = true;
        } else if (current == '"') {
          inQuotes = false;
        }
      } else if (current == '"') {
        inQuotes = true;
        result += current;
      } else if (!std::isspace(static_cast<unsigned char>(current))) {
        result += current;
      }
    }
    return result;
  }
 
  static std::string EscapeString(const std::string& input) {
    std::string result;
    result.reserve(input.size());
    for (char current : input) {
      switch (current) {
        case '"':
          result += "\\\"";
          break;
        case '\\':
          result += "\\\\";
          break;
        case '\n':
          result += "\\n";
          break;
        case '\r':
          result += "\\r";
          break;
        case '\t':
          result += "\\t";
          break;
        default:
          if (static_cast<unsigned char>(current) < 0x20) {
            char buffer[7];
            std::snprintf(buffer, sizeof(buffer), "\\u%04x",
                          static_cast<unsigned char>(current));
            result += buffer;
          } else {
            result += current;
          }
      }
    }
    return result;
  }
 
  static std::string PrettyFormatJSON(const std::string& json) {
    std::string result;
    std::string input = JsonParser::removeWhitespace(json);
    int indentLevel = 0;
    bool inQuotes = false;
 
    for (size_t i = 0; i < input.size(); ++i) {
      char current = input[i];
 
      switch (current) {
        case '{':
        case '[':
          result += current;
          if (!inQuotes) {
            result += '\n';
            indentLevel++;
            result += std::string(indentLevel * 4, ' ');
          }
          break;
 
        case '}':
        case ']':
          if (!inQuotes) {
            result += '\n';
            indentLevel--;
            result += std::string(indentLevel * 4, ' ');
          }
          result += current;
          break;
 
        case ',':
          result += current;
          if (!inQuotes) {
            result += '\n';
            result += std::string(indentLevel * 4, ' ');
          }
          break;
 
        case ':':
          result += current;
          if (!inQuotes) result += " ";
          break;
 
        case '"': {
          result += current;
          // A quote is escaped only when preceded by an odd number of '\'
          size_t backslashes = 0;
          for (size_t j = i; j > 0 && input[j - 1] == '\\'; --j) {
            backslashes++;
          }
          if (backslashes % 2 == 0) {
            inQuotes = !inQuotes;
          }
          break;
        }
 
        default:
          result += current;
          break;
      }
    }
    return result;
  }
 
 private:
  void SkipWhitespace();
  JsonValue ParseValue();
  JsonValue ParseNumber();
  JsonValue ParseString();
  JsonValue ParseBool();
  JsonValue ParseNull();
  JsonValue ParseObject();
  JsonValue ParseArray();
  void WriteJsonValue(std::ofstream& outputFile, JsonValue jsonValue);
  void PrintJsonValue(std::ostream& outputFile, JsonValue jsonValue);
  void Indent(std::ostream& outputFile, int level);
  void Indent(std::ofstream& outputFile, int level);
 
  std::string data; 
  size_t position;  
};
 
}  // namespace fims
#endif