json_data.hpp

Go to the documentation of this file.

#ifndef STAN__IO__JSON__JSON_DATA_HPP
#define STAN__IO__JSON__JSON_DATA_HPP

#include <cctype>
#include <iostream>
#include <limits>
#include <map>
#include <sstream>
#include <string>
#include <vector>
#include <boost/throw_exception.hpp>
#include <boost/lexical_cast.hpp>
#include <stan/math/matrix.hpp>
#include <stan/io/var_context.hpp>
#include <stan/io/json/json_error.hpp>
#include <stan/io/json/json_parser.hpp>
#include <stan/io/json/json_data_handler.hpp>


namespace stan {

  namespace json {

    class json_data : public stan::io::var_context {
    private: 
      vars_map_r vars_r_;
      vars_map_i vars_i_;

      std::vector<double> const empty_vec_r_;
      std::vector<int> const empty_vec_i_;
      std::vector<size_t> const empty_vec_ui_;

      bool contains_r_only(const std::string& name) const {
        return vars_r_.find(name) != vars_r_.end();
      }

    public: 

      json_data(std::istream& in) : vars_r_(), vars_i_() {
        json_data_handler handler(vars_r_, vars_i_);
        stan::json::parse(in, handler);
      }

      bool contains_r(const std::string& name) const {
        return contains_r_only(name) || contains_i(name);
      }

      bool contains_i(const std::string& name) const {
        return vars_i_.find(name) != vars_i_.end();
      }

      std::vector<double> vals_r(const std::string& name) const {
        if (contains_r_only(name)) {
          return (vars_r_.find(name)->second).first;
        } else if (contains_i(name)) {
          std::vector<int> vec_int = (vars_i_.find(name)->second).first;
          std::vector<double> vec_r(vec_int.size());
          for (size_t ii = 0; ii < vec_int.size(); ii++) {
            vec_r[ii] = vec_int[ii];
          }
          return vec_r;
        }
        return empty_vec_r_;
      }
      
      std::vector<size_t> dims_r(const std::string& name) const {
        if (contains_r_only(name)) {
          return (vars_r_.find(name)->second).second;
        } else if (contains_i(name)) {
          return (vars_i_.find(name)->second).second;
        }
        return empty_vec_ui_;
      }

      std::vector<int> vals_i(const std::string& name) const {
        if (contains_i(name)) {
          return (vars_i_.find(name)->second).first;
        }
        return empty_vec_i_;
      }
      
      std::vector<size_t> dims_i(const std::string& name) const {
        if (contains_i(name)) {
          return (vars_i_.find(name)->second).second;
        }
        return empty_vec_ui_;
      }

      virtual void names_r(std::vector<std::string>& names) const {
        names.resize(0);        
        for (vars_map_r::const_iterator it = vars_r_.begin();
             it != vars_r_.end(); ++it)
          names.push_back((*it).first);
      }

      virtual void names_i(std::vector<std::string>& names) const {
        names.resize(0);        
        for (vars_map_i::const_iterator it = vars_i_.begin();
             it != vars_i_.end(); ++it)
          names.push_back((*it).first);
      }

      bool remove(const std::string& name) {
        return (vars_i_.erase(name) > 0) 
          || (vars_r_.erase(name) > 0);
      }
      
    };
    
  }

}
#endif