Event/RawDataCnv/include/RawDataCnv/SniperJSON.h

Go to the documentation of this file.

#include <exception>
#include <map>
#include <sstream>
#include <string>
#include <typeinfo>
#include <vector>
 
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 {};
} // namespace PreCXX11
 
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" ) );
}