15#ifndef RAPIDJSON_SCHEMA_H_
16#define RAPIDJSON_SCHEMA_H_
22#if !defined(RAPIDJSON_SCHEMA_USE_INTERNALREGEX)
23#define RAPIDJSON_SCHEMA_USE_INTERNALREGEX 1
25#define RAPIDJSON_SCHEMA_USE_INTERNALREGEX 0
28#if !RAPIDJSON_SCHEMA_USE_INTERNALREGEX && !defined(RAPIDJSON_SCHEMA_USE_STDREGEX) && (__cplusplus >=201103L || (defined(_MSC_VER) && _MSC_VER >= 1800))
29#define RAPIDJSON_SCHEMA_USE_STDREGEX 1
31#define RAPIDJSON_SCHEMA_USE_STDREGEX 0
34#if RAPIDJSON_SCHEMA_USE_INTERNALREGEX
35#include "internal/regex.h"
36#elif RAPIDJSON_SCHEMA_USE_STDREGEX
40#if RAPIDJSON_SCHEMA_USE_INTERNALREGEX || RAPIDJSON_SCHEMA_USE_STDREGEX
41#define RAPIDJSON_SCHEMA_HAS_REGEX 1
43#define RAPIDJSON_SCHEMA_HAS_REGEX 0
46#ifndef RAPIDJSON_SCHEMA_VERBOSE
47#define RAPIDJSON_SCHEMA_VERBOSE 0
50#if RAPIDJSON_SCHEMA_VERBOSE
51#include "stringbuffer.h"
57RAPIDJSON_DIAG_OFF(effc++)
61RAPIDJSON_DIAG_OFF(weak-vtables)
62RAPIDJSON_DIAG_OFF(exit-time-destructors)
63RAPIDJSON_DIAG_OFF(c++98-compat-pedantic)
64RAPIDJSON_DIAG_OFF(variadic-macros)
68RAPIDJSON_DIAG_OFF(4512)
71RAPIDJSON_NAMESPACE_BEGIN
76#if RAPIDJSON_SCHEMA_VERBOSE
80inline void PrintInvalidKeyword(
const char* keyword) {
81 printf(
"Fail keyword: %s\n", keyword);
84inline void PrintInvalidKeyword(
const wchar_t* keyword) {
85 wprintf(L
"Fail keyword: %ls\n", keyword);
88inline void PrintInvalidDocument(
const char* document) {
89 printf(
"Fail document: %s\n\n", document);
92inline void PrintInvalidDocument(
const wchar_t* document) {
93 wprintf(L
"Fail document: %ls\n\n", document);
96inline void PrintValidatorPointers(
unsigned depth,
const char* s,
const char* d) {
97 printf(
"S: %*s%s\nD: %*s%s\n\n", depth * 4,
" ", s, depth * 4,
" ", d);
100inline void PrintValidatorPointers(
unsigned depth,
const wchar_t* s,
const wchar_t* d) {
101 wprintf(L
"S: %*ls%ls\nD: %*ls%ls\n\n", depth * 4, L
" ", s, depth * 4, L
" ", d);
111#if RAPIDJSON_SCHEMA_VERBOSE
112#define RAPIDJSON_INVALID_KEYWORD_VERBOSE(keyword) internal::PrintInvalidKeyword(keyword)
114#define RAPIDJSON_INVALID_KEYWORD_VERBOSE(keyword)
117#define RAPIDJSON_INVALID_KEYWORD_RETURN(keyword)\
118RAPIDJSON_MULTILINEMACRO_BEGIN\
119 context.invalidKeyword = keyword.GetString();\
120 RAPIDJSON_INVALID_KEYWORD_VERBOSE(keyword.GetString());\
122RAPIDJSON_MULTILINEMACRO_END
127template <
typename ValueType,
typename Allocator>
128class GenericSchemaDocument;
132template <
typename SchemaDocumentType>
138class ISchemaValidator {
140 virtual ~ISchemaValidator() {}
141 virtual bool IsValid()
const = 0;
147template <
typename SchemaType>
148class ISchemaStateFactory {
150 virtual ~ISchemaStateFactory() {}
151 virtual ISchemaValidator* CreateSchemaValidator(
const SchemaType&) = 0;
152 virtual void DestroySchemaValidator(ISchemaValidator* validator) = 0;
153 virtual void* CreateHasher() = 0;
154 virtual uint64_t GetHashCode(
void* hasher) = 0;
155 virtual void DestroryHasher(
void* hasher) = 0;
156 virtual void* MallocState(
size_t size) = 0;
157 virtual void FreeState(
void* p) = 0;
164template<
typename Encoding,
typename Allocator>
167 typedef typename Encoding::Ch Ch;
169 Hasher(
Allocator* allocator = 0,
size_t stackCapacity = kDefaultSize) : stack_(allocator, stackCapacity) {}
171 bool Null() {
return WriteType(kNullType); }
172 bool Bool(
bool b) {
return WriteType(b ? kTrueType :
kFalseType); }
173 bool Int(
int i) { Number n; n.u.i = i; n.d =
static_cast<double>(i);
return WriteNumber(n); }
174 bool Uint(
unsigned u) { Number n; n.u.u = u; n.d =
static_cast<double>(u);
return WriteNumber(n); }
175 bool Int64(int64_t i) { Number n; n.u.i = i; n.d =
static_cast<double>(i);
return WriteNumber(n); }
176 bool Uint64(uint64_t u) { Number n; n.u.u = u; n.d =
static_cast<double>(u);
return WriteNumber(n); }
177 bool Double(
double d) {
179 if (d < 0) n.u.i =
static_cast<int64_t
>(d);
180 else n.u.u =
static_cast<uint64_t
>(d);
182 return WriteNumber(n);
185 bool RawNumber(
const Ch* str, SizeType len,
bool) {
186 WriteBuffer(kNumberType, str, len *
sizeof(Ch));
190 bool String(
const Ch* str, SizeType len,
bool) {
191 WriteBuffer(kStringType, str, len *
sizeof(Ch));
195 bool StartObject() {
return true; }
196 bool Key(
const Ch* str, SizeType len,
bool copy) {
return String(str, len, copy); }
197 bool EndObject(SizeType memberCount) {
198 uint64_t h = Hash(0, kObjectType);
199 uint64_t* kv = stack_.template Pop<uint64_t>(memberCount * 2);
200 for (SizeType i = 0; i < memberCount; i++)
201 h ^= Hash(kv[i * 2], kv[i * 2 + 1]);
202 *stack_.template Push<uint64_t>() = h;
206 bool StartArray() {
return true; }
207 bool EndArray(SizeType elementCount) {
208 uint64_t h = Hash(0, kArrayType);
209 uint64_t* e = stack_.template Pop<uint64_t>(elementCount);
210 for (SizeType i = 0; i < elementCount; i++)
212 *stack_.template Push<uint64_t>() = h;
216 bool IsValid()
const {
return stack_.GetSize() ==
sizeof(uint64_t); }
218 uint64_t GetHashCode()
const {
220 return *stack_.template Top<uint64_t>();
224 static const size_t kDefaultSize = 256;
233 bool WriteType(Type type) {
return WriteBuffer(type, 0, 0); }
235 bool WriteNumber(
const Number& n) {
return WriteBuffer(kNumberType, &n,
sizeof(n)); }
237 bool WriteBuffer(Type type,
const void* data,
size_t len) {
240 const unsigned char* d =
static_cast<const unsigned char*
>(data);
241 for (
size_t i = 0; i < len; i++)
243 *stack_.template Push<uint64_t>() = h;
247 static uint64_t Hash(uint64_t h, uint64_t d) {
254 Stack<Allocator> stack_;
260template <
typename SchemaDocumentType>
261struct SchemaValidationContext {
262 typedef Schema<SchemaDocumentType> SchemaType;
263 typedef ISchemaStateFactory<SchemaType> SchemaValidatorFactoryType;
264 typedef typename SchemaType::ValueType ValueType;
265 typedef typename ValueType::Ch Ch;
267 enum PatternValidatorType {
268 kPatternValidatorOnly,
269 kPatternValidatorWithProperty,
270 kPatternValidatorWithAdditionalProperty
273 SchemaValidationContext(SchemaValidatorFactoryType& f,
const SchemaType* s) :
279 arrayElementHashCodes(),
282 patternPropertiesValidators(),
283 patternPropertiesValidatorCount(),
284 patternPropertiesSchemas(),
285 patternPropertiesSchemaCount(),
286 valuePatternValidatorType(kPatternValidatorOnly),
289 valueUniqueness(false),
290 arrayUniqueness(false)
294 ~SchemaValidationContext() {
296 factory.DestroryHasher(hasher);
298 for (SizeType i = 0; i < validatorCount; i++)
299 factory.DestroySchemaValidator(validators[i]);
300 factory.FreeState(validators);
302 if (patternPropertiesValidators) {
303 for (SizeType i = 0; i < patternPropertiesValidatorCount; i++)
304 factory.DestroySchemaValidator(patternPropertiesValidators[i]);
305 factory.FreeState(patternPropertiesValidators);
307 if (patternPropertiesSchemas)
308 factory.FreeState(patternPropertiesSchemas);
310 factory.FreeState(propertyExist);
313 SchemaValidatorFactoryType& factory;
314 const SchemaType* schema;
315 const SchemaType* valueSchema;
316 const Ch* invalidKeyword;
318 void* arrayElementHashCodes;
319 ISchemaValidator** validators;
321 ISchemaValidator** patternPropertiesValidators;
322 SizeType patternPropertiesValidatorCount;
323 const SchemaType** patternPropertiesSchemas;
324 SizeType patternPropertiesSchemaCount;
325 PatternValidatorType valuePatternValidatorType;
326 PatternValidatorType objectPatternValidatorType;
330 bool valueUniqueness;
331 bool arrayUniqueness;
337template <
typename SchemaDocumentType>
340 typedef typename SchemaDocumentType::ValueType ValueType;
341 typedef typename SchemaDocumentType::AllocatorType AllocatorType;
342 typedef typename SchemaDocumentType::PointerType PointerType;
343 typedef typename ValueType::EncodingType EncodingType;
344 typedef typename EncodingType::Ch Ch;
345 typedef SchemaValidationContext<SchemaDocumentType> Context;
346 typedef Schema<SchemaDocumentType> SchemaType;
347 typedef GenericValue<EncodingType, AllocatorType> SValue;
348 friend class GenericSchemaDocument<ValueType, AllocatorType>;
350 Schema(SchemaDocumentType* schemaDocument,
const PointerType& p,
const ValueType& value,
const ValueType& document, AllocatorType* allocator) :
351 allocator_(allocator),
352 typeless_(schemaDocument->GetTypeless()),
356 type_((1 << kTotalSchemaType) - 1),
359 additionalPropertiesSchema_(),
360 patternProperties_(),
361 patternPropertyCount_(),
365 additionalProperties_(true),
368 hasSchemaDependencies_(),
369 additionalItemsSchema_(),
375 additionalItems_(true),
380 exclusiveMinimum_(false),
381 exclusiveMaximum_(false)
383 typedef typename SchemaDocumentType::ValueType ValueType;
384 typedef typename ValueType::ConstValueIterator ConstValueIterator;
385 typedef typename ValueType::ConstMemberIterator ConstMemberIterator;
387 if (!value.IsObject())
390 if (
const ValueType* v = GetMember(value, GetTypeString())) {
394 else if (v->IsArray())
395 for (ConstValueIterator itr = v->Begin(); itr != v->End(); ++itr)
399 if (
const ValueType* v = GetMember(value, GetEnumString()))
400 if (v->IsArray() && v->Size() > 0) {
401 enum_ =
static_cast<uint64_t*
>(allocator_->Malloc(
sizeof(uint64_t) * v->Size()));
402 for (ConstValueIterator itr = v->Begin(); itr != v->End(); ++itr) {
403 typedef Hasher<EncodingType, MemoryPoolAllocator<> > EnumHasherType;
404 char buffer[256 + 24];
405 MemoryPoolAllocator<> hasherAllocator(buffer,
sizeof(buffer));
406 EnumHasherType h(&hasherAllocator, 256);
408 enum_[enumCount_++] = h.GetHashCode();
412 if (schemaDocument) {
413 AssignIfExist(allOf_, *schemaDocument, p, value, GetAllOfString(), document);
414 AssignIfExist(anyOf_, *schemaDocument, p, value, GetAnyOfString(), document);
415 AssignIfExist(oneOf_, *schemaDocument, p, value, GetOneOfString(), document);
418 if (
const ValueType* v = GetMember(value, GetNotString())) {
419 schemaDocument->CreateSchema(¬_, p.Append(GetNotString(), allocator_), *v, document);
420 notValidatorIndex_ = validatorCount_;
426 const ValueType* properties = GetMember(value, GetPropertiesString());
427 const ValueType* required = GetMember(value, GetRequiredString());
428 const ValueType* dependencies = GetMember(value, GetDependenciesString());
431 SValue allProperties(kArrayType);
433 if (properties && properties->IsObject())
434 for (ConstMemberIterator itr = properties->MemberBegin(); itr != properties->MemberEnd(); ++itr)
435 AddUniqueElement(allProperties, itr->name);
437 if (required && required->IsArray())
438 for (ConstValueIterator itr = required->Begin(); itr != required->End(); ++itr)
440 AddUniqueElement(allProperties, *itr);
442 if (dependencies && dependencies->IsObject())
443 for (ConstMemberIterator itr = dependencies->MemberBegin(); itr != dependencies->MemberEnd(); ++itr) {
444 AddUniqueElement(allProperties, itr->name);
445 if (itr->value.IsArray())
446 for (ConstValueIterator i = itr->value.Begin(); i != itr->value.End(); ++i)
448 AddUniqueElement(allProperties, *i);
451 if (allProperties.Size() > 0) {
452 propertyCount_ = allProperties.Size();
453 properties_ =
static_cast<Property*
>(allocator_->Malloc(
sizeof(Property) * propertyCount_));
454 for (SizeType i = 0; i < propertyCount_; i++) {
455 new (&properties_[i]) Property();
456 properties_[i].name = allProperties[i];
457 properties_[i].schema = typeless_;
462 if (properties && properties->IsObject()) {
463 PointerType q = p.Append(GetPropertiesString(), allocator_);
464 for (ConstMemberIterator itr = properties->MemberBegin(); itr != properties->MemberEnd(); ++itr) {
466 if (FindPropertyIndex(itr->name, &index))
467 schemaDocument->CreateSchema(&properties_[index].schema, q.Append(itr->name, allocator_), itr->value, document);
471 if (
const ValueType* v = GetMember(value, GetPatternPropertiesString())) {
472 PointerType q = p.Append(GetPatternPropertiesString(), allocator_);
473 patternProperties_ =
static_cast<PatternProperty*
>(allocator_->Malloc(
sizeof(PatternProperty) * v->MemberCount()));
474 patternPropertyCount_ = 0;
476 for (ConstMemberIterator itr = v->MemberBegin(); itr != v->MemberEnd(); ++itr) {
477 new (&patternProperties_[patternPropertyCount_]) PatternProperty();
478 patternProperties_[patternPropertyCount_].pattern = CreatePattern(itr->name);
479 schemaDocument->CreateSchema(&patternProperties_[patternPropertyCount_].schema, q.Append(itr->name, allocator_), itr->value, document);
480 patternPropertyCount_++;
484 if (required && required->IsArray())
485 for (ConstValueIterator itr = required->Begin(); itr != required->End(); ++itr)
486 if (itr->IsString()) {
488 if (FindPropertyIndex(*itr, &index)) {
489 properties_[index].required =
true;
494 if (dependencies && dependencies->IsObject()) {
495 PointerType q = p.Append(GetDependenciesString(), allocator_);
496 hasDependencies_ =
true;
497 for (ConstMemberIterator itr = dependencies->MemberBegin(); itr != dependencies->MemberEnd(); ++itr) {
499 if (FindPropertyIndex(itr->name, &sourceIndex)) {
500 if (itr->value.IsArray()) {
501 properties_[sourceIndex].dependencies =
static_cast<bool*
>(allocator_->Malloc(
sizeof(
bool) * propertyCount_));
502 std::memset(properties_[sourceIndex].dependencies, 0,
sizeof(
bool)* propertyCount_);
503 for (ConstValueIterator targetItr = itr->value.Begin(); targetItr != itr->value.End(); ++targetItr) {
505 if (FindPropertyIndex(*targetItr, &targetIndex))
506 properties_[sourceIndex].dependencies[targetIndex] =
true;
509 else if (itr->value.IsObject()) {
510 hasSchemaDependencies_ =
true;
511 schemaDocument->CreateSchema(&properties_[sourceIndex].dependenciesSchema, q.Append(itr->name, allocator_), itr->value, document);
512 properties_[sourceIndex].dependenciesValidatorIndex = validatorCount_;
519 if (
const ValueType* v = GetMember(value, GetAdditionalPropertiesString())) {
521 additionalProperties_ = v->GetBool();
522 else if (v->IsObject())
523 schemaDocument->CreateSchema(&additionalPropertiesSchema_, p.Append(GetAdditionalPropertiesString(), allocator_), *v, document);
526 AssignIfExist(minProperties_, value, GetMinPropertiesString());
527 AssignIfExist(maxProperties_, value, GetMaxPropertiesString());
530 if (
const ValueType* v = GetMember(value, GetItemsString())) {
531 PointerType q = p.Append(GetItemsString(), allocator_);
533 schemaDocument->CreateSchema(&itemsList_, q, *v, document);
534 else if (v->IsArray()) {
535 itemsTuple_ =
static_cast<const Schema**
>(allocator_->Malloc(
sizeof(
const Schema*) * v->Size()));
537 for (ConstValueIterator itr = v->Begin(); itr != v->End(); ++itr, index++)
538 schemaDocument->CreateSchema(&itemsTuple_[itemsTupleCount_++], q.Append(index, allocator_), *itr, document);
542 AssignIfExist(minItems_, value, GetMinItemsString());
543 AssignIfExist(maxItems_, value, GetMaxItemsString());
545 if (
const ValueType* v = GetMember(value, GetAdditionalItemsString())) {
547 additionalItems_ = v->GetBool();
548 else if (v->IsObject())
549 schemaDocument->CreateSchema(&additionalItemsSchema_, p.Append(GetAdditionalItemsString(), allocator_), *v, document);
552 AssignIfExist(uniqueItems_, value, GetUniqueItemsString());
555 AssignIfExist(minLength_, value, GetMinLengthString());
556 AssignIfExist(maxLength_, value, GetMaxLengthString());
558 if (
const ValueType* v = GetMember(value, GetPatternString()))
559 pattern_ = CreatePattern(*v);
562 if (
const ValueType* v = GetMember(value, GetMinimumString()))
564 minimum_.CopyFrom(*v, *allocator_);
566 if (
const ValueType* v = GetMember(value, GetMaximumString()))
568 maximum_.CopyFrom(*v, *allocator_);
570 AssignIfExist(exclusiveMinimum_, value, GetExclusiveMinimumString());
571 AssignIfExist(exclusiveMaximum_, value, GetExclusiveMaximumString());
573 if (
const ValueType* v = GetMember(value, GetMultipleOfString()))
574 if (v->IsNumber() && v->GetDouble() > 0.0)
575 multipleOf_.CopyFrom(*v, *allocator_);
579 AllocatorType::Free(enum_);
581 for (SizeType i = 0; i < propertyCount_; i++)
582 properties_[i].~Property();
583 AllocatorType::Free(properties_);
585 if (patternProperties_) {
586 for (SizeType i = 0; i < patternPropertyCount_; i++)
587 patternProperties_[i].~PatternProperty();
588 AllocatorType::Free(patternProperties_);
590 AllocatorType::Free(itemsTuple_);
591#if RAPIDJSON_SCHEMA_HAS_REGEX
593 pattern_->~RegexType();
594 AllocatorType::Free(pattern_);
599 bool BeginValue(Context& context)
const {
600 if (context.inArray) {
602 context.valueUniqueness =
true;
605 context.valueSchema = itemsList_;
606 else if (itemsTuple_) {
607 if (context.arrayElementIndex < itemsTupleCount_)
608 context.valueSchema = itemsTuple_[context.arrayElementIndex];
609 else if (additionalItemsSchema_)
610 context.valueSchema = additionalItemsSchema_;
611 else if (additionalItems_)
612 context.valueSchema = typeless_;
614 RAPIDJSON_INVALID_KEYWORD_RETURN(GetItemsString());
617 context.valueSchema = typeless_;
619 context.arrayElementIndex++;
624 RAPIDJSON_FORCEINLINE
bool EndValue(Context& context)
const {
625 if (context.patternPropertiesValidatorCount > 0) {
626 bool otherValid =
false;
627 SizeType count = context.patternPropertiesValidatorCount;
628 if (context.objectPatternValidatorType != Context::kPatternValidatorOnly)
629 otherValid = context.patternPropertiesValidators[--count]->IsValid();
631 bool patternValid =
true;
632 for (SizeType i = 0; i < count; i++)
633 if (!context.patternPropertiesValidators[i]->IsValid()) {
634 patternValid =
false;
638 if (context.objectPatternValidatorType == Context::kPatternValidatorOnly) {
640 RAPIDJSON_INVALID_KEYWORD_RETURN(GetPatternPropertiesString());
642 else if (context.objectPatternValidatorType == Context::kPatternValidatorWithProperty) {
643 if (!patternValid || !otherValid)
644 RAPIDJSON_INVALID_KEYWORD_RETURN(GetPatternPropertiesString());
646 else if (!patternValid && !otherValid)
647 RAPIDJSON_INVALID_KEYWORD_RETURN(GetPatternPropertiesString());
651 const uint64_t h = context.factory.GetHashCode(context.hasher);
652 for (SizeType i = 0; i < enumCount_; i++)
655 RAPIDJSON_INVALID_KEYWORD_RETURN(GetEnumString());
660 for (SizeType i = allOf_.begin; i < allOf_.begin + allOf_.count; i++)
661 if (!context.validators[i]->IsValid())
662 RAPIDJSON_INVALID_KEYWORD_RETURN(GetAllOfString());
664 if (anyOf_.schemas) {
665 for (SizeType i = anyOf_.begin; i < anyOf_.begin + anyOf_.count; i++)
666 if (context.validators[i]->IsValid())
668 RAPIDJSON_INVALID_KEYWORD_RETURN(GetAnyOfString());
672 if (oneOf_.schemas) {
673 bool oneValid =
false;
674 for (SizeType i = oneOf_.begin; i < oneOf_.begin + oneOf_.count; i++)
675 if (context.validators[i]->IsValid()) {
677 RAPIDJSON_INVALID_KEYWORD_RETURN(GetOneOfString());
682 RAPIDJSON_INVALID_KEYWORD_RETURN(GetOneOfString());
685 if (not_ && context.validators[notValidatorIndex_]->IsValid())
686 RAPIDJSON_INVALID_KEYWORD_RETURN(GetNotString());
691 bool Null(Context& context)
const {
692 if (!(type_ & (1 << kNullSchemaType)))
693 RAPIDJSON_INVALID_KEYWORD_RETURN(GetTypeString());
694 return CreateParallelValidator(context);
697 bool Bool(Context& context,
bool)
const {
698 if (!(type_ & (1 << kBooleanSchemaType)))
699 RAPIDJSON_INVALID_KEYWORD_RETURN(GetTypeString());
700 return CreateParallelValidator(context);
703 bool Int(Context& context,
int i)
const {
704 if (!CheckInt(context, i))
706 return CreateParallelValidator(context);
709 bool Uint(Context& context,
unsigned u)
const {
710 if (!CheckUint(context, u))
712 return CreateParallelValidator(context);
715 bool Int64(Context& context, int64_t i)
const {
716 if (!CheckInt(context, i))
718 return CreateParallelValidator(context);
721 bool Uint64(Context& context, uint64_t u)
const {
722 if (!CheckUint(context, u))
724 return CreateParallelValidator(context);
727 bool Double(Context& context,
double d)
const {
728 if (!(type_ & (1 << kNumberSchemaType)))
729 RAPIDJSON_INVALID_KEYWORD_RETURN(GetTypeString());
731 if (!minimum_.IsNull() && !CheckDoubleMinimum(context, d))
734 if (!maximum_.IsNull() && !CheckDoubleMaximum(context, d))
737 if (!multipleOf_.IsNull() && !CheckDoubleMultipleOf(context, d))
740 return CreateParallelValidator(context);
743 bool String(Context& context,
const Ch* str, SizeType length,
bool)
const {
744 if (!(type_ & (1 << kStringSchemaType)))
745 RAPIDJSON_INVALID_KEYWORD_RETURN(GetTypeString());
747 if (minLength_ != 0 || maxLength_ !=
SizeType(~0)) {
749 if (internal::CountStringCodePoint<EncodingType>(str, length, &count)) {
750 if (count < minLength_)
751 RAPIDJSON_INVALID_KEYWORD_RETURN(GetMinLengthString());
752 if (count > maxLength_)
753 RAPIDJSON_INVALID_KEYWORD_RETURN(GetMaxLengthString());
757 if (pattern_ && !IsPatternMatch(pattern_, str, length))
758 RAPIDJSON_INVALID_KEYWORD_RETURN(GetPatternString());
760 return CreateParallelValidator(context);
763 bool StartObject(Context& context)
const {
764 if (!(type_ & (1 << kObjectSchemaType)))
765 RAPIDJSON_INVALID_KEYWORD_RETURN(GetTypeString());
767 if (hasDependencies_ || hasRequired_) {
768 context.propertyExist =
static_cast<bool*
>(context.factory.MallocState(
sizeof(
bool) * propertyCount_));
769 std::memset(context.propertyExist, 0,
sizeof(
bool) * propertyCount_);
772 if (patternProperties_) {
773 SizeType count = patternPropertyCount_ + 1;
774 context.patternPropertiesSchemas =
static_cast<const SchemaType**
>(context.factory.MallocState(
sizeof(
const SchemaType*) * count));
775 context.patternPropertiesSchemaCount = 0;
776 std::memset(context.patternPropertiesSchemas, 0,
sizeof(SchemaType*) * count);
779 return CreateParallelValidator(context);
782 bool Key(Context& context,
const Ch* str, SizeType len,
bool)
const {
783 if (patternProperties_) {
784 context.patternPropertiesSchemaCount = 0;
785 for (SizeType i = 0; i < patternPropertyCount_; i++)
786 if (patternProperties_[i].pattern && IsPatternMatch(patternProperties_[i].pattern, str, len)) {
787 context.patternPropertiesSchemas[context.patternPropertiesSchemaCount++] = patternProperties_[i].schema;
788 context.valueSchema = typeless_;
793 if (FindPropertyIndex(ValueType(str, len).Move(), &index)) {
794 if (context.patternPropertiesSchemaCount > 0) {
795 context.patternPropertiesSchemas[context.patternPropertiesSchemaCount++] = properties_[index].schema;
796 context.valueSchema = typeless_;
797 context.valuePatternValidatorType = Context::kPatternValidatorWithProperty;
800 context.valueSchema = properties_[index].schema;
802 if (context.propertyExist)
803 context.propertyExist[index] =
true;
808 if (additionalPropertiesSchema_) {
809 if (additionalPropertiesSchema_ && context.patternPropertiesSchemaCount > 0) {
810 context.patternPropertiesSchemas[context.patternPropertiesSchemaCount++] = additionalPropertiesSchema_;
811 context.valueSchema = typeless_;
812 context.valuePatternValidatorType = Context::kPatternValidatorWithAdditionalProperty;
815 context.valueSchema = additionalPropertiesSchema_;
818 else if (additionalProperties_) {
819 context.valueSchema = typeless_;
823 if (context.patternPropertiesSchemaCount == 0)
824 RAPIDJSON_INVALID_KEYWORD_RETURN(GetAdditionalPropertiesString());
829 bool EndObject(Context& context, SizeType memberCount)
const {
831 for (SizeType index = 0; index < propertyCount_; index++)
832 if (properties_[index].required)
833 if (!context.propertyExist[index])
834 RAPIDJSON_INVALID_KEYWORD_RETURN(GetRequiredString());
836 if (memberCount < minProperties_)
837 RAPIDJSON_INVALID_KEYWORD_RETURN(GetMinPropertiesString());
839 if (memberCount > maxProperties_)
840 RAPIDJSON_INVALID_KEYWORD_RETURN(GetMaxPropertiesString());
842 if (hasDependencies_) {
843 for (SizeType sourceIndex = 0; sourceIndex < propertyCount_; sourceIndex++)
844 if (context.propertyExist[sourceIndex]) {
845 if (properties_[sourceIndex].dependencies) {
846 for (SizeType targetIndex = 0; targetIndex < propertyCount_; targetIndex++)
847 if (properties_[sourceIndex].dependencies[targetIndex] && !context.propertyExist[targetIndex])
848 RAPIDJSON_INVALID_KEYWORD_RETURN(GetDependenciesString());
850 else if (properties_[sourceIndex].dependenciesSchema)
851 if (!context.validators[properties_[sourceIndex].dependenciesValidatorIndex]->IsValid())
852 RAPIDJSON_INVALID_KEYWORD_RETURN(GetDependenciesString());
859 bool StartArray(Context& context)
const {
860 if (!(type_ & (1 << kArraySchemaType)))
861 RAPIDJSON_INVALID_KEYWORD_RETURN(GetTypeString());
863 context.arrayElementIndex = 0;
864 context.inArray =
true;
866 return CreateParallelValidator(context);
869 bool EndArray(Context& context, SizeType elementCount)
const {
870 context.inArray =
false;
872 if (elementCount < minItems_)
873 RAPIDJSON_INVALID_KEYWORD_RETURN(GetMinItemsString());
875 if (elementCount > maxItems_)
876 RAPIDJSON_INVALID_KEYWORD_RETURN(GetMaxItemsString());
882#define RAPIDJSON_STRING_(name, ...) \
883 static const ValueType& Get##name##String() {\
884 static const Ch s[] = { __VA_ARGS__, '\0' };\
885 static const ValueType v(s, static_cast<SizeType>(sizeof(s) / sizeof(Ch) - 1));\
889 RAPIDJSON_STRING_(Null,
'n',
'u',
'l',
'l')
890 RAPIDJSON_STRING_(Boolean, 'b', 'o', 'o', 'l', 'e', 'a', 'n')
891 RAPIDJSON_STRING_(Object, 'o', 'b', 'j', 'e', 'c', 't')
892 RAPIDJSON_STRING_(Array, 'a', 'r', 'r', 'a', 'y')
893 RAPIDJSON_STRING_(String, 's', 't', 'r', 'i', 'n', 'g')
894 RAPIDJSON_STRING_(Number, 'n', 'u', 'm', 'b', 'e', 'r')
895 RAPIDJSON_STRING_(Integer, 'i', 'n', 't', 'e', 'g', 'e', 'r')
896 RAPIDJSON_STRING_(Type, 't', 'y', 'p', 'e')
897 RAPIDJSON_STRING_(Enum, 'e', 'n', 'u', 'm')
898 RAPIDJSON_STRING_(AllOf, 'a', 'l', 'l', 'O', 'f')
899 RAPIDJSON_STRING_(AnyOf, 'a', 'n', 'y', 'O', 'f')
900 RAPIDJSON_STRING_(OneOf, 'o', 'n', 'e', 'O', 'f')
901 RAPIDJSON_STRING_(Not, 'n', 'o', 't')
902 RAPIDJSON_STRING_(Properties, 'p', 'r', 'o', 'p', 'e', 'r', 't', 'i', 'e', 's')
903 RAPIDJSON_STRING_(Required, 'r', 'e', 'q', 'u', 'i', 'r', 'e', 'd')
904 RAPIDJSON_STRING_(Dependencies, 'd', 'e', 'p', 'e', 'n', 'd', 'e', 'n', 'c', 'i', 'e', 's')
905 RAPIDJSON_STRING_(PatternProperties, 'p', 'a', 't', 't', 'e', 'r', 'n', 'P', 'r', 'o', 'p', 'e', 'r', 't', 'i', 'e', 's')
906 RAPIDJSON_STRING_(AdditionalProperties, 'a', 'd', 'd', 'i', 't', 'i', 'o', 'n', 'a', 'l', 'P', 'r', 'o', 'p', 'e', 'r', 't', 'i', 'e', 's')
907 RAPIDJSON_STRING_(MinProperties, 'm', 'i', 'n', 'P', 'r', 'o', 'p', 'e', 'r', 't', 'i', 'e', 's')
908 RAPIDJSON_STRING_(MaxProperties, 'm', 'a', 'x', 'P', 'r', 'o', 'p', 'e', 'r', 't', 'i', 'e', 's')
909 RAPIDJSON_STRING_(Items, 'i', 't', 'e', 'm', 's')
910 RAPIDJSON_STRING_(MinItems, 'm', 'i', 'n', 'I', 't', 'e', 'm', 's')
911 RAPIDJSON_STRING_(MaxItems, 'm', 'a', 'x', 'I', 't', 'e', 'm', 's')
912 RAPIDJSON_STRING_(AdditionalItems, 'a', 'd', 'd', 'i', 't', 'i', 'o', 'n', 'a', 'l', 'I', 't', 'e', 'm', 's')
913 RAPIDJSON_STRING_(UniqueItems, 'u', 'n', 'i', 'q', 'u', 'e', 'I', 't', 'e', 'm', 's')
914 RAPIDJSON_STRING_(MinLength, 'm', 'i', 'n', 'L', 'e', 'n', 'g', 't', 'h')
915 RAPIDJSON_STRING_(MaxLength, 'm', 'a', 'x', 'L', 'e', 'n', 'g', 't', 'h')
916 RAPIDJSON_STRING_(Pattern, 'p', 'a', 't', 't', 'e', 'r', 'n')
917 RAPIDJSON_STRING_(Minimum, 'm', 'i', 'n', 'i', 'm', 'u', 'm')
918 RAPIDJSON_STRING_(Maximum, 'm', 'a', 'x', 'i', 'm', 'u', 'm')
919 RAPIDJSON_STRING_(ExclusiveMinimum, 'e', 'x', 'c', 'l', 'u', 's', 'i', 'v', 'e', 'M', 'i', 'n', 'i', 'm', 'u', 'm')
920 RAPIDJSON_STRING_(ExclusiveMaximum, 'e', 'x', 'c', 'l', 'u', 's', 'i', 'v', 'e', 'M', 'a', 'x', 'i', 'm', 'u', 'm')
921 RAPIDJSON_STRING_(MultipleOf, 'm', 'u', 'l', 't', 'i', 'p', 'l', 'e', 'O', 'f')
923#undef RAPIDJSON_STRING_
926 enum SchemaValueType {
937#if RAPIDJSON_SCHEMA_USE_INTERNALREGEX
938 typedef internal::GenericRegex<EncodingType> RegexType;
939#elif RAPIDJSON_SCHEMA_USE_STDREGEX
940 typedef std::basic_regex<Ch> RegexType;
942 typedef char RegexType;
946 SchemaArray() : schemas(), count() {}
947 ~SchemaArray() { AllocatorType::Free(schemas); }
948 const SchemaType** schemas;
953 template <
typename V1,
typename V2>
954 void AddUniqueElement(V1& a,
const V2& v) {
955 for (
typename V1::ConstValueIterator itr = a.Begin(); itr != a.End(); ++itr)
958 V1 c(v, *allocator_);
959 a.PushBack(c, *allocator_);
962 static const ValueType* GetMember(
const ValueType& value,
const ValueType& name) {
963 typename ValueType::ConstMemberIterator itr = value.FindMember(name);
964 return itr != value.MemberEnd() ? &(itr->value) : 0;
967 static void AssignIfExist(
bool& out,
const ValueType& value,
const ValueType& name) {
968 if (
const ValueType* v = GetMember(value, name))
973 static void AssignIfExist(SizeType& out,
const ValueType& value,
const ValueType& name) {
974 if (
const ValueType* v = GetMember(value, name))
975 if (v->IsUint64() && v->GetUint64() <=
SizeType(~0))
976 out =
static_cast<SizeType>(v->GetUint64());
979 void AssignIfExist(SchemaArray& out, SchemaDocumentType& schemaDocument,
const PointerType& p,
const ValueType& value,
const ValueType& name,
const ValueType& document) {
980 if (
const ValueType* v = GetMember(value, name)) {
981 if (v->IsArray() && v->Size() > 0) {
982 PointerType q = p.Append(name, allocator_);
983 out.count = v->Size();
984 out.schemas =
static_cast<const Schema**
>(allocator_->Malloc(out.count *
sizeof(
const Schema*)));
985 memset(out.schemas, 0,
sizeof(Schema*)* out.count);
986 for (SizeType i = 0; i < out.count; i++)
987 schemaDocument.CreateSchema(&out.schemas[i], q.Append(i, allocator_), (*v)[i], document);
988 out.begin = validatorCount_;
989 validatorCount_ += out.count;
994#if RAPIDJSON_SCHEMA_USE_INTERNALREGEX
995 template <
typename ValueType>
996 RegexType* CreatePattern(
const ValueType& value) {
997 if (value.IsString()) {
998 RegexType* r =
new (allocator_->Malloc(
sizeof(RegexType))) RegexType(value.GetString());
1001 AllocatorType::Free(r);
1009 static bool IsPatternMatch(
const RegexType* pattern,
const Ch *str, SizeType) {
1010 GenericRegexSearch<RegexType> rs(*pattern);
1011 return rs.Search(str);
1013#elif RAPIDJSON_SCHEMA_USE_STDREGEX
1014 template <
typename ValueType>
1015 RegexType* CreatePattern(
const ValueType& value) {
1016 if (value.IsString())
1018 return new (allocator_->Malloc(
sizeof(RegexType))) RegexType(value.GetString(), std::size_t(value.GetStringLength()), std::regex_constants::ECMAScript);
1020 catch (
const std::regex_error&) {
1025 static bool IsPatternMatch(
const RegexType* pattern,
const Ch *str, SizeType length) {
1026 std::match_results<const Ch*> r;
1027 return std::regex_search(str, str + length, r, *pattern);
1030 template <
typename ValueType>
1031 RegexType* CreatePattern(
const ValueType&) {
return 0; }
1033 static bool IsPatternMatch(
const RegexType*,
const Ch *, SizeType) {
return true; }
1036 void AddType(
const ValueType& type) {
1037 if (type == GetNullString() ) type_ |= 1 << kNullSchemaType;
1038 else if (type == GetBooleanString()) type_ |= 1 << kBooleanSchemaType;
1039 else if (type == GetObjectString() ) type_ |= 1 << kObjectSchemaType;
1040 else if (type == GetArrayString() ) type_ |= 1 << kArraySchemaType;
1041 else if (type == GetStringString() ) type_ |= 1 << kStringSchemaType;
1042 else if (type == GetIntegerString()) type_ |= 1 << kIntegerSchemaType;
1043 else if (type == GetNumberString() ) type_ |= (1 << kNumberSchemaType) | (1 << kIntegerSchemaType);
1046 bool CreateParallelValidator(Context& context)
const {
1047 if (enum_ || context.arrayUniqueness)
1048 context.hasher = context.factory.CreateHasher();
1050 if (validatorCount_) {
1052 context.validators =
static_cast<ISchemaValidator**
>(context.factory.MallocState(
sizeof(ISchemaValidator*) * validatorCount_));
1053 context.validatorCount = validatorCount_;
1056 CreateSchemaValidators(context, allOf_);
1059 CreateSchemaValidators(context, anyOf_);
1062 CreateSchemaValidators(context, oneOf_);
1065 context.validators[notValidatorIndex_] = context.factory.CreateSchemaValidator(*not_);
1067 if (hasSchemaDependencies_) {
1068 for (SizeType i = 0; i < propertyCount_; i++)
1069 if (properties_[i].dependenciesSchema)
1070 context.validators[properties_[i].dependenciesValidatorIndex] = context.factory.CreateSchemaValidator(*properties_[i].dependenciesSchema);
1077 void CreateSchemaValidators(Context& context,
const SchemaArray& schemas)
const {
1078 for (SizeType i = 0; i < schemas.count; i++)
1079 context.validators[schemas.begin + i] = context.factory.CreateSchemaValidator(*schemas.schemas[i]);
1083 bool FindPropertyIndex(
const ValueType& name, SizeType* outIndex)
const {
1084 SizeType len = name.GetStringLength();
1085 const Ch* str = name.GetString();
1086 for (SizeType index = 0; index < propertyCount_; index++)
1087 if (properties_[index].name.GetStringLength() == len &&
1088 (std::memcmp(properties_[index].name.GetString(), str,
sizeof(Ch) * len) == 0))
1096 bool CheckInt(Context& context, int64_t i)
const {
1097 if (!(type_ & ((1 << kIntegerSchemaType) | (1 << kNumberSchemaType))))
1098 RAPIDJSON_INVALID_KEYWORD_RETURN(GetTypeString());
1100 if (!minimum_.IsNull()) {
1101 if (minimum_.IsInt64()) {
1102 if (exclusiveMinimum_ ? i <= minimum_.GetInt64() : i < minimum_.GetInt64())
1103 RAPIDJSON_INVALID_KEYWORD_RETURN(GetMinimumString());
1105 else if (minimum_.IsUint64()) {
1106 RAPIDJSON_INVALID_KEYWORD_RETURN(GetMinimumString());
1108 else if (!CheckDoubleMinimum(context,
static_cast<double>(i)))
1112 if (!maximum_.IsNull()) {
1113 if (maximum_.IsInt64()) {
1114 if (exclusiveMaximum_ ? i >= maximum_.GetInt64() : i > maximum_.GetInt64())
1115 RAPIDJSON_INVALID_KEYWORD_RETURN(GetMaximumString());
1117 else if (maximum_.IsUint64()) { }
1119 else if (!CheckDoubleMaximum(context,
static_cast<double>(i)))
1123 if (!multipleOf_.IsNull()) {
1124 if (multipleOf_.IsUint64()) {
1125 if (
static_cast<uint64_t
>(i >= 0 ? i : -i) % multipleOf_.GetUint64() != 0)
1126 RAPIDJSON_INVALID_KEYWORD_RETURN(GetMultipleOfString());
1128 else if (!CheckDoubleMultipleOf(context,
static_cast<double>(i)))
1135 bool CheckUint(Context& context, uint64_t i)
const {
1136 if (!(type_ & ((1 << kIntegerSchemaType) | (1 << kNumberSchemaType))))
1137 RAPIDJSON_INVALID_KEYWORD_RETURN(GetTypeString());
1139 if (!minimum_.IsNull()) {
1140 if (minimum_.IsUint64()) {
1141 if (exclusiveMinimum_ ? i <= minimum_.GetUint64() : i < minimum_.GetUint64())
1142 RAPIDJSON_INVALID_KEYWORD_RETURN(GetMinimumString());
1144 else if (minimum_.IsInt64())
1146 else if (!CheckDoubleMinimum(context,
static_cast<double>(i)))
1150 if (!maximum_.IsNull()) {
1151 if (maximum_.IsUint64()) {
1152 if (exclusiveMaximum_ ? i >= maximum_.GetUint64() : i > maximum_.GetUint64())
1153 RAPIDJSON_INVALID_KEYWORD_RETURN(GetMaximumString());
1155 else if (maximum_.IsInt64())
1156 RAPIDJSON_INVALID_KEYWORD_RETURN(GetMaximumString());
1157 else if (!CheckDoubleMaximum(context,
static_cast<double>(i)))
1161 if (!multipleOf_.IsNull()) {
1162 if (multipleOf_.IsUint64()) {
1163 if (i % multipleOf_.GetUint64() != 0)
1164 RAPIDJSON_INVALID_KEYWORD_RETURN(GetMultipleOfString());
1166 else if (!CheckDoubleMultipleOf(context,
static_cast<double>(i)))
1173 bool CheckDoubleMinimum(Context& context,
double d)
const {
1174 if (exclusiveMinimum_ ? d <= minimum_.GetDouble() : d < minimum_.GetDouble())
1175 RAPIDJSON_INVALID_KEYWORD_RETURN(GetMinimumString());
1179 bool CheckDoubleMaximum(Context& context,
double d)
const {
1180 if (exclusiveMaximum_ ? d >= maximum_.GetDouble() : d > maximum_.GetDouble())
1181 RAPIDJSON_INVALID_KEYWORD_RETURN(GetMaximumString());
1185 bool CheckDoubleMultipleOf(Context& context,
double d)
const {
1186 double a = std::abs(d), b = std::abs(multipleOf_.GetDouble());
1187 double q = std::floor(a / b);
1188 double r = a - q * b;
1190 RAPIDJSON_INVALID_KEYWORD_RETURN(GetMultipleOfString());
1195 Property() : schema(), dependenciesSchema(), dependenciesValidatorIndex(), dependencies(), required(false) {}
1196 ~Property() { AllocatorType::Free(dependencies); }
1198 const SchemaType* schema;
1199 const SchemaType* dependenciesSchema;
1200 SizeType dependenciesValidatorIndex;
1205 struct PatternProperty {
1206 PatternProperty() : schema(), pattern() {}
1207 ~PatternProperty() {
1209 pattern->~RegexType();
1210 AllocatorType::Free(pattern);
1213 const SchemaType* schema;
1217 AllocatorType* allocator_;
1218 const SchemaType* typeless_;
1224 const SchemaType* not_;
1229 Property* properties_;
1230 const SchemaType* additionalPropertiesSchema_;
1231 PatternProperty* patternProperties_;
1236 bool additionalProperties_;
1237 bool hasDependencies_;
1239 bool hasSchemaDependencies_;
1241 const SchemaType* additionalItemsSchema_;
1242 const SchemaType* itemsList_;
1243 const SchemaType** itemsTuple_;
1247 bool additionalItems_;
1250 RegexType* pattern_;
1257 bool exclusiveMinimum_;
1258 bool exclusiveMaximum_;
1261template<
typename Stack,
typename Ch>
1263 RAPIDJSON_FORCEINLINE
static void AppendIndexToken(Stack& documentStack, SizeType index) {
1264 *documentStack.template Push<Ch>() =
'/';
1266 size_t length =
static_cast<size_t>((
sizeof(
SizeType) == 4 ? u32toa(index, buffer) : u64toa(index, buffer)) - buffer);
1267 for (
size_t i = 0; i < length; i++)
1268 *documentStack.template Push<Ch>() =
static_cast<Ch
>(buffer[i]);
1273template <
typename Stack>
1274struct TokenHelper<Stack, char> {
1275 RAPIDJSON_FORCEINLINE
static void AppendIndexToken(Stack& documentStack, SizeType index) {
1276 if (
sizeof(SizeType) == 4) {
1277 char *buffer = documentStack.template Push<char>(1 + 10);
1279 const char* end = internal::u32toa(index, buffer);
1280 documentStack.template Pop<char>(
static_cast<size_t>(10 - (end - buffer)));
1283 char *buffer = documentStack.template Push<char>(1 + 20);
1285 const char* end = internal::u64toa(index, buffer);
1286 documentStack.template Pop<char>(
static_cast<size_t>(20 - (end - buffer)));
1296template <
typename SchemaDocumentType>
1299 typedef typename SchemaDocumentType::Ch Ch;
1317template <
typename ValueT,
typename Allocator = CrtAllocator>
1323 typedef typename ValueType::EncodingType EncodingType;
1324 typedef typename EncodingType::Ch Ch;
1325 typedef internal::Schema<GenericSchemaDocument> SchemaType;
1328 template <
typename,
typename,
typename>
1345 schemaMap_(
allocator, kInitialSchemaMapSize),
1346 schemaRef_(
allocator, kInitialSchemaRefSize)
1351 typeless_ =
static_cast<SchemaType*
>(allocator_->Malloc(
sizeof(SchemaType)));
1359 while (!schemaRef_.Empty()) {
1361 if (
const SchemaType* s = GetSchema(
refEntry->target)) {
1366 if (!GetSchema(
refEntry->source)) {
1367 new (schemaMap_.template
Push<SchemaEntry>()) SchemaEntry(
refEntry->source,
const_cast<SchemaType*
>(s),
false, allocator_);
1378 schemaRef_.ShrinkToFit();
1381#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
1384 remoteProvider_(
rhs.remoteProvider_),
1385 allocator_(
rhs.allocator_),
1386 ownAllocator_(
rhs.ownAllocator_),
1388 typeless_(
rhs.typeless_),
1389 schemaMap_(std::move(
rhs.schemaMap_)),
1390 schemaRef_(std::move(
rhs.schemaRef_))
1392 rhs.remoteProvider_ = 0;
1394 rhs.ownAllocator_ = 0;
1401 while (!schemaMap_.Empty())
1405 typeless_->~SchemaType();
1406 Allocator::Free(typeless_);
1413 const SchemaType&
GetRoot()
const {
return *root_; }
1421 struct SchemaRefEntry {
1425 const SchemaType** schema;
1428 struct SchemaEntry {
1429 SchemaEntry(
const PointerType& p, SchemaType* s,
bool o,
Allocator* allocator) : pointer(p, allocator), schema(s), owned(o) {}
1432 schema->~SchemaType();
1433 Allocator::Free(schema);
1436 PointerType pointer;
1441 void CreateSchemaRecursive(
const SchemaType** schema,
const PointerType& pointer,
const ValueType& v,
const ValueType& document) {
1443 *schema = typeless_;
1445 if (v.GetType() == kObjectType) {
1446 const SchemaType* s = GetSchema(pointer);
1448 CreateSchema(schema, pointer, v, document);
1450 for (
typename ValueType::ConstMemberIterator itr = v.MemberBegin(); itr != v.MemberEnd(); ++itr)
1451 CreateSchemaRecursive(0, pointer.Append(itr->name, allocator_), itr->value, document);
1454 for (SizeType i = 0; i < v.Size(); i++)
1455 CreateSchemaRecursive(0, pointer.Append(i, allocator_), v[i], document);
1458 void CreateSchema(
const SchemaType** schema,
const PointerType& pointer,
const ValueType& v,
const ValueType& document) {
1461 if (!HandleRefSchema(pointer, schema, v, document)) {
1462 SchemaType* s =
new (allocator_->Malloc(
sizeof(SchemaType))) SchemaType(
this, pointer, v, document, allocator_);
1463 new (schemaMap_.template Push<SchemaEntry>()) SchemaEntry(pointer, s,
true, allocator_);
1470 bool HandleRefSchema(
const PointerType& source,
const SchemaType** schema,
const ValueType& v,
const ValueType& document) {
1471 static const Ch kRefString[] = {
'$',
'r',
'e',
'f',
'\0' };
1472 static const ValueType kRefValue(kRefString, 4);
1474 typename ValueType::ConstMemberIterator itr = v.FindMember(kRefValue);
1475 if (itr == v.MemberEnd())
1478 if (itr->value.IsString()) {
1479 SizeType len = itr->value.GetStringLength();
1481 const Ch* s = itr->value.GetString();
1483 while (i < len && s[i] !=
'#')
1487 if (remoteProvider_) {
1488 if (
const GenericSchemaDocument* remoteDocument = remoteProvider_->GetRemoteDocument(s, i)) {
1489 PointerType pointer(&s[i], len - i, allocator_);
1490 if (pointer.IsValid()) {
1491 if (
const SchemaType* sc = remoteDocument->GetSchema(pointer)) {
1500 else if (s[i] ==
'#') {
1501 PointerType pointer(&s[i], len - i, allocator_);
1502 if (pointer.IsValid()) {
1503 if (
const ValueType* nv = pointer.Get(document))
1504 if (HandleRefSchema(source, schema, *nv, document))
1507 new (schemaRef_.template Push<SchemaRefEntry>()) SchemaRefEntry(source, pointer, schema, allocator_);
1516 const SchemaType* GetSchema(
const PointerType& pointer)
const {
1517 for (
const SchemaEntry* target = schemaMap_.template Bottom<SchemaEntry>(); target != schemaMap_.template End<SchemaEntry>(); ++target)
1518 if (pointer == target->pointer)
1519 return target->schema;
1523 PointerType GetPointer(
const SchemaType* schema)
const {
1524 for (
const SchemaEntry* target = schemaMap_.template Bottom<SchemaEntry>(); target != schemaMap_.template End<SchemaEntry>(); ++target)
1525 if (schema == target->schema)
1526 return target->pointer;
1527 return PointerType();
1530 const SchemaType* GetTypeless()
const {
return typeless_; }
1532 static const size_t kInitialSchemaMapSize = 64;
1533 static const size_t kInitialSchemaRefSize = 64;
1535 IRemoteSchemaDocumentProviderType* remoteProvider_;
1538 const SchemaType* root_;
1539 SchemaType* typeless_;
1540 internal::Stack<Allocator> schemaMap_;
1541 internal::Stack<Allocator> schemaRef_;
1565 typename SchemaDocumentType,
1566 typename OutputHandler = BaseReaderHandler<typename SchemaDocumentType::SchemaType::EncodingType>,
1567 typename StateAllocator = CrtAllocator>
1569 public internal::ISchemaStateFactory<typename SchemaDocumentType::SchemaType>,
1570 public internal::ISchemaValidator
1573 typedef typename SchemaDocumentType::SchemaType SchemaType;
1574 typedef typename SchemaDocumentType::PointerType PointerType;
1575 typedef typename SchemaType::EncodingType EncodingType;
1576 typedef typename EncodingType::Ch Ch;
1594 ownStateAllocator_(0),
1599#
if RAPIDJSON_SCHEMA_VERBOSE
1622 ownStateAllocator_(0),
1627#
if RAPIDJSON_SCHEMA_VERBOSE
1641 while (!schemaStack_.Empty())
1643 documentStack_.Clear();
1653 return schemaStack_.Empty() ? PointerType() : schemaDocument_->GetPointer(&CurrentSchema());
1658 return schemaStack_.Empty() ? 0 : CurrentContext().invalidKeyword;
1663 return documentStack_.Empty() ? PointerType() : PointerType(documentStack_.template
Bottom<Ch>(), documentStack_.GetSize() /
sizeof(Ch));
1666#if RAPIDJSON_SCHEMA_VERBOSE
1667#define RAPIDJSON_SCHEMA_HANDLE_BEGIN_VERBOSE_() \
1668RAPIDJSON_MULTILINEMACRO_BEGIN\
1669 *documentStack_.template Push<Ch>() = '\0';\
1670 documentStack_.template Pop<Ch>(1);\
1671 internal::PrintInvalidDocument(documentStack_.template Bottom<Ch>());\
1672RAPIDJSON_MULTILINEMACRO_END
1674#define RAPIDJSON_SCHEMA_HANDLE_BEGIN_VERBOSE_()
1677#define RAPIDJSON_SCHEMA_HANDLE_BEGIN_(method, arg1)\
1678 if (!valid_) return false; \
1679 if (!BeginValue() || !CurrentSchema().method arg1) {\
1680 RAPIDJSON_SCHEMA_HANDLE_BEGIN_VERBOSE_();\
1681 return valid_ = false;\
1684#define RAPIDJSON_SCHEMA_HANDLE_PARALLEL_(method, arg2)\
1685 for (Context* context = schemaStack_.template Bottom<Context>(); context != schemaStack_.template End<Context>(); context++) {\
1686 if (context->hasher)\
1687 static_cast<HasherType*>(context->hasher)->method arg2;\
1688 if (context->validators)\
1689 for (SizeType i_ = 0; i_ < context->validatorCount; i_++)\
1690 static_cast<GenericSchemaValidator*>(context->validators[i_])->method arg2;\
1691 if (context->patternPropertiesValidators)\
1692 for (SizeType i_ = 0; i_ < context->patternPropertiesValidatorCount; i_++)\
1693 static_cast<GenericSchemaValidator*>(context->patternPropertiesValidators[i_])->method arg2;\
1696#define RAPIDJSON_SCHEMA_HANDLE_END_(method, arg2)\
1697 return valid_ = EndValue() && (!outputHandler_ || outputHandler_->method arg2)
1699#define RAPIDJSON_SCHEMA_HANDLE_VALUE_(method, arg1, arg2) \
1700 RAPIDJSON_SCHEMA_HANDLE_BEGIN_ (method, arg1);\
1701 RAPIDJSON_SCHEMA_HANDLE_PARALLEL_(method, arg2);\
1702 RAPIDJSON_SCHEMA_HANDLE_END_ (method, arg2)
1704 bool Null() { RAPIDJSON_SCHEMA_HANDLE_VALUE_(Null, (CurrentContext() ), ( )); }
1705 bool Bool(
bool b) { RAPIDJSON_SCHEMA_HANDLE_VALUE_(Bool, (CurrentContext(), b), (b)); }
1706 bool Int(
int i) { RAPIDJSON_SCHEMA_HANDLE_VALUE_(Int, (CurrentContext(), i), (i)); }
1707 bool Uint(
unsigned u) { RAPIDJSON_SCHEMA_HANDLE_VALUE_(Uint, (CurrentContext(), u), (u)); }
1708 bool Int64(int64_t i) { RAPIDJSON_SCHEMA_HANDLE_VALUE_(Int64, (CurrentContext(), i), (i)); }
1709 bool Uint64(uint64_t u) { RAPIDJSON_SCHEMA_HANDLE_VALUE_(Uint64, (CurrentContext(), u), (u)); }
1710 bool Double(
double d) { RAPIDJSON_SCHEMA_HANDLE_VALUE_(Double, (CurrentContext(), d), (d)); }
1711 bool RawNumber(
const Ch* str, SizeType length,
bool copy)
1712 { RAPIDJSON_SCHEMA_HANDLE_VALUE_(String, (CurrentContext(), str, length, copy), (str, length, copy)); }
1713 bool String(
const Ch* str, SizeType length,
bool copy)
1714 { RAPIDJSON_SCHEMA_HANDLE_VALUE_(String, (CurrentContext(), str, length, copy), (str, length, copy)); }
1716 bool StartObject() {
1717 RAPIDJSON_SCHEMA_HANDLE_BEGIN_(StartObject, (CurrentContext()));
1718 RAPIDJSON_SCHEMA_HANDLE_PARALLEL_(StartObject, ());
1719 return valid_ = !outputHandler_ || outputHandler_->StartObject();
1722 bool Key(
const Ch* str, SizeType len,
bool copy) {
1723 if (!valid_)
return false;
1724 AppendToken(str, len);
1725 if (!CurrentSchema().Key(CurrentContext(), str, len, copy))
return valid_ =
false;
1726 RAPIDJSON_SCHEMA_HANDLE_PARALLEL_(Key, (str, len, copy));
1727 return valid_ = !outputHandler_ || outputHandler_->Key(str, len, copy);
1730 bool EndObject(SizeType memberCount) {
1731 if (!valid_)
return false;
1732 RAPIDJSON_SCHEMA_HANDLE_PARALLEL_(EndObject, (memberCount));
1733 if (!CurrentSchema().EndObject(CurrentContext(), memberCount))
return valid_ =
false;
1734 RAPIDJSON_SCHEMA_HANDLE_END_(EndObject, (memberCount));
1738 RAPIDJSON_SCHEMA_HANDLE_BEGIN_(StartArray, (CurrentContext()));
1739 RAPIDJSON_SCHEMA_HANDLE_PARALLEL_(StartArray, ());
1740 return valid_ = !outputHandler_ || outputHandler_->StartArray();
1743 bool EndArray(SizeType elementCount) {
1744 if (!valid_)
return false;
1745 RAPIDJSON_SCHEMA_HANDLE_PARALLEL_(EndArray, (elementCount));
1746 if (!CurrentSchema().EndArray(CurrentContext(), elementCount))
return valid_ =
false;
1747 RAPIDJSON_SCHEMA_HANDLE_END_(EndArray, (elementCount));
1750#undef RAPIDJSON_SCHEMA_HANDLE_BEGIN_VERBOSE_
1751#undef RAPIDJSON_SCHEMA_HANDLE_BEGIN_
1752#undef RAPIDJSON_SCHEMA_HANDLE_PARALLEL_
1753#undef RAPIDJSON_SCHEMA_HANDLE_VALUE_
1756 virtual ISchemaValidator* CreateSchemaValidator(
const SchemaType& root) {
1757 return new (GetStateAllocator().Malloc(
sizeof(GenericSchemaValidator))) GenericSchemaValidator(*schemaDocument_, root,
1758#
if RAPIDJSON_SCHEMA_VERBOSE
1761 &GetStateAllocator());
1764 virtual void DestroySchemaValidator(ISchemaValidator* validator) {
1765 GenericSchemaValidator* v =
static_cast<GenericSchemaValidator*
>(validator);
1766 v->~GenericSchemaValidator();
1767 StateAllocator::Free(v);
1770 virtual void* CreateHasher() {
1771 return new (GetStateAllocator().Malloc(
sizeof(HasherType))) HasherType(&GetStateAllocator());
1774 virtual uint64_t GetHashCode(
void* hasher) {
1775 return static_cast<HasherType*
>(hasher)->GetHashCode();
1778 virtual void DestroryHasher(
void* hasher) {
1779 HasherType* h =
static_cast<HasherType*
>(hasher);
1781 StateAllocator::Free(h);
1784 virtual void* MallocState(
size_t size) {
1785 return GetStateAllocator().Malloc(size);
1788 virtual void FreeState(
void* p) {
1789 StateAllocator::Free(p);
1793 typedef typename SchemaType::Context Context;
1794 typedef GenericValue<UTF8<>, StateAllocator> HashCodeArray;
1795 typedef internal::Hasher<EncodingType, StateAllocator> HasherType;
1797 GenericSchemaValidator(
1798 const SchemaDocumentType& schemaDocument,
1799 const SchemaType& root,
1800#
if RAPIDJSON_SCHEMA_VERBOSE
1803 StateAllocator* allocator = 0,
1804 size_t schemaStackCapacity = kDefaultSchemaStackCapacity,
1805 size_t documentStackCapacity = kDefaultDocumentStackCapacity)
1807 schemaDocument_(&schemaDocument),
1809 stateAllocator_(allocator),
1810 ownStateAllocator_(0),
1811 schemaStack_(allocator, schemaStackCapacity),
1812 documentStack_(allocator, documentStackCapacity),
1815#if RAPIDJSON_SCHEMA_VERBOSE
1821 StateAllocator& GetStateAllocator() {
1822 if (!stateAllocator_)
1823 stateAllocator_ = ownStateAllocator_ =
RAPIDJSON_NEW(StateAllocator)();
1824 return *stateAllocator_;
1828 if (schemaStack_.Empty())
1831 if (CurrentContext().inArray)
1832 internal::TokenHelper<internal::Stack<StateAllocator>, Ch>::AppendIndexToken(documentStack_, CurrentContext().arrayElementIndex);
1834 if (!CurrentSchema().BeginValue(CurrentContext()))
1837 SizeType count = CurrentContext().patternPropertiesSchemaCount;
1838 const SchemaType** sa = CurrentContext().patternPropertiesSchemas;
1839 typename Context::PatternValidatorType patternValidatorType = CurrentContext().valuePatternValidatorType;
1840 bool valueUniqueness = CurrentContext().valueUniqueness;
1842 PushSchema(*CurrentContext().valueSchema);
1845 CurrentContext().objectPatternValidatorType = patternValidatorType;
1846 ISchemaValidator**& va = CurrentContext().patternPropertiesValidators;
1847 SizeType& validatorCount = CurrentContext().patternPropertiesValidatorCount;
1848 va =
static_cast<ISchemaValidator**
>(MallocState(
sizeof(ISchemaValidator*) * count));
1849 for (SizeType i = 0; i < count; i++)
1850 va[validatorCount++] = CreateSchemaValidator(*sa[i]);
1853 CurrentContext().arrayUniqueness = valueUniqueness;
1859 if (!CurrentSchema().EndValue(CurrentContext()))
1862#if RAPIDJSON_SCHEMA_VERBOSE
1863 GenericStringBuffer<EncodingType> sb;
1864 schemaDocument_->GetPointer(&CurrentSchema()).Stringify(sb);
1866 *documentStack_.template Push<Ch>() =
'\0';
1867 documentStack_.template Pop<Ch>(1);
1868 internal::PrintValidatorPointers(depth_, sb.GetString(), documentStack_.template Bottom<Ch>());
1871 uint64_t h = CurrentContext().arrayUniqueness ?
static_cast<HasherType*
>(CurrentContext().hasher)->GetHashCode() : 0;
1875 if (!schemaStack_.Empty()) {
1876 Context& context = CurrentContext();
1877 if (context.valueUniqueness) {
1878 HashCodeArray* a =
static_cast<HashCodeArray*
>(context.arrayElementHashCodes);
1880 CurrentContext().arrayElementHashCodes = a =
new (GetStateAllocator().Malloc(
sizeof(HashCodeArray))) HashCodeArray(kArrayType);
1881 for (
typename HashCodeArray::ConstValueIterator itr = a->Begin(); itr != a->End(); ++itr)
1882 if (itr->GetUint64() == h)
1883 RAPIDJSON_INVALID_KEYWORD_RETURN(SchemaType::GetUniqueItemsString());
1884 a->PushBack(h, GetStateAllocator());
1889 while (!documentStack_.Empty() && *documentStack_.template Pop<Ch>(1) !=
'/')
1895 void AppendToken(
const Ch* str, SizeType len) {
1896 documentStack_.template Reserve<Ch>(1 + len * 2);
1897 *documentStack_.template PushUnsafe<Ch>() =
'/';
1898 for (SizeType i = 0; i < len; i++) {
1899 if (str[i] ==
'~') {
1900 *documentStack_.template PushUnsafe<Ch>() =
'~';
1901 *documentStack_.template PushUnsafe<Ch>() =
'0';
1903 else if (str[i] ==
'/') {
1904 *documentStack_.template PushUnsafe<Ch>() =
'~';
1905 *documentStack_.template PushUnsafe<Ch>() =
'1';
1908 *documentStack_.template PushUnsafe<Ch>() = str[i];
1912 RAPIDJSON_FORCEINLINE
void PushSchema(
const SchemaType& schema) {
new (schemaStack_.template Push<Context>()) Context(*
this, &schema); }
1914 RAPIDJSON_FORCEINLINE
void PopSchema() {
1915 Context* c = schemaStack_.template Pop<Context>(1);
1916 if (HashCodeArray* a =
static_cast<HashCodeArray*
>(c->arrayElementHashCodes)) {
1917 a->~HashCodeArray();
1918 StateAllocator::Free(a);
1923 const SchemaType& CurrentSchema()
const {
return *schemaStack_.template Top<Context>()->schema; }
1924 Context& CurrentContext() {
return *schemaStack_.template Top<Context>(); }
1925 const Context& CurrentContext()
const {
return *schemaStack_.template Top<Context>(); }
1927 static const size_t kDefaultSchemaStackCapacity = 1024;
1928 static const size_t kDefaultDocumentStackCapacity = 256;
1929 const SchemaDocumentType* schemaDocument_;
1930 const SchemaType& root_;
1931 StateAllocator* stateAllocator_;
1932 StateAllocator* ownStateAllocator_;
1933 internal::Stack<StateAllocator> schemaStack_;
1934 internal::Stack<StateAllocator> documentStack_;
1935 OutputHandler* outputHandler_;
1937#if RAPIDJSON_SCHEMA_VERBOSE
1942typedef GenericSchemaValidator<SchemaDocument> SchemaValidator;
1958 unsigned parseFlags,
1959 typename InputStream,
1960 typename SourceEncoding,
1962 typename StackAllocator = CrtAllocator>
1965 typedef typename SchemaDocumentType::PointerType PointerType;
1966 typedef typename InputStream::Ch Ch;
1975 template <
typename Handler>
1983 invalidSchemaPointer_ = PointerType();
1984 invalidSchemaKeyword_ = 0;
1985 invalidDocumentPointer_ = PointerType();
1988 invalidSchemaPointer_ = validator.GetInvalidSchemaPointer();
1989 invalidSchemaKeyword_ = validator.GetInvalidSchemaKeyword();
1990 invalidDocumentPointer_ = validator.GetInvalidDocumentPointer();
1993 return parseResult_;
1996 const ParseResult& GetParseResult()
const {
return parseResult_; }
1997 bool IsValid()
const {
return isValid_; }
1998 const PointerType& GetInvalidSchemaPointer()
const {
return invalidSchemaPointer_; }
1999 const Ch* GetInvalidSchemaKeyword()
const {
return invalidSchemaKeyword_; }
2000 const PointerType& GetInvalidDocumentPointer()
const {
return invalidDocumentPointer_; }
2004 const SchemaDocumentType& sd_;
2006 ParseResult parseResult_;
2007 PointerType invalidSchemaPointer_;
2008 const Ch* invalidSchemaKeyword_;
2009 PointerType invalidDocumentPointer_;
2013RAPIDJSON_NAMESPACE_END
Concept for allocating, resizing and freeing memory block.
JSON schema document.
Definition schema.h:1318
const SchemaType & GetRoot() const
Get the root schema.
Definition schema.h:1413
GenericSchemaDocument(const ValueType &document, IRemoteSchemaDocumentProviderType *remoteProvider=0, Allocator *allocator=0)
Constructor.
Definition schema.h:1339
~GenericSchemaDocument()
Destructor
Definition schema.h:1400
JSON Schema Validator.
Definition schema.h:1571
GenericSchemaValidator(const SchemaDocumentType &schemaDocument, OutputHandler &outputHandler, StateAllocator *allocator=0, size_t schemaStackCapacity=kDefaultSchemaStackCapacity, size_t documentStackCapacity=kDefaultDocumentStackCapacity)
Constructor with output handler.
Definition schema.h:1612
PointerType GetInvalidSchemaPointer() const
Gets the JSON pointer pointed to the invalid schema.
Definition schema.h:1652
PointerType GetInvalidDocumentPointer() const
Gets the JSON pointer pointed to the invalid value.
Definition schema.h:1662
const Ch * GetInvalidSchemaKeyword() const
Gets the keyword of invalid schema.
Definition schema.h:1657
GenericSchemaValidator(const SchemaDocumentType &schemaDocument, StateAllocator *allocator=0, size_t schemaStackCapacity=kDefaultSchemaStackCapacity, size_t documentStackCapacity=kDefaultDocumentStackCapacity)
Constructor without output handler.
Definition schema.h:1585
virtual bool IsValid() const
Checks whether the current state is valid.
Definition schema.h:1649
~GenericSchemaValidator()
Destructor.
Definition schema.h:1634
void Reset()
Reset the internal states.
Definition schema.h:1640
A Stream Wrapper
Definition stream.h:119
Concept for receiving events from GenericReader upon parsing. The functions return true if no error o...
A helper class for parsing with validation.
Definition schema.h:1963
SchemaValidatingReader(InputStream &is, const SchemaDocumentType &sd)
Constructor
Definition schema.h:1973
#define RAPIDJSON_ASSERT(x)
Assertion.
Definition rapidjson.h:411
unsigned SizeType
Size type (for string lengths, array sizes, etc.)
Definition rapidjson.h:389
GenericSchemaDocument< Value, CrtAllocator > SchemaDocument
GenericSchemaDocument using Value type.
Definition fwd.h:138
@ kArrayType
array
Definition rapidjson.h:621
@ kFalseType
false
Definition rapidjson.h:618
@ kObjectType
object
Definition rapidjson.h:620
IGenericRemoteSchemaDocumentProvider< SchemaDocument > IRemoteSchemaDocumentProvider
IGenericRemoteSchemaDocumentProvider using SchemaDocument.
Definition fwd.h:139
#define RAPIDJSON_DELETE(x)
! customization point for global delete
Definition rapidjson.h:603
#define RAPIDJSON_UINT64_C2(high32, low32)
Construct a 64-bit literal by a pair of 32-bit integer.
Definition rapidjson.h:294
#define RAPIDJSON_NEW(TypeName)
! customization point for global new
Definition rapidjson.h:599