#include <schema.h>

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

template<typename SchemaDocumentType >

typedef SchemaDocumentType::AllocatorType internal::Schema< SchemaDocumentType >::AllocatorType

Definition at line 399 of file schema.h.

template<typename SchemaDocumentType >

typedef EncodingType::Ch internal::Schema< SchemaDocumentType >::Ch

Definition at line 402 of file schema.h.

template<typename SchemaDocumentType >

typedef SchemaValidationContext<SchemaDocumentType> internal::Schema< SchemaDocumentType >::Context

Definition at line 403 of file schema.h.

template<typename SchemaDocumentType >

typedef ValueType::EncodingType internal::Schema< SchemaDocumentType >::EncodingType

Definition at line 401 of file schema.h.

template<typename SchemaDocumentType >

typedef IValidationErrorHandler<Schema> internal::Schema< SchemaDocumentType >::ErrorHandler

Definition at line 406 of file schema.h.

template<typename SchemaDocumentType >

typedef SchemaDocumentType::PointerType internal::Schema< SchemaDocumentType >::PointerType

Definition at line 400 of file schema.h.

template<typename SchemaDocumentType >

typedef internal::GenericRegex<EncodingType, AllocatorType> internal::Schema< SchemaDocumentType >::RegexType

private

Definition at line 1074 of file schema.h.

template<typename SchemaDocumentType >

typedef Schema<SchemaDocumentType> internal::Schema< SchemaDocumentType >::SchemaType

Definition at line 404 of file schema.h.

template<typename SchemaDocumentType >

typedef GenericValue<EncodingType, AllocatorType> internal::Schema< SchemaDocumentType >::SValue

Definition at line 405 of file schema.h.

template<typename SchemaDocumentType >

typedef SchemaDocumentType::ValueType internal::Schema< SchemaDocumentType >::ValueType

Definition at line 398 of file schema.h.

Member Enumeration Documentation

template<typename SchemaDocumentType >

enum internal::Schema::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

template<typename SchemaDocumentType >

internal::Schema< SchemaDocumentType >::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),
         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();
 
     }

template<typename SchemaDocumentType >

internal::Schema< SchemaDocumentType >::~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

template<typename SchemaDocumentType >

void internal::Schema< SchemaDocumentType >::AddType ( const ValueType & type )

inlineprivate

Definition at line 1172 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);
     }

template<typename SchemaDocumentType >

template<typename V1 , typename V2 >

void internal::Schema< SchemaDocumentType >::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_);
     }

template<typename SchemaDocumentType >

static void internal::Schema< SchemaDocumentType >::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();
     }

template<typename SchemaDocumentType >

static void internal::Schema< SchemaDocumentType >::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());
     }

template<typename SchemaDocumentType >

void internal::Schema< SchemaDocumentType >::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;
             }
         }
     }

template<typename SchemaDocumentType >

bool internal::Schema< SchemaDocumentType >::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;
     }

template<typename SchemaDocumentType >

bool internal::Schema< SchemaDocumentType >::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);
     }

template<typename SchemaDocumentType >

bool internal::Schema< SchemaDocumentType >::CheckDoubleMaximum	(	Context &	context,
		double	d
	)		const

inlineprivate

Definition at line 1336 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;
     }

template<typename SchemaDocumentType >

bool internal::Schema< SchemaDocumentType >::CheckDoubleMinimum	(	Context &	context,
		double	d
	)		const

inlineprivate

Definition at line 1328 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;
     }

template<typename SchemaDocumentType >

bool internal::Schema< SchemaDocumentType >::CheckDoubleMultipleOf	(	Context &	context,
		double	d
	)		const

inlineprivate

Definition at line 1344 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;
     }

template<typename SchemaDocumentType >

bool internal::Schema< SchemaDocumentType >::CheckInt	(	Context &	context,
		int64_t	i
	)		const

inlineprivate

Definition at line 1232 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;
     }

template<typename SchemaDocumentType >

bool internal::Schema< SchemaDocumentType >::CheckUint	(	Context &	context,
		uint64_t	i
	)		const

inlineprivate

Definition at line 1280 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;
     }

template<typename SchemaDocumentType >

bool internal::Schema< SchemaDocumentType >::CreateParallelValidator ( Context & context ) const

inlineprivate

Definition at line 1182 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;
     }

template<typename SchemaDocumentType >

template<typename ValueType >

RegexType* internal::Schema< SchemaDocumentType >::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;
     }

template<typename SchemaDocumentType >

void internal::Schema< SchemaDocumentType >::CreateSchemaValidators	(	Context &	context,
		const SchemaArray &	schemas
	)		const

inlineprivate

Definition at line 1213 of file schema.h.

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

template<typename SchemaDocumentType >

void internal::Schema< SchemaDocumentType >::DisallowedType	(	Context &	context,
		const ValueType &	actualType
	)		const

inlineprivate

Definition at line 1355 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);
     }

template<typename SchemaDocumentType >

bool internal::Schema< SchemaDocumentType >::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);
     }

template<typename SchemaDocumentType >

bool internal::Schema< SchemaDocumentType >::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;
     }

template<typename SchemaDocumentType >

bool internal::Schema< SchemaDocumentType >::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;
     }

template<typename SchemaDocumentType >

RAPIDJSON_FORCEINLINE bool internal::Schema< SchemaDocumentType >::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;
     }

template<typename SchemaDocumentType >

bool internal::Schema< SchemaDocumentType >::FindPropertyIndex	(	const ValueType &	name,
		SizeType *	outIndex
	)		const

inlineprivate

Definition at line 1219 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;
     }

template<typename SchemaDocumentType >

static const ValueType* internal::Schema< SchemaDocumentType >::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;
     }

template<typename SchemaDocumentType >

const PointerType& internal::Schema< SchemaDocumentType >::GetPointer ( ) const

inline

Definition at line 672 of file schema.h.

                                           {
         return pointer_;
     }

template<typename SchemaDocumentType >

const SValue& internal::Schema< SchemaDocumentType >::GetURI ( ) const

inline

Definition at line 668 of file schema.h.

                                  {
         return uri_;
     }

template<typename SchemaDocumentType >

bool internal::Schema< SchemaDocumentType >::Int	(	Context &	context,
		int	i
	)		const

inline

Definition at line 801 of file schema.h.

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

template<typename SchemaDocumentType >

bool internal::Schema< SchemaDocumentType >::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);
     }

template<typename SchemaDocumentType >

static bool internal::Schema< SchemaDocumentType >::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);
     }

template<typename SchemaDocumentType >

bool internal::Schema< SchemaDocumentType >::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;
     }

template<typename SchemaDocumentType >

bool internal::Schema< SchemaDocumentType >::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);
     }

template<typename SchemaDocumentType >

bool internal::Schema< SchemaDocumentType >::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);
     }

template<typename SchemaDocumentType >

bool internal::Schema< SchemaDocumentType >::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);
     }

template<typename SchemaDocumentType >

bool internal::Schema< SchemaDocumentType >::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);
     }

template<typename SchemaDocumentType >

bool internal::Schema< SchemaDocumentType >::Uint	(	Context &	context,
		unsigned	u
	)		const

inline

Definition at line 807 of file schema.h.

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

template<typename SchemaDocumentType >

bool internal::Schema< SchemaDocumentType >::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

template<typename SchemaDocumentType >

friend class GenericSchemaDocument< ValueType, AllocatorType >

friend

Definition at line 407 of file schema.h.

Member Data Documentation

template<typename SchemaDocumentType >

bool internal::Schema< SchemaDocumentType >::additionalItems_

private

Definition at line 1426 of file schema.h.

template<typename SchemaDocumentType >

const SchemaType* internal::Schema< SchemaDocumentType >::additionalItemsSchema_

private

Definition at line 1420 of file schema.h.

template<typename SchemaDocumentType >

bool internal::Schema< SchemaDocumentType >::additionalProperties_

private

Definition at line 1415 of file schema.h.

template<typename SchemaDocumentType >

const SchemaType* internal::Schema< SchemaDocumentType >::additionalPropertiesSchema_

private

Definition at line 1409 of file schema.h.

template<typename SchemaDocumentType >

AllocatorType* internal::Schema< SchemaDocumentType >::allocator_

private

Definition at line 1394 of file schema.h.

template<typename SchemaDocumentType >

SchemaArray internal::Schema< SchemaDocumentType >::allOf_

private

Definition at line 1400 of file schema.h.

template<typename SchemaDocumentType >

SchemaArray internal::Schema< SchemaDocumentType >::anyOf_

private

Definition at line 1401 of file schema.h.

template<typename SchemaDocumentType >

SizeType internal::Schema< SchemaDocumentType >::defaultValueLength_

private

Definition at line 1439 of file schema.h.

template<typename SchemaDocumentType >

uint64_t* internal::Schema< SchemaDocumentType >::enum_

private

Definition at line 1398 of file schema.h.

template<typename SchemaDocumentType >

SizeType internal::Schema< SchemaDocumentType >::enumCount_

private

Definition at line 1399 of file schema.h.

template<typename SchemaDocumentType >

bool internal::Schema< SchemaDocumentType >::exclusiveMaximum_

private

Definition at line 1437 of file schema.h.

template<typename SchemaDocumentType >

bool internal::Schema< SchemaDocumentType >::exclusiveMinimum_

private

Definition at line 1436 of file schema.h.

template<typename SchemaDocumentType >

bool internal::Schema< SchemaDocumentType >::hasDependencies_

private

Definition at line 1416 of file schema.h.

template<typename SchemaDocumentType >

bool internal::Schema< SchemaDocumentType >::hasRequired_

private

Definition at line 1417 of file schema.h.

template<typename SchemaDocumentType >

bool internal::Schema< SchemaDocumentType >::hasSchemaDependencies_

private

Definition at line 1418 of file schema.h.

template<typename SchemaDocumentType >

const SchemaType* internal::Schema< SchemaDocumentType >::itemsList_

private

Definition at line 1421 of file schema.h.

template<typename SchemaDocumentType >

const SchemaType** internal::Schema< SchemaDocumentType >::itemsTuple_

private

Definition at line 1422 of file schema.h.

template<typename SchemaDocumentType >

SizeType internal::Schema< SchemaDocumentType >::itemsTupleCount_

private

Definition at line 1423 of file schema.h.

template<typename SchemaDocumentType >

SValue internal::Schema< SchemaDocumentType >::maximum_

private

Definition at line 1434 of file schema.h.

template<typename SchemaDocumentType >

SizeType internal::Schema< SchemaDocumentType >::maxItems_

private

Definition at line 1425 of file schema.h.

template<typename SchemaDocumentType >

SizeType internal::Schema< SchemaDocumentType >::maxLength_

private

Definition at line 1431 of file schema.h.

template<typename SchemaDocumentType >

SizeType internal::Schema< SchemaDocumentType >::maxProperties_

private

Definition at line 1414 of file schema.h.

template<typename SchemaDocumentType >

SValue internal::Schema< SchemaDocumentType >::minimum_

private

Definition at line 1433 of file schema.h.

template<typename SchemaDocumentType >

SizeType internal::Schema< SchemaDocumentType >::minItems_

private

Definition at line 1424 of file schema.h.

template<typename SchemaDocumentType >

SizeType internal::Schema< SchemaDocumentType >::minLength_

private

Definition at line 1430 of file schema.h.

template<typename SchemaDocumentType >

SizeType internal::Schema< SchemaDocumentType >::minProperties_

private

Definition at line 1413 of file schema.h.

template<typename SchemaDocumentType >

SValue internal::Schema< SchemaDocumentType >::multipleOf_

private

Definition at line 1435 of file schema.h.

template<typename SchemaDocumentType >

const SchemaType* internal::Schema< SchemaDocumentType >::not_

private

Definition at line 1403 of file schema.h.

template<typename SchemaDocumentType >

SizeType internal::Schema< SchemaDocumentType >::notValidatorIndex_

private

Definition at line 1406 of file schema.h.

template<typename SchemaDocumentType >

SchemaArray internal::Schema< SchemaDocumentType >::oneOf_

private

Definition at line 1402 of file schema.h.

template<typename SchemaDocumentType >

RegexType* internal::Schema< SchemaDocumentType >::pattern_

private

Definition at line 1429 of file schema.h.

template<typename SchemaDocumentType >

PatternProperty* internal::Schema< SchemaDocumentType >::patternProperties_

private

Definition at line 1410 of file schema.h.

template<typename SchemaDocumentType >

SizeType internal::Schema< SchemaDocumentType >::patternPropertyCount_

private

Definition at line 1411 of file schema.h.

template<typename SchemaDocumentType >

PointerType internal::Schema< SchemaDocumentType >::pointer_

private

Definition at line 1396 of file schema.h.

template<typename SchemaDocumentType >

Property* internal::Schema< SchemaDocumentType >::properties_

private

Definition at line 1408 of file schema.h.

template<typename SchemaDocumentType >

SizeType internal::Schema< SchemaDocumentType >::propertyCount_

private

Definition at line 1412 of file schema.h.

template<typename SchemaDocumentType >

unsigned internal::Schema< SchemaDocumentType >::type_

private

Definition at line 1404 of file schema.h.

template<typename SchemaDocumentType >

const SchemaType* internal::Schema< SchemaDocumentType >::typeless_

private

Definition at line 1397 of file schema.h.

template<typename SchemaDocumentType >

bool internal::Schema< SchemaDocumentType >::uniqueItems_

private

Definition at line 1427 of file schema.h.

template<typename SchemaDocumentType >

SValue internal::Schema< SchemaDocumentType >::uri_

private

Definition at line 1395 of file schema.h.

template<typename SchemaDocumentType >

SizeType internal::Schema< SchemaDocumentType >::validatorCount_

private

Definition at line 1405 of file schema.h.

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

art/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

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation

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