json_wrapper.h

Go to the documentation of this file.

#pragma once
 
#include <iostream>
#include <fstream>
#include <string>
#include <sstream>
#include <stdexcept> //std::runtime_error
 
#ifdef DG_USE_JSONHPP
#include <nlohmann/json.hpp>
#else
#include "json/json.h"
#endif
 
//Note that the json utilities are separate from netcdf utilities because
//of the different library dependencies that they incur
namespace dg
{
namespace file
{
#ifdef DG_USE_JSONHPP
using JsonType = nlohmann::json;
#else
using JsonType = Json::Value;
#endif
 
 
enum class error{
    is_throw, 
    is_warning, 
    is_silent 
};
 
enum class comments{
    are_kept, 
    are_discarded, 
    are_forbidden 
};
 
struct WrappedJsonValue
{
    WrappedJsonValue() : m_js(0), m_mode( error::is_throw){}
    WrappedJsonValue( error mode): m_js(0), m_mode( mode) {}
    WrappedJsonValue(JsonType js): m_js(js), m_mode( error::is_throw) {}
    WrappedJsonValue(JsonType js, error mode): m_js(js), m_mode( mode) {}
    void set_mode( error new_mode){
        m_mode = new_mode;
    }
    const JsonType& asJson( ) const{ return m_js;}
    JsonType& asJson( ) { return m_js;}
 
    std::string access_string() const {return m_access_str;}
 
    std::string toStyledString() const{
#ifdef DG_USE_JSONHPP
        return m_js.dump(4);
#else
        return m_js.toStyledString();
#endif
    }
 
    bool isMember(std::string key) const{
#ifdef DG_USE_JSONHPP
        return m_js.contains(key);
#else
        return m_js.isMember(key);
#endif
    }
    bool isString() const {
#ifdef DG_USE_JSONHPP
        return m_js.is_string();
#else
        return m_js.isString();
#endif
    }
 
    // //////////Members imitating the original JsonType///////////////
    WrappedJsonValue operator[](std::string key) const{
#ifdef DG_USE_JSONHPP
        return get( key, nlohmann::json::object(), "empty object ");
#else
        return get( key, Json::ValueType::objectValue, "empty object ");
#endif
    }
//    The problem with this is that if key is misspelled then
//    it will silently generate it
//    JsonType& operator[]( std::string key){
//        return m_js[key];
//    }
    WrappedJsonValue get( std::string key, const JsonType& value) const{
        std::stringstream default_str;
        default_str << "value "<<value;
        return get( key, value, default_str.str());
    }
    WrappedJsonValue operator[]( unsigned idx) const{
#ifdef DG_USE_JSONHPP
        return get( idx, nlohmann::json::object(), "empty array");
#else
        return get( idx, Json::ValueType::objectValue, "empty array");
#endif
    }
    WrappedJsonValue get( unsigned idx, const JsonType& value) const{
        std::stringstream default_str;
        default_str << "value "<<value;
        return get( idx, value, default_str.str());
    }
    unsigned size() const{
        return (unsigned)m_js.size();
    }
    double asDouble( double value = 0) const{
#ifdef DG_USE_JSONHPP
        if( m_js.is_number()) // we just want anything that can be cast to double
            return m_js.template get<double>();
#else
        if( m_js.isDouble())
            return m_js.asDouble();
#endif
        return type_error<double>( value, "a Double");
    }
    unsigned asUInt( unsigned value = 0) const{
#ifdef DG_USE_JSONHPP
        if( m_js.is_number()) // check for sign?
            return m_js.template get<unsigned>();
#else
        if( m_js.isUInt())
            return m_js.asUInt();
#endif
        return type_error<unsigned>( value, "an Unsigned");
    }
    int asInt( int value = 0) const{
#ifdef DG_USE_JSONHPP
        if( m_js.is_number())
            return m_js.template get<int>();
#else
        if( m_js.isInt())
            return m_js.asInt();
#endif
        return type_error<int>( value, "an Int");
    }
    bool asBool( bool value = false) const{
#ifdef DG_USE_JSONHPP
        if( m_js.is_boolean())
            return m_js.template get<bool>();
#else
        if( m_js.isBool())
            return m_js.asBool();
#endif
        return type_error<bool>( value, "a Bool");
    }
    std::string asString( std::string value = "") const{
#ifdef DG_USE_JSONHPP
        if( m_js.is_string())
            return m_js.template get<std::string>();
#else
        //return m_js["hhaha"].asString(); //does not throw
        if( m_js.isString())
            return m_js.asString();
#endif
        return type_error<std::string>( value, "a String");
    }
    private:
    WrappedJsonValue(JsonType js, error mode, std::string access):m_js(js), m_mode( mode), m_access_str(access) {}
    WrappedJsonValue get( std::string key, const JsonType& value, std::string default_str) const
    {
        std::string access = m_access_str + "\""+key+"\": ";
        std::stringstream message;
#ifdef DG_USE_JSONHPP
        if( !m_js.is_object( ) || !m_js.contains(key))
#else
        if( !m_js.isObject( ) || !m_js.isMember(key))
#endif
        {
            message <<"*** Key error: "<<access<<" not found.";
            raise_error( message.str(), default_str);
            return WrappedJsonValue( value, m_mode, access);
        }
        return WrappedJsonValue(m_js[key], m_mode, access);
    }
    WrappedJsonValue get( unsigned idx, const JsonType& value, std::string default_str) const
    {
        std::string access = m_access_str + "["+std::to_string(idx)+"] ";
#ifdef DG_USE_JSONHPP
        if( !m_js.is_array() || !(idx < m_js.size()))
#else
        if( !m_js.isArray() || !m_js.isValidIndex(idx))
#endif
        {
            std::stringstream message;
            //if( !m_js.isArray())
            //    message <<"*** Key error: "<<m_access_str<<" is not an Array.";
            //else
            if( m_access_str.empty())
                message <<"*** Index error: Index "<<idx<<" not present.";
            else
                message <<"*** Index error: Index "<<idx<<" not present in "<<m_access_str<<".";
            raise_error( message.str(), default_str);
            return WrappedJsonValue( value, m_mode, access);
        }
        return WrappedJsonValue(m_js[idx], m_mode, access);
    }
    template<class T>
    T type_error( T value, std::string type) const
    {
        std::stringstream message, default_str;
        default_str << "value "<<value;
        message <<"*** Type error: "<<m_access_str<<" "<<m_js<<" is not "<<type<<".";
        raise_error( message.str(), default_str.str());
        return value;
    }
    void raise_error( std::string message, std::string default_str) const
    {
        if( error::is_throw == m_mode)
            throw std::runtime_error( message);
        else if ( error::is_warning == m_mode)
            std::cerr <<"WARNING "<< message<<" Using default "<<default_str<<"\n";
        else
        {
        }
    }
    JsonType m_js;
    error m_mode;
    std::string m_access_str = "";
};
 
 
inline JsonType file2Json(std::string filename, enum comments comm =
        file::comments::are_discarded, enum error err = file::error::is_throw)
{
    std::ifstream isI( filename);
    if( !isI.good())
    {
        std::string message = "\nAn error occured while parsing "+filename+"\n";
        message +=  "*** File does not exist! *** \n\n";
        if( err == error::is_throw)
            throw std::runtime_error( message);
        else if (err == error::is_warning)
            std::cerr << "WARNING: "<<message<<std::endl;
        else
        {
        }
        return JsonType();
    }
    JsonType js;
#ifdef DG_USE_JSONHPP
    bool ignore_comments = false, allow_exceptions = false;
    if ( comm == file::comments::are_discarded)
        ignore_comments =  true;
    if ( err == error::is_throw)
        allow_exceptions = true; //throws nlohmann::json::parse_error
 
    js = nlohmann::json::parse( isI, nullptr, allow_exceptions, ignore_comments);
    if( !allow_exceptions && err == error::is_warning && js.is_discarded())
    {
        std::string message = "An error occured while parsing "+filename+"\n";
        std::cerr << "WARNING: "<<message<<std::endl;
    }
#else
    Json::CharReaderBuilder parser;
    if( comments::are_forbidden == comm )
        Json::CharReaderBuilder::strictMode( &parser.settings_);
    else if( comments::are_discarded == comm )
    {
        Json::CharReaderBuilder::strictMode( &parser.settings_);
        // workaround for a linker bug in jsoncpp from package manager
        JsonType js_true (true);
        JsonType js_false (false);
        parser.settings_["allowComments"].swap( js_true);
        parser.settings_["collectComments"].swap(js_false);
    }
    else
        Json::CharReaderBuilder::setDefaults( &parser.settings_);
 
    std::string errs;
    if( !parseFromStream( parser, isI, &js, &errs) )
    {
        std::string message = "An error occured while parsing "+filename+"\n"+errs;
        if( err == error::is_throw)
            throw std::runtime_error( message);
        else if (err == error::is_warning)
            std::cerr << "WARNING: "<<message<<std::endl;
        else
        {
        }
    }
#endif
    return js;
}
 
inline void file2Json(std::string filename, JsonType& js, enum comments comm = file::comments::are_discarded, enum error err = file::error::is_throw)
{
    js = file2Json( filename, comm, err);
}
 
 
inline JsonType string2Json(std::string input, enum comments comm = file::comments::are_discarded, enum error err = file::error::is_throw)
{
    JsonType js;
#ifdef DG_USE_JSONHPP
    bool ignore_comments = false, allow_exceptions = false;
    if ( comm == file::comments::are_discarded)
        ignore_comments =  true;
    if ( err == error::is_throw)
        allow_exceptions = true; //throws nlohmann::json::parse_error
 
 
    js = nlohmann::json::parse( input, nullptr, allow_exceptions, ignore_comments);
    if( !allow_exceptions && err == error::is_warning && js.is_discarded())
    {
        std::string message = "An error occured while parsing \n";
        std::cerr << "WARNING: "<<message<<std::endl;
    }
    return js;
 
#else
 
    Json::CharReaderBuilder parser;
    if( comments::are_forbidden == comm )
        Json::CharReaderBuilder::strictMode( &parser.settings_);
    else if( comments::are_discarded == comm )
    {
        Json::CharReaderBuilder::strictMode( &parser.settings_);
        parser.settings_["allowComments"] = true;
        parser.settings_["collectComments"] = false;
    }
    else
        Json::CharReaderBuilder::setDefaults( &parser.settings_);
 
    std::string errs;
    std::stringstream ss(input);
    if( !parseFromStream( parser, ss, &js, &errs) )
    {
        if( err == error::is_throw)
            throw std::runtime_error( errs);
        else if (err == error::is_warning)
            std::cerr << "WARNING: "<<errs<<std::endl;
        else
        {
        }
    }
#endif
    return js;
}
 
inline void string2Json(std::string input, JsonType& js, enum comments comm = file::comments::are_discarded, enum error err = file::error::is_throw)
{
    js = string2Json( input, comm, err);
}
 
template<class ContainerType>
dg::file::JsonType vec2json( const ContainerType& shared)
{
#ifdef DG_USE_JSONHPP
    return nlohmann::json(shared);
#else
    Json::Value val;
    for( const auto& value : shared)
        val.append(value);
    return val;
#endif
}
 
template<class T>
dg::file::JsonType vec2json( std::initializer_list<T> shared)
{
    std::vector<T> cc( shared);
    return vec2json(cc);
}
 
 
}//namespace file
}//namespace dg