odjson.h

Go to the documentation of this file.

#pragma once
/*
________________________________________________________________________
 
 (C) dGB Beheer B.V.; (LICENSE) http://opendtect.org/OpendTect_license.txt
 Author:        Bert
 Date:          April 2018
________________________________________________________________________
 
*/
 
#include "filepath.h"
#include "od_iosfwd.h"
#include "typeset.h"
#include "uistringset.h"
 
class DBKeySet;
class DBKey;
class MultiID;
class SeparString;
class StringBuilder;
namespace Gason { struct JsonNode; }
 
 
namespace OD
{
 
namespace JSON
{
 
class Array;
class KeyedValue;
class Object;
class Value;
 
enum DataType
{
    Boolean, Number, String
};
 
typedef double NumberType;
 
 
mExpClass(Basic) ValArr
{
public:
 
    typedef BoolTypeSet::size_type      size_type;
    typedef size_type                   idx_type;
    typedef BoolTypeSet                 BSet;
    typedef TypeSet<NumberType>         NSet;
    typedef BufferStringSet             SSet;
 
                        ValArr(DataType);
                        ValArr(const ValArr&);
                        ~ValArr()               { delete set_; }
    DataType            dataType() const        { return type_; }
 
    size_type           size() const
                        { return (size_type)set_->nrItems(); }
    bool                validIdx( idx_type idx ) const
                        { return set_->validIdx(idx); }
    bool                isEmpty() const         { return set_->isEmpty(); }
    void                setEmpty()              { set_->setEmpty(); }
 
    OD::Set&            odSet()                 { return *set_; }
    const OD::Set&      odSet() const           { return *set_; }
    BSet&               bools()                 { return *((BSet*)set_); }
    const BSet&         bools() const           { return *((BSet*)set_); }
    NSet&               vals()                  { return *((NSet*)set_); }
    const NSet&         vals() const            { return *((NSet*)set_); }
    SSet&               strings()               { return *((SSet*)set_); }
    const SSet&         strings() const         { return *((SSet*)set_); }
 
    void                dumpJSon(BufferString&) const;
    void                dumpJSon(StringBuilder&) const;
    BufferString        dumpJSon() const;
 
protected:
 
    DataType            type_ = Boolean;
    OD::Set*            set_ = nullptr;
 
};
 
 
mExpClass(Basic) ValueSet
{ mODTextTranslationClass(OD::JSON::ValueSet)
public:
 
    typedef ValArr::size_type   size_type;
    typedef size_type           idx_type;
    enum ValueType              { Data, SubArray, SubObject };
    typedef Gason::JsonNode     GasonNode;
 
    virtual ValueSet*   clone() const                   = 0;
    virtual             ~ValueSet()                     { setEmpty(); }
    virtual bool        isArray() const                  = 0;
    inline Array&       asArray();
    inline const Array& asArray() const;
    inline Object&      asObject();
    inline const Object& asObject() const;
 
    virtual size_type   size() const
                        { return (size_type)values_.size(); }
    virtual bool        isEmpty() const
                        { return values_.isEmpty(); }
    virtual void        setEmpty();
 
    virtual ValueType   valueType(idx_type) const;
    inline bool         isPlainData( idx_type i ) const
                        { return valueType(i) == Data; }
    inline bool         isArrayChild( idx_type i ) const
                        { return valueType(i) == SubArray; }
    inline bool         isObjectChild( idx_type i ) const
                        { return valueType(i) == SubObject; }
 
    bool                isTop() const           { return !parent_; }
    ValueSet*           top();
    const ValueSet*     top() const;
 
#   define              mMkGetFns(typ,getfn,implfn) \
    inline typ&         getfn( idx_type i )             { return *implfn(i); } \
    inline const typ&   getfn( idx_type i ) const       { return *implfn(i); }
    mMkGetFns(ValueSet, child, gtChildByIdx )
    mMkGetFns(Array,    array, gtArrayByIdx )
    mMkGetFns(Object,   object, gtObjectByIdx )
#   undef               mMkSubFn
 
    bool                getBoolValue(idx_type) const;
    od_int64            getIntValue(idx_type) const;
    double              getDoubleValue(idx_type) const;
    BufferString        getStringValue(idx_type) const;
    FilePath            getFilePath(idx_type) const;
 
    uiRetVal            parseJSon(char* buf,int bufsz);
    static ValueSet*    getFromJSon(char* buf,int bufsz,uiRetVal&);
    void                dumpJSon(BufferString&) const;
    void                dumpJSon(StringBuilder&) const;
    BufferString        dumpJSon() const;
 
    uiRetVal            read(od_istream&);
    static ValueSet*    read(od_istream&,uiRetVal&);
    uiRetVal            write(od_ostream&);
 
protected:
 
                        ValueSet( ValueSet* p )
                            : parent_(p)        {}
                        ValueSet(const ValueSet&);
 
    ValueSet*           parent_;
    ObjectSet<Value>    values_;
 
    void                setParent( ValueSet* p )        { parent_ = p; }
 
    ValueSet*           gtChildByIdx(idx_type) const;
    Array*              gtArrayByIdx(idx_type) const;
    Object*             gtObjectByIdx(idx_type) const;
 
    static ValueSet*    gtByParse(char*,int,uiRetVal&,ValueSet*);
    void                use(const GasonNode&);
 
    friend class        Array;
    friend class        Object;
    friend class        Value;
    static const char* gtvalnotplaindatastr()
                                { return "ValueSet at idx is not plain data"; }
};
 
 
mExpClass(Basic) Array : public ValueSet
{
public:
 
                        Array(bool objects,ValueSet* p=0);
                        Array(DataType,ValueSet* p=0);
                        Array(const Array&);
                        ~Array();
    virtual Array*      clone() const           { return new Array(*this); }
    virtual bool        isArray() const         { return true; }
    virtual void        setEmpty();
 
    virtual ValueType   valueType(idx_type) const { return valtype_; }
    ValueType           valType() const         { return valtype_; }
    virtual size_type   size() const;
 
                        // Only available if valType() == Data
    inline ValArr&      valArr()                { return *valarr_; }
    inline const ValArr& valArr() const         { return *valarr_; }
 
    Array*              add(Array*);
    Object*             add(Object*);
 
                        // only usable if valType() == Data
    Array&              add(bool);
    Array&              add(od_int16);
    Array&              add(od_uint16);
    Array&              add(od_int32);
    Array&              add(od_uint32);
    Array&              add(od_int64);
    Array&              add(float);
    Array&              add(double);
    Array&              add(const char*);
    Array&              add( const OD::String& odstr )
                        { return add( odstr.str() ); }
    Array&              add(const uiString&);
    Array&              add(const FilePath&);
    Array&              add(const MultiID&);
    Array&              add(const DBKey&);
 
    Array&              set(bool);
    Array&              set(const od_int16);
    Array&              set(const od_uint16);
    Array&              set(const od_int32);
    Array&              set(const od_uint32);
    Array&              set(const od_int64);
    Array&              set(const float);
    Array&              set(const double);
    void                set(const uiStringSet&);
    void                set(const DBKeySet&);
    Array&              set(const char*);
    Array&              set(const OD::String&);
    Array&              set(const uiString&);
    Array&              set(const FilePath&);
 
    Array&              set(const MultiID&);
    Array&              set(const DBKey&);
 
    void                set(const BufferStringSet&);
    void                set(const BoolTypeSet&);
    void                set(const TypeSet<od_int16>&);
    void                set(const TypeSet<od_uint16>&);
    void                set(const TypeSet<od_int32>&);
    void                set(const TypeSet<od_uint32>&);
    void                set(const TypeSet<od_int64>&);
    void                set(const TypeSet<float>&);
    void                set(const TypeSet<double>&);
    Array&              set(const bool*,size_type);
    Array&              set(const od_int16*,size_type);
    Array&              set(const od_uint16*,size_type);
    Array&              set(const od_int32*,size_type);
    Array&              set(const od_uint32*,size_type);
    Array&              set(const od_int64*,size_type);
    Array&              set(const float*,size_type);
    Array&              set(const double*,size_type);
 
 
protected:
 
    ValueType           valtype_;
    ValArr*             valarr_;
 
    template <class T>
    void                setVals(const TypeSet<T>&);
    template <class T>
    Array&              setVals(const T*,size_type);
    void                addVS(ValueSet*);
 
    friend class        ValueSet;
    static const char* addarrnonvalstr()
                                { return "add value to non-value Array"; }
};
 
 
mExpClass(Basic) Object : public ValueSet
{
public:
 
                        Object( ValueSet* p=0 )
                            : ValueSet(p)       {}
                        Object(const Object&);
    virtual Object*     clone() const           { return new Object(*this); }
    virtual bool        isArray() const         { return false; }
 
    idx_type            indexOf(const char*) const;
    bool                isPresent( const char* ky ) const
                                                { return indexOf(ky) >= 0; }
 
#   define              mMkGetFn(typ,getfn,implfn) \
    inline typ*         getfn( const char* ky )         { return implfn(ky); } \
    inline const typ*   getfn( const char* ky ) const   { return implfn(ky); }
    mMkGetFn(ValueSet,  getChild, gtChildByKey )
    mMkGetFn(Array,     getArray, gtArrayByKey )
    mMkGetFn(Object,    getObject, gtObjectByKey )
#   undef               mMkGetFn
    void                getSubObjKeys(BufferStringSet&) const;
    inline ValueSet*    getChild( const BufferStringSet& bskey )
                                            { return gtChildByKeys( bskey ); }
    inline const ValueSet*      getChild( const BufferStringSet& bskey ) const
                                            { return gtChildByKeys( bskey ); }
    inline Array*       getArray( const BufferStringSet& bskey )
                                            { return gtArrayByKeys( bskey ); }
    inline const Array* getArray( const BufferStringSet& bskey ) const
                                            { return gtArrayByKeys( bskey ); }
    inline Object*      getObject( const BufferStringSet& bskey )
                                            { return gtObjectByKeys( bskey ); }
    inline const Object*        getObject( const BufferStringSet& bskey ) const
                                            { return gtObjectByKeys( bskey ); }
 
    bool                getBoolValue(const char*) const;
    od_int64            getIntValue(const char*) const;
    double              getDoubleValue(const char*) const;
    BufferString        getStringValue(const char*) const;
    FilePath        getFilePath(const char*) const;
    bool                getStrings(const char*,BufferStringSet&) const;
    bool                getGeomID(const char*,Pos::GeomID&) const;
    template <class T>
    bool                get(const char*,Interval<T>&) const;
 
    Array*              set(const char* ky,Array*);
    Object*             set(const char* ky,Object*);
 
    void                set(const char* ky,bool);
    void                set(const char* ky,od_int16);
    void                set(const char* ky,od_uint16);
    void                set(const char* ky,od_int32);
    void                set(const char* ky,od_uint32);
    void                set(const char* ky,od_int64);
    void                set(const char* ky,float);
    void                set(const char* ky,double);
    void                set(const char* ky,const char*);
    void                set( const char* ky, const OD::String& str )
                        { set( ky, str.str() ); }
    void                set(const char* ky,const FilePath&);
    void                set(const char* ky,const DBKey&);
    void                set(const char* ky,const MultiID&);
    void                set(const char* ky,const uiString&);
    template <class T>
    void                set(const char* ky,const Interval<T>&);
 
    void                remove(const char*);
 
protected:
 
    ValueSet*           gtChildByKey(const char*) const;
    Array*              gtArrayByKey(const char*) const;
    Object*             gtObjectByKey(const char*) const;
    ValueSet*           gtChildByKeys(const BufferStringSet&) const;
    Array*              gtArrayByKeys(const BufferStringSet&) const;
    Object*             gtObjectByKeys(const BufferStringSet&) const;
 
    void                set(KeyedValue*);
    void                setVS(const char*,ValueSet*);
    template <class T>
    void                setVal(const char*,T);
 
    friend class        ValueSet;
 
    static const char* errnoemptykey()
                                { return "Empty key not allowed for Object's"; }
};
 
 
inline Array& ValueSet::asArray()
{ return *static_cast<Array*>( this ); }
inline const Array& ValueSet::asArray() const
{ return *static_cast<const Array*>( this ); }
inline Object& ValueSet::asObject()
{ return *static_cast<Object*>( this ); }
inline const Object& ValueSet::asObject() const
{ return *static_cast<const Object*>( this ); }
 
template <class T>
inline bool OD::JSON::Object::get( const char* key, Interval<T>& intrvl ) const
{
    const Array* arr = getArray( key );
    if ( !arr )
        return false;
    const TypeSet<NumberType> intrvals = arr->valArr().vals();
 
    intrvl.start = intrvals[0];
    intrvl.stop = intrvals[1];
 
    if ( intrvl.hasStep() )
    {
        mDynamicCastGet(StepInterval<T>*,si,&intrvl)
            si->step = intrvals[2];
    }
    return true;
}
 
 
template <class T>
inline void OD::JSON::Object::set( const char* key, const Interval<T>& intrvl )
{
    Array* arr = new Array(DataType::Number);
    TypeSet<NumberType> intrvals;
    intrvals.add( intrvl.start ).add( intrvl.stop );
 
    if ( intrvl.hasStep() )
    {
        mDynamicCastGet(const StepInterval<T>*,si,&intrvl)
            intrvals.add( si->step );
    }
 
    arr->set( intrvals );
    set( key, arr );
}
 
} // namespace JSON
 
} // namespace OD