Json.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef ZYPP_BASE_JSON_H
#define ZYPP_BASE_JSON_H
 
#include <iosfwd>
#include <string>
#include <vector>
#include <list>
#include <set>
#include <map>
 
#include <zypp/base/Easy.h>
#include <zypp/base/String.h>
 
namespace zypp
{
  namespace json
  {
    // JSN Keywords
    inline static const std::string & nullJSON()        { static const std::string _s( "null" );  return _s; }
    inline static const std::string & trueJSON()        { static const std::string _s( "true" );  return _s; }
    inline static const std::string & falseJSON()       { static const std::string _s( "false" ); return _s; }
 
    namespace detail
    {
      inline std::string strEncode( std::string val_r )
      {
        typedef unsigned char uchar;
 
        std::string::size_type add = 2; // enclosing "s
        for_( r, val_r.begin(), val_r.end() )
        {
          if ( uchar(*r) < 32u )
          {
            switch ( *r )
            {
              case '\b':
              case '\f':
              case '\n':
              case '\r':
              case '\t':
                add += 1;       // "\c"
                break;
              default:
                add += 5;       // "\uXXXX"
                break;
            }
          }
          else
          {
            switch ( *r )
            {
              case '"':
              case '/':
              case '\\':
                add += 1;       // \-escape
                break;
            }
          }
        }
 
        val_r.resize( val_r.size() + add, '@' );
        auto w( val_r.rbegin() );
        auto r( w + add );
 
        *w++ = '"';
        for ( ; r != val_r.rend(); ++r )
        {
          if ( uchar(*r) < 32u )
          {
            static const char * digit = "0123456789abcdef";
            switch ( *r )
            {
              case '\b':        // "\c"
                *w++ = 'b';
                *w++ = '\\';
                break;
              case '\f':        // "\c"
                *w++ = 'f';
                *w++ = '\\';
                break;
              case '\n':        // "\c"
                *w++ = 'n';
                *w++ = '\\';
                break;
              case '\r':        // "\c"
                *w++ = 'r';
                *w++ = '\\';
                break;
              case '\t':        // "\c"
                *w++ = 't';
                *w++ = '\\';
                break;
              default:          // "\uXXXX"
                *w++ = digit[uchar(*r) % 15];
                *w++ = digit[uchar(*r) / 16];
                *w++ = '0';
                *w++ = '0';
                *w++ = 'u';
                *w++ = '\\';
                break;
            }
          }
          else
          {
            switch ( (*w++ = *r) )
            {
              case '"':
              case '/':
              case '\\':        // \-escape
                *w++ = '\\';
                break;
            }
          }
        }
        *w++ = '"';
        return val_r;
      }
    } // namespace detail
 
    // null
    inline std::string toJSON( void )                   { return nullJSON(); }
    inline std::string toJSON( std::nullptr_t )         { return nullJSON(); }
 
    // bool
    inline std::string toJSON( bool val_r  )            { return val_r ? trueJSON() : falseJSON(); }
    inline std::string toJSON( const void * val_r )     { return val_r ? trueJSON() : falseJSON(); }
 
    // numbers
    inline std::string toJSON( short val_r )            { return str::numstring( val_r ); }
    inline std::string toJSON( unsigned short val_r )   { return str::numstring( val_r ); }
    inline std::string toJSON( int val_r )              { return str::numstring( val_r ); }
    inline std::string toJSON( unsigned val_r )         { return str::numstring( val_r ); }
    inline std::string toJSON( long val_r )             { return str::numstring( val_r ); }
    inline std::string toJSON( unsigned long val_r )    { return str::numstring( val_r ); }
    inline std::string toJSON( long long val_r )        { return str::numstring( val_r ); }
    inline std::string toJSON( unsigned long long val_r ){ return str::numstring( val_r ); }
 
    // strings
    inline std::string toJSON( const char val_r )       { return detail::strEncode( std::string( 1, val_r ) ); }
    inline std::string toJSON( const char * val_r )     { return val_r ? detail::strEncode( val_r ) : nullJSON(); }
    inline std::string toJSON( const std::string & val_r ){ return detail::strEncode( val_r ); }
 
    // container to Array
    template <class V> std::string toJSON( const std::vector<V> & cont_r );
    template <class V> std::string toJSON( const std::list<V> & cont_r );
    template <class V> std::string toJSON( const std::set<V> & cont_r );
 
    // map to Object
    template <class K, class V> std::string toJSON( const std::map<K,V> & cont_r );
 
    template <class T>
    std::string toJSON( const T & val_r ) { return val_r.asJSON(); }
 
    struct Value
    {
      Value() : _data( toJSON() ) {}
 
      Value( const Value & rhs ) : _data( rhs._data ) {}
 
      template <class T>
      Value( const T & val_r ) : _data( toJSON( val_r ) ) {}
 
      const std::string & asJSON() const
      { return _data; }
 
      const std::string & asString() const
      { return asJSON(); }
 
      std::ostream & dumpOn( std::ostream & str ) const
      { return str << _data; }
 
    private:
      std::string _data;
    };
 
    inline std::ostream & operator<<( std::ostream & str, const Value & obj )
    { return obj.dumpOn( str ); }
 
 
    struct String : public Value
    {
      String()                          : Value( "" ) {}
      String( std::nullptr_t )          : Value( "" ) {}
 
      String( const char val_r )        : Value( val_r ) {}
      String( const char * val_r )      : Value( val_r ? val_r : "" ) {}
      String( const std::string & val_r ): Value( val_r ) {}
    };
 
    struct Array
    {
      Array() {}
 
      template <class Iterator>
      Array( Iterator begin, Iterator end )
      { for_( it, begin, end ) add( *it ); }
 
      Array( const std::initializer_list<Value> & contents_r )
        : Array( contents_r.begin(), contents_r.end() )
      {}
 
      void add( const Value & val_r )
      { _data.push_back( val_r.asJSON() ); }
 
      void add( const std::initializer_list<Value> & contents_r )
      { for_( it, contents_r.begin(), contents_r.end() ) add( *it ); }
 
      std::string asJSON() const
      { return str::Str() << *this; }
 
      std::string asString() const
      { return asJSON(); }
 
      std::ostream & dumpOn( std::ostream & str ) const
      {
        if ( _data.empty() )
          return str << "[]";
        str << '[' << *_data.begin();
        for_( val, ++_data.begin(), _data.end() )
          str << ", " << *val;
        return str << ']';
      }
 
    private:
      std::list<std::string> _data;
    };
 
    inline std::ostream & operator<<( std::ostream & str, const Array & obj )
    { return obj.dumpOn( str ); }
 
    template <class V>
    std::string toJSON( const std::vector<V> & cont_r )
    { return json::Array( cont_r.begin(), cont_r.end() ).asJSON(); }
 
    template <class V>
    std::string toJSON( const std::list<V> & cont_r )
    { return json::Array( cont_r.begin(), cont_r.end() ).asJSON(); }
 
    template <class V>
    std::string toJSON( const std::set<V> & cont_r )
    { return json::Array( cont_r.begin(), cont_r.end() ).asJSON(); }
 
    struct Object
    {
      Object() {}
 
      template <class Iterator>
      Object( Iterator begin, Iterator end )
      { for_( it, begin, end ) add( it->first, it->second ); }
 
      Object( const std::initializer_list<std::pair<String, Value>> & contents_r )
        : Object( contents_r.begin(), contents_r.end() )
      {}
 
      void add( const String & key_r, const Value & val_r )
      { _data[key_r.asJSON()] = val_r.asJSON(); }
 
      void add( const std::initializer_list<std::pair<String, Value>> & contents_r )
      { for_( it, contents_r.begin(), contents_r.end() ) add( it->first, it->second ); }
 
      std::string asJSON() const
      { return str::Str() << *this; }
 
      std::string asString() const
      { return asJSON(); }
 
      std::ostream & dumpOn( std::ostream & str ) const
      {
        using std::endl;
        if ( _data.empty() )
          return str << "{}";
        dumpOn( str << '{' << endl, _data.begin() );
        for_ ( val, ++_data.begin(), _data.end() )
          dumpOn( str << ',' << endl, val );
        return str << endl << '}';
      }
 
    private:
      std::ostream & dumpOn( std::ostream & str, std::map<std::string,std::string>::const_iterator val_r ) const
      { return str << val_r->first << ": " << val_r->second; }
 
      std::map<std::string,std::string> _data;
    };
 
    inline std::ostream & operator<<( std::ostream & str, const Object & obj )
    { return obj.dumpOn( str ); }
 
    template <class K, class V>
    std::string toJSON( const std::map<K,V> & cont_r )
    { return json::Object( cont_r.begin(), cont_r.end() ).asJSON(); }
 
 
  } // namespace json
} // namespace zypp
#endif // ZYPP_BASE_JSON_H