\endcode
*/
+
+/*! \def RAPIDJSON_ALLOCATOR_DEFAULT_CHUNK_CAPACITY
+ \ingroup RAPIDJSON_CONFIG
+ \brief User-defined kDefaultChunkCapacity definition.
+
+ User can define this as any \c size that is a power of 2.
+*/
+
+#ifndef RAPIDJSON_ALLOCATOR_DEFAULT_CHUNK_CAPACITY
+#define RAPIDJSON_ALLOCATOR_DEFAULT_CHUNK_CAPACITY (64 * 1024)
+#endif
+
+
///////////////////////////////////////////////////////////////////////////////
// CrtAllocator
return false;
}
- static const int kDefaultChunkCapacity = 64 * 1024; //!< Default chunk capacity.
+ static const int kDefaultChunkCapacity = RAPIDJSON_ALLOCATOR_DEFAULT_CHUNK_CAPACITY; //!< Default chunk capacity.
//! Chunk header for perpending to each chunk.
/*! Chunks are stored as a singly linked list.
#include <limits>
RAPIDJSON_DIAG_PUSH
-#ifdef _MSC_VER
-RAPIDJSON_DIAG_OFF(4127) // conditional expression is constant
-RAPIDJSON_DIAG_OFF(4244) // conversion from kXxxFlags to 'uint16_t', possible loss of data
-#endif
-
#ifdef __clang__
RAPIDJSON_DIAG_OFF(padded)
RAPIDJSON_DIAG_OFF(switch-enum)
RAPIDJSON_DIAG_OFF(c++98-compat)
+#elif defined(_MSC_VER)
+RAPIDJSON_DIAG_OFF(4127) // conditional expression is constant
+RAPIDJSON_DIAG_OFF(4244) // conversion from kXxxFlags to 'uint16_t', possible loss of data
#endif
#ifdef __GNUC__
RAPIDJSON_DIAG_OFF(effc++)
-#if __GNUC__ >= 6
-RAPIDJSON_DIAG_OFF(terminate) // ignore throwing RAPIDJSON_ASSERT in RAPIDJSON_NOEXCEPT functions
-#endif
#endif // __GNUC__
#ifndef RAPIDJSON_NOMEMBERITERATORCLASS
-#include <iterator> // std::iterator, std::random_access_iterator_tag
+#include <iterator> // std::random_access_iterator_tag
#endif
#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
struct GenericMember {
GenericValue<Encoding, Allocator> name; //!< name of member (must be a string)
GenericValue<Encoding, Allocator> value; //!< value of member.
+
+ // swap() for std::sort() and other potential use in STL.
+ friend inline void swap(GenericMember& a, GenericMember& b) RAPIDJSON_NOEXCEPT {
+ a.name.Swap(b.name);
+ a.value.Swap(b.value);
+ }
};
///////////////////////////////////////////////////////////////////////////////
\see GenericMember, GenericValue::MemberIterator, GenericValue::ConstMemberIterator
*/
template <bool Const, typename Encoding, typename Allocator>
-class GenericMemberIterator
- : public std::iterator<std::random_access_iterator_tag
- , typename internal::MaybeAddConst<Const,GenericMember<Encoding,Allocator> >::Type> {
+class GenericMemberIterator {
friend class GenericValue<Encoding,Allocator>;
template <bool, typename, typename> friend class GenericMemberIterator;
typedef GenericMember<Encoding,Allocator> PlainType;
typedef typename internal::MaybeAddConst<Const,PlainType>::Type ValueType;
- typedef std::iterator<std::random_access_iterator_tag,ValueType> BaseType;
public:
//! Iterator type itself
//! Non-constant iterator type
typedef GenericMemberIterator<false,Encoding,Allocator> NonConstIterator;
+ /** \name std::iterator_traits support */
+ //@{
+ typedef ValueType value_type;
+ typedef ValueType * pointer;
+ typedef ValueType & reference;
+ typedef std::ptrdiff_t difference_type;
+ typedef std::random_access_iterator_tag iterator_category;
+ //@}
+
//! Pointer to (const) GenericMember
- typedef typename BaseType::pointer Pointer;
+ typedef pointer Pointer;
//! Reference to (const) GenericMember
- typedef typename BaseType::reference Reference;
+ typedef reference Reference;
//! Signed integer type (e.g. \c ptrdiff_t)
- typedef typename BaseType::difference_type DifferenceType;
+ typedef difference_type DifferenceType;
//! Default constructor (singular value)
/*! Creates an iterator pointing to no element.
static ValueType& Set(ValueType& v, unsigned data, typename ValueType::AllocatorType&) { return v.SetUint(data); }
};
+#ifdef _MSC_VER
+RAPIDJSON_STATIC_ASSERT(sizeof(long) == sizeof(int));
+template<typename ValueType>
+struct TypeHelper<ValueType, long> {
+ static bool Is(const ValueType& v) { return v.IsInt(); }
+ static long Get(const ValueType& v) { return v.GetInt(); }
+ static ValueType& Set(ValueType& v, long data) { return v.SetInt(data); }
+ static ValueType& Set(ValueType& v, long data, typename ValueType::AllocatorType&) { return v.SetInt(data); }
+};
+
+RAPIDJSON_STATIC_ASSERT(sizeof(unsigned long) == sizeof(unsigned));
+template<typename ValueType>
+struct TypeHelper<ValueType, unsigned long> {
+ static bool Is(const ValueType& v) { return v.IsUint(); }
+ static unsigned long Get(const ValueType& v) { return v.GetUint(); }
+ static ValueType& Set(ValueType& v, unsigned long data) { return v.SetUint(data); }
+ static ValueType& Set(ValueType& v, unsigned long data, typename ValueType::AllocatorType&) { return v.SetUint(data); }
+};
+#endif
+
template<typename ValueType>
struct TypeHelper<ValueType, int64_t> {
static bool Is(const ValueType& v) { return v.IsInt64(); }
\note Default content for number is zero.
*/
explicit GenericValue(Type type) RAPIDJSON_NOEXCEPT : data_() {
- static const uint16_t defaultFlags[7] = {
+ static const uint16_t defaultFlags[] = {
kNullFlag, kFalseFlag, kTrueFlag, kObjectFlag, kArrayFlag, kShortStringFlag,
kNumberAnyFlag
};
- RAPIDJSON_ASSERT(type >= kNullType && type <= kNumberType);
+ RAPIDJSON_NOEXCEPT_ASSERT(type >= kNullType && type <= kNumberType);
data_.f.flags = defaultFlags[type];
// Use ShortString to store empty string.
/*! \param rhs Source of the assignment. It will become a null value after assignment.
*/
GenericValue& operator=(GenericValue& rhs) RAPIDJSON_NOEXCEPT {
- RAPIDJSON_ASSERT(this != &rhs);
- this->~GenericValue();
- RawAssign(rhs);
+ if (RAPIDJSON_LIKELY(this != &rhs)) {
+ this->~GenericValue();
+ RawAssign(rhs);
+ }
return *this;
}
//! Equal-to operator
/*!
\note If an object contains duplicated named member, comparing equality with any object is always \c false.
- \note Linear time complexity (number of all values in the subtree and total lengths of all strings).
+ \note Complexity is quadratic in Object's member number and linear for the rest (number of all values in the subtree and total lengths of all strings).
*/
template <typename SourceAllocator>
bool operator==(const GenericValue<Encoding, SourceAllocator>& rhs) const {
GenericValue n(StringRef(name));
return (*this)[n];
}
-
- template <typename T>
- float optFloat(T* name, float fallback = 0.0) {
- GenericValue n(StringRef(name));
- return optFloat(n, fallback);
- }
-
- template <typename T>
- double optDouble(T* name, double fallback = 0.0) {
- GenericValue n(StringRef(name));
- return optDouble(n, fallback);
- }
-
- template <typename T>
- int optInt(T* name, int fallback=0) {
- GenericValue n(StringRef(name));
- return optInt(n, fallback);
- }
-
template <typename T>
RAPIDJSON_DISABLEIF_RETURN((internal::NotExpr<internal::IsSame<typename internal::RemoveConst<T>::Type, Ch> >),(const GenericValue&)) operator[](T* name) const { return const_cast<GenericValue&>(*this)[name]; }
return *new (buffer) GenericValue();
}
}
-
- template <typename SourceAllocator>
- float optFloat(const GenericValue<Encoding, SourceAllocator>& name, float fallback) {
- MemberIterator member = FindMember(name);
- if (member != MemberEnd())
- return member->value.GetFloat();
- return fallback;
- }
-
- template <typename SourceAllocator>
- double optDouble(const GenericValue<Encoding, SourceAllocator>& name, double fallback) {
- MemberIterator member = FindMember(name);
- if (member != MemberEnd())
- return member->value.GetDouble();
- return fallback;
- }
-
- template <typename SourceAllocator>
- int optInt(const GenericValue<Encoding, SourceAllocator>& name, int fallback) {
- MemberIterator member = FindMember(name);
- if (member != MemberEnd() && member->value.IsInt())
- return member->value.GetInt();
- return fallback;
- }
-
template <typename SourceAllocator>
const GenericValue& operator[](const GenericValue<Encoding, SourceAllocator>& name) const { return const_cast<GenericValue&>(*this)[name]; }
MemberIterator pos = MemberBegin() + (first - MemberBegin());
for (MemberIterator itr = pos; itr != last; ++itr)
itr->~Member();
- std::memmove(&*pos, &*last, static_cast<size_t>(MemberEnd() - last) * sizeof(Member));
+ std::memmove(static_cast<void*>(&*pos), &*last, static_cast<size_t>(MemberEnd() - last) * sizeof(Member));
data_.o.size -= static_cast<SizeType>(last - first);
return pos;
}
RAPIDJSON_ASSERT(last <= End());
ValueIterator pos = Begin() + (first - Begin());
for (ValueIterator itr = pos; itr != last; ++itr)
- itr->~GenericValue();
- std::memmove(pos, last, static_cast<size_t>(End() - last) * sizeof(GenericValue));
+ itr->~GenericValue();
+ std::memmove(static_cast<void*>(pos), last, static_cast<size_t>(End() - last) * sizeof(GenericValue));
data_.a.size -= static_cast<SizeType>(last - first);
return pos;
}
if (count) {
GenericValue* e = static_cast<GenericValue*>(allocator.Malloc(count * sizeof(GenericValue)));
SetElementsPointer(e);
- std::memcpy(e, values, count * sizeof(GenericValue));
+ std::memcpy(static_cast<void*>(e), values, count * sizeof(GenericValue));
}
else
SetElementsPointer(0);
if (count) {
Member* m = static_cast<Member*>(allocator.Malloc(count * sizeof(Member)));
SetMembersPointer(m);
- std::memcpy(m, members, count * sizeof(Member));
+ std::memcpy(static_cast<void*>(m), members, count * sizeof(Member));
}
else
SetMembersPointer(0);
//! GenericValue with UTF8 encoding
typedef GenericValue<UTF8<> > Value;
-typedef GenericValue<UTF8<> > JsonObj;
-
///////////////////////////////////////////////////////////////////////////////
// GenericDocument
//!@name Handling parse errors
//!@{
- //! Whether a parse error has occured in the last parsing.
+ //! Whether a parse error has occurred in the last parsing.
bool HasParseError() const { return parseResult_.IsError(); }
//! Get the \ref ParseErrorCode of last parsing.
//! GenericDocument with UTF8 encoding
typedef GenericDocument<UTF8<> > Document;
-typedef GenericDocument<UTF8<> > JsonDoc;
-
//! Helper class for accessing Value of array type.
/*!
GenericArray(const GenericArray& rhs) : value_(rhs.value_) {}
GenericArray& operator=(const GenericArray& rhs) { value_ = rhs.value_; return *this; }
- ~GenericArray() = default;
+ ~GenericArray() {}
SizeType Size() const { return value_.Size(); }
SizeType Capacity() const { return value_.Capacity(); }
GenericObject(const GenericObject& rhs) : value_(rhs.value_) {}
GenericObject& operator=(const GenericObject& rhs) { value_ = rhs.value_; return *this; }
- ~GenericObject() = default;
+ ~GenericObject() {}
SizeType MemberCount() const { return value_.MemberCount(); }
SizeType MemberCapacity() const { return value_.MemberCapacity(); }
#include "rapidjson.h"
-#ifdef _MSC_VER
+#if defined(_MSC_VER) && !defined(__clang__)
RAPIDJSON_DIAG_PUSH
RAPIDJSON_DIAG_OFF(4244) // conversion from 'type1' to 'type2', possible loss of data
RAPIDJSON_DIAG_OFF(4702) // unreachable code
template <typename InputStream>
static bool Decode(InputStream& is, unsigned* codepoint) {
-#define COPY() c = is.Take(); *codepoint = (*codepoint << 6) | (static_cast<unsigned char>(c) & 0x3Fu)
-#define TRANS(mask) result &= ((GetRange(static_cast<unsigned char>(c)) & mask) != 0)
-#define TAIL() COPY(); TRANS(0x70)
+#define RAPIDJSON_COPY() c = is.Take(); *codepoint = (*codepoint << 6) | (static_cast<unsigned char>(c) & 0x3Fu)
+#define RAPIDJSON_TRANS(mask) result &= ((GetRange(static_cast<unsigned char>(c)) & mask) != 0)
+#define RAPIDJSON_TAIL() RAPIDJSON_COPY(); RAPIDJSON_TRANS(0x70)
typename InputStream::Ch c = is.Take();
if (!(c & 0x80)) {
*codepoint = static_cast<unsigned char>(c);
}
bool result = true;
switch (type) {
- case 2: TAIL(); return result;
- case 3: TAIL(); TAIL(); return result;
- case 4: COPY(); TRANS(0x50); TAIL(); return result;
- case 5: COPY(); TRANS(0x10); TAIL(); TAIL(); return result;
- case 6: TAIL(); TAIL(); TAIL(); return result;
- case 10: COPY(); TRANS(0x20); TAIL(); return result;
- case 11: COPY(); TRANS(0x60); TAIL(); TAIL(); return result;
+ case 2: RAPIDJSON_TAIL(); return result;
+ case 3: RAPIDJSON_TAIL(); RAPIDJSON_TAIL(); return result;
+ case 4: RAPIDJSON_COPY(); RAPIDJSON_TRANS(0x50); RAPIDJSON_TAIL(); return result;
+ case 5: RAPIDJSON_COPY(); RAPIDJSON_TRANS(0x10); RAPIDJSON_TAIL(); RAPIDJSON_TAIL(); return result;
+ case 6: RAPIDJSON_TAIL(); RAPIDJSON_TAIL(); RAPIDJSON_TAIL(); return result;
+ case 10: RAPIDJSON_COPY(); RAPIDJSON_TRANS(0x20); RAPIDJSON_TAIL(); return result;
+ case 11: RAPIDJSON_COPY(); RAPIDJSON_TRANS(0x60); RAPIDJSON_TAIL(); RAPIDJSON_TAIL(); return result;
default: return false;
}
-#undef COPY
-#undef TRANS
-#undef TAIL
+#undef RAPIDJSON_COPY
+#undef RAPIDJSON_TRANS
+#undef RAPIDJSON_TAIL
}
template <typename InputStream, typename OutputStream>
static bool Validate(InputStream& is, OutputStream& os) {
-#define COPY() os.Put(c = is.Take())
-#define TRANS(mask) result &= ((GetRange(static_cast<unsigned char>(c)) & mask) != 0)
-#define TAIL() COPY(); TRANS(0x70)
+#define RAPIDJSON_COPY() os.Put(c = is.Take())
+#define RAPIDJSON_TRANS(mask) result &= ((GetRange(static_cast<unsigned char>(c)) & mask) != 0)
+#define RAPIDJSON_TAIL() RAPIDJSON_COPY(); RAPIDJSON_TRANS(0x70)
Ch c;
- COPY();
+ RAPIDJSON_COPY();
if (!(c & 0x80))
return true;
bool result = true;
switch (GetRange(static_cast<unsigned char>(c))) {
- case 2: TAIL(); return result;
- case 3: TAIL(); TAIL(); return result;
- case 4: COPY(); TRANS(0x50); TAIL(); return result;
- case 5: COPY(); TRANS(0x10); TAIL(); TAIL(); return result;
- case 6: TAIL(); TAIL(); TAIL(); return result;
- case 10: COPY(); TRANS(0x20); TAIL(); return result;
- case 11: COPY(); TRANS(0x60); TAIL(); TAIL(); return result;
+ case 2: RAPIDJSON_TAIL(); return result;
+ case 3: RAPIDJSON_TAIL(); RAPIDJSON_TAIL(); return result;
+ case 4: RAPIDJSON_COPY(); RAPIDJSON_TRANS(0x50); RAPIDJSON_TAIL(); return result;
+ case 5: RAPIDJSON_COPY(); RAPIDJSON_TRANS(0x10); RAPIDJSON_TAIL(); RAPIDJSON_TAIL(); return result;
+ case 6: RAPIDJSON_TAIL(); RAPIDJSON_TAIL(); RAPIDJSON_TAIL(); return result;
+ case 10: RAPIDJSON_COPY(); RAPIDJSON_TRANS(0x20); RAPIDJSON_TAIL(); return result;
+ case 11: RAPIDJSON_COPY(); RAPIDJSON_TRANS(0x60); RAPIDJSON_TAIL(); RAPIDJSON_TAIL(); return result;
default: return false;
}
-#undef COPY
-#undef TRANS
-#undef TAIL
+#undef RAPIDJSON_COPY
+#undef RAPIDJSON_TRANS
+#undef RAPIDJSON_TAIL
}
static unsigned char GetRange(unsigned char c) {
RAPIDJSON_NAMESPACE_END
-#if defined(__GNUC__) || defined(_MSC_VER)
+#if defined(__GNUC__) || (defined(_MSC_VER) && !defined(__clang__))
RAPIDJSON_DIAG_POP
#endif
// For encoding detection only.
const Ch* Peek4() const {
- return (current_ + 4 <= bufferLast_) ? current_ : 0;
+ return (current_ + 4 - !eof_ <= bufferLast_) ? current_ : 0;
}
private:
RAPIDJSON_NAMESPACE_BEGIN
-//! Wrapper of C file stream for input using fread().
+//! Wrapper of C file stream for output using fwrite().
/*!
\note implements Stream concept
*/
#include "../rapidjson.h"
-#if defined(_MSC_VER) && defined(_M_AMD64)
+#if defined(_MSC_VER) && !__INTEL_COMPILER && defined(_M_AMD64)
#include <intrin.h> // for _umul128
#pragma intrinsic(_umul128)
#endif
RAPIDJSON_ASSERT(count_ + offset <= kCapacity);
if (interShift == 0) {
- std::memmove(&digits_[count_ - 1 + offset], &digits_[count_ - 1], count_ * sizeof(Type));
+ std::memmove(digits_ + offset, digits_, count_ * sizeof(Type));
count_ += offset;
}
else {
// Tencent is pleased to support the open source community by making RapidJSON available.
-//
+//
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
//
// Licensed under the MIT License (the "License"); you may not use this file except
//
// http://opensource.org/licenses/MIT
//
-// Unless required by applicable law or agreed to in writing, software distributed
-// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
-// CONDITIONS OF ANY KIND, either express or implied. See the License for the
+// Unless required by applicable law or agreed to in writing, software distributed
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the
// specific language governing permissions and limitations under the License.
// This is a C++ header-only implementation of Grisu2 algorithm from the publication:
#define RAPIDJSON_DIYFP_H_
#include "../rapidjson.h"
+#include <limits>
#if defined(_MSC_VER) && defined(_M_AMD64) && !defined(__INTEL_COMPILER)
#include <intrin.h>
if (biased_e != 0) {
f = significand + kDpHiddenBit;
e = biased_e - kDpExponentBias;
- }
+ }
else {
f = significand;
e = kDpMinExponent + 1;
}
DiyFp Normalize() const {
+ RAPIDJSON_ASSERT(f != 0); // https://stackoverflow.com/a/26809183/291737
#if defined(_MSC_VER) && defined(_M_AMD64)
unsigned long index;
_BitScanReverse64(&index, f);
double d;
uint64_t u64;
}u;
- const uint64_t be = (e == kDpDenormalExponent && (f & kDpHiddenBit) == 0) ? 0 :
+ RAPIDJSON_ASSERT(f <= kDpHiddenBit + kDpSignificandMask);
+ if (e < kDpDenormalExponent) {
+ // Underflow.
+ return 0.0;
+ }
+ if (e >= kDpMaxExponent) {
+ // Overflow.
+ return std::numeric_limits<double>::infinity();
+ }
+ const uint64_t be = (e == kDpDenormalExponent && (f & kDpHiddenBit) == 0) ? 0 :
static_cast<uint64_t>(e + kDpExponentBias);
u.u64 = (f & kDpSignificandMask) | (be << kDpSignificandSize);
return u.d;
641, 667, 694, 720, 747, 774, 800, 827, 853, 880,
907, 933, 960, 986, 1013, 1039, 1066
};
+ RAPIDJSON_ASSERT(index < 87);
return DiyFp(kCachedPowers_F[index], kCachedPowers_E[index]);
}
-
+
inline DiyFp GetCachedPower(int e, int* K) {
//int k = static_cast<int>(ceil((-61 - e) * 0.30102999566398114)) + 374;
}
inline DiyFp GetCachedPower10(int exp, int *outExp) {
- unsigned index = (static_cast<unsigned>(exp) + 348u) / 8u;
- *outExp = -348 + static_cast<int>(index) * 8;
- return GetCachedPowerByIndex(index);
- }
+ RAPIDJSON_ASSERT(exp >= -348);
+ unsigned index = static_cast<unsigned>(exp + 348) / 8u;
+ *outExp = -348 + static_cast<int>(index) * 8;
+ return GetCachedPowerByIndex(index);
+}
#ifdef __GNUC__
RAPIDJSON_DIAG_POP
class Double {
public:
- Double() = default;
+ Double() {}
Double(double d) : d_(d) {}
Double(uint64_t u) : u_(u) {}
// Tencent is pleased to support the open source community by making RapidJSON available.
-//
+//
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
//
// Licensed under the MIT License (the "License"); you may not use this file except
//
// http://opensource.org/licenses/MIT
//
-// Unless required by applicable law or agreed to in writing, software distributed
-// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
-// CONDITIONS OF ANY KIND, either express or implied. See the License for the
+// Unless required by applicable law or agreed to in writing, software distributed
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the
// specific language governing permissions and limitations under the License.
#ifndef RAPIDJSON_ITOA_
}
inline char* u32toa(uint32_t value, char* buffer) {
+ RAPIDJSON_ASSERT(buffer != 0);
+
const char* cDigitsLut = GetDigitsLut();
if (value < 10000) {
const uint32_t d1 = (value / 100) << 1;
const uint32_t d2 = (value % 100) << 1;
-
+
if (value >= 1000)
*buffer++ = cDigitsLut[d1];
if (value >= 100)
// value = bbbbcccc
const uint32_t b = value / 10000;
const uint32_t c = value % 10000;
-
+
const uint32_t d1 = (b / 100) << 1;
const uint32_t d2 = (b % 100) << 1;
-
+
const uint32_t d3 = (c / 100) << 1;
const uint32_t d4 = (c % 100) << 1;
-
+
if (value >= 10000000)
*buffer++ = cDigitsLut[d1];
if (value >= 1000000)
if (value >= 100000)
*buffer++ = cDigitsLut[d2];
*buffer++ = cDigitsLut[d2 + 1];
-
+
*buffer++ = cDigitsLut[d3];
*buffer++ = cDigitsLut[d3 + 1];
*buffer++ = cDigitsLut[d4];
}
else {
// value = aabbbbcccc in decimal
-
+
const uint32_t a = value / 100000000; // 1 to 42
value %= 100000000;
-
+
if (a >= 10) {
const unsigned i = a << 1;
*buffer++ = cDigitsLut[i];
const uint32_t b = value / 10000; // 0 to 9999
const uint32_t c = value % 10000; // 0 to 9999
-
+
const uint32_t d1 = (b / 100) << 1;
const uint32_t d2 = (b % 100) << 1;
-
+
const uint32_t d3 = (c / 100) << 1;
const uint32_t d4 = (c % 100) << 1;
-
+
*buffer++ = cDigitsLut[d1];
*buffer++ = cDigitsLut[d1 + 1];
*buffer++ = cDigitsLut[d2];
}
inline char* i32toa(int32_t value, char* buffer) {
+ RAPIDJSON_ASSERT(buffer != 0);
uint32_t u = static_cast<uint32_t>(value);
if (value < 0) {
*buffer++ = '-';
}
inline char* u64toa(uint64_t value, char* buffer) {
+ RAPIDJSON_ASSERT(buffer != 0);
const char* cDigitsLut = GetDigitsLut();
const uint64_t kTen8 = 100000000;
const uint64_t kTen9 = kTen8 * 10;
const uint64_t kTen14 = kTen8 * 1000000;
const uint64_t kTen15 = kTen8 * 10000000;
const uint64_t kTen16 = kTen8 * kTen8;
-
+
if (value < kTen8) {
uint32_t v = static_cast<uint32_t>(value);
if (v < 10000) {
const uint32_t d1 = (v / 100) << 1;
const uint32_t d2 = (v % 100) << 1;
-
+
if (v >= 1000)
*buffer++ = cDigitsLut[d1];
if (v >= 100)
// value = bbbbcccc
const uint32_t b = v / 10000;
const uint32_t c = v % 10000;
-
+
const uint32_t d1 = (b / 100) << 1;
const uint32_t d2 = (b % 100) << 1;
-
+
const uint32_t d3 = (c / 100) << 1;
const uint32_t d4 = (c % 100) << 1;
-
+
if (value >= 10000000)
*buffer++ = cDigitsLut[d1];
if (value >= 1000000)
if (value >= 100000)
*buffer++ = cDigitsLut[d2];
*buffer++ = cDigitsLut[d2 + 1];
-
+
*buffer++ = cDigitsLut[d3];
*buffer++ = cDigitsLut[d3 + 1];
*buffer++ = cDigitsLut[d4];
else if (value < kTen16) {
const uint32_t v0 = static_cast<uint32_t>(value / kTen8);
const uint32_t v1 = static_cast<uint32_t>(value % kTen8);
-
+
const uint32_t b0 = v0 / 10000;
const uint32_t c0 = v0 % 10000;
-
+
const uint32_t d1 = (b0 / 100) << 1;
const uint32_t d2 = (b0 % 100) << 1;
-
+
const uint32_t d3 = (c0 / 100) << 1;
const uint32_t d4 = (c0 % 100) << 1;
const uint32_t b1 = v1 / 10000;
const uint32_t c1 = v1 % 10000;
-
+
const uint32_t d5 = (b1 / 100) << 1;
const uint32_t d6 = (b1 % 100) << 1;
-
+
const uint32_t d7 = (c1 / 100) << 1;
const uint32_t d8 = (c1 % 100) << 1;
*buffer++ = cDigitsLut[d3 + 1];
if (value >= kTen9)
*buffer++ = cDigitsLut[d4];
- if (value >= kTen8)
- *buffer++ = cDigitsLut[d4 + 1];
-
+
+ *buffer++ = cDigitsLut[d4 + 1];
*buffer++ = cDigitsLut[d5];
*buffer++ = cDigitsLut[d5 + 1];
*buffer++ = cDigitsLut[d6];
else {
const uint32_t a = static_cast<uint32_t>(value / kTen16); // 1 to 1844
value %= kTen16;
-
+
if (a < 10)
*buffer++ = static_cast<char>('0' + static_cast<char>(a));
else if (a < 100) {
}
else if (a < 1000) {
*buffer++ = static_cast<char>('0' + static_cast<char>(a / 100));
-
+
const uint32_t i = (a % 100) << 1;
*buffer++ = cDigitsLut[i];
*buffer++ = cDigitsLut[i + 1];
*buffer++ = cDigitsLut[j];
*buffer++ = cDigitsLut[j + 1];
}
-
+
const uint32_t v0 = static_cast<uint32_t>(value / kTen8);
const uint32_t v1 = static_cast<uint32_t>(value % kTen8);
-
+
const uint32_t b0 = v0 / 10000;
const uint32_t c0 = v0 % 10000;
-
+
const uint32_t d1 = (b0 / 100) << 1;
const uint32_t d2 = (b0 % 100) << 1;
-
+
const uint32_t d3 = (c0 / 100) << 1;
const uint32_t d4 = (c0 % 100) << 1;
-
+
const uint32_t b1 = v1 / 10000;
const uint32_t c1 = v1 % 10000;
-
+
const uint32_t d5 = (b1 / 100) << 1;
const uint32_t d6 = (b1 % 100) << 1;
-
+
const uint32_t d7 = (c1 / 100) << 1;
const uint32_t d8 = (c1 % 100) << 1;
-
+
*buffer++ = cDigitsLut[d1];
*buffer++ = cDigitsLut[d1 + 1];
*buffer++ = cDigitsLut[d2];
*buffer++ = cDigitsLut[d8];
*buffer++ = cDigitsLut[d8 + 1];
}
-
+
return buffer;
}
inline char* i64toa(int64_t value, char* buffer) {
+ RAPIDJSON_ASSERT(buffer != 0);
uint64_t u = static_cast<uint64_t>(value);
if (value < 0) {
*buffer++ = '-';
RAPIDJSON_DIAG_PUSH
RAPIDJSON_DIAG_OFF(effc++)
#endif
-#if defined(_MSC_VER)
+
+#if defined(_MSC_VER) && !defined(__clang__)
RAPIDJSON_DIAG_PUSH
RAPIDJSON_DIAG_OFF(6334)
#endif
RAPIDJSON_NAMESPACE_END
//@endcond
-#if defined(__GNUC__) || defined(_MSC_VER)
+#if defined(_MSC_VER) && !defined(__clang__)
+RAPIDJSON_DIAG_POP
+#endif
+
+#ifdef __GNUC__
RAPIDJSON_DIAG_POP
#endif
RAPIDJSON_DIAG_OFF(padded)
RAPIDJSON_DIAG_OFF(switch-enum)
RAPIDJSON_DIAG_OFF(implicit-fallthrough)
+#elif defined(_MSC_VER)
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(4512) // assignment operator could not be generated
#endif
#ifdef __GNUC__
#endif
#endif
-#ifdef _MSC_VER
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(4512) // assignment operator could not be generated
-#endif
-
#ifndef RAPIDJSON_REGEX_VERBOSE
#define RAPIDJSON_REGEX_VERBOSE 0
#endif
template <typename, typename> friend class GenericRegexSearch;
GenericRegex(const Ch* source, Allocator* allocator = 0) :
- states_(allocator, 256), ranges_(allocator, 256), root_(kRegexInvalidState), stateCount_(), rangeCount_(),
+ ownAllocator_(allocator ? 0 : RAPIDJSON_NEW(Allocator)()), allocator_(allocator ? allocator : ownAllocator_),
+ states_(allocator_, 256), ranges_(allocator_, 256), root_(kRegexInvalidState), stateCount_(), rangeCount_(),
anchorBegin_(), anchorEnd_()
{
GenericStringStream<Encoding> ss(source);
Parse(ds);
}
- ~GenericRegex() {}
+ ~GenericRegex()
+ {
+ RAPIDJSON_DELETE(ownAllocator_);
+ }
bool IsValid() const {
return root_ != kRegexInvalidState;
template <typename InputStream>
void Parse(DecodedStream<InputStream, Encoding>& ds) {
- Allocator allocator;
- Stack<Allocator> operandStack(&allocator, 256); // Frag
- Stack<Allocator> operatorStack(&allocator, 256); // Operator
- Stack<Allocator> atomCountStack(&allocator, 256); // unsigned (Atom per parenthesis)
+ Stack<Allocator> operandStack(allocator_, 256); // Frag
+ Stack<Allocator> operatorStack(allocator_, 256); // Operator
+ Stack<Allocator> atomCountStack(allocator_, 256); // unsigned (Atom per parenthesis)
*atomCountStack.template Push<unsigned>() = 0;
}
return false;
- default:
- RAPIDJSON_ASSERT(op == kOneOrMore);
+ case kOneOrMore:
if (operandStack.GetSize() >= sizeof(Frag)) {
Frag e = *operandStack.template Pop<Frag>(1);
SizeType s = NewState(kRegexInvalidState, e.start, 0);
return true;
}
return false;
+
+ default:
+ // syntax error (e.g. unclosed kLeftParenthesis)
+ return false;
}
}
}
}
+ Allocator* ownAllocator_;
+ Allocator* allocator_;
Stack<Allocator> states_;
Stack<Allocator> ranges_;
SizeType root_;
} // namespace internal
RAPIDJSON_NAMESPACE_END
-#ifdef __clang__
+#ifdef __GNUC__
RAPIDJSON_DIAG_POP
#endif
-#ifdef _MSC_VER
+#if defined(__clang__) || defined(_MSC_VER)
RAPIDJSON_DIAG_POP
#endif
#include "../allocators.h"
#include "swap.h"
+#include <cstddef>
#if defined(__clang__)
RAPIDJSON_DIAG_PUSH
void ShrinkToFit() {
if (Empty()) {
// If the stack is empty, completely deallocate the memory.
- Allocator::Free(stack_);
+ Allocator::Free(stack_); // NOLINT (+clang-analyzer-unix.Malloc)
stack_ = 0;
stackTop_ = 0;
stackEnd_ = 0;
template<typename T>
RAPIDJSON_FORCEINLINE void Reserve(size_t count = 1) {
// Expand the stack if needed
- if (RAPIDJSON_UNLIKELY(stackTop_ + sizeof(T) * count > stackEnd_))
+ if (RAPIDJSON_UNLIKELY(static_cast<std::ptrdiff_t>(sizeof(T) * count) > (stackEnd_ - stackTop_)))
Expand<T>(count);
}
template<typename T>
RAPIDJSON_FORCEINLINE T* PushUnsafe(size_t count = 1) {
RAPIDJSON_ASSERT(stackTop_);
- RAPIDJSON_ASSERT(stackTop_ + sizeof(T) * count <= stackEnd_);
+ RAPIDJSON_ASSERT(static_cast<std::ptrdiff_t>(sizeof(T) * count) <= (stackEnd_ - stackTop_));
T* ret = reinterpret_cast<T*>(stackTop_);
stackTop_ += sizeof(T) * count;
return ret;
#include "biginteger.h"
#include "diyfp.h"
#include "pow10.h"
+#include <climits>
+#include <limits>
RAPIDJSON_NAMESPACE_BEGIN
namespace internal {
}
// Compute an approximation and see if it is within 1/2 ULP
-inline bool StrtodDiyFp(const char* decimals, size_t length, size_t decimalPosition, int exp, double* result) {
+inline bool StrtodDiyFp(const char* decimals, int dLen, int dExp, double* result) {
uint64_t significand = 0;
- size_t i = 0; // 2^64 - 1 = 18446744073709551615, 1844674407370955161 = 0x1999999999999999
- for (; i < length; i++) {
+ int i = 0; // 2^64 - 1 = 18446744073709551615, 1844674407370955161 = 0x1999999999999999
+ for (; i < dLen; i++) {
if (significand > RAPIDJSON_UINT64_C2(0x19999999, 0x99999999) ||
(significand == RAPIDJSON_UINT64_C2(0x19999999, 0x99999999) && decimals[i] > '5'))
break;
significand = significand * 10u + static_cast<unsigned>(decimals[i] - '0');
}
- if (i < length && decimals[i] >= '5') // Rounding
+ if (i < dLen && decimals[i] >= '5') // Rounding
significand++;
- size_t remaining = length - i;
+ int remaining = dLen - i;
const int kUlpShift = 3;
const int kUlp = 1 << kUlpShift;
int64_t error = (remaining == 0) ? 0 : kUlp / 2;
v = v.Normalize();
error <<= -v.e;
- const int dExp = static_cast<int>(decimalPosition) - static_cast<int>(i) + exp;
+ dExp += remaining;
int actualExp;
DiyFp cachedPower = GetCachedPower10(dExp, &actualExp);
if (actualExp != dExp) {
static const DiyFp kPow10[] = {
- DiyFp(RAPIDJSON_UINT64_C2(0xa0000000, 00000000), -60), // 10^1
- DiyFp(RAPIDJSON_UINT64_C2(0xc8000000, 00000000), -57), // 10^2
- DiyFp(RAPIDJSON_UINT64_C2(0xfa000000, 00000000), -54), // 10^3
- DiyFp(RAPIDJSON_UINT64_C2(0x9c400000, 00000000), -50), // 10^4
- DiyFp(RAPIDJSON_UINT64_C2(0xc3500000, 00000000), -47), // 10^5
- DiyFp(RAPIDJSON_UINT64_C2(0xf4240000, 00000000), -44), // 10^6
- DiyFp(RAPIDJSON_UINT64_C2(0x98968000, 00000000), -40) // 10^7
+ DiyFp(RAPIDJSON_UINT64_C2(0xa0000000, 0x00000000), -60), // 10^1
+ DiyFp(RAPIDJSON_UINT64_C2(0xc8000000, 0x00000000), -57), // 10^2
+ DiyFp(RAPIDJSON_UINT64_C2(0xfa000000, 0x00000000), -54), // 10^3
+ DiyFp(RAPIDJSON_UINT64_C2(0x9c400000, 0x00000000), -50), // 10^4
+ DiyFp(RAPIDJSON_UINT64_C2(0xc3500000, 0x00000000), -47), // 10^5
+ DiyFp(RAPIDJSON_UINT64_C2(0xf4240000, 0x00000000), -44), // 10^6
+ DiyFp(RAPIDJSON_UINT64_C2(0x98968000, 0x00000000), -40) // 10^7
};
- int adjustment = dExp - actualExp - 1;
- RAPIDJSON_ASSERT(adjustment >= 0 && adjustment < 7);
- v = v * kPow10[adjustment];
- if (length + static_cast<unsigned>(adjustment)> 19u) // has more digits than decimal digits in 64-bit
+ int adjustment = dExp - actualExp;
+ RAPIDJSON_ASSERT(adjustment >= 1 && adjustment < 8);
+ v = v * kPow10[adjustment - 1];
+ if (dLen + adjustment > 19) // has more digits than decimal digits in 64-bit
error += kUlp / 2;
}
return halfWay - static_cast<unsigned>(error) >= precisionBits || precisionBits >= halfWay + static_cast<unsigned>(error);
}
-inline double StrtodBigInteger(double approx, const char* decimals, size_t length, size_t decimalPosition, int exp) {
- const BigInteger dInt(decimals, length);
- const int dExp = static_cast<int>(decimalPosition) - static_cast<int>(length) + exp;
+inline double StrtodBigInteger(double approx, const char* decimals, int dLen, int dExp) {
+ RAPIDJSON_ASSERT(dLen >= 0);
+ const BigInteger dInt(decimals, static_cast<unsigned>(dLen));
Double a(approx);
int cmp = CheckWithinHalfULP(a.Value(), dInt, dExp);
if (cmp < 0)
RAPIDJSON_ASSERT(d >= 0.0);
RAPIDJSON_ASSERT(length >= 1);
- double result;
+ double result = 0.0;
if (StrtodFast(d, p, &result))
return result;
+ RAPIDJSON_ASSERT(length <= INT_MAX);
+ int dLen = static_cast<int>(length);
+
+ RAPIDJSON_ASSERT(length >= decimalPosition);
+ RAPIDJSON_ASSERT(length - decimalPosition <= INT_MAX);
+ int dExpAdjust = static_cast<int>(length - decimalPosition);
+
+ RAPIDJSON_ASSERT(exp >= INT_MIN + dExpAdjust);
+ int dExp = exp - dExpAdjust;
+
+ // Make sure length+dExp does not overflow
+ RAPIDJSON_ASSERT(dExp <= INT_MAX - dLen);
+
// Trim leading zeros
- while (*decimals == '0' && length > 1) {
- length--;
+ while (dLen > 0 && *decimals == '0') {
+ dLen--;
decimals++;
- decimalPosition--;
}
// Trim trailing zeros
- while (decimals[length - 1] == '0' && length > 1) {
- length--;
- decimalPosition--;
- exp++;
+ while (dLen > 0 && decimals[dLen - 1] == '0') {
+ dLen--;
+ dExp++;
+ }
+
+ if (dLen == 0) { // Buffer only contains zeros.
+ return 0.0;
}
// Trim right-most digits
- const int kMaxDecimalDigit = 780;
- if (static_cast<int>(length) > kMaxDecimalDigit) {
- int delta = (static_cast<int>(length) - kMaxDecimalDigit);
- exp += delta;
- decimalPosition -= static_cast<unsigned>(delta);
- length = kMaxDecimalDigit;
+ const int kMaxDecimalDigit = 767 + 1;
+ if (dLen > kMaxDecimalDigit) {
+ dExp += dLen - kMaxDecimalDigit;
+ dLen = kMaxDecimalDigit;
}
- // If too small, underflow to zero
- if (int(length) + exp < -324)
+ // If too small, underflow to zero.
+ // Any x <= 10^-324 is interpreted as zero.
+ if (dLen + dExp <= -324)
return 0.0;
- if (StrtodDiyFp(decimals, length, decimalPosition, exp, &result))
+ // If too large, overflow to infinity.
+ // Any x >= 10^309 is interpreted as +infinity.
+ if (dLen + dExp > 309)
+ return std::numeric_limits<double>::infinity();
+
+ if (StrtodDiyFp(decimals, dLen, dExp, &result))
return result;
// Use approximation from StrtodDiyFp and make adjustment with BigInteger comparison
- return StrtodBigInteger(result, decimals, length, decimalPosition, exp);
+ return StrtodBigInteger(result, decimals, dLen, dExp);
}
} // namespace internal
#include "stream.h"
#include <iosfwd>
+#include <ios>
#ifdef __clang__
RAPIDJSON_DIAG_PUSH
RAPIDJSON_DIAG_OFF(padded)
-#endif
-
-#ifdef _MSC_VER
+#elif defined(_MSC_VER)
RAPIDJSON_DIAG_PUSH
RAPIDJSON_DIAG_OFF(4351) // new behavior: elements of array 'array' will be default initialized
#endif
class BasicIStreamWrapper {
public:
typedef typename StreamType::char_type Ch;
- BasicIStreamWrapper(StreamType& stream) : stream_(stream), count_(), peekBuffer_() {}
- Ch Peek() const {
- typename StreamType::int_type c = stream_.peek();
- return RAPIDJSON_LIKELY(c != StreamType::traits_type::eof()) ? static_cast<Ch>(c) : static_cast<Ch>('\0');
+ //! Constructor.
+ /*!
+ \param stream stream opened for read.
+ */
+ BasicIStreamWrapper(StreamType &stream) : stream_(stream), buffer_(peekBuffer_), bufferSize_(4), bufferLast_(0), current_(buffer_), readCount_(0), count_(0), eof_(false) {
+ Read();
}
- Ch Take() {
- typename StreamType::int_type c = stream_.get();
- if (RAPIDJSON_LIKELY(c != StreamType::traits_type::eof())) {
- count_++;
- return static_cast<Ch>(c);
- }
- else
- return '\0';
+ //! Constructor.
+ /*!
+ \param stream stream opened for read.
+ \param buffer user-supplied buffer.
+ \param bufferSize size of buffer in bytes. Must >=4 bytes.
+ */
+ BasicIStreamWrapper(StreamType &stream, char* buffer, size_t bufferSize) : stream_(stream), buffer_(buffer), bufferSize_(bufferSize), bufferLast_(0), current_(buffer_), readCount_(0), count_(0), eof_(false) {
+ RAPIDJSON_ASSERT(bufferSize >= 4);
+ Read();
}
- // tellg() may return -1 when failed. So we count by ourself.
- size_t Tell() const { return count_; }
+ Ch Peek() const { return *current_; }
+ Ch Take() { Ch c = *current_; Read(); return c; }
+ size_t Tell() const { return count_ + static_cast<size_t>(current_ - buffer_); }
- Ch* PutBegin() { RAPIDJSON_ASSERT(false); return 0; }
+ // Not implemented
void Put(Ch) { RAPIDJSON_ASSERT(false); }
- void Flush() { RAPIDJSON_ASSERT(false); }
+ void Flush() { RAPIDJSON_ASSERT(false); }
+ Ch* PutBegin() { RAPIDJSON_ASSERT(false); return 0; }
size_t PutEnd(Ch*) { RAPIDJSON_ASSERT(false); return 0; }
// For encoding detection only.
const Ch* Peek4() const {
- RAPIDJSON_ASSERT(sizeof(Ch) == 1); // Only usable for byte stream.
- int i;
- bool hasError = false;
- for (i = 0; i < 4; ++i) {
- typename StreamType::int_type c = stream_.get();
- if (c == StreamType::traits_type::eof()) {
- hasError = true;
- stream_.clear();
- break;
- }
- peekBuffer_[i] = static_cast<Ch>(c);
- }
- for (--i; i >= 0; --i)
- stream_.putback(peekBuffer_[i]);
- return !hasError ? peekBuffer_ : 0;
+ return (current_ + 4 - !eof_ <= bufferLast_) ? current_ : 0;
}
private:
+ BasicIStreamWrapper();
BasicIStreamWrapper(const BasicIStreamWrapper&);
BasicIStreamWrapper& operator=(const BasicIStreamWrapper&);
- StreamType& stream_;
- size_t count_; //!< Number of characters read. Note:
- mutable Ch peekBuffer_[4];
+ void Read() {
+ if (current_ < bufferLast_)
+ ++current_;
+ else if (!eof_) {
+ count_ += readCount_;
+ readCount_ = bufferSize_;
+ bufferLast_ = buffer_ + readCount_ - 1;
+ current_ = buffer_;
+
+ if (!stream_.read(buffer_, static_cast<std::streamsize>(bufferSize_))) {
+ readCount_ = static_cast<size_t>(stream_.gcount());
+ *(bufferLast_ = buffer_ + readCount_) = '\0';
+ eof_ = true;
+ }
+ }
+ }
+
+ StreamType &stream_;
+ Ch peekBuffer_[4], *buffer_;
+ size_t bufferSize_;
+ Ch *bufferLast_;
+ Ch *current_;
+ size_t readCount_;
+ size_t count_; //!< Number of characters read
+ bool eof_;
};
typedef BasicIStreamWrapper<std::istream> IStreamWrapper;
+++ /dev/null
-ssg_sources_lottie_rapidjson = []
-
-ssg_lottie_rapidjson_file = ['jsontest.cpp'
- ]
-
-foreach file: ssg_lottie_rapidjson_file
- ssg_sources_lottie_rapidjson += join_paths('rapidjson', file)
-endforeach
#ifdef __clang__
RAPIDJSON_DIAG_PUSH
RAPIDJSON_DIAG_OFF(switch-enum)
-#endif
-
-#ifdef _MSC_VER
+#elif defined(_MSC_VER)
RAPIDJSON_DIAG_PUSH
RAPIDJSON_DIAG_OFF(4512) // assignment operator could not be generated
#endif
GenericPointer(const Token* tokens, size_t tokenCount) : allocator_(), ownAllocator_(), nameBuffer_(), tokens_(const_cast<Token*>(tokens)), tokenCount_(tokenCount), parseErrorOffset_(), parseErrorCode_(kPointerParseErrorNone) {}
//! Copy constructor.
- GenericPointer(const GenericPointer& rhs, Allocator* allocator = 0) : allocator_(allocator), ownAllocator_(), nameBuffer_(), tokens_(), tokenCount_(), parseErrorOffset_(), parseErrorCode_(kPointerParseErrorNone) {
+ GenericPointer(const GenericPointer& rhs) : allocator_(rhs.allocator_), ownAllocator_(), nameBuffer_(), tokens_(), tokenCount_(), parseErrorOffset_(), parseErrorCode_(kPointerParseErrorNone) {
+ *this = rhs;
+ }
+
+ //! Copy constructor.
+ GenericPointer(const GenericPointer& rhs, Allocator* allocator) : allocator_(allocator), ownAllocator_(), nameBuffer_(), tokens_(), tokenCount_(), parseErrorOffset_(), parseErrorCode_(kPointerParseErrorNone) {
*this = rhs;
}
return *this;
}
+ //! Swap the content of this pointer with an other.
+ /*!
+ \param other The pointer to swap with.
+ \note Constant complexity.
+ */
+ GenericPointer& Swap(GenericPointer& other) RAPIDJSON_NOEXCEPT {
+ internal::Swap(allocator_, other.allocator_);
+ internal::Swap(ownAllocator_, other.ownAllocator_);
+ internal::Swap(nameBuffer_, other.nameBuffer_);
+ internal::Swap(tokens_, other.tokens_);
+ internal::Swap(tokenCount_, other.tokenCount_);
+ internal::Swap(parseErrorOffset_, other.parseErrorOffset_);
+ internal::Swap(parseErrorCode_, other.parseErrorCode_);
+ return *this;
+ }
+
+ //! free-standing swap function helper
+ /*!
+ Helper function to enable support for common swap implementation pattern based on \c std::swap:
+ \code
+ void swap(MyClass& a, MyClass& b) {
+ using std::swap;
+ swap(a.pointer, b.pointer);
+ // ...
+ }
+ \endcode
+ \see Swap()
+ */
+ friend inline void swap(GenericPointer& a, GenericPointer& b) RAPIDJSON_NOEXCEPT { a.Swap(b); }
+
//@}
//!@name Append token
*/
bool operator!=(const GenericPointer& rhs) const { return !(*this == rhs); }
+ //! Less than operator.
+ /*!
+ \note Invalid pointers are always greater than valid ones.
+ */
+ bool operator<(const GenericPointer& rhs) const {
+ if (!IsValid())
+ return false;
+ if (!rhs.IsValid())
+ return true;
+
+ if (tokenCount_ != rhs.tokenCount_)
+ return tokenCount_ < rhs.tokenCount_;
+
+ for (size_t i = 0; i < tokenCount_; i++) {
+ if (tokens_[i].index != rhs.tokens_[i].index)
+ return tokens_[i].index < rhs.tokens_[i].index;
+
+ if (tokens_[i].length != rhs.tokens_[i].length)
+ return tokens_[i].length < rhs.tokens_[i].length;
+
+ if (int cmp = std::memcmp(tokens_[i].name, rhs.tokens_[i].name, sizeof(Ch) * tokens_[i].length))
+ return cmp < 0;
+ }
+
+ return false;
+ }
+
//@}
//!@name Stringify
*/
ValueType& GetWithDefault(ValueType& root, const ValueType& defaultValue, typename ValueType::AllocatorType& allocator) const {
bool alreadyExist;
- Value& v = Create(root, allocator, &alreadyExist);
+ ValueType& v = Create(root, allocator, &alreadyExist);
return alreadyExist ? v : v.CopyFrom(defaultValue, allocator);
}
//! Query a value in a subtree with default null-terminated string.
ValueType& GetWithDefault(ValueType& root, const Ch* defaultValue, typename ValueType::AllocatorType& allocator) const {
bool alreadyExist;
- Value& v = Create(root, allocator, &alreadyExist);
+ ValueType& v = Create(root, allocator, &alreadyExist);
return alreadyExist ? v : v.SetString(defaultValue, allocator);
}
//! Query a value in a subtree with default std::basic_string.
ValueType& GetWithDefault(ValueType& root, const std::basic_string<Ch>& defaultValue, typename ValueType::AllocatorType& allocator) const {
bool alreadyExist;
- Value& v = Create(root, allocator, &alreadyExist);
+ ValueType& v = Create(root, allocator, &alreadyExist);
return alreadyExist ? v : v.SetString(defaultValue, allocator);
}
#endif
RAPIDJSON_NAMESPACE_END
-#ifdef __clang__
-RAPIDJSON_DIAG_POP
-#endif
-
-#ifdef _MSC_VER
+#if defined(__clang__) || defined(_MSC_VER)
RAPIDJSON_DIAG_POP
#endif
//! Writer with indentation and spacing.
/*!
- \tparam OutputStream Type of ouptut os.
+ \tparam OutputStream Type of output os.
\tparam SourceEncoding Encoding of source string.
\tparam TargetEncoding Encoding of output stream.
\tparam StackAllocator Type of allocator for allocating memory of stack.
*/
//@{
- bool Null() { PrettyPrefix(kNullType); return Base::WriteNull(); }
- bool Bool(bool b) { PrettyPrefix(b ? kTrueType : kFalseType); return Base::WriteBool(b); }
- bool Int(int i) { PrettyPrefix(kNumberType); return Base::WriteInt(i); }
- bool Uint(unsigned u) { PrettyPrefix(kNumberType); return Base::WriteUint(u); }
- bool Int64(int64_t i64) { PrettyPrefix(kNumberType); return Base::WriteInt64(i64); }
- bool Uint64(uint64_t u64) { PrettyPrefix(kNumberType); return Base::WriteUint64(u64); }
- bool Double(double d) { PrettyPrefix(kNumberType); return Base::WriteDouble(d); }
+ bool Null() { PrettyPrefix(kNullType); return Base::EndValue(Base::WriteNull()); }
+ bool Bool(bool b) { PrettyPrefix(b ? kTrueType : kFalseType); return Base::EndValue(Base::WriteBool(b)); }
+ bool Int(int i) { PrettyPrefix(kNumberType); return Base::EndValue(Base::WriteInt(i)); }
+ bool Uint(unsigned u) { PrettyPrefix(kNumberType); return Base::EndValue(Base::WriteUint(u)); }
+ bool Int64(int64_t i64) { PrettyPrefix(kNumberType); return Base::EndValue(Base::WriteInt64(i64)); }
+ bool Uint64(uint64_t u64) { PrettyPrefix(kNumberType); return Base::EndValue(Base::WriteUint64(u64)); }
+ bool Double(double d) { PrettyPrefix(kNumberType); return Base::EndValue(Base::WriteDouble(d)); }
bool RawNumber(const Ch* str, SizeType length, bool copy = false) {
RAPIDJSON_ASSERT(str != 0);
(void)copy;
PrettyPrefix(kNumberType);
- return Base::WriteString(str, length);
+ return Base::EndValue(Base::WriteString(str, length));
}
bool String(const Ch* str, SizeType length, bool copy = false) {
RAPIDJSON_ASSERT(str != 0);
(void)copy;
PrettyPrefix(kStringType);
- return Base::WriteString(str, length);
+ return Base::EndValue(Base::WriteString(str, length));
}
#if RAPIDJSON_HAS_STDSTRING
Base::os_->Put('\n');
WriteIndent();
}
- bool ret = Base::WriteEndObject();
+ bool ret = Base::EndValue(Base::WriteEndObject());
(void)ret;
RAPIDJSON_ASSERT(ret == true);
if (Base::level_stack_.Empty()) // end of json text
Base::os_->Put('\n');
WriteIndent();
}
- bool ret = Base::WriteEndArray();
+ bool ret = Base::EndValue(Base::WriteEndArray());
(void)ret;
RAPIDJSON_ASSERT(ret == true);
if (Base::level_stack_.Empty()) // end of json text
bool RawValue(const Ch* json, size_t length, Type type) {
RAPIDJSON_ASSERT(json != 0);
PrettyPrefix(type);
- return Base::WriteRawValue(json, length);
+ return Base::EndValue(Base::WriteRawValue(json, length));
}
protected:
Some RapidJSON features are configurable to adapt the library to a wide
variety of platforms, environments and usage scenarios. Most of the
- features can be configured in terms of overriden or predefined
+ features can be configured in terms of overridden or predefined
preprocessor macros at compile-time.
Some additional customization is available in the \ref RAPIDJSON_ERRORS APIs.
# elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
# define RAPIDJSON_ENDIAN RAPIDJSON_BIGENDIAN
# else
-# error Unknown machine endianess detected. User needs to define RAPIDJSON_ENDIAN.
+# error Unknown machine endianness detected. User needs to define RAPIDJSON_ENDIAN.
# endif // __BYTE_ORDER__
// Detect with GLIBC's endian.h
# elif defined(__GLIBC__)
# elif (__BYTE_ORDER == __BIG_ENDIAN)
# define RAPIDJSON_ENDIAN RAPIDJSON_BIGENDIAN
# else
-# error Unknown machine endianess detected. User needs to define RAPIDJSON_ENDIAN.
+# error Unknown machine endianness detected. User needs to define RAPIDJSON_ENDIAN.
# endif // __GLIBC__
// Detect with _LITTLE_ENDIAN and _BIG_ENDIAN macro
# elif defined(_LITTLE_ENDIAN) && !defined(_BIG_ENDIAN)
# elif defined(RAPIDJSON_DOXYGEN_RUNNING)
# define RAPIDJSON_ENDIAN
# else
-# error Unknown machine endianess detected. User needs to define RAPIDJSON_ENDIAN.
+# error Unknown machine endianness detected. User needs to define RAPIDJSON_ENDIAN.
# endif
#endif // RAPIDJSON_ENDIAN
/*! \ingroup RAPIDJSON_CONFIG
\param x pointer to align
- Some machines require strict data alignment. Currently the default uses 4 bytes
- alignment on 32-bit platforms and 8 bytes alignment for 64-bit platforms.
+ Some machines require strict data alignment. The default is 8 bytes.
User can customize by defining the RAPIDJSON_ALIGN function macro.
*/
#ifndef RAPIDJSON_ALIGN
-#if RAPIDJSON_64BIT == 1
-#define RAPIDJSON_ALIGN(x) (((x) + static_cast<uint64_t>(7u)) & ~static_cast<uint64_t>(7u))
-#else
-#define RAPIDJSON_ALIGN(x) (((x) + 3u) & ~3u)
-#endif
+#define RAPIDJSON_ALIGN(x) (((x) + static_cast<size_t>(7u)) & ~static_cast<size_t>(7u))
#endif
///////////////////////////////////////////////////////////////////////////////
template <size_t x> struct StaticAssertTest {};
RAPIDJSON_NAMESPACE_END
-#if defined(__GNUC__)
+#if defined(__GNUC__) || defined(__clang__)
#define RAPIDJSON_STATIC_ASSERT_UNUSED_ATTRIBUTE __attribute__((unused))
#else
#define RAPIDJSON_STATIC_ASSERT_UNUSED_ATTRIBUTE
///////////////////////////////////////////////////////////////////////////////
// C++11 features
-//enable c++11 feature
-#define RAPIDJSON_HAS_CXX11_RVALUE_REFS 1
#ifndef RAPIDJSON_HAS_CXX11_RVALUE_REFS
#if defined(__clang__)
#if __has_feature(cxx_rvalue_references) && \
- (defined(_LIBCPP_VERSION) || defined(__GLIBCXX__) && __GLIBCXX__ >= 20080306)
+ (defined(_MSC_VER) || defined(_LIBCPP_VERSION) || defined(__GLIBCXX__) && __GLIBCXX__ >= 20080306)
#define RAPIDJSON_HAS_CXX11_RVALUE_REFS 1
#else
#define RAPIDJSON_HAS_CXX11_RVALUE_REFS 0
#endif
#elif (defined(RAPIDJSON_GNUC) && (RAPIDJSON_GNUC >= RAPIDJSON_VERSION_CODE(4,3,0)) && defined(__GXX_EXPERIMENTAL_CXX0X__)) || \
- (defined(_MSC_VER) && _MSC_VER >= 1600)
+ (defined(_MSC_VER) && _MSC_VER >= 1600) || \
+ (defined(__SUNPRO_CC) && __SUNPRO_CC >= 0x5140 && defined(__GXX_EXPERIMENTAL_CXX0X__))
#define RAPIDJSON_HAS_CXX11_RVALUE_REFS 1
#else
#ifndef RAPIDJSON_HAS_CXX11_NOEXCEPT
#if defined(__clang__)
#define RAPIDJSON_HAS_CXX11_NOEXCEPT __has_feature(cxx_noexcept)
-#elif (defined(RAPIDJSON_GNUC) && (RAPIDJSON_GNUC >= RAPIDJSON_VERSION_CODE(4,6,0)) && defined(__GXX_EXPERIMENTAL_CXX0X__))
-// (defined(_MSC_VER) && _MSC_VER >= ????) // not yet supported
+#elif (defined(RAPIDJSON_GNUC) && (RAPIDJSON_GNUC >= RAPIDJSON_VERSION_CODE(4,6,0)) && defined(__GXX_EXPERIMENTAL_CXX0X__)) || \
+ (defined(_MSC_VER) && _MSC_VER >= 1900) || \
+ (defined(__SUNPRO_CC) && __SUNPRO_CC >= 0x5140 && defined(__GXX_EXPERIMENTAL_CXX0X__))
#define RAPIDJSON_HAS_CXX11_NOEXCEPT 1
#else
#define RAPIDJSON_HAS_CXX11_NOEXCEPT 0
// no automatic detection, yet
#ifndef RAPIDJSON_HAS_CXX11_TYPETRAITS
+#if (defined(_MSC_VER) && _MSC_VER >= 1700)
+#define RAPIDJSON_HAS_CXX11_TYPETRAITS 1
+#else
#define RAPIDJSON_HAS_CXX11_TYPETRAITS 0
#endif
+#endif
#ifndef RAPIDJSON_HAS_CXX11_RANGE_FOR
#if defined(__clang__)
#define RAPIDJSON_HAS_CXX11_RANGE_FOR __has_feature(cxx_range_for)
#elif (defined(RAPIDJSON_GNUC) && (RAPIDJSON_GNUC >= RAPIDJSON_VERSION_CODE(4,6,0)) && defined(__GXX_EXPERIMENTAL_CXX0X__)) || \
- (defined(_MSC_VER) && _MSC_VER >= 1700)
+ (defined(_MSC_VER) && _MSC_VER >= 1700) || \
+ (defined(__SUNPRO_CC) && __SUNPRO_CC >= 0x5140 && defined(__GXX_EXPERIMENTAL_CXX0X__))
#define RAPIDJSON_HAS_CXX11_RANGE_FOR 1
#else
#define RAPIDJSON_HAS_CXX11_RANGE_FOR 0
//!@endcond
+//! Assertion (in non-throwing contexts).
+ /*! \ingroup RAPIDJSON_CONFIG
+ Some functions provide a \c noexcept guarantee, if the compiler supports it.
+ In these cases, the \ref RAPIDJSON_ASSERT macro cannot be overridden to
+ throw an exception. This macro adds a separate customization point for
+ such cases.
+
+ Defaults to C \c assert() (as \ref RAPIDJSON_ASSERT), if \c noexcept is
+ supported, and to \ref RAPIDJSON_ASSERT otherwise.
+ */
+
+///////////////////////////////////////////////////////////////////////////////
+// RAPIDJSON_NOEXCEPT_ASSERT
+
+#ifndef RAPIDJSON_NOEXCEPT_ASSERT
+#ifdef RAPIDJSON_ASSERT_THROWS
+#if RAPIDJSON_HAS_CXX11_NOEXCEPT
+#define RAPIDJSON_NOEXCEPT_ASSERT(x)
+#else
+#define RAPIDJSON_NOEXCEPT_ASSERT(x) RAPIDJSON_ASSERT(x)
+#endif // RAPIDJSON_HAS_CXX11_NOEXCEPT
+#else
+#define RAPIDJSON_NOEXCEPT_ASSERT(x) RAPIDJSON_ASSERT(x)
+#endif // RAPIDJSON_ASSERT_THROWS
+#endif // RAPIDJSON_NOEXCEPT_ASSERT
+
///////////////////////////////////////////////////////////////////////////////
// new/delete
#include <arm_neon.h>
#endif
-#ifdef _MSC_VER
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(4127) // conditional expression is constant
-RAPIDJSON_DIAG_OFF(4702) // unreachable code
-#endif
-
#ifdef __clang__
RAPIDJSON_DIAG_PUSH
RAPIDJSON_DIAG_OFF(old-style-cast)
RAPIDJSON_DIAG_OFF(padded)
RAPIDJSON_DIAG_OFF(switch-enum)
+#elif defined(_MSC_VER)
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(4127) // conditional expression is constant
+RAPIDJSON_DIAG_OFF(4702) // unreachable code
#endif
#ifdef __GNUC__
/*! \param stackAllocator Optional allocator for allocating stack memory. (Only use for non-destructive parsing)
\param stackCapacity stack capacity in bytes for storing a single decoded string. (Only use for non-destructive parsing)
*/
- GenericReader(StackAllocator* stackAllocator = 0, size_t stackCapacity = kDefaultStackCapacity) : stack_(stackAllocator, stackCapacity), parseResult_() {}
+ GenericReader(StackAllocator* stackAllocator = 0, size_t stackCapacity = kDefaultStackCapacity) :
+ stack_(stackAllocator, stackCapacity), parseResult_(), state_(IterativeParsingStartState) {}
//! Parse JSON text.
/*! \tparam parseFlags Combination of \ref ParseFlag.
parseResult_.Clear();
state_ = IterativeParsingStartState;
}
-
+
//! Parse one token from JSON text
/*! \tparam InputStream Type of input stream, implementing Stream concept
\tparam Handler Type of handler, implementing Handler concept.
bool IterativeParseNext(InputStream& is, Handler& handler) {
while (RAPIDJSON_LIKELY(is.Peek() != '\0')) {
SkipWhitespaceAndComments<parseFlags>(is);
-
+
Token t = Tokenize(is.Peek());
IterativeParsingState n = Predict(state_, t);
IterativeParsingState d = Transit<parseFlags>(state_, t, n, is, handler);
-
+
// If we've finished or hit an error...
if (RAPIDJSON_UNLIKELY(IsIterativeParsingCompleteState(d))) {
// Report errors.
HandleError(state_, is);
return false;
}
-
+
// Transition to the finish state.
RAPIDJSON_ASSERT(d == IterativeParsingFinishState);
state_ = d;
-
+
// If StopWhenDone is not set...
if (!(parseFlags & kParseStopWhenDoneFlag)) {
// ... and extra non-whitespace data is found...
return false;
}
}
-
+
// Success! We are done!
return true;
}
-
+
// Transition to the new state.
state_ = d;
if (!IsIterativeParsingDelimiterState(n))
return true;
}
-
+
// We reached the end of file.
stack_.Clear();
HandleError(state_, is);
return false;
}
-
+
return true;
}
-
+
//! Check if token-by-token parsing JSON text is complete
/*! \return Whether the JSON has been fully decoded.
*/
- RAPIDJSON_FORCEINLINE bool IterativeParseComplete() {
+ RAPIDJSON_FORCEINLINE bool IterativeParseComplete() const {
return IsIterativeParsingCompleteState(state_);
}
- //! Whether a parse error has occured in the last parsing.
+ //! Whether a parse error has occurred in the last parsing.
bool HasParseError() const { return parseResult_.IsError(); }
//! Get the \ref ParseErrorCode of last parsing.
return false;
}
- // Helper function to parse four hexidecimal digits in \uXXXX in ParseString().
+ // Helper function to parse four hexadecimal digits in \uXXXX in ParseString().
template<typename InputStream>
unsigned ParseHex4(InputStream& is, size_t escapeOffset) {
unsigned codepoint = 0;
Ch c = is.Peek();
if (RAPIDJSON_UNLIKELY(c == '\\')) { // Escape
- size_t escapeOffset = is.Tell(); // For invalid escaping, report the inital '\\' as error offset
+ size_t escapeOffset = is.Tell(); // For invalid escaping, report the initial '\\' as error offset
is.Take();
Ch e = is.Peek();
if ((sizeof(Ch) == 1 || unsigned(e) < 256) && RAPIDJSON_LIKELY(escape[static_cast<unsigned char>(e)])) {
}
}
}
-
+
if (RAPIDJSON_UNLIKELY(!useNanOrInf)) {
RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, s.Tell());
}
// Force double for big integer
if (useDouble) {
while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
- if (RAPIDJSON_UNLIKELY(d >= 1.7976931348623157e307)) // DBL_MAX / 10.0
- RAPIDJSON_PARSE_ERROR(kParseErrorNumberTooBig, startOffset);
d = d * 10 + (s.TakePush() - '0');
}
}
if (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
exp = static_cast<int>(s.Take() - '0');
if (expMinus) {
+ // (exp + expFrac) must not underflow int => we're detecting when -exp gets
+ // dangerously close to INT_MIN (a pessimistic next digit 9 would push it into
+ // underflow territory):
+ //
+ // -(exp * 10 + 9) + expFrac >= INT_MIN
+ // <=> exp <= (expFrac - INT_MIN - 9) / 10
+ RAPIDJSON_ASSERT(expFrac <= 0);
+ int maxExp = (expFrac + 2147483639) / 10;
+
while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
exp = exp * 10 + static_cast<int>(s.Take() - '0');
- if (exp >= 214748364) { // Issue #313: prevent overflow exponent
+ if (RAPIDJSON_UNLIKELY(exp > maxExp)) {
while (RAPIDJSON_UNLIKELY(s.Peek() >= '0' && s.Peek() <= '9')) // Consume the rest of exponent
s.Take();
}
else
d = internal::StrtodNormalPrecision(d, p);
+ // Use > max, instead of == inf, to fix bogus warning -Wfloat-equal
+ if (d > (std::numeric_limits<double>::max)()) {
+ // Overflow
+ // TODO: internal::StrtodX should report overflow (or underflow)
+ RAPIDJSON_PARSE_ERROR(kParseErrorNumberTooBig, startOffset);
+ }
+
cont = handler.Double(minus ? -d : d);
}
else if (useNanOrInf) {
// Single value state
IterativeParsingValueState,
-
+
// Delimiter states (at bottom)
IterativeParsingElementDelimiterState,
IterativeParsingMemberDelimiterState,
IterativeParsingKeyValueDelimiterState,
-
+
cIterativeParsingStateCount
};
kTokenCount
};
- RAPIDJSON_FORCEINLINE Token Tokenize(Ch c) {
+ RAPIDJSON_FORCEINLINE Token Tokenize(Ch c) const {
//!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN
#define N NumberToken
return NumberToken;
}
- RAPIDJSON_FORCEINLINE IterativeParsingState Predict(IterativeParsingState state, Token token) {
+ RAPIDJSON_FORCEINLINE IterativeParsingState Predict(IterativeParsingState state, Token token) const {
// current state x one lookahead token -> new state
static const char G[cIterativeParsingStateCount][kTokenCount] = {
// Finish(sink state)
}
}
- RAPIDJSON_FORCEINLINE bool IsIterativeParsingDelimiterState(IterativeParsingState s) {
+ RAPIDJSON_FORCEINLINE bool IsIterativeParsingDelimiterState(IterativeParsingState s) const {
return s >= IterativeParsingElementDelimiterState;
}
-
- RAPIDJSON_FORCEINLINE bool IsIterativeParsingCompleteState(IterativeParsingState s) {
+
+ RAPIDJSON_FORCEINLINE bool IsIterativeParsingCompleteState(IterativeParsingState s) const {
return s <= IterativeParsingErrorState;
}
-
+
template <unsigned parseFlags, typename InputStream, typename Handler>
ParseResult IterativeParse(InputStream& is, Handler& handler) {
parseResult_.Clear();
ClearStackOnExit scope(*this);
IterativeParsingState state = IterativeParsingStartState;
-
+
SkipWhitespaceAndComments<parseFlags>(is);
RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
while (is.Peek() != '\0') {
Token t = Tokenize(is.Peek());
IterativeParsingState n = Predict(state, t);
IterativeParsingState d = Transit<parseFlags>(state, t, n, is, handler);
-
+
if (d == IterativeParsingErrorState) {
HandleError(state, is);
break;
}
-
+
state = d;
-
+
// Do not further consume streams if a root JSON has been parsed.
if ((parseFlags & kParseStopWhenDoneFlag) && state == IterativeParsingFinishState)
break;
-
+
SkipWhitespaceAndComments<parseFlags>(is);
RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
}
-
+
// Handle the end of file.
if (state != IterativeParsingFinishState)
HandleError(state, is);
-
+
return parseResult_;
}
static const size_t kDefaultStackCapacity = 256; //!< Default stack capacity in bytes for storing a single decoded string.
internal::Stack<StackAllocator> stack_; //!< A stack for storing decoded string temporarily during non-destructive parsing.
ParseResult parseResult_;
- IterativeParsingState state_{IterativeParsingStartState};
+ IterativeParsingState state_;
}; // class GenericReader
//! Reader with UTF8 encoding and default allocator.
RAPIDJSON_NAMESPACE_END
-#ifdef __clang__
+#if defined(__clang__) || defined(_MSC_VER)
RAPIDJSON_DIAG_POP
#endif
RAPIDJSON_DIAG_POP
#endif
-#ifdef _MSC_VER
-RAPIDJSON_DIAG_POP
-#endif
-
#endif // RAPIDJSON_READER_H_
#include "document.h"
#include "pointer.h"
+#include "stringbuffer.h"
#include <cmath> // abs, floor
#if !defined(RAPIDJSON_SCHEMA_USE_INTERNALREGEX)
#define RAPIDJSON_SCHEMA_USE_INTERNALREGEX 0
#endif
-#if !RAPIDJSON_SCHEMA_USE_INTERNALREGEX && !defined(RAPIDJSON_SCHEMA_USE_STDREGEX) && (__cplusplus >=201103L || (defined(_MSC_VER) && _MSC_VER >= 1800))
+#if !RAPIDJSON_SCHEMA_USE_INTERNALREGEX && defined(RAPIDJSON_SCHEMA_USE_STDREGEX) && (__cplusplus >=201103L || (defined(_MSC_VER) && _MSC_VER >= 1800))
#define RAPIDJSON_SCHEMA_USE_STDREGEX 1
#else
#define RAPIDJSON_SCHEMA_USE_STDREGEX 0
RAPIDJSON_DIAG_OFF(exit-time-destructors)
RAPIDJSON_DIAG_OFF(c++98-compat-pedantic)
RAPIDJSON_DIAG_OFF(variadic-macros)
-#endif
-
-#ifdef _MSC_VER
+#elif defined(_MSC_VER)
RAPIDJSON_DIAG_OFF(4512) // assignment operator could not be generated
#endif
virtual void FreeState(void* p) = 0;
};
+///////////////////////////////////////////////////////////////////////////////
+// IValidationErrorHandler
+
+template <typename SchemaType>
+class IValidationErrorHandler {
+public:
+ typedef typename SchemaType::Ch Ch;
+ typedef typename SchemaType::SValue SValue;
+
+ virtual ~IValidationErrorHandler() {}
+
+ virtual void NotMultipleOf(int64_t actual, const SValue& expected) = 0;
+ virtual void NotMultipleOf(uint64_t actual, const SValue& expected) = 0;
+ virtual void NotMultipleOf(double actual, const SValue& expected) = 0;
+ virtual void AboveMaximum(int64_t actual, const SValue& expected, bool exclusive) = 0;
+ virtual void AboveMaximum(uint64_t actual, const SValue& expected, bool exclusive) = 0;
+ virtual void AboveMaximum(double actual, const SValue& expected, bool exclusive) = 0;
+ virtual void BelowMinimum(int64_t actual, const SValue& expected, bool exclusive) = 0;
+ virtual void BelowMinimum(uint64_t actual, const SValue& expected, bool exclusive) = 0;
+ virtual void BelowMinimum(double actual, const SValue& expected, bool exclusive) = 0;
+
+ virtual void TooLong(const Ch* str, SizeType length, SizeType expected) = 0;
+ virtual void TooShort(const Ch* str, SizeType length, SizeType expected) = 0;
+ virtual void DoesNotMatch(const Ch* str, SizeType length) = 0;
+
+ virtual void DisallowedItem(SizeType index) = 0;
+ virtual void TooFewItems(SizeType actualCount, SizeType expectedCount) = 0;
+ virtual void TooManyItems(SizeType actualCount, SizeType expectedCount) = 0;
+ virtual void DuplicateItems(SizeType index1, SizeType index2) = 0;
+
+ virtual void TooManyProperties(SizeType actualCount, SizeType expectedCount) = 0;
+ virtual void TooFewProperties(SizeType actualCount, SizeType expectedCount) = 0;
+ virtual void StartMissingProperties() = 0;
+ virtual void AddMissingProperty(const SValue& name) = 0;
+ virtual bool EndMissingProperties() = 0;
+ virtual void PropertyViolations(ISchemaValidator** subvalidators, SizeType count) = 0;
+ virtual void DisallowedProperty(const Ch* name, SizeType length) = 0;
+
+ virtual void StartDependencyErrors() = 0;
+ virtual void StartMissingDependentProperties() = 0;
+ virtual void AddMissingDependentProperty(const SValue& targetName) = 0;
+ virtual void EndMissingDependentProperties(const SValue& sourceName) = 0;
+ virtual void AddDependencySchemaError(const SValue& souceName, ISchemaValidator* subvalidator) = 0;
+ virtual bool EndDependencyErrors() = 0;
+
+ virtual void DisallowedValue() = 0;
+ virtual void StartDisallowedType() = 0;
+ virtual void AddExpectedType(const typename SchemaType::ValueType& expectedType) = 0;
+ virtual void EndDisallowedType(const typename SchemaType::ValueType& actualType) = 0;
+ virtual void NotAllOf(ISchemaValidator** subvalidators, SizeType count) = 0;
+ virtual void NoneOf(ISchemaValidator** subvalidators, SizeType count) = 0;
+ virtual void NotOneOf(ISchemaValidator** subvalidators, SizeType count) = 0;
+ virtual void Disallowed() = 0;
+};
+
+
///////////////////////////////////////////////////////////////////////////////
// Hasher
struct SchemaValidationContext {
typedef Schema<SchemaDocumentType> SchemaType;
typedef ISchemaStateFactory<SchemaType> SchemaValidatorFactoryType;
+ typedef IValidationErrorHandler<SchemaType> ErrorHandlerType;
typedef typename SchemaType::ValueType ValueType;
typedef typename ValueType::Ch Ch;
kPatternValidatorWithAdditionalProperty
};
- SchemaValidationContext(SchemaValidatorFactoryType& f, const SchemaType* s) :
+ SchemaValidationContext(SchemaValidatorFactoryType& f, ErrorHandlerType& eh, const SchemaType* s) :
factory(f),
+ error_handler(eh),
schema(s),
valueSchema(),
invalidKeyword(),
}
SchemaValidatorFactoryType& factory;
+ ErrorHandlerType& error_handler;
const SchemaType* schema;
const SchemaType* valueSchema;
const Ch* invalidKeyword;
typedef SchemaValidationContext<SchemaDocumentType> Context;
typedef Schema<SchemaDocumentType> SchemaType;
typedef GenericValue<EncodingType, AllocatorType> SValue;
+ typedef IValidationErrorHandler<Schema> ErrorHandler;
friend class GenericSchemaDocument<ValueType, AllocatorType>;
Schema(SchemaDocumentType* schemaDocument, const PointerType& p, const ValueType& value, const ValueType& document, AllocatorType* allocator) :
allocator_(allocator),
+ uri_(schemaDocument->GetURI(), *allocator),
+ pointer_(p, allocator),
typeless_(schemaDocument->GetTypeless()),
enum_(),
enumCount_(),
minLength_(0),
maxLength_(~SizeType(0)),
exclusiveMinimum_(false),
- exclusiveMaximum_(false)
+ exclusiveMaximum_(false),
+ defaultValueLength_(0)
{
typedef typename SchemaDocumentType::ValueType ValueType;
typedef typename ValueType::ConstValueIterator ConstValueIterator;
enum_ = static_cast<uint64_t*>(allocator_->Malloc(sizeof(uint64_t) * v->Size()));
for (ConstValueIterator itr = v->Begin(); itr != v->End(); ++itr) {
typedef Hasher<EncodingType, MemoryPoolAllocator<> > EnumHasherType;
- char buffer[256 + 24];
+ char buffer[256u + 24];
MemoryPoolAllocator<> hasherAllocator(buffer, sizeof(buffer));
EnumHasherType h(&hasherAllocator, 256);
itr->Accept(h);
if (const ValueType* v = GetMember(value, GetMultipleOfString()))
if (v->IsNumber() && v->GetDouble() > 0.0)
multipleOf_.CopyFrom(*v, *allocator_);
+
+ // Default
+ if (const ValueType* v = GetMember(value, GetDefaultValueString()))
+ if (v->IsString())
+ defaultValueLength_ = v->GetStringLength();
+
}
~Schema() {
#endif
}
+ const SValue& GetURI() const {
+ return uri_;
+ }
+
+ const PointerType& GetPointer() const {
+ return pointer_;
+ }
+
bool BeginValue(Context& context) const {
if (context.inArray) {
if (uniqueItems_)
context.valueSchema = additionalItemsSchema_;
else if (additionalItems_)
context.valueSchema = typeless_;
- else
+ else {
+ context.error_handler.DisallowedItem(context.arrayElementIndex);
RAPIDJSON_INVALID_KEYWORD_RETURN(GetItemsString());
+ }
}
else
context.valueSchema = typeless_;
}
if (context.objectPatternValidatorType == Context::kPatternValidatorOnly) {
- if (!patternValid)
+ if (!patternValid) {
+ context.error_handler.PropertyViolations(context.patternPropertiesValidators, count);
RAPIDJSON_INVALID_KEYWORD_RETURN(GetPatternPropertiesString());
+ }
}
else if (context.objectPatternValidatorType == Context::kPatternValidatorWithProperty) {
- if (!patternValid || !otherValid)
+ if (!patternValid || !otherValid) {
+ context.error_handler.PropertyViolations(context.patternPropertiesValidators, count + 1);
RAPIDJSON_INVALID_KEYWORD_RETURN(GetPatternPropertiesString());
+ }
}
- else if (!patternValid && !otherValid) // kPatternValidatorWithAdditionalProperty)
+ else if (!patternValid && !otherValid) { // kPatternValidatorWithAdditionalProperty)
+ context.error_handler.PropertyViolations(context.patternPropertiesValidators, count + 1);
RAPIDJSON_INVALID_KEYWORD_RETURN(GetPatternPropertiesString());
+ }
}
if (enum_) {
for (SizeType i = 0; i < enumCount_; i++)
if (enum_[i] == h)
goto foundEnum;
+ context.error_handler.DisallowedValue();
RAPIDJSON_INVALID_KEYWORD_RETURN(GetEnumString());
foundEnum:;
}
if (allOf_.schemas)
for (SizeType i = allOf_.begin; i < allOf_.begin + allOf_.count; i++)
- if (!context.validators[i]->IsValid())
+ if (!context.validators[i]->IsValid()) {
+ context.error_handler.NotAllOf(&context.validators[allOf_.begin], allOf_.count);
RAPIDJSON_INVALID_KEYWORD_RETURN(GetAllOfString());
+ }
if (anyOf_.schemas) {
for (SizeType i = anyOf_.begin; i < anyOf_.begin + anyOf_.count; i++)
if (context.validators[i]->IsValid())
goto foundAny;
+ context.error_handler.NoneOf(&context.validators[anyOf_.begin], anyOf_.count);
RAPIDJSON_INVALID_KEYWORD_RETURN(GetAnyOfString());
foundAny:;
}
bool oneValid = false;
for (SizeType i = oneOf_.begin; i < oneOf_.begin + oneOf_.count; i++)
if (context.validators[i]->IsValid()) {
- if (oneValid)
+ if (oneValid) {
+ context.error_handler.NotOneOf(&context.validators[oneOf_.begin], oneOf_.count);
RAPIDJSON_INVALID_KEYWORD_RETURN(GetOneOfString());
- else
+ } else
oneValid = true;
}
- if (!oneValid)
+ if (!oneValid) {
+ context.error_handler.NotOneOf(&context.validators[oneOf_.begin], oneOf_.count);
RAPIDJSON_INVALID_KEYWORD_RETURN(GetOneOfString());
+ }
}
- if (not_ && context.validators[notValidatorIndex_]->IsValid())
+ if (not_ && context.validators[notValidatorIndex_]->IsValid()) {
+ context.error_handler.Disallowed();
RAPIDJSON_INVALID_KEYWORD_RETURN(GetNotString());
+ }
return true;
}
- bool Null(Context& context) const {
- if (!(type_ & (1 << kNullSchemaType)))
+ bool Null(Context& context) const {
+ if (!(type_ & (1 << kNullSchemaType))) {
+ DisallowedType(context, GetNullString());
RAPIDJSON_INVALID_KEYWORD_RETURN(GetTypeString());
+ }
return CreateParallelValidator(context);
}
- bool Bool(Context& context, bool) const {
- if (!(type_ & (1 << kBooleanSchemaType)))
+ bool Bool(Context& context, bool) const {
+ if (!(type_ & (1 << kBooleanSchemaType))) {
+ DisallowedType(context, GetBooleanString());
RAPIDJSON_INVALID_KEYWORD_RETURN(GetTypeString());
+ }
return CreateParallelValidator(context);
}
}
bool Double(Context& context, double d) const {
- if (!(type_ & (1 << kNumberSchemaType)))
+ if (!(type_ & (1 << kNumberSchemaType))) {
+ DisallowedType(context, GetNumberString());
RAPIDJSON_INVALID_KEYWORD_RETURN(GetTypeString());
+ }
if (!minimum_.IsNull() && !CheckDoubleMinimum(context, d))
return false;
}
bool String(Context& context, const Ch* str, SizeType length, bool) const {
- if (!(type_ & (1 << kStringSchemaType)))
+ if (!(type_ & (1 << kStringSchemaType))) {
+ DisallowedType(context, GetStringString());
RAPIDJSON_INVALID_KEYWORD_RETURN(GetTypeString());
+ }
if (minLength_ != 0 || maxLength_ != SizeType(~0)) {
SizeType count;
if (internal::CountStringCodePoint<EncodingType>(str, length, &count)) {
- if (count < minLength_)
+ if (count < minLength_) {
+ context.error_handler.TooShort(str, length, minLength_);
RAPIDJSON_INVALID_KEYWORD_RETURN(GetMinLengthString());
- if (count > maxLength_)
+ }
+ if (count > maxLength_) {
+ context.error_handler.TooLong(str, length, maxLength_);
RAPIDJSON_INVALID_KEYWORD_RETURN(GetMaxLengthString());
+ }
}
}
- if (pattern_ && !IsPatternMatch(pattern_, str, length))
+ if (pattern_ && !IsPatternMatch(pattern_, str, length)) {
+ context.error_handler.DoesNotMatch(str, length);
RAPIDJSON_INVALID_KEYWORD_RETURN(GetPatternString());
+ }
return CreateParallelValidator(context);
}
- bool StartObject(Context& context) const {
- if (!(type_ & (1 << kObjectSchemaType)))
+ bool StartObject(Context& context) const {
+ if (!(type_ & (1 << kObjectSchemaType))) {
+ DisallowedType(context, GetObjectString());
RAPIDJSON_INVALID_KEYWORD_RETURN(GetTypeString());
+ }
if (hasDependencies_ || hasRequired_) {
context.propertyExist = static_cast<bool*>(context.factory.MallocState(sizeof(bool) * propertyCount_));
return true;
}
- if (context.patternPropertiesSchemaCount == 0) // patternProperties are not additional properties
+ if (context.patternPropertiesSchemaCount == 0) { // patternProperties are not additional properties
+ context.error_handler.DisallowedProperty(str, len);
RAPIDJSON_INVALID_KEYWORD_RETURN(GetAdditionalPropertiesString());
+ }
return true;
}
bool EndObject(Context& context, SizeType memberCount) const {
- if (hasRequired_)
+ if (hasRequired_) {
+ context.error_handler.StartMissingProperties();
for (SizeType index = 0; index < propertyCount_; index++)
- if (properties_[index].required)
- if (!context.propertyExist[index])
- RAPIDJSON_INVALID_KEYWORD_RETURN(GetRequiredString());
+ if (properties_[index].required && !context.propertyExist[index])
+ if (properties_[index].schema->defaultValueLength_ == 0 )
+ context.error_handler.AddMissingProperty(properties_[index].name);
+ if (context.error_handler.EndMissingProperties())
+ RAPIDJSON_INVALID_KEYWORD_RETURN(GetRequiredString());
+ }
- if (memberCount < minProperties_)
+ if (memberCount < minProperties_) {
+ context.error_handler.TooFewProperties(memberCount, minProperties_);
RAPIDJSON_INVALID_KEYWORD_RETURN(GetMinPropertiesString());
+ }
- if (memberCount > maxProperties_)
+ if (memberCount > maxProperties_) {
+ context.error_handler.TooManyProperties(memberCount, maxProperties_);
RAPIDJSON_INVALID_KEYWORD_RETURN(GetMaxPropertiesString());
+ }
if (hasDependencies_) {
- for (SizeType sourceIndex = 0; sourceIndex < propertyCount_; sourceIndex++)
+ context.error_handler.StartDependencyErrors();
+ for (SizeType sourceIndex = 0; sourceIndex < propertyCount_; sourceIndex++) {
+ const Property& source = properties_[sourceIndex];
if (context.propertyExist[sourceIndex]) {
- if (properties_[sourceIndex].dependencies) {
+ if (source.dependencies) {
+ context.error_handler.StartMissingDependentProperties();
for (SizeType targetIndex = 0; targetIndex < propertyCount_; targetIndex++)
- if (properties_[sourceIndex].dependencies[targetIndex] && !context.propertyExist[targetIndex])
- RAPIDJSON_INVALID_KEYWORD_RETURN(GetDependenciesString());
+ if (source.dependencies[targetIndex] && !context.propertyExist[targetIndex])
+ context.error_handler.AddMissingDependentProperty(properties_[targetIndex].name);
+ context.error_handler.EndMissingDependentProperties(source.name);
+ }
+ else if (source.dependenciesSchema) {
+ ISchemaValidator* dependenciesValidator = context.validators[source.dependenciesValidatorIndex];
+ if (!dependenciesValidator->IsValid())
+ context.error_handler.AddDependencySchemaError(source.name, dependenciesValidator);
}
- else if (properties_[sourceIndex].dependenciesSchema)
- if (!context.validators[properties_[sourceIndex].dependenciesValidatorIndex]->IsValid())
- RAPIDJSON_INVALID_KEYWORD_RETURN(GetDependenciesString());
}
+ }
+ if (context.error_handler.EndDependencyErrors())
+ RAPIDJSON_INVALID_KEYWORD_RETURN(GetDependenciesString());
}
return true;
}
- bool StartArray(Context& context) const {
- if (!(type_ & (1 << kArraySchemaType)))
+ bool StartArray(Context& context) const {
+ if (!(type_ & (1 << kArraySchemaType))) {
+ DisallowedType(context, GetArrayString());
RAPIDJSON_INVALID_KEYWORD_RETURN(GetTypeString());
+ }
context.arrayElementIndex = 0;
context.inArray = true;
return CreateParallelValidator(context);
}
- bool EndArray(Context& context, SizeType elementCount) const {
+ bool EndArray(Context& context, SizeType elementCount) const {
context.inArray = false;
- if (elementCount < minItems_)
+ if (elementCount < minItems_) {
+ context.error_handler.TooFewItems(elementCount, minItems_);
RAPIDJSON_INVALID_KEYWORD_RETURN(GetMinItemsString());
+ }
- if (elementCount > maxItems_)
+ if (elementCount > maxItems_) {
+ context.error_handler.TooManyItems(elementCount, maxItems_);
RAPIDJSON_INVALID_KEYWORD_RETURN(GetMaxItemsString());
+ }
return true;
}
RAPIDJSON_STRING_(ExclusiveMinimum, 'e', 'x', 'c', 'l', 'u', 's', 'i', 'v', 'e', 'M', 'i', 'n', 'i', 'm', 'u', 'm')
RAPIDJSON_STRING_(ExclusiveMaximum, 'e', 'x', 'c', 'l', 'u', 's', 'i', 'v', 'e', 'M', 'a', 'x', 'i', 'm', 'u', 'm')
RAPIDJSON_STRING_(MultipleOf, 'm', 'u', 'l', 't', 'i', 'p', 'l', 'e', 'O', 'f')
+ RAPIDJSON_STRING_(DefaultValue, 'd', 'e', 'f', 'a', 'u', 'l', 't')
#undef RAPIDJSON_STRING_
#elif RAPIDJSON_SCHEMA_USE_STDREGEX
template <typename ValueType>
RegexType* CreatePattern(const ValueType& value) {
- if (value.IsString())
+ if (value.IsString()) {
+ RegexType *r = static_cast<RegexType*>(allocator_->Malloc(sizeof(RegexType)));
try {
- return new (allocator_->Malloc(sizeof(RegexType))) RegexType(value.GetString(), std::size_t(value.GetStringLength()), std::regex_constants::ECMAScript);
+ return new (r) RegexType(value.GetString(), std::size_t(value.GetStringLength()), std::regex_constants::ECMAScript);
}
catch (const std::regex_error&) {
+ AllocatorType::Free(r);
}
+ }
return 0;
}
}
bool CheckInt(Context& context, int64_t i) const {
- if (!(type_ & ((1 << kIntegerSchemaType) | (1 << kNumberSchemaType))))
+ if (!(type_ & ((1 << kIntegerSchemaType) | (1 << kNumberSchemaType)))) {
+ DisallowedType(context, GetIntegerString());
RAPIDJSON_INVALID_KEYWORD_RETURN(GetTypeString());
+ }
if (!minimum_.IsNull()) {
if (minimum_.IsInt64()) {
- if (exclusiveMinimum_ ? i <= minimum_.GetInt64() : i < minimum_.GetInt64())
+ if (exclusiveMinimum_ ? i <= minimum_.GetInt64() : i < minimum_.GetInt64()) {
+ context.error_handler.BelowMinimum(i, minimum_, exclusiveMinimum_);
RAPIDJSON_INVALID_KEYWORD_RETURN(GetMinimumString());
+ }
}
else if (minimum_.IsUint64()) {
+ context.error_handler.BelowMinimum(i, minimum_, exclusiveMinimum_);
RAPIDJSON_INVALID_KEYWORD_RETURN(GetMinimumString()); // i <= max(int64_t) < minimum.GetUint64()
}
else if (!CheckDoubleMinimum(context, static_cast<double>(i)))
if (!maximum_.IsNull()) {
if (maximum_.IsInt64()) {
- if (exclusiveMaximum_ ? i >= maximum_.GetInt64() : i > maximum_.GetInt64())
+ if (exclusiveMaximum_ ? i >= maximum_.GetInt64() : i > maximum_.GetInt64()) {
+ context.error_handler.AboveMaximum(i, maximum_, exclusiveMaximum_);
RAPIDJSON_INVALID_KEYWORD_RETURN(GetMaximumString());
+ }
}
else if (maximum_.IsUint64()) { }
/* do nothing */ // i <= max(int64_t) < maximum_.GetUint64()
if (!multipleOf_.IsNull()) {
if (multipleOf_.IsUint64()) {
- if (static_cast<uint64_t>(i >= 0 ? i : -i) % multipleOf_.GetUint64() != 0)
+ if (static_cast<uint64_t>(i >= 0 ? i : -i) % multipleOf_.GetUint64() != 0) {
+ context.error_handler.NotMultipleOf(i, multipleOf_);
RAPIDJSON_INVALID_KEYWORD_RETURN(GetMultipleOfString());
+ }
}
else if (!CheckDoubleMultipleOf(context, static_cast<double>(i)))
return false;
}
bool CheckUint(Context& context, uint64_t i) const {
- if (!(type_ & ((1 << kIntegerSchemaType) | (1 << kNumberSchemaType))))
+ if (!(type_ & ((1 << kIntegerSchemaType) | (1 << kNumberSchemaType)))) {
+ DisallowedType(context, GetIntegerString());
RAPIDJSON_INVALID_KEYWORD_RETURN(GetTypeString());
+ }
if (!minimum_.IsNull()) {
if (minimum_.IsUint64()) {
- if (exclusiveMinimum_ ? i <= minimum_.GetUint64() : i < minimum_.GetUint64())
+ if (exclusiveMinimum_ ? i <= minimum_.GetUint64() : i < minimum_.GetUint64()) {
+ context.error_handler.BelowMinimum(i, minimum_, exclusiveMinimum_);
RAPIDJSON_INVALID_KEYWORD_RETURN(GetMinimumString());
+ }
}
else if (minimum_.IsInt64())
/* do nothing */; // i >= 0 > minimum.Getint64()
if (!maximum_.IsNull()) {
if (maximum_.IsUint64()) {
- if (exclusiveMaximum_ ? i >= maximum_.GetUint64() : i > maximum_.GetUint64())
+ if (exclusiveMaximum_ ? i >= maximum_.GetUint64() : i > maximum_.GetUint64()) {
+ context.error_handler.AboveMaximum(i, maximum_, exclusiveMaximum_);
RAPIDJSON_INVALID_KEYWORD_RETURN(GetMaximumString());
+ }
}
- else if (maximum_.IsInt64())
+ else if (maximum_.IsInt64()) {
+ context.error_handler.AboveMaximum(i, maximum_, exclusiveMaximum_);
RAPIDJSON_INVALID_KEYWORD_RETURN(GetMaximumString()); // i >= 0 > maximum_
+ }
else if (!CheckDoubleMaximum(context, static_cast<double>(i)))
return false;
}
if (!multipleOf_.IsNull()) {
if (multipleOf_.IsUint64()) {
- if (i % multipleOf_.GetUint64() != 0)
+ if (i % multipleOf_.GetUint64() != 0) {
+ context.error_handler.NotMultipleOf(i, multipleOf_);
RAPIDJSON_INVALID_KEYWORD_RETURN(GetMultipleOfString());
+ }
}
else if (!CheckDoubleMultipleOf(context, static_cast<double>(i)))
return false;
}
bool CheckDoubleMinimum(Context& context, double d) const {
- if (exclusiveMinimum_ ? d <= minimum_.GetDouble() : d < minimum_.GetDouble())
+ if (exclusiveMinimum_ ? d <= minimum_.GetDouble() : d < minimum_.GetDouble()) {
+ context.error_handler.BelowMinimum(d, minimum_, exclusiveMinimum_);
RAPIDJSON_INVALID_KEYWORD_RETURN(GetMinimumString());
+ }
return true;
}
bool CheckDoubleMaximum(Context& context, double d) const {
- if (exclusiveMaximum_ ? d >= maximum_.GetDouble() : d > maximum_.GetDouble())
+ if (exclusiveMaximum_ ? d >= maximum_.GetDouble() : d > maximum_.GetDouble()) {
+ context.error_handler.AboveMaximum(d, maximum_, exclusiveMaximum_);
RAPIDJSON_INVALID_KEYWORD_RETURN(GetMaximumString());
+ }
return true;
}
double a = std::abs(d), b = std::abs(multipleOf_.GetDouble());
double q = std::floor(a / b);
double r = a - q * b;
- if (r > 0.0)
+ if (r > 0.0) {
+ context.error_handler.NotMultipleOf(d, multipleOf_);
RAPIDJSON_INVALID_KEYWORD_RETURN(GetMultipleOfString());
+ }
return true;
}
+ void DisallowedType(Context& context, const ValueType& actualType) const {
+ ErrorHandler& eh = context.error_handler;
+ eh.StartDisallowedType();
+
+ if (type_ & (1 << kNullSchemaType)) eh.AddExpectedType(GetNullString());
+ if (type_ & (1 << kBooleanSchemaType)) eh.AddExpectedType(GetBooleanString());
+ if (type_ & (1 << kObjectSchemaType)) eh.AddExpectedType(GetObjectString());
+ if (type_ & (1 << kArraySchemaType)) eh.AddExpectedType(GetArrayString());
+ if (type_ & (1 << kStringSchemaType)) eh.AddExpectedType(GetStringString());
+
+ if (type_ & (1 << kNumberSchemaType)) eh.AddExpectedType(GetNumberString());
+ else if (type_ & (1 << kIntegerSchemaType)) eh.AddExpectedType(GetIntegerString());
+
+ eh.EndDisallowedType(actualType);
+ }
+
struct Property {
Property() : schema(), dependenciesSchema(), dependenciesValidatorIndex(), dependencies(), required(false) {}
~Property() { AllocatorType::Free(dependencies); }
};
AllocatorType* allocator_;
+ SValue uri_;
+ PointerType pointer_;
const SchemaType* typeless_;
uint64_t* enum_;
SizeType enumCount_;
SValue multipleOf_;
bool exclusiveMinimum_;
bool exclusiveMaximum_;
+
+ SizeType defaultValueLength_;
};
template<typename Stack, typename Ch>
typedef typename EncodingType::Ch Ch;
typedef internal::Schema<GenericSchemaDocument> SchemaType;
typedef GenericPointer<ValueType, Allocator> PointerType;
+ typedef GenericValue<EncodingType, Allocator> URIType;
friend class internal::Schema<GenericSchemaDocument>;
template <typename, typename, typename>
friend class GenericSchemaValidator;
Compile a JSON document into schema document.
\param document A JSON document as source.
+ \param uri The base URI of this schema document for purposes of violation reporting.
+ \param uriLength Length of \c name, in code points.
\param remoteProvider An optional remote schema document provider for resolving remote reference. Can be null.
\param allocator An optional allocator instance for allocating memory. Can be null.
*/
- explicit GenericSchemaDocument(const ValueType& document, IRemoteSchemaDocumentProviderType* remoteProvider = 0, Allocator* allocator = 0) :
+ explicit GenericSchemaDocument(const ValueType& document, const Ch* uri = 0, SizeType uriLength = 0,
+ IRemoteSchemaDocumentProviderType* remoteProvider = 0, Allocator* allocator = 0) :
remoteProvider_(remoteProvider),
allocator_(allocator),
ownAllocator_(),
if (!allocator_)
ownAllocator_ = allocator_ = RAPIDJSON_NEW(Allocator)();
+ Ch noUri[1] = {0};
+ uri_.SetString(uri ? uri : noUri, uriLength, *allocator_);
+
typeless_ = static_cast<SchemaType*>(allocator_->Malloc(sizeof(SchemaType)));
- new (typeless_) SchemaType(this, PointerType(), ValueType(kObjectType).Move(), ValueType(kObjectType).Move(), 0);
+ new (typeless_) SchemaType(this, PointerType(), ValueType(kObjectType).Move(), ValueType(kObjectType).Move(), allocator_);
// Generate root schema, it will call CreateSchema() to create sub-schemas,
// And call AddRefSchema() if there are $ref.
root_(rhs.root_),
typeless_(rhs.typeless_),
schemaMap_(std::move(rhs.schemaMap_)),
- schemaRef_(std::move(rhs.schemaRef_))
+ schemaRef_(std::move(rhs.schemaRef_)),
+ uri_(std::move(rhs.uri_))
{
rhs.remoteProvider_ = 0;
rhs.allocator_ = 0;
RAPIDJSON_DELETE(ownAllocator_);
}
+ const URIType& GetURI() const { return uri_; }
+
//! Get the root schema.
const SchemaType& GetRoot() const { return *root_; }
if (const SchemaType* sc = remoteDocument->GetSchema(pointer)) {
if (schema)
*schema = sc;
+ new (schemaMap_.template Push<SchemaEntry>()) SchemaEntry(source, const_cast<SchemaType*>(sc), false, allocator_);
return true;
}
}
SchemaType* typeless_;
internal::Stack<Allocator> schemaMap_; // Stores created Pointer -> Schemas
internal::Stack<Allocator> schemaRef_; // Stores Pointer from $ref and schema which holds the $ref
+ URIType uri_;
};
//! GenericSchemaDocument using Value type.
typename StateAllocator = CrtAllocator>
class GenericSchemaValidator :
public internal::ISchemaStateFactory<typename SchemaDocumentType::SchemaType>,
- public internal::ISchemaValidator
+ public internal::ISchemaValidator,
+ public internal::IValidationErrorHandler<typename SchemaDocumentType::SchemaType>
{
public:
typedef typename SchemaDocumentType::SchemaType SchemaType;
typedef typename SchemaDocumentType::PointerType PointerType;
typedef typename SchemaType::EncodingType EncodingType;
+ typedef typename SchemaType::SValue SValue;
typedef typename EncodingType::Ch Ch;
+ typedef GenericStringRef<Ch> StringRefType;
+ typedef GenericValue<EncodingType, StateAllocator> ValueType;
//! Constructor without output handler.
/*!
schemaStack_(allocator, schemaStackCapacity),
documentStack_(allocator, documentStackCapacity),
outputHandler_(0),
+ error_(kObjectType),
+ currentError_(),
+ missingDependents_(),
valid_(true)
#if RAPIDJSON_SCHEMA_VERBOSE
, depth_(0)
schemaStack_(allocator, schemaStackCapacity),
documentStack_(allocator, documentStackCapacity),
outputHandler_(&outputHandler),
+ error_(kObjectType),
+ currentError_(),
+ missingDependents_(),
valid_(true)
#if RAPIDJSON_SCHEMA_VERBOSE
, depth_(0)
while (!schemaStack_.Empty())
PopSchema();
documentStack_.Clear();
+ error_.SetObject();
+ currentError_.SetNull();
+ missingDependents_.SetNull();
valid_ = true;
}
// Implementation of ISchemaValidator
virtual bool IsValid() const { return valid_; }
+ //! Gets the error object.
+ ValueType& GetError() { return error_; }
+ const ValueType& GetError() const { return error_; }
+
//! Gets the JSON pointer pointed to the invalid schema.
PointerType GetInvalidSchemaPointer() const {
- return schemaStack_.Empty() ? PointerType() : schemaDocument_->GetPointer(&CurrentSchema());
+ return schemaStack_.Empty() ? PointerType() : CurrentSchema().GetPointer();
}
//! Gets the keyword of invalid schema.
//! Gets the JSON pointer pointed to the invalid value.
PointerType GetInvalidDocumentPointer() const {
- return documentStack_.Empty() ? PointerType() : PointerType(documentStack_.template Bottom<Ch>(), documentStack_.GetSize() / sizeof(Ch));
+ if (documentStack_.Empty()) {
+ return PointerType();
+ }
+ else {
+ return PointerType(documentStack_.template Bottom<Ch>(), documentStack_.GetSize() / sizeof(Ch));
+ }
+ }
+
+ void NotMultipleOf(int64_t actual, const SValue& expected) {
+ AddNumberError(SchemaType::GetMultipleOfString(), ValueType(actual).Move(), expected);
+ }
+ void NotMultipleOf(uint64_t actual, const SValue& expected) {
+ AddNumberError(SchemaType::GetMultipleOfString(), ValueType(actual).Move(), expected);
+ }
+ void NotMultipleOf(double actual, const SValue& expected) {
+ AddNumberError(SchemaType::GetMultipleOfString(), ValueType(actual).Move(), expected);
+ }
+ void AboveMaximum(int64_t actual, const SValue& expected, bool exclusive) {
+ AddNumberError(SchemaType::GetMaximumString(), ValueType(actual).Move(), expected,
+ exclusive ? &SchemaType::GetExclusiveMaximumString : 0);
+ }
+ void AboveMaximum(uint64_t actual, const SValue& expected, bool exclusive) {
+ AddNumberError(SchemaType::GetMaximumString(), ValueType(actual).Move(), expected,
+ exclusive ? &SchemaType::GetExclusiveMaximumString : 0);
+ }
+ void AboveMaximum(double actual, const SValue& expected, bool exclusive) {
+ AddNumberError(SchemaType::GetMaximumString(), ValueType(actual).Move(), expected,
+ exclusive ? &SchemaType::GetExclusiveMaximumString : 0);
+ }
+ void BelowMinimum(int64_t actual, const SValue& expected, bool exclusive) {
+ AddNumberError(SchemaType::GetMinimumString(), ValueType(actual).Move(), expected,
+ exclusive ? &SchemaType::GetExclusiveMinimumString : 0);
+ }
+ void BelowMinimum(uint64_t actual, const SValue& expected, bool exclusive) {
+ AddNumberError(SchemaType::GetMinimumString(), ValueType(actual).Move(), expected,
+ exclusive ? &SchemaType::GetExclusiveMinimumString : 0);
+ }
+ void BelowMinimum(double actual, const SValue& expected, bool exclusive) {
+ AddNumberError(SchemaType::GetMinimumString(), ValueType(actual).Move(), expected,
+ exclusive ? &SchemaType::GetExclusiveMinimumString : 0);
+ }
+
+ void TooLong(const Ch* str, SizeType length, SizeType expected) {
+ AddNumberError(SchemaType::GetMaxLengthString(),
+ ValueType(str, length, GetStateAllocator()).Move(), SValue(expected).Move());
+ }
+ void TooShort(const Ch* str, SizeType length, SizeType expected) {
+ AddNumberError(SchemaType::GetMinLengthString(),
+ ValueType(str, length, GetStateAllocator()).Move(), SValue(expected).Move());
+ }
+ void DoesNotMatch(const Ch* str, SizeType length) {
+ currentError_.SetObject();
+ currentError_.AddMember(GetActualString(), ValueType(str, length, GetStateAllocator()).Move(), GetStateAllocator());
+ AddCurrentError(SchemaType::GetPatternString());
+ }
+
+ void DisallowedItem(SizeType index) {
+ currentError_.SetObject();
+ currentError_.AddMember(GetDisallowedString(), ValueType(index).Move(), GetStateAllocator());
+ AddCurrentError(SchemaType::GetAdditionalItemsString(), true);
+ }
+ void TooFewItems(SizeType actualCount, SizeType expectedCount) {
+ AddNumberError(SchemaType::GetMinItemsString(),
+ ValueType(actualCount).Move(), SValue(expectedCount).Move());
+ }
+ void TooManyItems(SizeType actualCount, SizeType expectedCount) {
+ AddNumberError(SchemaType::GetMaxItemsString(),
+ ValueType(actualCount).Move(), SValue(expectedCount).Move());
+ }
+ void DuplicateItems(SizeType index1, SizeType index2) {
+ ValueType duplicates(kArrayType);
+ duplicates.PushBack(index1, GetStateAllocator());
+ duplicates.PushBack(index2, GetStateAllocator());
+ currentError_.SetObject();
+ currentError_.AddMember(GetDuplicatesString(), duplicates, GetStateAllocator());
+ AddCurrentError(SchemaType::GetUniqueItemsString(), true);
+ }
+
+ void TooManyProperties(SizeType actualCount, SizeType expectedCount) {
+ AddNumberError(SchemaType::GetMaxPropertiesString(),
+ ValueType(actualCount).Move(), SValue(expectedCount).Move());
+ }
+ void TooFewProperties(SizeType actualCount, SizeType expectedCount) {
+ AddNumberError(SchemaType::GetMinPropertiesString(),
+ ValueType(actualCount).Move(), SValue(expectedCount).Move());
+ }
+ void StartMissingProperties() {
+ currentError_.SetArray();
+ }
+ void AddMissingProperty(const SValue& name) {
+ currentError_.PushBack(ValueType(name, GetStateAllocator()).Move(), GetStateAllocator());
+ }
+ bool EndMissingProperties() {
+ if (currentError_.Empty())
+ return false;
+ ValueType error(kObjectType);
+ error.AddMember(GetMissingString(), currentError_, GetStateAllocator());
+ currentError_ = error;
+ AddCurrentError(SchemaType::GetRequiredString());
+ return true;
+ }
+ void PropertyViolations(ISchemaValidator** subvalidators, SizeType count) {
+ for (SizeType i = 0; i < count; ++i)
+ MergeError(static_cast<GenericSchemaValidator*>(subvalidators[i])->GetError());
+ }
+ void DisallowedProperty(const Ch* name, SizeType length) {
+ currentError_.SetObject();
+ currentError_.AddMember(GetDisallowedString(), ValueType(name, length, GetStateAllocator()).Move(), GetStateAllocator());
+ AddCurrentError(SchemaType::GetAdditionalPropertiesString(), true);
+ }
+
+ void StartDependencyErrors() {
+ currentError_.SetObject();
+ }
+ void StartMissingDependentProperties() {
+ missingDependents_.SetArray();
+ }
+ void AddMissingDependentProperty(const SValue& targetName) {
+ missingDependents_.PushBack(ValueType(targetName, GetStateAllocator()).Move(), GetStateAllocator());
+ }
+ void EndMissingDependentProperties(const SValue& sourceName) {
+ if (!missingDependents_.Empty())
+ currentError_.AddMember(ValueType(sourceName, GetStateAllocator()).Move(),
+ missingDependents_, GetStateAllocator());
+ }
+ void AddDependencySchemaError(const SValue& sourceName, ISchemaValidator* subvalidator) {
+ currentError_.AddMember(ValueType(sourceName, GetStateAllocator()).Move(),
+ static_cast<GenericSchemaValidator*>(subvalidator)->GetError(), GetStateAllocator());
+ }
+ bool EndDependencyErrors() {
+ if (currentError_.ObjectEmpty())
+ return false;
+ ValueType error(kObjectType);
+ error.AddMember(GetErrorsString(), currentError_, GetStateAllocator());
+ currentError_ = error;
+ AddCurrentError(SchemaType::GetDependenciesString());
+ return true;
+ }
+
+ void DisallowedValue() {
+ currentError_.SetObject();
+ AddCurrentError(SchemaType::GetEnumString());
+ }
+ void StartDisallowedType() {
+ currentError_.SetArray();
+ }
+ void AddExpectedType(const typename SchemaType::ValueType& expectedType) {
+ currentError_.PushBack(ValueType(expectedType, GetStateAllocator()).Move(), GetStateAllocator());
+ }
+ void EndDisallowedType(const typename SchemaType::ValueType& actualType) {
+ ValueType error(kObjectType);
+ error.AddMember(GetExpectedString(), currentError_, GetStateAllocator());
+ error.AddMember(GetActualString(), ValueType(actualType, GetStateAllocator()).Move(), GetStateAllocator());
+ currentError_ = error;
+ AddCurrentError(SchemaType::GetTypeString());
+ }
+ void NotAllOf(ISchemaValidator** subvalidators, SizeType count) {
+ for (SizeType i = 0; i < count; ++i) {
+ MergeError(static_cast<GenericSchemaValidator*>(subvalidators[i])->GetError());
+ }
+ }
+ void NoneOf(ISchemaValidator** subvalidators, SizeType count) {
+ AddErrorArray(SchemaType::GetAnyOfString(), subvalidators, count);
+ }
+ void NotOneOf(ISchemaValidator** subvalidators, SizeType count) {
+ AddErrorArray(SchemaType::GetOneOfString(), subvalidators, count);
+ }
+ void Disallowed() {
+ currentError_.SetObject();
+ AddCurrentError(SchemaType::GetNotString());
}
+#define RAPIDJSON_STRING_(name, ...) \
+ static const StringRefType& Get##name##String() {\
+ static const Ch s[] = { __VA_ARGS__, '\0' };\
+ static const StringRefType v(s, static_cast<SizeType>(sizeof(s) / sizeof(Ch) - 1)); \
+ return v;\
+ }
+
+ RAPIDJSON_STRING_(InstanceRef, 'i', 'n', 's', 't', 'a', 'n', 'c', 'e', 'R', 'e', 'f')
+ RAPIDJSON_STRING_(SchemaRef, 's', 'c', 'h', 'e', 'm', 'a', 'R', 'e', 'f')
+ RAPIDJSON_STRING_(Expected, 'e', 'x', 'p', 'e', 'c', 't', 'e', 'd')
+ RAPIDJSON_STRING_(Actual, 'a', 'c', 't', 'u', 'a', 'l')
+ RAPIDJSON_STRING_(Disallowed, 'd', 'i', 's', 'a', 'l', 'l', 'o', 'w', 'e', 'd')
+ RAPIDJSON_STRING_(Missing, 'm', 'i', 's', 's', 'i', 'n', 'g')
+ RAPIDJSON_STRING_(Errors, 'e', 'r', 'r', 'o', 'r', 's')
+ RAPIDJSON_STRING_(Duplicates, 'd', 'u', 'p', 'l', 'i', 'c', 'a', 't', 'e', 's')
+
+#undef RAPIDJSON_STRING_
+
#if RAPIDJSON_SCHEMA_VERBOSE
#define RAPIDJSON_SCHEMA_HANDLE_BEGIN_VERBOSE_() \
RAPIDJSON_MULTILINEMACRO_BEGIN\
RAPIDJSON_SCHEMA_HANDLE_PARALLEL_(method, arg2);\
RAPIDJSON_SCHEMA_HANDLE_END_ (method, arg2)
- bool Null() { RAPIDJSON_SCHEMA_HANDLE_VALUE_(Null, (CurrentContext() ), ( )); }
+ bool Null() { RAPIDJSON_SCHEMA_HANDLE_VALUE_(Null, (CurrentContext()), ( )); }
bool Bool(bool b) { RAPIDJSON_SCHEMA_HANDLE_VALUE_(Bool, (CurrentContext(), b), (b)); }
bool Int(int i) { RAPIDJSON_SCHEMA_HANDLE_VALUE_(Int, (CurrentContext(), i), (i)); }
bool Uint(unsigned u) { RAPIDJSON_SCHEMA_HANDLE_VALUE_(Uint, (CurrentContext(), u), (u)); }
// Implementation of ISchemaStateFactory<SchemaType>
virtual ISchemaValidator* CreateSchemaValidator(const SchemaType& root) {
- return new (GetStateAllocator().Malloc(sizeof(GenericSchemaValidator))) GenericSchemaValidator(*schemaDocument_, root,
+ return new (GetStateAllocator().Malloc(sizeof(GenericSchemaValidator))) GenericSchemaValidator(*schemaDocument_, root, documentStack_.template Bottom<char>(), documentStack_.GetSize(),
#if RAPIDJSON_SCHEMA_VERBOSE
depth_ + 1,
#endif
GenericSchemaValidator(
const SchemaDocumentType& schemaDocument,
const SchemaType& root,
+ const char* basePath, size_t basePathSize,
#if RAPIDJSON_SCHEMA_VERBOSE
unsigned depth,
#endif
schemaStack_(allocator, schemaStackCapacity),
documentStack_(allocator, documentStackCapacity),
outputHandler_(0),
+ error_(kObjectType),
+ currentError_(),
+ missingDependents_(),
valid_(true)
#if RAPIDJSON_SCHEMA_VERBOSE
, depth_(depth)
#endif
{
+ if (basePath && basePathSize)
+ memcpy(documentStack_.template Push<char>(basePathSize), basePath, basePathSize);
}
StateAllocator& GetStateAllocator() {
if (!a)
CurrentContext().arrayElementHashCodes = a = new (GetStateAllocator().Malloc(sizeof(HashCodeArray))) HashCodeArray(kArrayType);
for (typename HashCodeArray::ConstValueIterator itr = a->Begin(); itr != a->End(); ++itr)
- if (itr->GetUint64() == h)
+ if (itr->GetUint64() == h) {
+ DuplicateItems(static_cast<SizeType>(itr - a->Begin()), a->Size());
RAPIDJSON_INVALID_KEYWORD_RETURN(SchemaType::GetUniqueItemsString());
+ }
a->PushBack(h, GetStateAllocator());
}
}
}
}
- RAPIDJSON_FORCEINLINE void PushSchema(const SchemaType& schema) { new (schemaStack_.template Push<Context>()) Context(*this, &schema); }
+ RAPIDJSON_FORCEINLINE void PushSchema(const SchemaType& schema) { new (schemaStack_.template Push<Context>()) Context(*this, *this, &schema); }
RAPIDJSON_FORCEINLINE void PopSchema() {
Context* c = schemaStack_.template Pop<Context>(1);
c->~Context();
}
+ void AddErrorLocation(ValueType& result, bool parent) {
+ GenericStringBuffer<EncodingType> sb;
+ PointerType instancePointer = GetInvalidDocumentPointer();
+ ((parent && instancePointer.GetTokenCount() > 0)
+ ? PointerType(instancePointer.GetTokens(), instancePointer.GetTokenCount() - 1)
+ : instancePointer).StringifyUriFragment(sb);
+ ValueType instanceRef(sb.GetString(), static_cast<SizeType>(sb.GetSize() / sizeof(Ch)),
+ GetStateAllocator());
+ result.AddMember(GetInstanceRefString(), instanceRef, GetStateAllocator());
+ sb.Clear();
+ memcpy(sb.Push(CurrentSchema().GetURI().GetStringLength()),
+ CurrentSchema().GetURI().GetString(),
+ CurrentSchema().GetURI().GetStringLength() * sizeof(Ch));
+ GetInvalidSchemaPointer().StringifyUriFragment(sb);
+ ValueType schemaRef(sb.GetString(), static_cast<SizeType>(sb.GetSize() / sizeof(Ch)),
+ GetStateAllocator());
+ result.AddMember(GetSchemaRefString(), schemaRef, GetStateAllocator());
+ }
+
+ void AddError(ValueType& keyword, ValueType& error) {
+ typename ValueType::MemberIterator member = error_.FindMember(keyword);
+ if (member == error_.MemberEnd())
+ error_.AddMember(keyword, error, GetStateAllocator());
+ else {
+ if (member->value.IsObject()) {
+ ValueType errors(kArrayType);
+ errors.PushBack(member->value, GetStateAllocator());
+ member->value = errors;
+ }
+ member->value.PushBack(error, GetStateAllocator());
+ }
+ }
+
+ void AddCurrentError(const typename SchemaType::ValueType& keyword, bool parent = false) {
+ AddErrorLocation(currentError_, parent);
+ AddError(ValueType(keyword, GetStateAllocator(), false).Move(), currentError_);
+ }
+
+ void MergeError(ValueType& other) {
+ for (typename ValueType::MemberIterator it = other.MemberBegin(), end = other.MemberEnd(); it != end; ++it) {
+ AddError(it->name, it->value);
+ }
+ }
+
+ void AddNumberError(const typename SchemaType::ValueType& keyword, ValueType& actual, const SValue& expected,
+ const typename SchemaType::ValueType& (*exclusive)() = 0) {
+ currentError_.SetObject();
+ currentError_.AddMember(GetActualString(), actual, GetStateAllocator());
+ currentError_.AddMember(GetExpectedString(), ValueType(expected, GetStateAllocator()).Move(), GetStateAllocator());
+ if (exclusive)
+ currentError_.AddMember(ValueType(exclusive(), GetStateAllocator()).Move(), true, GetStateAllocator());
+ AddCurrentError(keyword);
+ }
+
+ void AddErrorArray(const typename SchemaType::ValueType& keyword,
+ ISchemaValidator** subvalidators, SizeType count) {
+ ValueType errors(kArrayType);
+ for (SizeType i = 0; i < count; ++i)
+ errors.PushBack(static_cast<GenericSchemaValidator*>(subvalidators[i])->GetError(), GetStateAllocator());
+ currentError_.SetObject();
+ currentError_.AddMember(GetErrorsString(), errors, GetStateAllocator());
+ AddCurrentError(keyword);
+ }
+
const SchemaType& CurrentSchema() const { return *schemaStack_.template Top<Context>()->schema; }
Context& CurrentContext() { return *schemaStack_.template Top<Context>(); }
const Context& CurrentContext() const { return *schemaStack_.template Top<Context>(); }
internal::Stack<StateAllocator> schemaStack_; //!< stack to store the current path of schema (BaseSchemaType *)
internal::Stack<StateAllocator> documentStack_; //!< stack to store the current path of validating document (Ch)
OutputHandler* outputHandler_;
+ ValueType error_;
+ ValueType currentError_;
+ ValueType missingDependents_;
bool valid_;
#if RAPIDJSON_SCHEMA_VERBOSE
unsigned depth_;
public:
typedef typename SchemaDocumentType::PointerType PointerType;
typedef typename InputStream::Ch Ch;
+ typedef GenericValue<SourceEncoding, StackAllocator> ValueType;
//! Constructor
/*!
\param is Input stream.
\param sd Schema document.
*/
- SchemaValidatingReader(InputStream& is, const SchemaDocumentType& sd) : is_(is), sd_(sd), invalidSchemaKeyword_(), isValid_(true) {}
+ SchemaValidatingReader(InputStream& is, const SchemaDocumentType& sd) : is_(is), sd_(sd), invalidSchemaKeyword_(), error_(kObjectType), isValid_(true) {}
template <typename Handler>
bool operator()(Handler& handler) {
invalidSchemaPointer_ = PointerType();
invalidSchemaKeyword_ = 0;
invalidDocumentPointer_ = PointerType();
+ error_.SetObject();
}
else {
invalidSchemaPointer_ = validator.GetInvalidSchemaPointer();
invalidSchemaKeyword_ = validator.GetInvalidSchemaKeyword();
invalidDocumentPointer_ = validator.GetInvalidDocumentPointer();
+ error_.CopyFrom(validator.GetError(), allocator_);
}
return parseResult_;
const PointerType& GetInvalidSchemaPointer() const { return invalidSchemaPointer_; }
const Ch* GetInvalidSchemaKeyword() const { return invalidSchemaKeyword_; }
const PointerType& GetInvalidDocumentPointer() const { return invalidDocumentPointer_; }
+ const ValueType& GetError() const { return error_; }
private:
InputStream& is_;
PointerType invalidSchemaPointer_;
const Ch* invalidSchemaKeyword_;
PointerType invalidDocumentPointer_;
+ StackAllocator allocator_;
+ ValueType error_;
bool isValid_;
};
#include <arm_neon.h>
#endif
-#ifdef _MSC_VER
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(4127) // conditional expression is constant
-#endif
-
#ifdef __clang__
RAPIDJSON_DIAG_PUSH
RAPIDJSON_DIAG_OFF(padded)
RAPIDJSON_DIAG_OFF(unreachable-code)
RAPIDJSON_DIAG_OFF(c++98-compat)
+#elif defined(_MSC_VER)
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(4127) // conditional expression is constant
#endif
RAPIDJSON_NAMESPACE_BEGIN
bool WriteRawValue(const Ch* json, size_t length) {
PutReserve(*os_, length);
- for (size_t i = 0; i < length; i++) {
- RAPIDJSON_ASSERT(json[i] != '\0');
- PutUnsafe(*os_, json[i]);
+ GenericStringStream<SourceEncoding> is(json);
+ while (RAPIDJSON_LIKELY(is.Tell() < length)) {
+ RAPIDJSON_ASSERT(is.Peek() != '\0');
+ if (RAPIDJSON_UNLIKELY(!(writeFlags & kWriteValidateEncodingFlag ?
+ Transcoder<SourceEncoding, TargetEncoding>::Validate(is, *os_) :
+ Transcoder<SourceEncoding, TargetEncoding>::TranscodeUnsafe(is, *os_))))
+ return false;
}
return true;
}
RAPIDJSON_NAMESPACE_END
-#ifdef _MSC_VER
-RAPIDJSON_DIAG_POP
-#endif
-
-#ifdef __clang__
+#if defined(_MSC_VER) || defined(__clang__)
RAPIDJSON_DIAG_POP
#endif
projects / platform / core / uifw / lottie-player.git / commitdiff