json.hpp

#pragma once
//                                                                             
//  Copyright (C) 2008-2012  Artyom Beilis (Tonkikh) <artyomtnk@yahoo.com>     
//                                                                             
//  See accompanying file COPYING.TXT file for licensing details.
//
#include <vector>
#include <map>
#include <string>
#include <iostream>
#include <limits>
#include <string.h>
#include <typeinfo>

#ifndef DLPRIM_API
#define DLPRIM_API
#endif

namespace dlprim {
namespace json {
        template<typename T>
        class copy_ptr {
                T *ptr_;
        public:
                copy_ptr() : ptr_(0) {}
                explicit copy_ptr(T *v) : ptr_(v) {}
                copy_ptr(copy_ptr const &other) :
                        ptr_(other.ptr_ ? new T(*other.ptr_) : 0)
                {
                }
                copy_ptr(copy_ptr &&other) : ptr_(other.ptr_)
                {
                        other.ptr_ = 0;
                }
                copy_ptr &operator=(copy_ptr &&other) 
                {
                        if(this!=&other) {
                                this->swap(other);
                                other.reset();
                        }
                        return *this;
                }
                copy_ptr const &operator=(copy_ptr const &other)
                {
                        if(this != &other) {
                                copy_ptr tmp(other);
                                swap(tmp);
                        }
                        return *this;
                }
                ~copy_ptr() {
                        if(ptr_) delete ptr_;
                }

                T const *get() const { return ptr_; }
                T *get() { return ptr_; }

                T const &operator *() const { return *ptr_; }
                T &operator *() { return *ptr_; }
                T const *operator->() const { return ptr_; }
                T *operator->() { return ptr_; }
                T *release() { T *tmp=ptr_; ptr_=0; return tmp; }
                void reset(T *p=0)
                {
                        if(ptr_) delete ptr_;
                        ptr_=p;
                }
                void swap(copy_ptr &other)
                {
                        T *tmp=other.ptr_;
                        other.ptr_=ptr_;
                        ptr_=tmp;
                }
        };
        class string_key {
        public:

                typedef char const *const_iterator;

                static const size_t npos = -1;
                
                string_key() : 
                        begin_(0),
                        end_(0)
                {
                }

                string_key(char const *key) :
                        begin_(0),
                        end_(0),
                        key_(key)
                {
                }
                string_key(std::string const &key) :
                        begin_(0),
                        end_(0),
                        key_(key)
                {
                }
                size_t size() const
                {
                        return end() - begin();
                }
                size_t length() const
                {
                        return size();
                }
                void clear()
                {
                        begin_ = end_ = 0;
                        key_.clear();
                }
                bool empty() const
                {
                        return end() == begin();
                }
                size_t find(char c,size_t pos = 0) const
                {
                        size_t s = size();
                        if(pos >= s)
                                return npos;
                        char const *p=begin() + pos;
                        while(pos <= s && *p!=c) {
                                pos++;
                                p++;
                        }
                        if(pos >= s)
                                return npos;
                        return pos;
                }

                string_key substr(size_t pos = 0,size_t n=npos) const
                {
                        string_key tmp = unowned_substr(pos,n);
                        return string_key(std::string(tmp.begin(),tmp.end()));
                }
                string_key unowned_substr(size_t pos = 0,size_t n=npos) const
                {
                        if(pos >= size()) {
                                return string_key();
                        }
                        char const *p=begin() + pos;
                        char const *e=end();
                        if(n > size_t(e-p)) {
                                return string_key(p,e);
                        }
                        else {
                                return string_key(p,p+n);
                        }
                }
                
                char const &operator[](size_t n) const
                {
                        return *(begin() + n);
                }
                char const &at(size_t n) const
                {
                        if(n > size())
                                throw std::out_of_range("dlprim::string_key::at() range error");
                        return *(begin() + n);
                }

                static string_key unowned(std::string const &v) 
                {
                        return string_key(v.c_str(),v.c_str()+v.size());
                }
                static string_key unowned(char const *str) 
                {
                        char const *end = str;
                        while(*end)
                                end++;
                        return string_key(str,end);
                }
                static string_key unowned(char const *begin,char const *end) 
                {
                        return string_key(begin,end);
                }

                char const *begin() const
                {
                        if(begin_)
                                return begin_;
                        return key_.c_str();
                }
                char const *end() const
                {
                        if(begin_)
                                return end_;
                        return key_.c_str() + key_.size();
                }
                bool operator<(string_key const &other) const
                {
                        return std::lexicographical_compare(    begin(),end(),
                                                                other.begin(),other.end(),
                                                                std::char_traits<char>::lt);
                }
                bool operator>(string_key const &other) const
                {
                        return other < *this;
                }
                bool operator>=(string_key const &other) const
                {
                        return !(*this < other);
                }
                bool operator<=(string_key const &other) const
                {
                        return !(*this > other);
                }
                bool operator==(string_key const &other) const
                {
                        return (end() - begin() == other.end() - other.begin())
                                && memcmp(begin(),other.begin(),end()-begin()) == 0;
                }
                bool operator!=(string_key const &other) const
                {
                        return !(*this==other);
                }

                char const *data() const
                {
                        return begin();
                }

                std::string str() const
                {
                        if(begin_)
                                return std::string(begin_,end_-begin_);
                        else
                                return key_;
                }
                operator std::string() const
                {
                        return str();
                }
        private:
                string_key(char const *b,char const *e) :
                        begin_(b),
                        end_(e)
                {
                }

                char const *begin_;
                char const *end_;
                std::string key_;
        };

        inline std::ostream &operator<<(std::ostream &out,string_key const &s)
        {
                out.write(s.data(),s.size());
                return out;
        }

        inline bool operator==(string_key const &l,char const *r)
        {
                return l==string_key::unowned(r);
        }

        inline bool operator==(char const *l,string_key const &r)
        {
                return string_key::unowned(l) == r;
        }

        inline bool operator==(string_key const &l,std::string const &r)
        {
                return l==string_key::unowned(r);
        }


        inline bool operator==(std::string const &l,string_key const &r)
        {
                return string_key::unowned(l) == r;
        }

        inline bool operator!=(string_key const &l,char const *r)
        {
                return l!=string_key::unowned(r);
        }

        inline bool operator!=(char const *l,string_key const &r)
        {
                return string_key::unowned(l) != r;
        }

        inline bool operator!=(string_key const &l,std::string const &r)
        {
                return l!=string_key::unowned(r);
        }

        inline bool operator!=(std::string const &l,string_key const &r)
        {
                return string_key::unowned(l) != r;
        }
        inline bool operator<=(string_key const &l,char const *r)
        {
                return l<=string_key::unowned(r);
        }

        inline bool operator<=(char const *l,string_key const &r)
        {
                return string_key::unowned(l) <= r;
        }

        inline bool operator<=(string_key const &l,std::string const &r)
        {
                return l<=string_key::unowned(r);
        }

        inline bool operator<=(std::string const &l,string_key const &r)
        {
                return string_key::unowned(l) <= r;
        }
        inline bool operator>=(string_key const &l,char const *r)
        {
                return l>=string_key::unowned(r);
        }

        inline bool operator>=(char const *l,string_key const &r)
        {
                return string_key::unowned(l) >= r;
        }

        inline bool operator>=(string_key const &l,std::string const &r)
        {
                return l>=string_key::unowned(r);
        }

        inline bool operator>=(std::string const &l,string_key const &r)
        {
                return string_key::unowned(l) >= r;
        }


        inline bool operator<(string_key const &l,char const *r)
        {
                return l<string_key::unowned(r);
        }

        inline bool operator<(char const *l,string_key const &r)
        {
                return string_key::unowned(l) < r;
        }

        inline bool operator<(string_key const &l,std::string const &r)
        {
                return l<string_key::unowned(r);
        }

        inline bool operator<(std::string const &l,string_key const &r)
        {
                return string_key::unowned(l) < r;
        }
        inline bool operator>(string_key const &l,char const *r)
        {
                return l>string_key::unowned(r);
        }

        inline bool operator>(char const *l,string_key const &r)
        {
                return string_key::unowned(l) > r;
        }

        inline bool operator>(string_key const &l,std::string const &r)
        {
                return l>string_key::unowned(r);
        }

        inline bool operator>(std::string const &l,string_key const &r)
        {
                return string_key::unowned(l) > r;
        }


        class value;

        struct null {};
        struct undefined {};

        inline bool operator==(undefined const &/*l*/,undefined const &/*r*/) {return true;}
        inline bool operator!=(undefined const &/*l*/,undefined const &/*r*/) {return false;}
        inline bool operator==(null const &/*l*/,null const &/*r*/) {return true;}
        inline bool operator!=(null const &/*l*/,null const &/*r*/) {return false;}

        typedef std::vector<value> array;
        typedef std::map<string_key,value> object;

        
        template<typename T>
        struct traits;


        typedef enum {
                is_undefined,   
                is_null,        
                is_boolean,     
                is_number,      
                is_string,      
                is_object,      
                is_array        
        } json_type;


        enum {
                compact = 0, 
                readable = 1 
        };
        
        class DLPRIM_API bad_value_cast : public std::bad_cast {
        public:
                bad_value_cast(); 
                bad_value_cast(std::string const &s);
                bad_value_cast(std::string const &s,json_type actual);
                bad_value_cast(std::string const &s,json_type expected, json_type actual);

                virtual ~bad_value_cast() throw();
                virtual const char* what() const throw();
        private:
                std::string msg_;
        };
        
        class value;

        std::istream DLPRIM_API &operator>>(std::istream &in,value &v);

        std::ostream DLPRIM_API &operator<<(std::ostream &out,value const &v);

        std::ostream DLPRIM_API &operator<<(std::ostream &out,json_type);

        class DLPRIM_API value {
        public:

                json_type type() const;
                
                bool is_undefined() const;
                bool is_null() const;

                bool const &boolean() const;
                double const &number() const;
                std::string const &str() const;
                json::object const &object() const;
                json::array const &array() const;

                bool &boolean();
                double &number();
                std::string &str();
                json::object &object();
                json::array &array();

                void undefined();
                void null();

                void boolean(bool);
                void number(double );
                void str(std::string const &);
                void object(json::object const &);
                void array(json::array const &);


                template<typename T>
                T get_value() const
                {
                        return traits<T>::get(*this);
                }
                
                template<typename T>
                void set_value(T const &v)
                {
                        traits<T>::set(*this,v);
                }

                value const &find(std::string const &path) const;               
                value const &find(char const *path) const;              

                value const &at(std::string const &path) const;  
                value const &at(char const *path) const;  
                value &at(std::string const &path);
                value &at(char const *path);

                void at(std::string const &path,value const &v);
                void at(char const *path,value const &v);

                
                template<typename T>
                value(T const &v)
                {
                        set_value(v);
                }

                json_type type(std::string const &path) const
                {
                        return find(path).type();
                }
                json_type type(char const *path) const
                {
                        return find(path).type();
                }

                template<typename T>
                void set(std::string const &path,T const &v)
                {
                        at(path,value(v));
                }
                template<typename T>
                void set(char const *path,T const &v)
                {
                        at(path,value(v));
                }

                std::string get(std::string const &path,char const *def) const
                {
                        value const &v=find(path);
                        if(v.is_undefined())
                                return def;
                        try {
                                return v.get_value<std::string>();
                        }
                        catch(std::bad_cast const &e) {
                                return def;
                        }
                }
                std::string get(char const *path,char const *def) const
                {
                        value const &v=find(path);
                        if(v.is_undefined())
                                return def;
                        try {
                                return v.get_value<std::string>();
                        }
                        catch(std::bad_cast const &e) {
                                return def;
                        }
                }
                
                template<typename T>
                T get(std::string const &path) const
                {
                        return at(path).get_value<T>();
                }
                template<typename T>
                T get(char const *path) const
                {
                        return at(path).get_value<T>();
                }

                template<typename T>
                T get(char const *path,T const &def) const
                {
                        value const &v=find(path);
                        if(v.is_undefined())
                                return def;
                        try {
                                return v.get_value<T>();
                        }
                        catch(std::bad_cast const &e) {
                                return def;
                        }
                }
                template<typename T>
                T get(std::string const &path,T const &def) const
                {
                        value const &v=find(path);
                        if(v.is_undefined())
                                return def;
                        try {
                                return v.get_value<T>();
                        }
                        catch(std::bad_cast const &e) {
                                return def;
                        }
                }

                value &operator[](std::string const &name);

                value const &operator[](std::string const &name) const;

                value &operator[](size_t n);
                value const &operator[](size_t n) const;

                std::string save(int how=compact) const;
                void save(std::ostream &out,int how=compact) const;
                bool load(std::istream &in,bool full,int *line_number=0);

                bool load(char const *&begin,char const *end,bool full,int *line_number=0);

                bool operator==(value const &other) const;
                bool operator!=(value const &other) const;


                value &operator=(value &&other)
                {
                        d=std::move(other.d);
                        return *this;
                }
                value(value &&other) : d(std::move(other.d))
                {
                        
                }
                value(value const &other) :
                        d(other.d)
                {
                }
                value const &operator=(value const &other)
                {
                        d=other.d;
                        return *this;
                }
                value()
                {
                }
                

                ~value()
                {
                }

                void swap(value &other)
                {
                        d.swap(other.d);
                }

        private:

                void write(std::ostream &out,int tabs) const;
                void write_value(std::ostream &out,int tabs) const;

                struct _data;
                struct DLPRIM_API copyable {

                        _data *operator->() { return &*d; }
                        _data &operator*() { return *d; }
                        _data const *operator->() const { return &*d; }
                        _data const &operator*() const { return *d; }

                        copyable();
                        copyable(copyable const &r);
                        copyable(copyable &&);
                        copyable &operator=(copyable &&r);
                        copyable const &operator=(copyable const &r);
                        ~copyable();

                        void swap(copyable &other) 
                        {
                                d.swap(other.d);
                        }
                private:
                        copy_ptr<_data> d;
                } d;

                friend struct copyable;
        };


        std::string DLPRIM_API to_json(std::string const &utf);
        std::string DLPRIM_API to_json(char const *begin,char const *end);
        void DLPRIM_API to_json(char const *begin,char const *end,std::ostream &out);
        //
        void DLPRIM_API to_json(std::string const &str,std::ostream &out);

        

        template<typename T1,typename T2>
        struct traits<std::pair<T1,T2> > {
                static std::pair<T1,T2> get(value const &v)
                {
                        if(v.object().size()!=2)
                                throw bad_value_cast("Object with two members expected");
                        std::pair<T1,T2> pair(v.get_value<T1>("first"),v.get_value<T2>("second"));
                        return pair;
                }
                static void set(value &v,std::pair<T1,T2> const &in)
                {
                        v=json::object();
                        v.set_value("first",in.first);
                        v.set_value("second",in.second);
                }
        };

        template<typename T>
        struct traits<std::vector<T> > {
                static std::vector<T> get(value const &v)
                {
                        std::vector<T> result;
                        json::array const &a=v.array();
                        result.resize(a.size());
                        for(unsigned i=0;i<a.size();i++) 
                                result[i]=a[i].get_value<T>();
                        return result;
                }
                static void set(value &v,std::vector<T> const &in)
                {
                        v=json::array();
                        json::array &a=v.array();
                        a.resize(in.size());
                        for(unsigned i=0;i<in.size();i++)
                                a[i].set_value(in[i]);
                }
        };


        #define DLPRIM_JSON_SPECIALIZE(type,method)     \
        template<>                                      \
        struct traits<type> {                           \
                static type get(value const &v)         \
                {                                       \
                        return v.method();              \
                }                                       \
                static void set(value &v,type const &in)\
                {                                       \
                        v.method(in);                   \
                }                                       \
        };

        DLPRIM_JSON_SPECIALIZE(bool,boolean);
        DLPRIM_JSON_SPECIALIZE(double,number);
        DLPRIM_JSON_SPECIALIZE(std::string,str);
        DLPRIM_JSON_SPECIALIZE(json::object,object);
        DLPRIM_JSON_SPECIALIZE(json::array,array);

        #undef DLPRIM_JSON_SPECIALIZE
        
        #define DLPRIM_JSON_SPECIALIZE_INT(type)                        \
        template<>                                                      \
        struct traits<type> {                                           \
                static type get(value const &v)                         \
                {                                                       \
                        type res=static_cast<type>(v.number());         \
                        if(res!=v.number())                             \
                                throw bad_value_cast();                 \
                        return res;                                     \
                }                                                       \
                static void set(value &v,type const &in)                \
                {                                                       \
                        if(std::numeric_limits<type>::digits >          \
                                std::numeric_limits<double>::digits     \
                                && static_cast<double>(in)!=in)         \
                        {                                               \
                                throw bad_value_cast();                 \
                        }                                               \
                        v.number(static_cast<double>(in));              \
                }                                                       \
        };

        DLPRIM_JSON_SPECIALIZE_INT(char)
        DLPRIM_JSON_SPECIALIZE_INT(unsigned char)
        DLPRIM_JSON_SPECIALIZE_INT(signed char)
        DLPRIM_JSON_SPECIALIZE_INT(wchar_t)
        DLPRIM_JSON_SPECIALIZE_INT(short)
        DLPRIM_JSON_SPECIALIZE_INT(unsigned short)
        DLPRIM_JSON_SPECIALIZE_INT(int)
        DLPRIM_JSON_SPECIALIZE_INT(unsigned int)
        DLPRIM_JSON_SPECIALIZE_INT(long)
        DLPRIM_JSON_SPECIALIZE_INT(unsigned long)
        DLPRIM_JSON_SPECIALIZE_INT(long long)
        DLPRIM_JSON_SPECIALIZE_INT(unsigned long long)

        #undef DLPRIM_JSON_SPECIALIZE_INT

        template<>
        struct traits<float> {
                static float get(value const &v)
                {
                        double r=v.number();
                        if(     r < (-std::numeric_limits<float>::max()) // actually should be C++11 lowest, but it should be under IEEE float lowest()=-max()
                             || std::numeric_limits<float>::max() < r )
                        {
                                throw bad_value_cast();
                        }
                        return static_cast<float>(r);
                }
                static void set(value &v,float const &in)
                {
                        v.number(in);
                }
        };
        
        template<>
        struct traits<long double> {
                static long double get(value const &v)
                {
                        return v.number();
                }
                static void set(value &v,long double const &in)
                {
                        if( in < -std::numeric_limits<double>::max() // should actually be std::numeric_limits<float>::lowest() but it is ==-max()
                             || std::numeric_limits<double>::max() < in )
                        {
                                throw bad_value_cast();
                        }
                        v.number(static_cast<double>(in));
                }
        };

        template<>                                      
        struct traits<json::null> {                             
                static void set(value &v,json::null const &/*in*/)
                {                                       
                        v.null();
                }                                       
        };

        template<int n>                                 
        struct traits<char[n]> {                        
                typedef char vtype[n];
                static void set(value &v,vtype const &in)
                {                                       
                        v.str(in);
                }                                       
        };
        template<int n>                                 
        struct traits<char const [n]> {                 
                typedef char const vtype[n];
                static void set(value &v,vtype const &in)
                {                                       
                        v.str(in);
                }
        };

        
        template<>                                      
        struct traits<char const *> {                   
                static void set(value &v,char const * const &in)
                {                                       
                        v.str(in);
                }                                       
        };
        


} // json
} // dlprim