include/json/value.h

/*
 * Copyright © 2007 Pippijn van Steenhoven / The Ermyth Team
 * Rights to this code are as documented in doc/pod/license.pod.
 *
 * JSON-RPC for Ermyth
 *
 * $Id: value.h,v 1.3 2007-08-30 19:56:24 pippijn Exp $
 */

//>>>>>>>>>>> value.h <<<<<<<<<<<//
#ifndef VALUE_H
#define VALUE_H

#include <string>
#include <vector>
#include <map>

#include "svsconfig.h"

namespace json
{
  class ValueIterator;
  class ValueConstIterator;

  enum ValueType
  {
    nullValue,
    intValue,
    uintValue,
    realValue,
    stringValue,
    booleanValue,
    arrayValue,
    objectValue
  };
  
  enum CommentPlacement
  {
    commentBefore,
    commentAfterOnSameLine,
    commentAfter,
    numberOfCommentPlacement
  };
  
  /** \brief Lightweight wrapper to tag static string.
   *
   * Value constructor and objectValue member assignement takes advantage of the
   * StaticString and avoid the cost of string duplication when storing the
   * string or the member name.
   *
   * Example of usage:
   *
   * \code
   * json::Value aValue (StaticString ("some text"));
   * json::Value object;
   * static const StaticString code ("code");
   * object[code] = 1234;
   * \endcode
   */
  class StaticString
  {
  public:
    explicit StaticString (char const *czstring)
      : str_ (czstring)
    {
    }

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

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

  private:
    char const *str_;
  };

  class Value 
  {
    friend class ValueIteratorBase;
  public:
    typedef std::vector<std::string> Members;
    typedef ValueIterator iterator;
    typedef ValueConstIterator const_iterator;
    typedef unsigned ArrayIndex;

    static const Value null;
    static const int minInt;
    static const int maxInt;
    static const unsigned maxUInt;

  private:
    class CZString 
    {
    public:
      enum DuplicationPolicy 
      {
        noDuplication = 0,
        duplicate,
        duplicateOnCopy
      };
      CZString (int index);
      CZString (char const *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;
      char const *c_str () const;
      bool isStaticString () const;
    private:
      void swap (CZString &other);
      char const *cstr_;
      int index_;
    };

  public:
    typedef std::map<CZString, Value> ObjectValues;

  public:
    Value (ValueType type = nullValue);
    Value (int value);
    Value (unsigned value);
    Value (double value);
    Value (char const *value);
    Value (const StaticString &value);
    Value (const std::string &value);
    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;

    operator char const * () const;
    operator std::string () const;
    operator int () const;
    operator unsigned () const;
    operator double () const;
    operator bool () 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;

    unsigned size () const;

    bool empty () const;

    bool operator ! () const;

    void clear ();

    void resize (unsigned size);

    Value &operator [] (int index);
    Value &operator [] (unsigned index);
    const Value &operator [] (int index) const;
    const Value &operator [] (unsigned index) const;
    Value get (int index, const Value &defaultValue) const;
    Value get (unsigned index, const Value &defaultValue) const;
    bool isValidIndex (int index) const;
    bool isValidIndex (unsigned index) const;

    Value &append (const Value &value);

    Value &operator [] (char const *key);
    const Value &operator [] (char const *key) const;
    Value &operator [] (const std::string &key);
    const Value &operator [] (const std::string &key) const;
    Value &operator [] (const StaticString &key);
    Value get (char const *key, const Value &defaultValue) const;
    Value get (const std::string &key, const Value &defaultValue) const;
    Value removeMember (char const* key);
    Value removeMember (const std::string &key);

    bool isMember (char const *key) const;
    bool isMember (const std::string &key) const;

    Members getMemberNames () const;

    void setComment (char const *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 (char const *key, bool isStatic);

    struct CommentInfo
    {
      CommentInfo ();
      ~CommentInfo ();

      void setComment (char const *text);

      char *comment_;
    };

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

    union ValueHolder
    {
      int               int_;
      unsigned          uint_;
      double            real_;
      bool              bool_;
      char              *string_;
      ObjectValues      *map_;
    } value_;

    ValueType   type_      : 8;
    int         allocated_ : 1;
    CommentInfo *comments_;
  };


  class PathArgument
  {
  public:
    friend class Path;

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

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

  class Path
  {
  public:
    Path (char const *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 (char const *path,
                   const InArgs &in);
    void addPathInArg (char const *path, 
                       const InArgs &in, 
                       InArgs::const_iterator &itInArg, 
                       PathArgument::Kind kind);
    void invalidPath (char const *path, 
                      int location);

    Args args_;
  };

  class ValueAllocator
  {
  public:
    enum
    {
      unknown = ~0u // UINT_MAX
    };

    virtual ~ValueAllocator ();

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

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

    ValueIteratorBase ();
    explicit ValueIteratorBase (const Value::ObjectValues::iterator &current);

    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;

    unsigned index () const;

    char const *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:
    Value::ObjectValues::iterator current_;
  };

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

    ValueConstIterator ();
  private:
    explicit ValueConstIterator (const Value::ObjectValues::iterator &current);
  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 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:
    explicit ValueIterator (const Value::ObjectValues::iterator &current);

  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 // JSON_H
Revision:	1.4
Committed:	Wed Sep 5 11:23:15 2007 UTC (19 years, 2 months ago) by pippijn
Content type:	text/plain
Branch:	MAIN
CVS Tags:	HEAD
Changes since 1.3:	+2 -2 lines
Log Message:	removed GPLed code and put license back to BSD
#	Content
1	/*
2	* Copyright © 2007 Pippijn van Steenhoven / The Ermyth Team
3	* Rights to this code are as documented in doc/pod/license.pod.
4	*
5	* JSON-RPC for Ermyth
6	*
7	* $Id: value.h,v 1.3 2007-08-30 19:56:24 pippijn Exp $
8	*/
9
10	//>>>>>>>>>>> value.h <<<<<<<<<<<//
11	#ifndef VALUE_H
12	#define VALUE_H
13
14	#include <string>
15	#include <vector>
16	#include <map>
17
18	#include "svsconfig.h"
19
20	namespace json
21	{
22	class ValueIterator;
23	class ValueConstIterator;
24
25	enum ValueType
26	{
27	nullValue,
28	intValue,
29	uintValue,
30	realValue,
31	stringValue,
32	booleanValue,
33	arrayValue,
34	objectValue
35	};
36
37	enum CommentPlacement
38	{
39	commentBefore,
40	commentAfterOnSameLine,
41	commentAfter,
42	numberOfCommentPlacement
43	};
44
45	/** \brief Lightweight wrapper to tag static string.
46	*
47	* Value constructor and objectValue member assignement takes advantage of the
48	* StaticString and avoid the cost of string duplication when storing the
49	* string or the member name.
50	*
51	* Example of usage:
52	*
53	* \code
54	* json::Value aValue (StaticString ("some text"));
55	* json::Value object;
56	* static const StaticString code ("code");
57	* object[code] = 1234;
58	* \endcode
59	*/
60	class StaticString
61	{
62	public:
63	explicit StaticString (char const *czstring)
64	: str_ (czstring)
65	{
66	}
67
68	operator char const *() const
69	{
70	return str_;
71	}
72
73	char const *c_str() const
74	{
75	return str_;
76	}
77
78	private:
79	char const *str_;
80	};
81
82	class Value
83	{
84	friend class ValueIteratorBase;
85	public:
86	typedef std::vector<std::string> Members;
87	typedef ValueIterator iterator;
88	typedef ValueConstIterator const_iterator;
89	typedef unsigned ArrayIndex;
90
91	static const Value null;
92	static const int minInt;
93	static const int maxInt;
94	static const unsigned maxUInt;
95
96	private:
97	class CZString
98	{
99	public:
100	enum DuplicationPolicy
101	{
102	noDuplication = 0,
103	duplicate,
104	duplicateOnCopy
105	};
106	CZString (int index);
107	CZString (char const *cstr, DuplicationPolicy allocate);
108	CZString (const CZString &other);
109	~CZString ();
110	CZString &operator = (const CZString &other);
111	bool operator < (const CZString &other) const;
112	bool operator == (const CZString &other) const;
113	int index () const;
114	char const *c_str () const;
115	bool isStaticString () const;
116	private:
117	void swap (CZString &other);
118	char const *cstr_;
119	int index_;
120	};
121
122	public:
123	typedef std::map<CZString, Value> ObjectValues;
124
125	public:
126	Value (ValueType type = nullValue);
127	Value (int value);
128	Value (unsigned value);
129	Value (double value);
130	Value (char const *value);
131	Value (const StaticString &value);
132	Value (const std::string &value);
133	Value (bool value);
134	Value (const Value &other);
135	~Value ();
136
137	Value &operator = (const Value &other);
138
139	void swap (Value &other);
140
141	ValueType type () const;
142
143	bool operator < (const Value &other) const;
144	bool operator <= (const Value &other) const;
145	bool operator >= (const Value &other) const;
146	bool operator > (const Value &other) const;
147
148	bool operator == (const Value &other) const;
149	bool operator != (const Value &other) const;
150
151	operator char const * () const;
152	operator std::string () const;
153	operator int () const;
154	operator unsigned () const;
155	operator double () const;
156	operator bool () const;
157
158	bool isNull () const;
159	bool isBool () const;
160	bool isInt () const;
161	bool isUInt () const;
162	bool isIntegral () const;
163	bool isDouble () const;
164	bool isNumeric () const;
165	bool isString () const;
166	bool isArray () const;
167	bool isObject () const;
168
169	bool isConvertibleTo (ValueType other) const;
170
171	unsigned size () const;
172
173	bool empty () const;
174
175	bool operator ! () const;
176
177	void clear ();
178
179	void resize (unsigned size);
180
181	Value &operator [] (int index);
182	Value &operator [] (unsigned index);
183	const Value &operator [] (int index) const;
184	const Value &operator [] (unsigned index) const;
185	Value get (int index, const Value &defaultValue) const;
186	Value get (unsigned index, const Value &defaultValue) const;
187	bool isValidIndex (int index) const;
188	bool isValidIndex (unsigned index) const;
189
190	Value &append (const Value &value);
191
192	Value &operator [] (char const *key);
193	const Value &operator [] (char const *key) const;
194	Value &operator [] (const std::string &key);
195	const Value &operator [] (const std::string &key) const;
196	Value &operator [] (const StaticString &key);
197	Value get (char const *key, const Value &defaultValue) const;
198	Value get (const std::string &key, const Value &defaultValue) const;
199	Value removeMember (char const* key);
200	Value removeMember (const std::string &key);
201
202	bool isMember (char const *key) const;
203	bool isMember (const std::string &key) const;
204
205	Members getMemberNames () const;
206
207	void setComment (char const *comment, CommentPlacement placement);
208	void setComment (const std::string &comment, CommentPlacement placement);
209	bool hasComment (CommentPlacement placement) const;
210	std::string getComment (CommentPlacement placement) const;
211
212	std::string toStyledString () const;
213
214	const_iterator begin () const;
215	const_iterator end () const;
216
217	iterator begin ();
218	iterator end ();
219
220	private:
221	Value &resolveReference (char const *key, bool isStatic);
222
223	struct CommentInfo
224	{
225	CommentInfo ();
226	~CommentInfo ();
227
228	void setComment (char const *text);
229
230	char *comment_;
231	};
232
233	struct MemberNamesTransform
234	{
235	typedef char const *result_type;
236	char const *operator () (const CZString &name) const
237	{
238	return name.c_str ();
239	}
240	};
241
242	union ValueHolder
243	{
244	int int_;
245	unsigned uint_;
246	double real_;
247	bool bool_;
248	char *string_;
249	ObjectValues *map_;
250	} value_;
251
252	ValueType type_ : 8;
253	int allocated_ : 1;
254	CommentInfo *comments_;
255	};
256
257
258	class PathArgument
259	{
260	public:
261	friend class Path;
262
263	PathArgument ();
264	PathArgument (unsigned index);
265	PathArgument (char const *key);
266	PathArgument (const std::string &key);
267
268	private:
269	enum Kind
270	{
271	kindNone = 0,
272	kindIndex,
273	kindKey
274	};
275
276	std::string key_;
277	unsigned index_;
278	Kind kind_;
279	};
280
281	class Path
282	{
283	public:
284	Path (char const *path,
285	const PathArgument &a1 = PathArgument (),
286	const PathArgument &a2 = PathArgument (),
287	const PathArgument &a3 = PathArgument (),
288	const PathArgument &a4 = PathArgument (),
289	const PathArgument &a5 = PathArgument ());
290
291	const Value &resolve (const Value &root) const;
292	Value resolve (const Value &root,
293	const Value &defaultValue) const;
294	Value &make (Value &root) const;
295
296	private:
297	typedef std::vector<const PathArgument *> InArgs;
298	typedef std::vector<PathArgument> Args;
299
300	void makePath (char const *path,
301	const InArgs &in);
302	void addPathInArg (char const *path,
303	const InArgs &in,
304	InArgs::const_iterator &itInArg,
305	PathArgument::Kind kind);
306	void invalidPath (char const *path,
307	int location);
308
309	Args args_;
310	};
311
312	class ValueAllocator
313	{
314	public:
315	enum
316	{
317	unknown = ~0u // UINT_MAX
318	};
319
320	virtual ~ValueAllocator ();
321
322	virtual char makeMemberName (char const memberName) = 0;
323	virtual void releaseMemberName (char *memberName) = 0;
324	virtual char duplicateStringValue (char const value, unsigned length = unknown) = 0;
325	virtual void releaseStringValue (char *value) = 0;
326	};
327
328	class ValueIteratorBase
329	{
330	public:
331	typedef unsigned size_t;
332	typedef int difference_type;
333	typedef ValueIteratorBase SelfType;
334
335	ValueIteratorBase ();
336	explicit ValueIteratorBase (const Value::ObjectValues::iterator &current);
337
338	bool operator == (const SelfType &other) const
339	{
340	return isEqual (other);
341	}
342
343	bool operator != (const SelfType &other) const
344	{
345	return !isEqual (other);
346	}
347
348	difference_type operator - (const SelfType &other) const
349	{
350	return computeDistance (other);
351	}
352
353	Value key () const;
354
355	unsigned index () const;
356
357	char const *memberName () const;
358
359	protected:
360	Value &deref () const;
361
362	void increment ();
363
364	void decrement ();
365
366	difference_type computeDistance (const SelfType &other) const;
367
368	bool isEqual (const SelfType &other) const;
369
370	void copy (const SelfType &other);
371
372	private:
373	Value::ObjectValues::iterator current_;
374	};
375
376	class ValueConstIterator : public ValueIteratorBase
377	{
378	friend class Value;
379	public:
380	typedef unsigned size_t;
381	typedef int difference_type;
382	typedef const Value &reference;
383	typedef const Value *pointer;
384	typedef ValueConstIterator SelfType;
385
386	ValueConstIterator ();
387	private:
388	explicit ValueConstIterator (const Value::ObjectValues::iterator &current);
389	public:
390	SelfType &operator = (const ValueIteratorBase &other);
391
392	SelfType operator ++ (int)
393	{
394	SelfType temp (*this);
395	++*this;
396	return temp;
397	}
398
399	SelfType operator -- (int)
400	{
401	SelfType temp (*this);
402	--*this;
403	return temp;
404	}
405
406	SelfType &operator -- ()
407	{
408	decrement ();
409	return *this;
410	}
411
412	SelfType &operator ++ ()
413	{
414	increment ();
415	return *this;
416	}
417
418	reference operator * () const
419	{
420	return deref ();
421	}
422	};
423
424
425	class ValueIterator : public ValueIteratorBase
426	{
427	friend class Value;
428	public:
429	typedef unsigned size_t;
430	typedef int difference_type;
431	typedef Value &reference;
432	typedef Value *pointer;
433	typedef ValueIterator SelfType;
434
435	ValueIterator ();
436	ValueIterator (const ValueConstIterator &other);
437	ValueIterator (const ValueIterator &other);
438
439	private:
440	explicit ValueIterator (const Value::ObjectValues::iterator &current);
441
442	public:
443
444	SelfType &operator = (const SelfType &other);
445
446	SelfType operator ++ (int)
447	{
448	SelfType temp (*this);
449	++*this;
450	return temp;
451	}
452
453	SelfType operator -- (int)
454	{
455	SelfType temp (*this);
456	--*this;
457	return temp;
458	}
459
460	SelfType &operator -- ()
461	{
462	decrement ();
463	return *this;
464	}
465
466	SelfType &operator ++ ()
467	{
468	increment ();
469	return *this;
470	}
471
472	reference operator * () const
473	{
474	return deref ();
475	}
476	};
477	} // namespace json
478
479
480	#endif // JSON_H