This commit adds some simple tests for the deep-copying
of values, either based on the explicit constructor, or
the CopyFrom function.

It uses the CrtAllocator to test for possible double-free
errors due to insufficient copying.

To allow deep copying from an existing GenericValue, an
explicit "copy constructor" (with required Allocator param)
and an "CopyFrom" assignment function are added.

  Document d; Document::AllocatorType& a = d.GetAllocator();
  Value v1("foo");
  // Value v2(v1); // not allowed

  Value v2(v1,a);                             // make a copy
  RAPIDJSON_ASSERT(v1.IsString());            // v1 untouched
  d.SetArray().PushBack(v1,a).PushBack(v2,a);
  RAPIDJSON_ASSERT(v1.Empty() && v2.Empty());

  v2.CopyFrom(d,a);                           // copy whole document
  RAPIDJSON_ASSERT(d.IsArray() && d.Size());  // d untouched
  v1.SetObject().AddMember( "array", v2, a );
  d.PushBack(v1,a);

Additionally, the Handler implementation in GenericDocument is made
private again, restricting access to GenericReader and GenericValue.

Instead of always just shallowly referencing the potentially allocated
strings when calling the Handler::String function, request a copy in
case the string has been allocated from an Allocator before.

This is necessary to avoid double free()s of the string memory,
especially when using the Handler to create a deep copy of a Value.

The explicit comparison against '0' is done to suppress the warning
C4800 on MSVC, see pah/rapidjson#5.

some minor fixes

GenericDocument::ParseStream: make SourceEncoding optional

GenericDocument: forward allocator to GenericReader

GenericValue: explicit constructors

GenericValue: fixup construction from NumberType

drop trailing commas in enums

FileStream::current_ is now explicitly initialized in the constructor.
Avoids reading the garbage value in case of an empty file.

The MemoryPoolAllocator implementation cannot and should not be
copied (Rule of Three).  Declare copy constructor and copy-assignment
operator as private.

This patch fixes some misspellings of "allocator" in document.h.
Fixes the Doxygen documentation of GenericDocument as well.

The ParseStream() function current requires explicitly passing
the SourceEncoding parameter as explicit template argument
while the other Parse*() functions provide overloads to omit
this parameter and use the document's own encoding by default.

This patch adds the corresponding overload for ParseStream(),
enabling the simple usage again:

  rapidjson::FileStream is(fp);
  rapidjson::Document   d;
  d.ParseStream<0>(is);

Fixes http://code.google.com/p/rapidjson/issues/detail?id=72.

In case of overloaded functions taking either a GenericValue or another
class that can also be constructed from the same primitive types
(e.g. std::string, which can be constructed from const char*), the
overloading becomes ambiguous:

  void foo( const std::string& );
  void foo( const rapidjson::Value & );

Declaring the GenericValue constructors taking primitive types as
'explicit' avoids this problem.  This should not have any negative
side-effects, since a GenericValue can't be copied or implicitly
converted to other types.

Fixes http://code.google.com/p/rapidjson/issues/detail?id=70.

Constructing an empty GenericValue with a specific Type has failed
for any kNumberType (Int, Int64, Double...) due to incomplete definition
of the corresponding default flag value.

This patch adds a new constant kNumberAnyFlag to the flags enumeration
in GenericValue to cover this case.

This fixes http://code.google.com/p/rapidjson/issues/detail?id=57

In C++'98/03, trailing commas in enumerations are not allowed, but have
been introduced in C++11.  This patch drops the trailing commas in order
to avoid compiler warnings (e.g. GCC with -pedantic).

Fixes http://code.google.com/p/rapidjson/issues/detail?id=49.

This reverts commit e4ffa48a.

This reverts commit d4cb506d, reversing
changes made to dfe201e3.

This reverts commit 84f64ba5.

https://github.com/pah/rapidjson/commit/77e5c6b1

The original FindMember() may access out-of-bound of the 'const char*
name' parameter.
This commit firstly follows
https://github.com/pah/rapidjson/commit/f86af8c232dc280ae510b119018d66ca08b82312

However, this must incur an StrLen() for name. A better API is by using
Value as the name, which provides the length of string internally. So a
set of new API are added:

operator[](const GenericValue& name)
FindMember(const GenericValue& name)
RemoveMember(const GenericValue& name)

During refactoring, it also adds an API:

RemoveMember(MemberIterator m)

which can be used for other purpose, such as removing a member while
iterating an object.

Fixes #7

To avoid writing outside of the current GenericValue object and to
follow the C++ standard more closely, this patch drops the
memset/memcpy(this,...) occurences in GenericValue in favour of explicit
initialisations/assignments of the data_ and flag_ members.

https://code.google.com/p/rapidjson/issues/detail?id=11
https://github.com/pah/rapidjson/commit/7475a969

tmpnam() in VS prepends backslash in the path.

git-svn-id: https://rapidjson.googlecode.com/svn/trunk@105 c5894555-1306-4e8d-425f-1f6f381ee07c

git-svn-id: https://rapidjson.googlecode.com/svn/trunk@95 c5894555-1306-4e8d-425f-1f6f381ee07c

git-svn-id: https://rapidjson.googlecode.com/svn/trunk@89 c5894555-1306-4e8d-425f-1f6f381ee07c

git-svn-id: https://rapidjson.googlecode.com/svn/trunk@88 c5894555-1306-4e8d-425f-1f6f381ee07c

git-svn-id: https://rapidjson.googlecode.com/svn/trunk@87 c5894555-1306-4e8d-425f-1f6f381ee07c