value.h

Go to the documentation of this file.

#ifndef CPPTL_JSON_H_INCLUDED
#define CPPTL_JSON_H_INCLUDED

#include "forwards.h"
#include <string>
#include <vector>

#ifndef JSON_USE_CPPTL_SMALLMAP
#include <map>
#else
#include <cpptl/smallmap.h>
#endif
#ifdef JSON_USE_CPPTL
#include <cpptl/forwards.h>
#endif

namespace Json {

  enum ValueType {
    nullValue = 0,  
    intValue,       
    uintValue,      
    realValue,      
    stringValue,    
    booleanValue,   
    arrayValue,     
    objectValue     
  };

  enum CommentPlacement {
    commentBefore = 0,       
    commentAfterOnSameLine,  
    commentAfter,            
    numberOfCommentPlacement
  };

  //# ifdef JSON_USE_CPPTL
  //   typedef CppTL::AnyEnumerator<const char *> EnumMemberNames;
  //   typedef CppTL::AnyEnumerator<const Value &> EnumValues;
  //# endif

  class JSON_API StaticString {
  public:
    explicit StaticString(const char *czstring) : str_(czstring) {}

    operator const char *() const { return str_; }

    const char *c_str() const { return str_; }

  private:
    const char *str_;
  };

  class JSON_API Value {
    friend class ValueIteratorBase;
#ifdef JSON_VALUE_USE_INTERNAL_MAP
    friend class ValueInternalLink;
    friend class ValueInternalMap;
#endif
  public:
    typedef std::vector<std::string> Members;
    typedef ValueIterator iterator;
    typedef ValueConstIterator const_iterator;
    typedef Json::UInt UInt;
    typedef Json::Int Int;
    typedef UInt ArrayIndex;

    static const Value null;
    static const Int minInt;
    static const Int maxInt;
    static const UInt maxUInt;

  private:
#ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
#ifndef JSON_VALUE_USE_INTERNAL_MAP
    class CZString {
    public:
      enum DuplicationPolicy { noDuplication = 0, duplicate, duplicateOnCopy };
      CZString(int index);
      CZString(const char *cstr, DuplicationPolicy allocate);
      CZString(const CZString &other);
      ~CZString();
      CZString &operator=(const CZString &other);
      bool operator<(const CZString &other) const;
      bool operator==(const CZString &other) const;
      int index() const;
      const char *c_str() const;
      bool isStaticString() const;

    private:
      void swap(CZString &other);
      const char *cstr_;
      int index_;
    };

  public:
#ifndef JSON_USE_CPPTL_SMALLMAP
    typedef std::map<CZString, Value> ObjectValues;
#else
    typedef CppTL::SmallMap<CZString, Value> ObjectValues;
#endif  // ifndef JSON_USE_CPPTL_SMALLMAP
#endif  // ifndef JSON_VALUE_USE_INTERNAL_MAP
#endif  // ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION

  public:
    Value(ValueType type = nullValue);
    Value(Int value);
    Value(UInt value);
    Value(double value);
    Value(const char *value);
    Value(const char *beginValue, const char *endValue);
    Value(const StaticString &value);
    Value(const std::string &value);
#ifdef JSON_USE_CPPTL
    Value(const CppTL::ConstString &value);
#endif
    Value(bool value);
    Value(const Value &other);
    ~Value();

    Value &operator=(const Value &other);
    void swap(Value &other);

    ValueType type() const;

    bool operator<(const Value &other) const;
    bool operator<=(const Value &other) const;
    bool operator>=(const Value &other) const;
    bool operator>(const Value &other) const;

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

    int compare(const Value &other);

    const char *asCString() const;
    std::string asString() const;
#ifdef JSON_USE_CPPTL
    CppTL::ConstString asConstString() const;
#endif
    Int asInt() const;
    UInt asUInt() const;
    double asDouble() const;
    bool asBool() const;

    bool isNull() const;
    bool isBool() const;
    bool isInt() const;
    bool isUInt() const;
    bool isIntegral() const;
    bool isDouble() const;
    bool isNumeric() const;
    bool isString() const;
    bool isArray() const;
    bool isObject() const;

    bool isConvertibleTo(ValueType other) const;

    UInt size() const;

    bool empty() const;

    bool operator!() const;

    void clear();

    void resize(UInt size);

    Value &operator[](UInt index);
    const Value &operator[](UInt index) const;
    Value get(UInt index, const Value &defaultValue) const;
    bool isValidIndex(UInt index) const;
    Value &append(const Value &value);

    Value &operator[](const char *key);
    const Value &operator[](const char *key) const;
    Value &operator[](const std::string &key);
    const Value &operator[](const std::string &key) const;
    Value &operator[](const StaticString &key);
#ifdef JSON_USE_CPPTL
    Value &operator[](const CppTL::ConstString &key);
    const Value &operator[](const CppTL::ConstString &key) const;
#endif
    Value get(const char *key, const Value &defaultValue) const;
    Value get(const std::string &key, const Value &defaultValue) const;
#ifdef JSON_USE_CPPTL
    Value get(const CppTL::ConstString &key, const Value &defaultValue) const;
#endif
    Value removeMember(const char *key);
    Value removeMember(const std::string &key);

    bool isMember(const char *key) const;
    bool isMember(const std::string &key) const;
#ifdef JSON_USE_CPPTL
    bool isMember(const CppTL::ConstString &key) const;
#endif

    Members getMemberNames() const;

    //# ifdef JSON_USE_CPPTL
    //      EnumMemberNames enumMemberNames() const;
    //      EnumValues enumValues() const;
    //# endif

    void setComment(const char *comment, CommentPlacement placement);
    void setComment(const std::string &comment, CommentPlacement placement);
    bool hasComment(CommentPlacement placement) const;
    std::string getComment(CommentPlacement placement) const;

    std::string toStyledString() const;

    const_iterator begin() const;
    const_iterator end() const;

    iterator begin();
    iterator end();

  private:
    Value &resolveReference(const char *key, bool isStatic);

#ifdef JSON_VALUE_USE_INTERNAL_MAP
    inline bool isItemAvailable() const { return itemIsUsed_ == 0; }

    inline void setItemUsed(bool isUsed = true) { itemIsUsed_ = isUsed ? 1 : 0; }

    inline bool isMemberNameStatic() const { return memberNameIsStatic_ == 0; }

    inline void setMemberNameIsStatic(bool isStatic) { memberNameIsStatic_ = isStatic ? 1 : 0; }
#endif  // # ifdef JSON_VALUE_USE_INTERNAL_MAP

  private:
    struct CommentInfo {
      CommentInfo();
      ~CommentInfo();

      void setComment(const char *text);

      char *comment_;
    };

    //struct MemberNamesTransform
    //{
    //   typedef const char *result_type;
    //   const char *operator()( const CZString &name ) const
    //   {
    //      return name.c_str();
    //   }
    //};

    union ValueHolder {
      Int int_;
      UInt uint_;
      double real_;
      bool bool_;
      char *string_;
#ifdef JSON_VALUE_USE_INTERNAL_MAP
      ValueInternalArray *array_;
      ValueInternalMap *map_;
#else
      ObjectValues *map_;
#endif
    } value_;
    ValueType type_ : 8;
    int allocated_ : 1;  // Notes: if declared as bool, bitfield is useless.
#ifdef JSON_VALUE_USE_INTERNAL_MAP
    unsigned int itemIsUsed_ : 1;  // used by the ValueInternalMap container.
    int memberNameIsStatic_ : 1;   // used by the ValueInternalMap container.
#endif
    CommentInfo *comments_;
  };

  class PathArgument {
  public:
    friend class Path;

    PathArgument();
    PathArgument(UInt index);
    PathArgument(const char *key);
    PathArgument(const std::string &key);

  private:
    enum Kind { kindNone = 0, kindIndex, kindKey };
    std::string key_;
    UInt index_;
    Kind kind_;
  };

  class Path {
  public:
    Path(const std::string &path,
         const PathArgument &a1 = PathArgument(),
         const PathArgument &a2 = PathArgument(),
         const PathArgument &a3 = PathArgument(),
         const PathArgument &a4 = PathArgument(),
         const PathArgument &a5 = PathArgument());

    const Value &resolve(const Value &root) const;
    Value resolve(const Value &root, const Value &defaultValue) const;
    Value &make(Value &root) const;

  private:
    typedef std::vector<const PathArgument *> InArgs;
    typedef std::vector<PathArgument> Args;

    void makePath(const std::string &path, const InArgs &in);
    void addPathInArg(const std::string &path,
                      const InArgs &in,
                      InArgs::const_iterator &itInArg,
                      PathArgument::Kind kind);
    void invalidPath(const std::string &path, int location);

    Args args_;
  };

  class ValueAllocator {
  public:
    enum { unknown = (unsigned)-1 };

    virtual ~ValueAllocator();

    virtual char *makeMemberName(const char *memberName) const = 0;
    virtual void releaseMemberName(char *memberName) const = 0;
    virtual char *duplicateStringValue(const char *value, unsigned int length = unknown) const = 0;
    virtual void releaseStringValue(char *value) const = 0;
  };

#ifdef JSON_VALUE_USE_INTERNAL_MAP

  class JSON_API ValueMapAllocator {
  public:
    virtual ~ValueMapAllocator();
    virtual ValueInternalMap *newMap() = 0;
    virtual ValueInternalMap *newMapCopy(const ValueInternalMap &other) = 0;
    virtual void destructMap(ValueInternalMap *map) = 0;
    virtual ValueInternalLink *allocateMapBuckets(unsigned int size) = 0;
    virtual void releaseMapBuckets(ValueInternalLink *links) = 0;
    virtual ValueInternalLink *allocateMapLink() = 0;
    virtual void releaseMapLink(ValueInternalLink *link) = 0;
  };

  class JSON_API ValueInternalLink {
  public:
    enum { itemPerLink = 6 };  // sizeof(ValueInternalLink) = 128 on 32 bits architecture.
    enum InternalFlags { flagAvailable = 0, flagUsed = 1 };

    ValueInternalLink();

    ~ValueInternalLink();

    Value items_[itemPerLink];
    char *keys_[itemPerLink];
    ValueInternalLink *previous_;
    ValueInternalLink *next_;
  };

  class JSON_API ValueInternalMap {
    friend class ValueIteratorBase;
    friend class Value;

  public:
    typedef unsigned int HashKey;
    typedef unsigned int BucketIndex;

#ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
    struct IteratorState {
      IteratorState() : map_(0), link_(0), itemIndex_(0), bucketIndex_(0) {}
      ValueInternalMap *map_;
      ValueInternalLink *link_;
      BucketIndex itemIndex_;
      BucketIndex bucketIndex_;
    };
#endif  // ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION

    ValueInternalMap();
    ValueInternalMap(const ValueInternalMap &other);
    ValueInternalMap &operator=(const ValueInternalMap &other);
    ~ValueInternalMap();

    void swap(ValueInternalMap &other);

    BucketIndex size() const;

    void clear();

    bool reserveDelta(BucketIndex growth);

    bool reserve(BucketIndex newItemCount);

    const Value *find(const char *key) const;

    Value *find(const char *key);

    Value &resolveReference(const char *key, bool isStatic);

    void remove(const char *key);

    void doActualRemove(ValueInternalLink *link, BucketIndex index, BucketIndex bucketIndex);

    ValueInternalLink *&getLastLinkInBucket(BucketIndex bucketIndex);

    Value &setNewItem(const char *key, bool isStatic, ValueInternalLink *link, BucketIndex index);

    Value &unsafeAdd(const char *key, bool isStatic, HashKey hashedKey);

    HashKey hash(const char *key) const;

    int compare(const ValueInternalMap &other) const;

  private:
    void makeBeginIterator(IteratorState &it) const;
    void makeEndIterator(IteratorState &it) const;
    static bool equals(const IteratorState &x, const IteratorState &other);
    static void increment(IteratorState &iterator);
    static void incrementBucket(IteratorState &iterator);
    static void decrement(IteratorState &iterator);
    static const char *key(const IteratorState &iterator);
    static const char *key(const IteratorState &iterator, bool &isStatic);
    static Value &value(const IteratorState &iterator);
    static int distance(const IteratorState &x, const IteratorState &y);

  private:
    ValueInternalLink *buckets_;
    ValueInternalLink *tailLink_;
    BucketIndex bucketsSize_;
    BucketIndex itemCount_;
  };

  class JSON_API ValueInternalArray {
    friend class Value;
    friend class ValueIteratorBase;

  public:
    enum { itemsPerPage = 8 };  // should be a power of 2 for fast divide and modulo.
    typedef Value::ArrayIndex ArrayIndex;
    typedef unsigned int PageIndex;

#ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
    struct IteratorState  // Must be a POD
    {
      IteratorState() : array_(0), currentPageIndex_(0), currentItemIndex_(0) {}
      ValueInternalArray *array_;
      Value **currentPageIndex_;
      unsigned int currentItemIndex_;
    };
#endif  // ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION

    ValueInternalArray();
    ValueInternalArray(const ValueInternalArray &other);
    ValueInternalArray &operator=(const ValueInternalArray &other);
    ~ValueInternalArray();
    void swap(ValueInternalArray &other);

    void clear();
    void resize(ArrayIndex newSize);

    Value &resolveReference(ArrayIndex index);

    Value *find(ArrayIndex index) const;

    ArrayIndex size() const;

    int compare(const ValueInternalArray &other) const;

  private:
    static bool equals(const IteratorState &x, const IteratorState &other);
    static void increment(IteratorState &iterator);
    static void decrement(IteratorState &iterator);
    static Value &dereference(const IteratorState &iterator);
    static Value &unsafeDereference(const IteratorState &iterator);
    static int distance(const IteratorState &x, const IteratorState &y);
    static ArrayIndex indexOf(const IteratorState &iterator);
    void makeBeginIterator(IteratorState &it) const;
    void makeEndIterator(IteratorState &it) const;
    void makeIterator(IteratorState &it, ArrayIndex index) const;

    void makeIndexValid(ArrayIndex index);

    Value **pages_;
    ArrayIndex size_;
    PageIndex pageCount_;
  };

  class JSON_API ValueArrayAllocator {
  public:
    virtual ~ValueArrayAllocator();
    virtual ValueInternalArray *newArray() = 0;
    virtual ValueInternalArray *newArrayCopy(const ValueInternalArray &other) = 0;
    virtual void destructArray(ValueInternalArray *array) = 0;
    virtual void reallocateArrayPageIndex(Value **&indexes,
                                          ValueInternalArray::PageIndex &indexCount,
                                          ValueInternalArray::PageIndex minNewIndexCount) = 0;
    virtual void releaseArrayPageIndex(Value **indexes, ValueInternalArray::PageIndex indexCount) = 0;
    virtual Value *allocateArrayPage() = 0;
    virtual void releaseArrayPage(Value *value) = 0;
  };
#endif  // #ifdef JSON_VALUE_USE_INTERNAL_MAP

  class ValueIteratorBase {
  public:
    typedef unsigned int size_t;
    typedef int difference_type;
    typedef ValueIteratorBase SelfType;

    ValueIteratorBase();
#ifndef JSON_VALUE_USE_INTERNAL_MAP
    explicit ValueIteratorBase(const Value::ObjectValues::iterator &current);
#else
    ValueIteratorBase(const ValueInternalArray::IteratorState &state);
    ValueIteratorBase(const ValueInternalMap::IteratorState &state);
#endif

    bool operator==(const SelfType &other) const { return isEqual(other); }

    bool operator!=(const SelfType &other) const { return !isEqual(other); }

    difference_type operator-(const SelfType &other) const { return computeDistance(other); }

    Value key() const;

    UInt index() const;

    const char *memberName() const;

  protected:
    Value &deref() const;

    void increment();

    void decrement();

    difference_type computeDistance(const SelfType &other) const;

    bool isEqual(const SelfType &other) const;

    void copy(const SelfType &other);

  private:
#ifndef JSON_VALUE_USE_INTERNAL_MAP
    Value::ObjectValues::iterator current_;
    // Indicates that iterator is for a null value.
    bool isNull_;
#else
    union {
      ValueInternalArray::IteratorState array_;
      ValueInternalMap::IteratorState map_;
    } iterator_;
    bool isArray_;
#endif
  };

  class ValueConstIterator : public ValueIteratorBase {
    friend class Value;

  public:
    typedef unsigned int size_t;
    typedef int difference_type;
    typedef const Value &reference;
    typedef const Value *pointer;
    typedef ValueConstIterator SelfType;

    ValueConstIterator();

  private:
#ifndef JSON_VALUE_USE_INTERNAL_MAP
    explicit ValueConstIterator(const Value::ObjectValues::iterator &current);
#else
    ValueConstIterator(const ValueInternalArray::IteratorState &state);
    ValueConstIterator(const ValueInternalMap::IteratorState &state);
#endif
  public:
    SelfType &operator=(const ValueIteratorBase &other);

    SelfType operator++(int) {
      SelfType temp(*this);
      ++*this;
      return temp;
    }

    SelfType operator--(int) {
      SelfType temp(*this);
      --*this;
      return temp;
    }

    SelfType &operator--() {
      decrement();
      return *this;
    }

    SelfType &operator++() {
      increment();
      return *this;
    }

    reference operator*() const { return deref(); }
  };

  class ValueIterator : public ValueIteratorBase {
    friend class Value;

  public:
    typedef unsigned int size_t;
    typedef int difference_type;
    typedef Value &reference;
    typedef Value *pointer;
    typedef ValueIterator SelfType;

    ValueIterator();
    ValueIterator(const ValueConstIterator &other);
    ValueIterator(const ValueIterator &other);

  private:
#ifndef JSON_VALUE_USE_INTERNAL_MAP
    explicit ValueIterator(const Value::ObjectValues::iterator &current);
#else
    ValueIterator(const ValueInternalArray::IteratorState &state);
    ValueIterator(const ValueInternalMap::IteratorState &state);
#endif
  public:
    SelfType &operator=(const SelfType &other);

    SelfType operator++(int) {
      SelfType temp(*this);
      ++*this;
      return temp;
    }

    SelfType operator--(int) {
      SelfType temp(*this);
      --*this;
      return temp;
    }

    SelfType &operator--() {
      decrement();
      return *this;
    }

    SelfType &operator++() {
      increment();
      return *this;
    }

    reference operator*() const { return deref(); }
  };

}  // namespace Json

#endif  // CPPTL_JSON_H_INCLUDED