fims_json.hpp

Go to the documentation of this file.

#ifndef FIMS_JSON_HPP
#define FIMS_JSON_HPP
 
#include <cctype>
#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 = input;
    result.erase(std::remove_if(result.begin(), result.end(), ::isspace),
                 result.end());
    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;
          // Toggle inQuotes when we encounter a double-quote
          if (i == 0 || input[i - 1] != '\\') {
            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