#include <schema.h>

Collaboration diagram for Schema< SchemaDocumentType >:

Classes
struct	PatternProperty

struct	Property

struct	SchemaArray

Public Types
typedef SchemaDocumentType::ValueType	ValueType

typedef SchemaDocumentType::AllocatorType	AllocatorType

typedef SchemaDocumentType::PointerType	PointerType

typedef ValueType::EncodingType	EncodingType

typedef EncodingType::Ch	Ch

typedef SchemaValidationContext< SchemaDocumentType >	Context

typedef Schema< SchemaDocumentType >	SchemaType

typedef GenericValue< EncodingType, AllocatorType >	SValue

typedef IValidationErrorHandler< Schema >	ErrorHandler

Public Member Functions
	Schema (SchemaDocumentType schemaDocument, const PointerType &p, const ValueType &value, const ValueType &document, AllocatorType allocator)

	~Schema ()

const SValue &	GetURI () const

const PointerType &	GetPointer () const

bool	BeginValue (Context &context) const

RAPIDJSON_FORCEINLINE bool	EndValue (Context &context) const

bool	Null (Context &context) const

bool	Bool (Context &context, bool) const

bool	Int (Context &context, int i) const

bool	Uint (Context &context, unsigned u) const

bool	Int64 (Context &context, int64_t i) const

bool	Uint64 (Context &context, uint64_t u) const

bool	Double (Context &context, double d) const

bool	String (Context &context, const Ch *str, SizeType length, bool) const

bool	StartObject (Context &context) const

bool	Key (Context &context, const Ch *str, SizeType len, bool) const

bool	EndObject (Context &context, SizeType memberCount) const

bool	StartArray (Context &context) const

bool	EndArray (Context &context, SizeType elementCount) const

Private Types
enum	SchemaValueType { kNullSchemaType, kBooleanSchemaType, kObjectSchemaType, kArraySchemaType, kStringSchemaType, kNumberSchemaType, kIntegerSchemaType, kTotalSchemaType }

typedef internal::GenericRegex< EncodingType, AllocatorType >	RegexType

Private Member Functions
template<typename V1 , typename V2 >
void	AddUniqueElement (V1 &a, const V2 &v)

void	AssignIfExist (SchemaArray &out, SchemaDocumentType &schemaDocument, const PointerType &p, const ValueType &value, const ValueType &name, const ValueType &document)

template<typename ValueType >
RegexType *	CreatePattern (const ValueType &value)

void	AddType (const ValueType &type)

bool	CreateParallelValidator (Context &context) const

void	CreateSchemaValidators (Context &context, const SchemaArray &schemas) const

bool	FindPropertyIndex (const ValueType &name, SizeType *outIndex) const

bool	CheckInt (Context &context, int64_t i) const

bool	CheckUint (Context &context, uint64_t i) const

bool	CheckDoubleMinimum (Context &context, double d) const

bool	CheckDoubleMaximum (Context &context, double d) const

bool	CheckDoubleMultipleOf (Context &context, double d) const

void	DisallowedType (Context &context, const ValueType &actualType) const

Static Private Member Functions
static const ValueType *	GetMember (const ValueType &value, const ValueType &name)

static void	AssignIfExist (bool &out, const ValueType &value, const ValueType &name)

static void	AssignIfExist (SizeType &out, const ValueType &value, const ValueType &name)

static bool	IsPatternMatch (const RegexType pattern, const Ch str, SizeType)

Private Attributes
AllocatorType *	allocator_

SValue	uri_

PointerType	pointer_

const SchemaType *	typeless_

uint64_t *	enum_

SizeType	enumCount_

SchemaArray	allOf_

SchemaArray	anyOf_

SchemaArray	oneOf_

const SchemaType *	not_

unsigned	type_

SizeType	validatorCount_

SizeType	notValidatorIndex_

Property *	properties_

const SchemaType *	additionalPropertiesSchema_

PatternProperty *	patternProperties_

SizeType	patternPropertyCount_

SizeType	propertyCount_

SizeType	minProperties_

SizeType	maxProperties_

bool	additionalProperties_

bool	hasDependencies_

bool	hasRequired_

bool	hasSchemaDependencies_

const SchemaType *	additionalItemsSchema_

const SchemaType *	itemsList_

const SchemaType **	itemsTuple_

SizeType	itemsTupleCount_

SizeType	minItems_

SizeType	maxItems_

bool	additionalItems_

bool	uniqueItems_

RegexType *	pattern_

SizeType	minLength_

SizeType	maxLength_

SValue	minimum_

SValue	maximum_

SValue	multipleOf_

bool	exclusiveMinimum_

bool	exclusiveMaximum_

SizeType	defaultValueLength_

Friends
class	GenericSchemaDocument< ValueType, AllocatorType >

Detailed Description

template<typename SchemaDocumentType>
class internal::Schema< SchemaDocumentType >

Definition at line 132 of file schema.h.

Member Typedef Documentation

◆ AllocatorType

typedef SchemaDocumentType::AllocatorType AllocatorType

Definition at line 399 of file schema.h.

◆ Ch

typedef EncodingType::Ch Ch

Definition at line 402 of file schema.h.

◆ Context

typedef SchemaValidationContext<SchemaDocumentType> Context

Definition at line 403 of file schema.h.

◆ EncodingType

typedef ValueType::EncodingType EncodingType

Definition at line 401 of file schema.h.

◆ ErrorHandler

typedef IValidationErrorHandler<Schema> ErrorHandler

Definition at line 406 of file schema.h.

◆ PointerType

typedef SchemaDocumentType::PointerType PointerType

Definition at line 400 of file schema.h.

◆ RegexType

typedef internal::GenericRegex<EncodingType, AllocatorType> RegexType

private

Definition at line 1074 of file schema.h.

◆ SchemaType

typedef Schema<SchemaDocumentType> SchemaType

Definition at line 404 of file schema.h.

◆ SValue

typedef GenericValue<EncodingType, AllocatorType> SValue

Definition at line 405 of file schema.h.

◆ ValueType

typedef SchemaDocumentType::ValueType ValueType

Definition at line 398 of file schema.h.

Member Enumeration Documentation

◆ SchemaValueType

enum SchemaValueType

private

Enumerator
kNullSchemaType
kBooleanSchemaType
kObjectSchemaType
kArraySchemaType
kStringSchemaType
kNumberSchemaType
kIntegerSchemaType
kTotalSchemaType

Definition at line 1062 of file schema.h.

                          {
         kNullSchemaType,
         kBooleanSchemaType,
         kObjectSchemaType,
         kArraySchemaType,
         kStringSchemaType,
         kNumberSchemaType,
         kIntegerSchemaType,
         kTotalSchemaType
     };

Constructor & Destructor Documentation

◆ Schema()

Schema	(	SchemaDocumentType *	schemaDocument,
		const PointerType &	p,
		const ValueType &	value,
		const ValueType &	document,
		AllocatorType *	allocator
	)

inline

Definition at line 409 of file schema.h.

                                                                                                                                                   :
         allocator_(allocator),
         uri_(schemaDocument->GetURI(), *allocator),
         pointer_(p, allocator),
         typeless_(schemaDocument->GetTypeless()),
         enum_(),
         enumCount_(),
         not_(),
         type_((1 << kTotalSchemaType) - 1), // typeless
         validatorCount_(),
         notValidatorIndex_(),
         properties_(),
         additionalPropertiesSchema_(),
         patternProperties_(),
         patternPropertyCount_(),
         propertyCount_(),
         minProperties_(),
         maxProperties_(SizeType(~0)),
         additionalProperties_(true),
         hasDependencies_(),
         hasRequired_(),
         hasSchemaDependencies_(),
         additionalItemsSchema_(),
         itemsList_(),
         itemsTuple_(),
         itemsTupleCount_(),
         minItems_(),
         maxItems_(SizeType(~0)),
         additionalItems_(true),
         uniqueItems_(false),
         pattern_(),
         minLength_(0),
         maxLength_(~SizeType(0)),
         exclusiveMinimum_(false),
         exclusiveMaximum_(false),
         defaultValueLength_(0)
     {
         typedef typename SchemaDocumentType::ValueType ValueType;
         typedef typename ValueType::ConstValueIterator ConstValueIterator;
         typedef typename ValueType::ConstMemberIterator ConstMemberIterator;
 
         if (!value.IsObject())
             return;
 
         if (const ValueType* v = GetMember(value, GetTypeString())) {
             type_ = 0;
             if (v->IsString())
                 AddType(*v);
             else if (v->IsArray())
                 for (ConstValueIterator itr = v->Begin(); itr != v->End(); ++itr)
                     AddType(*itr);
         }
 
         if (const ValueType* v = GetMember(value, GetEnumString()))
             if (v->IsArray() && v->Size() > 0) {
                 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[256u + 24];
                     MemoryPoolAllocator<> hasherAllocator(buffer, sizeof(buffer));
                     EnumHasherType h(&hasherAllocator, 256);
                     itr->Accept(h);
                     enum_[enumCount_++] = h.GetHashCode();
                 }
             }
 
         if (schemaDocument) {
             AssignIfExist(allOf_, *schemaDocument, p, value, GetAllOfString(), document);
             AssignIfExist(anyOf_, *schemaDocument, p, value, GetAnyOfString(), document);
             AssignIfExist(oneOf_, *schemaDocument, p, value, GetOneOfString(), document);
         }
 
         if (const ValueType* v = GetMember(value, GetNotString())) {
             schemaDocument->CreateSchema(&not_, p.Append(GetNotString(), allocator_), *v, document);
             notValidatorIndex_ = validatorCount_;
             validatorCount_++;
         }
 
         // Object
 
         const ValueType* properties = GetMember(value, GetPropertiesString());
         const ValueType* required = GetMember(value, GetRequiredString());
         const ValueType* dependencies = GetMember(value, GetDependenciesString());
         {
             // Gather properties from properties/required/dependencies
             SValue allProperties(kArrayType);
 
             if (properties && properties->IsObject())
                 for (ConstMemberIterator itr = properties->MemberBegin(); itr != properties->MemberEnd(); ++itr)
                     AddUniqueElement(allProperties, itr->name);
             
             if (required && required->IsArray())
                 for (ConstValueIterator itr = required->Begin(); itr != required->End(); ++itr)
                     if (itr->IsString())
                         AddUniqueElement(allProperties, *itr);
 
             if (dependencies && dependencies->IsObject())
                 for (ConstMemberIterator itr = dependencies->MemberBegin(); itr != dependencies->MemberEnd(); ++itr) {
                     AddUniqueElement(allProperties, itr->name);
                     if (itr->value.IsArray())
                         for (ConstValueIterator i = itr->value.Begin(); i != itr->value.End(); ++i)
                             if (i->IsString())
                                 AddUniqueElement(allProperties, *i);
                 }
 
             if (allProperties.Size() > 0) {
                 propertyCount_ = allProperties.Size();
                 properties_ = static_cast<Property*>(allocator_->Malloc(sizeof(Property) * propertyCount_));
                 for (SizeType i = 0; i < propertyCount_; i++) {
                     new (&properties_[i]) Property();
                     properties_[i].name = allProperties[i];
                     properties_[i].schema = typeless_;
                 }
             }
         }
 
         if (properties && properties->IsObject()) {
             PointerType q = p.Append(GetPropertiesString(), allocator_);
             for (ConstMemberIterator itr = properties->MemberBegin(); itr != properties->MemberEnd(); ++itr) {
                 SizeType index;
                 if (FindPropertyIndex(itr->name, &index))
                     schemaDocument->CreateSchema(&properties_[index].schema, q.Append(itr->name, allocator_), itr->value, document);
             }
         }
 
         if (const ValueType* v = GetMember(value, GetPatternPropertiesString())) {
             PointerType q = p.Append(GetPatternPropertiesString(), allocator_);
             patternProperties_ = static_cast<PatternProperty*>(allocator_->Malloc(sizeof(PatternProperty) * v->MemberCount()));
             patternPropertyCount_ = 0;
 
             for (ConstMemberIterator itr = v->MemberBegin(); itr != v->MemberEnd(); ++itr) {
                 new (&patternProperties_[patternPropertyCount_]) PatternProperty();
                 patternProperties_[patternPropertyCount_].pattern = CreatePattern(itr->name);
                 schemaDocument->CreateSchema(&patternProperties_[patternPropertyCount_].schema, q.Append(itr->name, allocator_), itr->value, document);
                 patternPropertyCount_++;
             }
         }
 
         if (required && required->IsArray())
             for (ConstValueIterator itr = required->Begin(); itr != required->End(); ++itr)
                 if (itr->IsString()) {
                     SizeType index;
                     if (FindPropertyIndex(*itr, &index)) {
                         properties_[index].required = true;
                         hasRequired_ = true;
                     }
                 }
 
         if (dependencies && dependencies->IsObject()) {
             PointerType q = p.Append(GetDependenciesString(), allocator_);
             hasDependencies_ = true;
             for (ConstMemberIterator itr = dependencies->MemberBegin(); itr != dependencies->MemberEnd(); ++itr) {
                 SizeType sourceIndex;
                 if (FindPropertyIndex(itr->name, &sourceIndex)) {
                     if (itr->value.IsArray()) {
                         properties_[sourceIndex].dependencies = static_cast<bool*>(allocator_->Malloc(sizeof(bool) * propertyCount_));
                         std::memset(properties_[sourceIndex].dependencies, 0, sizeof(bool)* propertyCount_);
                         for (ConstValueIterator targetItr = itr->value.Begin(); targetItr != itr->value.End(); ++targetItr) {
                             SizeType targetIndex;
                             if (FindPropertyIndex(*targetItr, &targetIndex))
                                 properties_[sourceIndex].dependencies[targetIndex] = true;
                         }
                     }
                     else if (itr->value.IsObject()) {
                         hasSchemaDependencies_ = true;
                         schemaDocument->CreateSchema(&properties_[sourceIndex].dependenciesSchema, q.Append(itr->name, allocator_), itr->value, document);
                         properties_[sourceIndex].dependenciesValidatorIndex = validatorCount_;
                         validatorCount_++;
                     }
                 }
             }
         }
 
         if (const ValueType* v = GetMember(value, GetAdditionalPropertiesString())) {
             if (v->IsBool())
                 additionalProperties_ = v->GetBool();
             else if (v->IsObject())
                 schemaDocument->CreateSchema(&additionalPropertiesSchema_, p.Append(GetAdditionalPropertiesString(), allocator_), *v, document);
         }
 
         AssignIfExist(minProperties_, value, GetMinPropertiesString());
         AssignIfExist(maxProperties_, value, GetMaxPropertiesString());
 
         // Array
         if (const ValueType* v = GetMember(value, GetItemsString())) {
             PointerType q = p.Append(GetItemsString(), allocator_);
             if (v->IsObject()) // List validation
                 schemaDocument->CreateSchema(&itemsList_, q, *v, document);
             else if (v->IsArray()) { // Tuple validation
                 itemsTuple_ = static_cast<const Schema**>(allocator_->Malloc(sizeof(const Schema*) * v->Size()));
                 SizeType index = 0;
                 for (ConstValueIterator itr = v->Begin(); itr != v->End(); ++itr, index++)
                     schemaDocument->CreateSchema(&itemsTuple_[itemsTupleCount_++], q.Append(index, allocator_), *itr, document);
             }
         }
 
         AssignIfExist(minItems_, value, GetMinItemsString());
         AssignIfExist(maxItems_, value, GetMaxItemsString());
 
         if (const ValueType* v = GetMember(value, GetAdditionalItemsString())) {
             if (v->IsBool())
                 additionalItems_ = v->GetBool();
             else if (v->IsObject())
                 schemaDocument->CreateSchema(&additionalItemsSchema_, p.Append(GetAdditionalItemsString(), allocator_), *v, document);
         }
 
         AssignIfExist(uniqueItems_, value, GetUniqueItemsString());
 
         // String
         AssignIfExist(minLength_, value, GetMinLengthString());
         AssignIfExist(maxLength_, value, GetMaxLengthString());
 
         if (const ValueType* v = GetMember(value, GetPatternString()))
             pattern_ = CreatePattern(*v);
 
         // Number
         if (const ValueType* v = GetMember(value, GetMinimumString()))
             if (v->IsNumber())
                 minimum_.CopyFrom(*v, *allocator_);
 
         if (const ValueType* v = GetMember(value, GetMaximumString()))
             if (v->IsNumber())
                 maximum_.CopyFrom(*v, *allocator_);
 
         AssignIfExist(exclusiveMinimum_, value, GetExclusiveMinimumString());
         AssignIfExist(exclusiveMaximum_, value, GetExclusiveMaximumString());
 
         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()

~Schema ( )

inline

Definition at line 647 of file schema.h.

               {
         AllocatorType::Free(enum_);
         if (properties_) {
             for (SizeType i = 0; i < propertyCount_; i++)
                 properties_[i].~Property();
             AllocatorType::Free(properties_);
         }
         if (patternProperties_) {
             for (SizeType i = 0; i < patternPropertyCount_; i++)
                 patternProperties_[i].~PatternProperty();
             AllocatorType::Free(patternProperties_);
         }
         AllocatorType::Free(itemsTuple_);
 #if RAPIDJSON_SCHEMA_HAS_REGEX
         if (pattern_) {
             pattern_->~RegexType();
             AllocatorType::Free(pattern_);
         }
 #endif
     }

Member Function Documentation

◆ AddType()

void AddType ( const ValueType & type )

inlineprivate

Definition at line 1174 of file schema.h.

                                         {
         if      (type == GetNullString()   ) type_ |= 1 << kNullSchemaType;
         else if (type == GetBooleanString()) type_ |= 1 << kBooleanSchemaType;
         else if (type == GetObjectString() ) type_ |= 1 << kObjectSchemaType;
         else if (type == GetArrayString()  ) type_ |= 1 << kArraySchemaType;
         else if (type == GetStringString() ) type_ |= 1 << kStringSchemaType;
         else if (type == GetIntegerString()) type_ |= 1 << kIntegerSchemaType;
         else if (type == GetNumberString() ) type_ |= (1 << kNumberSchemaType) | (1 << kIntegerSchemaType);
     }

◆ AddUniqueElement()

void AddUniqueElement	(	V1 &	a,
		const V2 &	v
	)

inlineprivate

Definition at line 1090 of file schema.h.

                                               {
         for (typename V1::ConstValueIterator itr = a.Begin(); itr != a.End(); ++itr)
             if (*itr == v)
                 return;
         V1 c(v, *allocator_);
         a.PushBack(c, *allocator_);
     }

◆ AssignIfExist() [1/3]

static void AssignIfExist	(	bool &	out,
		const ValueType &	value,
		const ValueType &	name
	)

inlinestaticprivate

Definition at line 1103 of file schema.h.

                                                                                         {
         if (const ValueType* v = GetMember(value, name))
             if (v->IsBool())
                 out = v->GetBool();
     }

◆ AssignIfExist() [2/3]

static void AssignIfExist	(	SizeType &	out,
		const ValueType &	value,
		const ValueType &	name
	)

inlinestaticprivate

Definition at line 1109 of file schema.h.

                                                                                             {
         if (const ValueType* v = GetMember(value, name))
             if (v->IsUint64() && v->GetUint64() <= SizeType(~0))
                 out = static_cast<SizeType>(v->GetUint64());
     }

◆ AssignIfExist() [3/3]

void AssignIfExist	(	SchemaArray &	out,
		SchemaDocumentType &	schemaDocument,
		const PointerType &	p,
		const ValueType &	value,
		const ValueType &	name,
		const ValueType &	document
	)

inlineprivate

Definition at line 1115 of file schema.h.

                                                                                                                                                                              {
         if (const ValueType* v = GetMember(value, name)) {
             if (v->IsArray() && v->Size() > 0) {
                 PointerType q = p.Append(name, allocator_);
                 out.count = v->Size();
                 out.schemas = static_cast<const Schema**>(allocator_->Malloc(out.count * sizeof(const Schema*)));
                 memset(out.schemas, 0, sizeof(Schema*)* out.count);
                 for (SizeType i = 0; i < out.count; i++)
                     schemaDocument.CreateSchema(&out.schemas[i], q.Append(i, allocator_), (*v)[i], document);
                 out.begin = validatorCount_;
                 validatorCount_ += out.count;
             }
         }
     }

◆ BeginValue()

bool BeginValue ( Context & context ) const

inline

Definition at line 676 of file schema.h.

                                             {
         if (context.inArray) {
             if (uniqueItems_)
                 context.valueUniqueness = true;
 
             if (itemsList_)
                 context.valueSchema = itemsList_;
             else if (itemsTuple_) {
                 if (context.arrayElementIndex < itemsTupleCount_)
                     context.valueSchema = itemsTuple_[context.arrayElementIndex];
                 else if (additionalItemsSchema_)
                     context.valueSchema = additionalItemsSchema_;
                 else if (additionalItems_)
                     context.valueSchema = typeless_;
                 else {
                     context.error_handler.DisallowedItem(context.arrayElementIndex);
                     RAPIDJSON_INVALID_KEYWORD_RETURN(GetItemsString());
                 }
             }
             else
                 context.valueSchema = typeless_;
 
             context.arrayElementIndex++;
         }
         return true;
     }

Here is the call graph for this function:

◆ Bool()

bool Bool	(	Context &	context,
		bool
	)		const

inline

Definition at line 793 of file schema.h.

                                             {
         if (!(type_ & (1 << kBooleanSchemaType))) {
             DisallowedType(context, GetBooleanString());
             RAPIDJSON_INVALID_KEYWORD_RETURN(GetTypeString());
         }
         return CreateParallelValidator(context);
     }

◆ CheckDoubleMaximum()

bool CheckDoubleMaximum	(	Context &	context,
		double	d
	)		const

inlineprivate

Definition at line 1338 of file schema.h.

                                                               {
         if (exclusiveMaximum_ ? d >= maximum_.GetDouble() : d > maximum_.GetDouble()) {
             context.error_handler.AboveMaximum(d, maximum_, exclusiveMaximum_);
             RAPIDJSON_INVALID_KEYWORD_RETURN(GetMaximumString());
         }
         return true;
     }

Here is the call graph for this function:

◆ CheckDoubleMinimum()

bool CheckDoubleMinimum	(	Context &	context,
		double	d
	)		const

inlineprivate

Definition at line 1330 of file schema.h.

                                                               {
         if (exclusiveMinimum_ ? d <= minimum_.GetDouble() : d < minimum_.GetDouble()) {
             context.error_handler.BelowMinimum(d, minimum_, exclusiveMinimum_);
             RAPIDJSON_INVALID_KEYWORD_RETURN(GetMinimumString());
         }
         return true;
     }

Here is the call graph for this function:

◆ CheckDoubleMultipleOf()

bool CheckDoubleMultipleOf	(	Context &	context,
		double	d
	)		const

inlineprivate

Definition at line 1346 of file schema.h.

                                                                  {
         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) {
             context.error_handler.NotMultipleOf(d, multipleOf_);
             RAPIDJSON_INVALID_KEYWORD_RETURN(GetMultipleOfString());
         }
         return true;
     }

Here is the call graph for this function:

◆ CheckInt()

bool CheckInt	(	Context &	context,
		int64_t	i
	)		const

inlineprivate

Definition at line 1234 of file schema.h.

                                                      {
         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()) {
                     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)))
                 return false;
         }
 
         if (!maximum_.IsNull()) {
             if (maximum_.IsInt64()) {
                 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()
             else if (!CheckDoubleMaximum(context, static_cast<double>(i)))
                 return false;
         }
 
         if (!multipleOf_.IsNull()) {
             if (multipleOf_.IsUint64()) {
                 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;
         }
 
         return true;
     }

Here is the call graph for this function:

◆ CheckUint()

bool CheckUint	(	Context &	context,
		uint64_t	i
	)		const

inlineprivate

Definition at line 1282 of file schema.h.

                                                        {
         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()) {
                     context.error_handler.BelowMinimum(i, minimum_, exclusiveMinimum_);
                     RAPIDJSON_INVALID_KEYWORD_RETURN(GetMinimumString());
                 }
             }
             else if (minimum_.IsInt64())
                 /* do nothing */; // i >= 0 > minimum.Getint64()
             else if (!CheckDoubleMinimum(context, static_cast<double>(i)))
                 return false;
         }
 
         if (!maximum_.IsNull()) {
             if (maximum_.IsUint64()) {
                 if (exclusiveMaximum_ ? i >= maximum_.GetUint64() : i > maximum_.GetUint64()) {
                     context.error_handler.AboveMaximum(i, maximum_, exclusiveMaximum_);
                     RAPIDJSON_INVALID_KEYWORD_RETURN(GetMaximumString());
                 }
             }
             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) {
                     context.error_handler.NotMultipleOf(i, multipleOf_);
                     RAPIDJSON_INVALID_KEYWORD_RETURN(GetMultipleOfString());
                 }
             }
             else if (!CheckDoubleMultipleOf(context, static_cast<double>(i)))
                 return false;
         }
 
         return true;
     }

Here is the call graph for this function:

◆ CreateParallelValidator()

bool CreateParallelValidator ( Context & context ) const

inlineprivate

Definition at line 1184 of file schema.h.

                                                          {
         if (enum_ || context.arrayUniqueness)
             context.hasher = context.factory.CreateHasher();
 
         if (validatorCount_) {
             RAPIDJSON_ASSERT(context.validators == 0);
             context.validators = static_cast<ISchemaValidator**>(context.factory.MallocState(sizeof(ISchemaValidator*) * validatorCount_));
             context.validatorCount = validatorCount_;
 
             if (allOf_.schemas)
                 CreateSchemaValidators(context, allOf_);
 
             if (anyOf_.schemas)
                 CreateSchemaValidators(context, anyOf_);
             
             if (oneOf_.schemas)
                 CreateSchemaValidators(context, oneOf_);
             
             if (not_)
                 context.validators[notValidatorIndex_] = context.factory.CreateSchemaValidator(*not_);
             
             if (hasSchemaDependencies_) {
                 for (SizeType i = 0; i < propertyCount_; i++)
                     if (properties_[i].dependenciesSchema)
                         context.validators[properties_[i].dependenciesValidatorIndex] = context.factory.CreateSchemaValidator(*properties_[i].dependenciesSchema);
             }
         }
 
         return true;
     }

Here is the call graph for this function:

◆ CreatePattern()

RegexType* CreatePattern ( const ValueType & value )

inlineprivate

Definition at line 1132 of file schema.h.

                                                      {
         if (value.IsString()) {
             RegexType* r = new (allocator_->Malloc(sizeof(RegexType))) RegexType(value.GetString(), allocator_);
             if (!r->IsValid()) {
                 r->~RegexType();
                 AllocatorType::Free(r);
                 r = 0;
             }
             return r;
         }
         return 0;
     }

Here is the call graph for this function:

◆ CreateSchemaValidators()

void CreateSchemaValidators	(	Context &	context,
		const SchemaArray &	schemas
	)		const

inlineprivate

Definition at line 1215 of file schema.h.

                                                                                     {
         for (SizeType i = 0; i < schemas.count; i++)
             context.validators[schemas.begin + i] = context.factory.CreateSchemaValidator(*schemas.schemas[i]);
     }

Here is the call graph for this function:

◆ DisallowedType()

void DisallowedType	(	Context &	context,
		const ValueType &	actualType
	)		const

inlineprivate

Definition at line 1357 of file schema.h.

                                                                              {
         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);
     }

Here is the call graph for this function:

◆ Double()

bool Double	(	Context &	context,
		double	d
	)		const

inline

Definition at line 825 of file schema.h.

                                                   {
         if (!(type_ & (1 << kNumberSchemaType))) {
             DisallowedType(context, GetNumberString());
             RAPIDJSON_INVALID_KEYWORD_RETURN(GetTypeString());
         }
 
         if (!minimum_.IsNull() && !CheckDoubleMinimum(context, d))
             return false;
 
         if (!maximum_.IsNull() && !CheckDoubleMaximum(context, d))
             return false;
         
         if (!multipleOf_.IsNull() && !CheckDoubleMultipleOf(context, d))
             return false;
         
         return CreateParallelValidator(context);
     }

◆ EndArray()

bool EndArray	(	Context &	context,
		SizeType	elementCount
	)		const

inline

Definition at line 1000 of file schema.h.

                                                                  {
         context.inArray = false;
         
         if (elementCount < minItems_) {
             context.error_handler.TooFewItems(elementCount, minItems_);
             RAPIDJSON_INVALID_KEYWORD_RETURN(GetMinItemsString());
         }
         
         if (elementCount > maxItems_) {
             context.error_handler.TooManyItems(elementCount, maxItems_);
             RAPIDJSON_INVALID_KEYWORD_RETURN(GetMaxItemsString());
         }
 
         return true;
     }

Here is the call graph for this function:

◆ EndObject()

bool EndObject	(	Context &	context,
		SizeType	memberCount
	)		const

inline

Definition at line 941 of file schema.h.

                                                                  {
         if (hasRequired_) {
             context.error_handler.StartMissingProperties();
             for (SizeType index = 0; index < propertyCount_; index++)
                 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_) {
             context.error_handler.TooFewProperties(memberCount, minProperties_);
             RAPIDJSON_INVALID_KEYWORD_RETURN(GetMinPropertiesString());
         }
 
         if (memberCount > maxProperties_) {
             context.error_handler.TooManyProperties(memberCount, maxProperties_);
             RAPIDJSON_INVALID_KEYWORD_RETURN(GetMaxPropertiesString());
         }
 
         if (hasDependencies_) {
             context.error_handler.StartDependencyErrors();
             for (SizeType sourceIndex = 0; sourceIndex < propertyCount_; sourceIndex++) {
                 const Property& source = properties_[sourceIndex];
                 if (context.propertyExist[sourceIndex]) {
                     if (source.dependencies) {
                         context.error_handler.StartMissingDependentProperties();
                         for (SizeType targetIndex = 0; targetIndex < propertyCount_; targetIndex++)
                             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);
                     }
                 }
             }
             if (context.error_handler.EndDependencyErrors())
                 RAPIDJSON_INVALID_KEYWORD_RETURN(GetDependenciesString());
         }
 
         return true;
     }

Here is the call graph for this function:

◆ EndValue()

RAPIDJSON_FORCEINLINE bool EndValue ( Context & context ) const

inline

Definition at line 703 of file schema.h.

                                                                 {
         if (context.patternPropertiesValidatorCount > 0) {
             bool otherValid = false;
             SizeType count = context.patternPropertiesValidatorCount;
             if (context.objectPatternValidatorType != Context::kPatternValidatorOnly)
                 otherValid = context.patternPropertiesValidators[--count]->IsValid();
 
             bool patternValid = true;
             for (SizeType i = 0; i < count; i++)
                 if (!context.patternPropertiesValidators[i]->IsValid()) {
                     patternValid = false;
                     break;
                 }
 
             if (context.objectPatternValidatorType == Context::kPatternValidatorOnly) {
                 if (!patternValid) {
                     context.error_handler.PropertyViolations(context.patternPropertiesValidators, count);
                     RAPIDJSON_INVALID_KEYWORD_RETURN(GetPatternPropertiesString());
                 }
             }
             else if (context.objectPatternValidatorType == Context::kPatternValidatorWithProperty) {
                 if (!patternValid || !otherValid) {
                     context.error_handler.PropertyViolations(context.patternPropertiesValidators, count + 1);
                     RAPIDJSON_INVALID_KEYWORD_RETURN(GetPatternPropertiesString());
                 }
             }
             else if (!patternValid && !otherValid) { // kPatternValidatorWithAdditionalProperty)
                 context.error_handler.PropertyViolations(context.patternPropertiesValidators, count + 1);
                 RAPIDJSON_INVALID_KEYWORD_RETURN(GetPatternPropertiesString());
             }
         }
 
         if (enum_) {
             const uint64_t h = context.factory.GetHashCode(context.hasher);
             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()) {
                     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:;
         }
 
         if (oneOf_.schemas) {
             bool oneValid = false;
             for (SizeType i = oneOf_.begin; i < oneOf_.begin + oneOf_.count; i++)
                 if (context.validators[i]->IsValid()) {
                     if (oneValid) {
                         context.error_handler.NotOneOf(&context.validators[oneOf_.begin], oneOf_.count);
                         RAPIDJSON_INVALID_KEYWORD_RETURN(GetOneOfString());
                     } else
                         oneValid = true;
                 }
             if (!oneValid) {
                 context.error_handler.NotOneOf(&context.validators[oneOf_.begin], oneOf_.count);
                 RAPIDJSON_INVALID_KEYWORD_RETURN(GetOneOfString());
             }
         }
 
         if (not_ && context.validators[notValidatorIndex_]->IsValid()) {
             context.error_handler.Disallowed();
             RAPIDJSON_INVALID_KEYWORD_RETURN(GetNotString());
         }
 
         return true;
     }

Here is the call graph for this function:

◆ FindPropertyIndex()

bool FindPropertyIndex	(	const ValueType &	name,
		SizeType *	outIndex
	)		const

inlineprivate

Definition at line 1221 of file schema.h.

                                                                             {
         SizeType len = name.GetStringLength();
         const Ch* str = name.GetString();
         for (SizeType index = 0; index < propertyCount_; index++)
             if (properties_[index].name.GetStringLength() == len && 
                 (std::memcmp(properties_[index].name.GetString(), str, sizeof(Ch) * len) == 0))
             {
                 *outIndex = index;
                 return true;
             }
         return false;
     }

◆ GetMember()

static const ValueType* GetMember	(	const ValueType &	value,
		const ValueType &	name
	)

inlinestaticprivate

Definition at line 1098 of file schema.h.

                                                                                      {
         typename ValueType::ConstMemberIterator itr = value.FindMember(name);
         return itr != value.MemberEnd() ? &(itr->value) : 0;
     }

◆ GetPointer()

const PointerType& GetPointer ( ) const

inline

Definition at line 672 of file schema.h.

                                           {
         return pointer_;
     }

◆ GetURI()

const SValue& GetURI ( ) const

inline

Definition at line 668 of file schema.h.

                                  {
         return uri_;
     }

◆ Int()

bool Int	(	Context &	context,
		int	i
	)		const

inline

Definition at line 801 of file schema.h.

                                             {
         if (!CheckInt(context, i))
             return false;
         return CreateParallelValidator(context);
     }

◆ Int64()

bool Int64	(	Context &	context,
		int64_t	i
	)		const

inline

Definition at line 813 of file schema.h.

                                                   {
         if (!CheckInt(context, i))
             return false;
         return CreateParallelValidator(context);
     }

◆ IsPatternMatch()

static bool IsPatternMatch	(	const RegexType *	pattern,
		const Ch *	str,
		SizeType
	)

inlinestaticprivate

Definition at line 1145 of file schema.h.

                                                                                   {
         GenericRegexSearch<RegexType> rs(*pattern);
         return rs.Search(str);
     }

Here is the call graph for this function:

◆ Key()

bool Key	(	Context &	context,
		const Ch *	str,
		SizeType	len,
		bool
	)		const

inline

Definition at line 892 of file schema.h.

                                                                         {
         if (patternProperties_) {
             context.patternPropertiesSchemaCount = 0;
             for (SizeType i = 0; i < patternPropertyCount_; i++)
                 if (patternProperties_[i].pattern && IsPatternMatch(patternProperties_[i].pattern, str, len)) {
                     context.patternPropertiesSchemas[context.patternPropertiesSchemaCount++] = patternProperties_[i].schema;
                     context.valueSchema = typeless_;
                 }
         }
 
         SizeType index;
         if (FindPropertyIndex(ValueType(str, len).Move(), &index)) {
             if (context.patternPropertiesSchemaCount > 0) {
                 context.patternPropertiesSchemas[context.patternPropertiesSchemaCount++] = properties_[index].schema;
                 context.valueSchema = typeless_;
                 context.valuePatternValidatorType = Context::kPatternValidatorWithProperty;
             }
             else
                 context.valueSchema = properties_[index].schema;
 
             if (context.propertyExist)
                 context.propertyExist[index] = true;
 
             return true;
         }
 
         if (additionalPropertiesSchema_) {
             if (additionalPropertiesSchema_ && context.patternPropertiesSchemaCount > 0) {
                 context.patternPropertiesSchemas[context.patternPropertiesSchemaCount++] = additionalPropertiesSchema_;
                 context.valueSchema = typeless_;
                 context.valuePatternValidatorType = Context::kPatternValidatorWithAdditionalProperty;
             }
             else
                 context.valueSchema = additionalPropertiesSchema_;
             return true;
         }
         else if (additionalProperties_) {
             context.valueSchema = typeless_;
             return true;
         }
 
         if (context.patternPropertiesSchemaCount == 0) { // patternProperties are not additional properties
             context.error_handler.DisallowedProperty(str, len);
             RAPIDJSON_INVALID_KEYWORD_RETURN(GetAdditionalPropertiesString());
         }
 
         return true;
     }

Here is the call graph for this function:

◆ Null()

bool Null ( Context & context ) const

inline

Definition at line 785 of file schema.h.

                                       {
         if (!(type_ & (1 << kNullSchemaType))) {
             DisallowedType(context, GetNullString());
             RAPIDJSON_INVALID_KEYWORD_RETURN(GetTypeString());
         }
         return CreateParallelValidator(context);
     }

◆ StartArray()

bool StartArray ( Context & context ) const

inline

Definition at line 988 of file schema.h.

                                             {
         if (!(type_ & (1 << kArraySchemaType))) {
             DisallowedType(context, GetArrayString());
             RAPIDJSON_INVALID_KEYWORD_RETURN(GetTypeString());
         }
 
         context.arrayElementIndex = 0;
         context.inArray = true;
 
         return CreateParallelValidator(context);
     }

◆ StartObject()

bool StartObject ( Context & context ) const

inline

Definition at line 871 of file schema.h.

                                              {
         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_));
             std::memset(context.propertyExist, 0, sizeof(bool) * propertyCount_);
         }
 
         if (patternProperties_) { // pre-allocate schema array
             SizeType count = patternPropertyCount_ + 1; // extra for valuePatternValidatorType
             context.patternPropertiesSchemas = static_cast<const SchemaType**>(context.factory.MallocState(sizeof(const SchemaType*) * count));
             context.patternPropertiesSchemaCount = 0;
             std::memset(context.patternPropertiesSchemas, 0, sizeof(SchemaType*) * count);
         }
 
         return CreateParallelValidator(context);
     }

Here is the call graph for this function:

◆ String()

bool String	(	Context &	context,
		const Ch *	str,
		SizeType	length,
		bool
	)		const

inline

Definition at line 843 of file schema.h.

                                                                               {
         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_) {
                     context.error_handler.TooShort(str, length, minLength_);
                     RAPIDJSON_INVALID_KEYWORD_RETURN(GetMinLengthString());
                 }
                 if (count > maxLength_) {
                     context.error_handler.TooLong(str, length, maxLength_);
                     RAPIDJSON_INVALID_KEYWORD_RETURN(GetMaxLengthString());
                 }
             }
         }
 
         if (pattern_ && !IsPatternMatch(pattern_, str, length)) {
             context.error_handler.DoesNotMatch(str, length);
             RAPIDJSON_INVALID_KEYWORD_RETURN(GetPatternString());
         }
 
         return CreateParallelValidator(context);
     }

Here is the call graph for this function:

◆ Uint()

bool Uint	(	Context &	context,
		unsigned	u
	)		const

inline

Definition at line 807 of file schema.h.

                                                   {
         if (!CheckUint(context, u))
             return false;
         return CreateParallelValidator(context);
     }

◆ Uint64()

bool Uint64	(	Context &	context,
		uint64_t	u
	)		const

inline

Definition at line 819 of file schema.h.

                                                     {
         if (!CheckUint(context, u))
             return false;
         return CreateParallelValidator(context);
     }

Friends And Related Function Documentation

◆ GenericSchemaDocument< ValueType, AllocatorType >

friend class GenericSchemaDocument< ValueType, AllocatorType >

friend

Definition at line 407 of file schema.h.

Member Data Documentation

◆ additionalItems_

bool additionalItems_

private

Definition at line 1428 of file schema.h.

◆ additionalItemsSchema_

const SchemaType* additionalItemsSchema_

private

Definition at line 1422 of file schema.h.

◆ additionalProperties_

bool additionalProperties_

private

Definition at line 1417 of file schema.h.

◆ additionalPropertiesSchema_

const SchemaType* additionalPropertiesSchema_

private

Definition at line 1411 of file schema.h.

◆ allocator_

AllocatorType* allocator_

private

Definition at line 1396 of file schema.h.

◆ allOf_

SchemaArray allOf_

private

Definition at line 1402 of file schema.h.

◆ anyOf_

SchemaArray anyOf_

private

Definition at line 1403 of file schema.h.

◆ defaultValueLength_

SizeType defaultValueLength_

private

Definition at line 1441 of file schema.h.

◆ enum_

uint64_t* enum_

private

Definition at line 1400 of file schema.h.

◆ enumCount_

SizeType enumCount_

private

Definition at line 1401 of file schema.h.

◆ exclusiveMaximum_

bool exclusiveMaximum_

private

Definition at line 1439 of file schema.h.

◆ exclusiveMinimum_

bool exclusiveMinimum_

private

Definition at line 1438 of file schema.h.

◆ hasDependencies_

bool hasDependencies_

private

Definition at line 1418 of file schema.h.

◆ hasRequired_

bool hasRequired_

private

Definition at line 1419 of file schema.h.

◆ hasSchemaDependencies_

bool hasSchemaDependencies_

private

Definition at line 1420 of file schema.h.

◆ itemsList_

const SchemaType* itemsList_

private

Definition at line 1423 of file schema.h.

◆ itemsTuple_

const SchemaType** itemsTuple_

private

Definition at line 1424 of file schema.h.

◆ itemsTupleCount_

SizeType itemsTupleCount_

private

Definition at line 1425 of file schema.h.

◆ maximum_

SValue maximum_

private

Definition at line 1436 of file schema.h.

◆ maxItems_

SizeType maxItems_

private

Definition at line 1427 of file schema.h.

◆ maxLength_

SizeType maxLength_

private

Definition at line 1433 of file schema.h.

◆ maxProperties_

SizeType maxProperties_

private

Definition at line 1416 of file schema.h.

◆ minimum_

SValue minimum_

private

Definition at line 1435 of file schema.h.

◆ minItems_

SizeType minItems_

private

Definition at line 1426 of file schema.h.

◆ minLength_

SizeType minLength_

private

Definition at line 1432 of file schema.h.

◆ minProperties_

SizeType minProperties_

private

Definition at line 1415 of file schema.h.

◆ multipleOf_

SValue multipleOf_

private

Definition at line 1437 of file schema.h.

◆ not_

const SchemaType* not_

private

Definition at line 1405 of file schema.h.

◆ notValidatorIndex_

SizeType notValidatorIndex_

private

Definition at line 1408 of file schema.h.

◆ oneOf_

SchemaArray oneOf_

private

Definition at line 1404 of file schema.h.

◆ pattern_

RegexType* pattern_

private

Definition at line 1431 of file schema.h.

◆ patternProperties_

PatternProperty* patternProperties_

private

Definition at line 1412 of file schema.h.

◆ patternPropertyCount_

SizeType patternPropertyCount_

private

Definition at line 1413 of file schema.h.

◆ pointer_

PointerType pointer_

private

Definition at line 1398 of file schema.h.

◆ properties_

Property* properties_

private

Definition at line 1410 of file schema.h.

◆ propertyCount_

SizeType propertyCount_

private

Definition at line 1414 of file schema.h.

◆ type_

unsigned type_

private

Definition at line 1406 of file schema.h.

◆ typeless_

const SchemaType* typeless_

private

Definition at line 1399 of file schema.h.

◆ uniqueItems_

bool uniqueItems_

private

Definition at line 1429 of file schema.h.

◆ uri_

SValue uri_

private

Definition at line 1397 of file schema.h.

◆ validatorCount_

SizeType validatorCount_

private

Definition at line 1407 of file schema.h.

The documentation for this class was generated from the following file:

rapidjson/schema.h

Classes

Public Types

Public Member Functions

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Friends

Detailed Description

template<typename SchemaDocumentType> class internal::Schema< SchemaDocumentType >

Member Typedef Documentation

◆ AllocatorType

◆ Ch

◆ Context

◆ EncodingType

◆ ErrorHandler

◆ PointerType

◆ RegexType

◆ SchemaType

◆ SValue

◆ ValueType

Member Enumeration Documentation

◆ SchemaValueType

Constructor & Destructor Documentation

◆ Schema()

◆ ~Schema()

Member Function Documentation

◆ AddType()

◆ AddUniqueElement()

◆ AssignIfExist() [1/3]

◆ AssignIfExist() [2/3]

◆ AssignIfExist() [3/3]

◆ BeginValue()

◆ Bool()

◆ CheckDoubleMaximum()

◆ CheckDoubleMinimum()

◆ CheckDoubleMultipleOf()

◆ CheckInt()

◆ CheckUint()

◆ CreateParallelValidator()

◆ CreatePattern()

◆ CreateSchemaValidators()

◆ DisallowedType()

◆ Double()

◆ EndArray()

◆ EndObject()

◆ EndValue()

◆ FindPropertyIndex()

◆ GetMember()

◆ GetPointer()

◆ GetURI()

◆ Int()

◆ Int64()

◆ IsPatternMatch()

◆ Key()

◆ Null()

◆ StartArray()

◆ StartObject()

◆ String()

◆ Uint()

◆ Uint64()

Friends And Related Function Documentation

◆ GenericSchemaDocument< ValueType, AllocatorType >

Member Data Documentation

◆ additionalItems_

◆ additionalItemsSchema_

◆ additionalProperties_

◆ additionalPropertiesSchema_

◆ allocator_

◆ allOf_

◆ anyOf_

◆ defaultValueLength_

◆ enum_

◆ enumCount_

◆ exclusiveMaximum_

◆ exclusiveMinimum_

◆ hasDependencies_

◆ hasRequired_

◆ hasSchemaDependencies_

◆ itemsList_

template<typename SchemaDocumentType>
class internal::Schema< SchemaDocumentType >