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 jsoncollector {
  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
}  // namespace jsoncollector
#endif  // CPPTL_JSON_H_INCLUDED