SniperJSON.h

Go to the documentation of this file.

#include <string>
#include <vector>
#include <map>
#include <sstream>
#include <typeinfo>
#include <exception>
 
class SniperJSON
{
public:
    typedef std::vector<SniperJSON>::const_iterator vec_iterator;
    typedef std::map<std::string, SniperJSON>::const_iterator map_iterator;
 
    // default constructor
    SniperJSON();
 
    // construct from a json string
    SniperJSON(const std::string &jstr);
 
    // whether this is a scalar or string
    bool isScalar() const { return m_type > 2; }
 
    // whether this is a vector
    bool isVector() const { return m_type == 2; }
 
    // whether this is a map
    bool isMap() const { return m_type == 1; }
 
    /* get a C++ object from this element, T can be
     * type[1]: C++ scalar and std::string
     * type[2]: std::vector< type[1,2,3] >
     * type[3]: std::map< type[1], type[1,2,3] >
     */
    template <typename T>
    T get() const;
 
    // push_back an element in case of a vector
    bool push_back(const SniperJSON &var);
 
    // insert a key/value pair in case of a map
    bool insert(const std::string &key, const SniperJSON &val);
 
    // clear all the contents of this element
    void reset();
 
    // get the array/vector or object/map size
    int size() const;
 
    // get the vector begin iterator
    vec_iterator vec_begin() const { return m_jvec.begin(); }
    // get the vector end iterator
    vec_iterator vec_end() const { return m_jvec.end(); }
 
    // get the object in vector via index
    SniperJSON &operator[](int index) { return m_jvec.at(index); }
    // get the object in vector via index
    const SniperJSON &operator[](int index) const { return m_jvec.at(index); }
 
    // get the map begin iterator
    map_iterator map_begin() const { return m_jmap.begin(); }
    // get the map end iterator
    map_iterator map_end() const { return m_jmap.end(); }
    // find the iterator via key
    map_iterator find(const std::string &key) const { return m_jmap.find(key); }
 
    // get the object in map via key
    SniperJSON &operator[](const std::string &key);
    // get the object in map via key
    const SniperJSON &operator[](const std::string &key) const;
 
    // load json from an input stream
    static SniperJSON load(std::istream &is);
 
    // load json from a string
    static SniperJSON loads(const std::string &jstr);
 
private:
    typedef std::string::size_type StrCursor;
 
    // 0:invalid, 1:object/map, 2:array/vector, 3:string, 9:other scalars
    int m_type;
    // scalar or std::string element holder
    std::string m_jvar;
    // array/vector element holder
    std::vector<SniperJSON> m_jvec;
    // object/map element holder
    std::map<std::string, SniperJSON> m_jmap;
 
    // control string for space charactors
    static const std::string SPACES;
    // control string for delimit charactors
    static const std::string DELIMITS;
 
    // construct a sub-element from a json string
    SniperJSON(const std::string &jstr, StrCursor &cursor);
 
    // initialize the json element from a string
    void init(const std::string &jstr, StrCursor &cursor);
 
    // get next valid charactor
    char getValidChar(const std::string &jstr, StrCursor &cursor);
 
    // read the content of a json object/map to m_jmap;
    void readObjectMap(const std::string &jstr, StrCursor &cursor);
 
    // read the content of a json array/vector to m_jvec
    void readArrayVec(const std::string &jstr, StrCursor &cursor);
 
    // read the content of a json string to m_jvar
    void readStringStr(const std::string &jstr, StrCursor &cursor);
 
    // read the content of other scalars to m_jvar
    void readScalarStr(const std::string &jstr, StrCursor &cursor);
 
    // function template helps to access type[1]
    template <typename T>
    inline void toCppVar(T &var) const;
 
    // function template helps to access type[2]
    template <typename T>
    inline void toCppVar(std::vector<T> &var) const;
 
    // function template helps to access type[3]
    template <typename K, typename V>
    inline void toCppVar(std::map<K, V> &var) const;
 
    // an inner class for any exception while json parsing
    class Exception : public std::exception
    {
    public:
        Exception(const std::string &msg);
        Exception(const std::string &jstr, int cursor);
        virtual ~Exception() throw();
        const char *what() const throw();
 
    private:
        std::string m_msg;
    };
};
 
template <typename T>
T SniperJSON::get() const
{
    T v;
    toCppVar(v);
    return v;
}
 
template <typename T>
inline void SniperJSON::toCppVar(T &var) const
{
    if (m_type == 9)
    {
        std::stringstream ss;
        ss << m_jvar;
        ss >> var;
 
        if (ss.eof())
        {
            return;
        }
    }
 
    throw Exception(
        std::string("cannot set <") + typeid(T).name() + "> with '" + m_jvar + "'");
}
 
template <>
inline void SniperJSON::toCppVar<bool>(bool &var) const
{
    if (m_type == 9)
    {
        if (m_jvar == "true")
        {
            var = true;
            return;
        }
        else if (m_jvar == "false")
        {
            var = false;
            return;
        }
    }
 
    throw Exception(std::string("cannot set <bool> with '") + m_jvar + "'");
}
 
template <>
inline void SniperJSON::toCppVar<std::string>(std::string &var) const
{
    if (m_type == 3)
    {
        var = m_jvar.substr(1, m_jvar.size() - 2);
        return;
    }
 
    throw Exception(std::string("cannot set <std::string> with '") + m_jvar + "'");
}
 
template <typename T>
inline void SniperJSON::toCppVar(std::vector<T> &var) const
{
    if (m_type == 2)
    {
        for (vec_iterator it = m_jvec.begin(); it != m_jvec.end(); ++it)
        {
            var.push_back(it->get<T>());
        }
        return;
    }
 
    throw Exception(std::string("not a valid vector"));
}
 
//This implementaiton should be replaced by "std::is_same" when c++11 is valid 
namespace PreCXX11 {
    struct true_value {
        static bool value;
    };
 
    struct false_value {
        static bool value;
    };
 
    template<typename, typename>
        struct is_same : public false_value {};
 
    template<typename T>
        struct is_same<T, T> : public true_value {};
}
 
template <typename K, typename V>
inline void SniperJSON::toCppVar(std::map<K, V> &var) const
{
    if (m_type == 1)
    {
        for (map_iterator it = m_jmap.begin(); it != m_jmap.end(); ++it)
        {
            var.insert(std::make_pair(
                SniperJSON(
                    PreCXX11::is_same<K, std::string>::value ? it->first : it->first.substr(1, it->first.size() - 2))
                    .get<K>(),
                it->second.get<V>()));
        }
        return;
    }
 
    throw Exception(std::string("not a valid map"));
}