path_json.cc

Go to the documentation of this file.

/*!
 *
 * Copyright (C) 2015 Technical University of Liberec.  All rights reserved.
 * 
 * This program is free software; you can redistribute it and/or modify it under
 * the terms of the GNU General Public License version 3 as published by the
 * Free Software Foundation. (http://www.gnu.org/licenses/gpl-3.0.en.html)
 * 
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
 *
 * 
 * @file    path_json.cc
 * @brief   
 */
 
#include "input/path_json.hh"
#include "input/reader_internal_base.hh"
#include "input/comment_filter.hh"
#include "system/system.hh"
 
#include "json_spirit/json_spirit_error_position.h"
#include "input/json_spirit/json_spirit_reader.h"            // for read_or_...
 
#include <boost/iostreams/device/file.hpp>
#include <boost/iostreams/filtering_stream.hpp>
#include <boost/algorithm/string.hpp>
 
 
namespace Input {
using namespace std;
 
 
PathJSON::PathJSON(istream &in)
: PathJSON()
{
    io::filtering_istream filter_in;
 
    filter_in.push(uncommenting_filter());
    filter_in.push(in);
 
    root_node_ = std::make_shared<Node>();
 
    try {
        json_spirit::read_or_throw( filter_in, *root_node_);
    } catch (json_spirit::Error_position &e ) {
        THROW( ReaderInternalBase::ExcNotJSONFormat() << ReaderInternalBase::EI_JSONLine(e.line_) << ReaderInternalBase::EI_JSONColumn(e.column_)
            << ReaderInternalBase::EI_JSONReason(e.reason_));
    }
 
    nodes_.push_back( root_node_.get() );
}
 
 
PathJSON::PathJSON()
: PathBase()
{
    /* from json_spirit_value.hh:
     * enum Value_type{ obj_type, array_type, str_type, bool_type, int_type, real_type, null_type };
     */
    json_type_names.push_back("JSON object");
    json_type_names.push_back("JSON array");
    json_type_names.push_back("JSON string");
    json_type_names.push_back("JSON bool");
    json_type_names.push_back("JSON int");
    json_type_names.push_back("JSON real");
    json_type_names.push_back("JSON null");
    json_type_names.push_back(""); //scalar type
    json_type_names.push_back(""); //undefined type
}
 
 
PathJSON::~PathJSON()
{
    this->go_to_root();
}
 
bool PathJSON::down(unsigned int index)
{
    const Node * head_node = nodes_.back();
    const json_spirit::mArray &array = head_node->get_array(); // the type should be checked in make_storage
 
    if (  index >= array.size()) return false;
    path_.push_back( make_pair( index, string("") ) );
    nodes_.push_back( &( array[index] ) );
    return true;
}
 
 
bool PathJSON::down(const string& key, int index)
{
    const Node * head_node = nodes_.back();
    const json_spirit::mObject &obj = head_node->get_obj(); // the type should be checked in make_storage
 
    json_spirit::mObject::const_iterator it = obj.find(key);
    if (it == obj.end()) {
        return false;
    } else {
        path_.push_back( make_pair( index, key) );
        nodes_.push_back( &( it->second ) );
    }
    return true;
}
 
 
void PathJSON::up()
{
    if (path_.size() > 1) {
        path_.pop_back();
        nodes_.pop_back();
    }
}
 
 
/**
 * This returns path to reference given by address in ref_address.
 *
 */
PathBase * PathJSON::find_ref_node()
{
    namespace ba = boost::algorithm;
 
    const Node * head_node = nodes_.back();
    if (head_node->type() != json_spirit::obj_type) return NULL;
    const json_spirit::mObject &obj = head_node->get_obj();
    if (obj.size() != 1) return NULL;
    if (obj.begin()->first != "REF") return NULL;
 
    const Node &ref_node = obj.begin()->second;
    if (ref_node.type() != json_spirit::str_type) {
        THROW( ExcRefOfWrongType() << EI_ErrorAddress(this->as_string()) );
 
    }
    string ref_address = ref_node.get_str();
 
    PathJSON * ref_path = this->clone();
    string::size_type pos = 0;
    string::size_type new_pos = 0;
    string address = ref_address + '/';
    string tmp_str;
    bool relative_ref = false;
 
    std::set<string>::iterator it = previous_references_.find(ref_address);
    if (it == previous_references_.end()) {
        ref_path->previous_references_.insert(ref_address);
    } else {
        THROW( ExcReferenceNotFound() << EI_RefAddress(this->as_string()) << EI_ErrorAddress(ref_path->as_string()) << EI_RefStr(ref_address)
               << EI_Specification("cannot follow reference") );
    }
 
    while ( ( new_pos=address.find('/',pos) ) != string::npos ) {
        tmp_str = address.substr(pos, new_pos - pos);
        if (pos==0 && tmp_str == "") {
            // absolute path
            ref_path->go_to_root();
 
        } else if ( ba::all( tmp_str, ba::is_digit()) ) {
            // integer == index in array
            if ( !ref_path->is_array_type() ) {
                THROW( ExcReferenceNotFound() << EI_RefAddress(this->as_string()) << EI_ErrorAddress(ref_path->as_string()) << EI_RefStr(ref_address)
                        << EI_Specification("there should be Array") );
            }
 
            if ( !ref_path->down( atoi(tmp_str.c_str()) ) ) {
                THROW( ExcReferenceNotFound() << EI_RefAddress(this->as_string()) << EI_ErrorAddress(ref_path->as_string()) << EI_RefStr(ref_address)
                        << EI_Specification("index out of size of Array") );
            }
 
        } else if (tmp_str == "..") {
            relative_ref = true;
            if (ref_path->level() <= 0 ) {
                THROW( ExcReferenceNotFound() << EI_RefAddress(this->as_string()) << EI_ErrorAddress(ref_path->as_string()) << EI_RefStr(ref_address)
                        << EI_Specification("can not go up from root") );
            }
            ref_path->up();
 
        } else {
            if ( !ref_path->is_record_type() )
                THROW( ExcReferenceNotFound() << EI_RefAddress(this->as_string()) << EI_ErrorAddress(ref_path->as_string()) << EI_RefStr(ref_address)
                        << EI_Specification("there should be Record") );
            if ( !ref_path->down(tmp_str) )
                THROW( ExcReferenceNotFound() << EI_RefAddress(this->as_string()) << EI_ErrorAddress(ref_path->as_string()) << EI_RefStr(ref_address)
                        << EI_Specification("key '"+tmp_str+"' not found") );
        }
        pos = new_pos+1;
    }
    if (relative_ref) {
        MessageOut() << "Referencing '" << this->as_string() << "' to '" << ref_path->as_string() << "'." << std::endl;
    }
    return ref_path;
}
 
 
 
bool PathJSON::is_null_type() const {
    return head()->type() == json_spirit::null_type;
}
 
 
bool PathJSON::get_bool_value() const {
    if (head()->type() == json_spirit::bool_type) {
        return head()->get_bool();
    } else {
        THROW( ReaderInternalBase::ExcInputError()  );
    }
    return false;
}
 
 
 
std::int64_t PathJSON::get_int_value() const {
    if (head()->type() == json_spirit::int_type) {
        return head()->get_int64();
    } else {
        THROW( ReaderInternalBase::ExcInputError() );
    }
    return 0;
}
 
 
 
double PathJSON::get_double_value() const {
    auto value_type = head()->type();
    if (    value_type== json_spirit::real_type
         || value_type == json_spirit::int_type) {
        return head()->get_real();
    } else {
        THROW( ReaderInternalBase::ExcInputError() );
    }
    return 0.0;
}
 
 
 
std::string PathJSON::get_string_value() const {
    if (head()->type() == json_spirit::str_type) {
        return head()->get_str();
    } else {
        THROW( ReaderInternalBase::ExcInputError() );
    }
    return "";
}
 
 
 
unsigned int PathJSON::get_node_type_index() const {
    return head()->type();
}
 
 
 
bool PathJSON::get_record_key_set(std::set<std::string> &keys_list) const {
    if ( this->is_record_type() ) {
        const json_spirit::mObject & j_map = head()->get_obj();
        json_spirit::mObject::const_iterator map_it;
        std::set<string>::iterator set_it;
 
        for( map_it = j_map.begin(); map_it != j_map.end(); ++map_it) {
            keys_list.insert(map_it->first);
        }
 
        return true;
    }
 
    return false;
}
 
 
 
int PathJSON::get_array_size() const {
    if (head()->type() == json_spirit::array_type) {
        const json_spirit::mArray & j_array = head()->get_array();
        return j_array.size();
    }
 
    return -1;
}
 
 
 
bool PathJSON::is_record_type() const {
    return head()->type() == json_spirit::obj_type;
}
 
 
 
bool PathJSON::is_array_type() const {
    return head()->type() == json_spirit::array_type;
}
 
 
 
PathJSON * PathJSON::clone() const {
    return new PathJSON(*this);
}
 
 
 
std::string PathJSON::get_record_tag() const {
    std::string tag_value;
    if ( this->is_record_type() ) {
        PathJSON type_path(*this);
        if ( type_path.down("TYPE") ) {
            //check if TYPE key is reference
            PathBase * ref_path = type_path.find_ref_node();
            if (ref_path) {
                tag_value = ref_path->get_string_value();
                delete ref_path;
            } else {
                tag_value = type_path.get_string_value();
            }
        }
    } else {
        tag_value = "";
    }
 
    return tag_value;
}
 
 
 
void PathJSON::remember_reference() {
    previous_references_.insert(as_string());
}
 
 
 
bool PathJSON::is_effectively_null() const {
    return false;
}
 
 
 
std::ostream& operator<<(std::ostream& stream, const PathJSON& path) {
    path.output(stream);
    return stream;
}
 
 
} // namespace Input