SniperJSON.cxx

Go to the documentation of this file.

#include "RawDataCnv/SniperJSON.h"
 
bool PreCXX11::true_value::value  = true;
bool PreCXX11::false_value::value = false;
 
const std::string SniperJSON::SPACES( " \n\t\r" );
const std::string SniperJSON::DELIMITS( ", \n]}\t\r" );
 
SniperJSON::SniperJSON() : m_type( 0 ) {}
 
SniperJSON::SniperJSON( const std::string& jstr ) : m_type( 0 ) {
  StrCursor cursor = 0;
  init( jstr, cursor );
 
  cursor = jstr.find_first_not_of( SniperJSON::SPACES, cursor );
  if ( cursor != std::string::npos ) { throw Exception( jstr, cursor ); }
}
 
SniperJSON::SniperJSON( const std::string& jstr, StrCursor& cursor ) : m_type( 0 ) {
  init( jstr, cursor );
}
 
bool SniperJSON::push_back( const SniperJSON& var ) {
  if ( m_type == 2 || m_type == 0 )
  {
    m_jvec.push_back( var );
    m_type = 2;
    return true;
  }
  return false;
}
 
bool SniperJSON::insert( const std::string& key, const SniperJSON& val ) {
  if ( m_type == 1 || m_type == 0 )
  {
    std::string _key = '"' + key + '"';
    m_jmap.insert( std::make_pair( _key, val ) );
    m_type = 1;
    return true;
  }
  return false;
}
 
void SniperJSON::reset() {
  m_type = 0;
  m_jvar.clear();
  m_jvec.clear();
  m_jmap.clear();
}
 
int SniperJSON::size() const {
  if ( m_type == 1 ) { return m_jmap.size(); }
  else if ( m_type == 2 ) { return m_jvec.size(); }
 
  return -1;
}
 
SniperJSON& SniperJSON::operator[]( const std::string& key ) {
  return m_jmap.at( '"' + key + '"' );
}
 
const SniperJSON& SniperJSON::operator[]( const std::string& key ) const {
  return m_jmap.at( '"' + key + '"' );
}
 
SniperJSON SniperJSON::load( std::istream& is ) {
  std::ostringstream oss;
  oss << is.rdbuf();
 
  return loads( oss.str() );
}
 
SniperJSON SniperJSON::loads( const std::string& jstr ) { return SniperJSON( jstr ); }
 
void SniperJSON::init( const std::string& jstr, StrCursor& cursor ) {
  switch ( getValidChar( jstr, cursor ) )
  {
  case '{': // object
    readObjectMap( jstr, cursor );
    m_type = 1;
    break;
  case '[': // array
    readArrayVec( jstr, cursor );
    m_type = 2;
    break;
  case '"': // string
    readStringStr( jstr, cursor );
    m_type = 3;
    break;
  default: // number, true, false or null
    readScalarStr( jstr, cursor );
    m_type = 9;
  }
}
 
char SniperJSON::getValidChar( const std::string& jstr, StrCursor& cursor ) {
  cursor = jstr.find_first_not_of( SPACES, cursor );
  if ( cursor != std::string::npos ) { return jstr.at( cursor ); }
  throw Exception( jstr, cursor );
}
 
void SniperJSON::readObjectMap( const std::string& jstr, StrCursor& cursor ) {
  bool status = true;
 
  if ( getValidChar( jstr, ++cursor ) != '}' )
  {
    --cursor; // reset the cursor just before the first key
    do {
      readStringStr( jstr, ++cursor );
      const std::string& key = m_jvar;
      if ( key.size() == 2 || getValidChar( jstr, cursor ) != ':' )
      {
        status = false;
        break;
      }
      m_jmap.insert( std::make_pair( key, SniperJSON( jstr, ++cursor ) ) );
    } while ( getValidChar( jstr, cursor ) == ',' );
  }
 
  m_jvar.clear();
 
  if ( status && getValidChar( jstr, cursor ) == '}' )
  {
    ++cursor;
    return;
  }
 
  throw Exception( jstr, cursor );
}
 
void SniperJSON::readArrayVec( const std::string& jstr, StrCursor& cursor ) {
  if ( getValidChar( jstr, ++cursor ) != ']' )
  {
    --cursor; // reset the cursor just before the first variable
    do {
      m_jvec.push_back( SniperJSON( jstr, ++cursor ) );
    } while ( getValidChar( jstr, cursor ) == ',' );
  }
 
  if ( getValidChar( jstr, cursor ) == ']' )
  {
    ++cursor;
    return;
  }
 
  throw Exception( jstr, cursor );
}
 
void SniperJSON::readStringStr( const std::string& jstr, StrCursor& cursor ) {
  if ( getValidChar( jstr, cursor ) == '"' )
  {
    StrCursor pstart = cursor;
    cursor           = jstr.find( '"', pstart + 1 );
    if ( cursor != std::string::npos )
    {
      ++cursor;
      m_jvar = jstr.substr( pstart, cursor - pstart );
      return;
    }
  }
 
  throw Exception( jstr, cursor );
}
 
void SniperJSON::readScalarStr( const std::string& jstr, StrCursor& cursor ) {
  StrCursor pstart = cursor;
  cursor           = jstr.find_first_of( DELIMITS, pstart + 1 );
  if ( cursor != std::string::npos || pstart == 0 )
  {
    m_jvar = jstr.substr( pstart, cursor - pstart );
    return;
  }
 
  throw Exception( jstr, cursor );
}
 
SniperJSON::Exception::Exception( const std::string& msg ) : m_msg( "json error: " ) {
  m_msg += msg;
}
 
SniperJSON::Exception::Exception( const std::string& jstr, int cursor )
    : m_msg( "invalid json:\n" ) {
  m_msg += jstr.substr( 0, cursor + 1 );
  m_msg += " <<< parsing error";
}
 
SniperJSON::Exception::~Exception() throw() {}
 
const char* SniperJSON::Exception::what() const throw() { return m_msg.c_str(); }