json.hpp

Go to the documentation of this file.

 
/*
 * This code is loosely based on that of the SimpleJSON Library (http://mjpa.in/json)
 * by Mike Anchor.
 *
 * COPYRIGHT (c) 2015-2023 John Reppy (http://cs.uchicago.edu/~jhr)
 * All rights reserved.
 */
 
#ifndef _JSON_HPP_
#define _JSON_HPP_
 
#include <vector>
#include <string>
#include <map>
#include <cstdint>
 
namespace json {
 
    enum Type {
        T_OBJECT,       
        T_ARRAY,        
        T_INTEGER,      
        T_REAL,         
        T_STRING,       
        T_BOOL,         
        T_NULL          
    };
 
    class Value;
    class Object;
    class Array;
    class Number;
    class Integer;
    class Real;
    class String;
    class Bool;
    class Null;
 
  // parse a JSON file; this returns nullptr if there is a parsing error
    Value *parseFile (std::string filename);
 
  // virtual base class of JSON values
    class Value {
      public:
 
        Type type() const { return this->_ty; }
 
        bool isObject() const { return (this->type() == T_OBJECT); }
 
        bool isArray() const { return (this->type() == T_ARRAY); }
 
        bool isNumber() const
        {
            return (this->type() == T_REAL) || (this->type() == T_INTEGER);
        }
 
        bool isInteger() const { return (this->type() == T_INTEGER); }
 
        bool isReal() const { return (this->type() == T_REAL); }
 
        bool isString() const { return (this->type() == T_STRING); }
 
        bool isBool() const { return (this->type() == T_BOOL); }
 
        bool isNull() const { return (this->type() == T_NULL); }
 
        const Object *asObject () const;
 
        const Array *asArray () const;
 
        const Number *asNumber () const;
 
        const Integer *asInteger () const;
 
        const Real *asReal () const;
 
        const String *asString () const;
 
        const Bool *asBool () const;
 
        virtual ~Value();
        virtual std::string toString() = 0;
 
      protected:
 
        explicit Value (Type ty) : _ty(ty) { };
 
        Type    _ty;
    };
 
    inline std::ostream& operator<< (std::ostream& s, Value *v)
    {
        return s << v->toString();
    }
 
    class Object : public Value {
      public:
        Object () : Value(T_OBJECT), _value() { };
        ~Object ();
 
        int size () const { return this->_value.size(); }
 
        void insert (std::string key, Value *val);
 
        Value *operator[] (std::string key) const;
 
        const Object *fieldAsObject (std::string key) const
        {
            const Value *v = (*this)[key];
            return (v != nullptr) ? v->asObject() : nullptr;
        }
 
        const Array *fieldAsArray (std::string key) const
        {
            const Value *v = (*this)[key];
            return (v != nullptr) ? v->asArray() : nullptr;
        }
 
        const Number *fieldAsNumber (std::string key) const
        {
            const Value *v = (*this)[key];
            return (v != nullptr) ? v->asNumber() : nullptr;
        }
 
        const Integer *fieldAsInteger (std::string key) const
        {
            const Value *v = (*this)[key];
            return (v != nullptr) ? v->asInteger() : nullptr;
        }
 
        const Real *fieldAsReal (std::string key) const
        {
            const Value *v = (*this)[key];
            return (v != nullptr) ? v->asReal() : nullptr;
        }
 
        const String *fieldAsString (std::string key) const
        {
            const Value *v = (*this)[key];
            return (v != nullptr) ? v->asString() : nullptr;
        }
 
        const Bool *fieldAsBool (std::string key) const
        {
            const Value *v = (*this)[key];
            return (v != nullptr) ? v->asBool() : nullptr;
        }
 
        std::string toString();
 
      private:
        std::map<std::string, Value *> _value;
    };
 
    class Array : public Value {
      public:
        Array () : Value(T_ARRAY), _value() { };
        ~Array ();
 
        int length () const { return static_cast<int>(this->_value.size()); }
        void add (Value *v) { this->_value.push_back(v); }
 
        Value *operator[] (int idx) const { return this->_value[idx]; }
 
        std::string toString();
 
      private:
        std::vector<Value *> _value;
    };
 
    class Number : public Value {
      public:
        virtual ~Number ();
 
        virtual std::string toString() = 0;
        virtual double realVal () const = 0;
 
      protected:
        explicit Number (Type ty) : Value(ty) { };
 
    };
 
    class Integer : public Number {
      public:
        Integer (int64_t v) : Number(T_INTEGER), _value(v) { }
        ~Integer ();
 
        int64_t intVal () const { return this->_value; }
        double realVal () const { return static_cast<double>(this->_value); }
 
        std::string toString();
 
      private:
        int64_t _value;
    };
 
    class Real : public Number {
      public:
        Real (double v) : Number(T_REAL), _value(v) { }
        ~Real ();
 
        double realVal () const { return this->_value; }
 
        std::string toString();
 
      private:
        double _value;
    };
 
    class String : public Value {
      public:
        String (std::string v) : Value(T_STRING), _value(v) { };
        ~String ();
 
        std::string value () const { return this->_value; }
 
        std::string toString();
 
      private:
        std::string _value;
    };
 
    class Bool : public Value {
      public:
        Bool (bool v) : Value(T_BOOL), _value(v) { };
        ~Bool ();
 
        bool value () const { return this->_value; }
 
        std::string toString();
 
      private:
        bool _value;
    };
 
    class Null : public Value {
      public:
        Null () : Value(T_NULL) { };
        ~Null ();
 
        std::string toString();
 
    };
 
} // namespace json
 
#endif // !_JSON_HPP_