JSON schema document. More...

#include <fwd.h>

Classes
struct	SchemaEntry

struct	SchemaRefEntry

Public Types
typedef ValueT	ValueType

typedef IGenericRemoteSchemaDocumentProvider< GenericSchemaDocument >	IRemoteSchemaDocumentProviderType

typedef Allocator	AllocatorType

typedef ValueType::EncodingType	EncodingType

typedef EncodingType::Ch	Ch

typedef internal::Schema< GenericSchemaDocument >	SchemaType

typedef GenericPointer< ValueType, Allocator >	PointerType

typedef GenericValue< EncodingType, Allocator >	URIType

Public Member Functions
	GenericSchemaDocument (const ValueType &document, const Ch uri=0, SizeType uriLength=0, IRemoteSchemaDocumentProviderType remoteProvider=0, Allocator *allocator=0)
	Constructor. More...

	~GenericSchemaDocument ()
	Destructor. More...

const URIType &	GetURI () const

const SchemaType &	GetRoot () const
	Get the root schema. More...

Private Member Functions
	GenericSchemaDocument (const GenericSchemaDocument &)
	Prohibit copying. More...

GenericSchemaDocument &	operator= (const GenericSchemaDocument &)
	Prohibit assignment. More...

void	CreateSchemaRecursive (const SchemaType **schema, const PointerType &pointer, const ValueType &v, const ValueType &document)

void	CreateSchema (const SchemaType **schema, const PointerType &pointer, const ValueType &v, const ValueType &document)

bool	HandleRefSchema (const PointerType &source, const SchemaType **schema, const ValueType &v, const ValueType &document)

const SchemaType *	GetSchema (const PointerType &pointer) const

PointerType	GetPointer (const SchemaType *schema) const

const SchemaType *	GetTypeless () const

Private Attributes
IRemoteSchemaDocumentProviderType *	remoteProvider_

Allocator *	allocator_

Allocator *	ownAllocator_

const SchemaType *	root_
	Root schema. More...

SchemaType *	typeless_

internal::Stack< Allocator >	schemaMap_

internal::Stack< Allocator >	schemaRef_

URIType	uri_

Static Private Attributes
static const size_t	kInitialSchemaMapSize = 64

static const size_t	kInitialSchemaRefSize = 64

Friends
class	internal::Schema< GenericSchemaDocument >

template<typename , typename , typename >
class	GenericSchemaValidator

Detailed Description

template<typename ValueT, typename Allocator = CrtAllocator>
class GenericSchemaDocument< ValueT, Allocator >

JSON schema document.

A JSON schema document is a compiled version of a JSON schema. It is basically a tree of internal::Schema.

Note: This is an immutable class (i.e. its instance cannot be modified after construction).

Template Parameters

ValueT	Type of JSON value (e.g. `Value` ), which also determine the encoding.
Allocator	Allocator type for allocating memory of this document.

Definition at line 136 of file fwd.h.

Member Typedef Documentation

template<typename ValueT , typename Allocator = CrtAllocator>

typedef Allocator GenericSchemaDocument< ValueT, Allocator >::AllocatorType

Definition at line 1503 of file schema.h.

template<typename ValueT , typename Allocator = CrtAllocator>

typedef EncodingType::Ch GenericSchemaDocument< ValueT, Allocator >::Ch

Definition at line 1505 of file schema.h.

template<typename ValueT , typename Allocator = CrtAllocator>

typedef ValueType::EncodingType GenericSchemaDocument< ValueT, Allocator >::EncodingType

Definition at line 1504 of file schema.h.

template<typename ValueT , typename Allocator = CrtAllocator>

typedef IGenericRemoteSchemaDocumentProvider<GenericSchemaDocument> GenericSchemaDocument< ValueT, Allocator >::IRemoteSchemaDocumentProviderType

Definition at line 1502 of file schema.h.

template<typename ValueT , typename Allocator = CrtAllocator>

typedef GenericPointer<ValueType, Allocator> GenericSchemaDocument< ValueT, Allocator >::PointerType

Definition at line 1507 of file schema.h.

template<typename ValueT , typename Allocator = CrtAllocator>

typedef internal::Schema<GenericSchemaDocument> GenericSchemaDocument< ValueT, Allocator >::SchemaType

Definition at line 1506 of file schema.h.

template<typename ValueT , typename Allocator = CrtAllocator>

typedef GenericValue<EncodingType, Allocator> GenericSchemaDocument< ValueT, Allocator >::URIType

Definition at line 1508 of file schema.h.

template<typename ValueT , typename Allocator = CrtAllocator>

typedef ValueT GenericSchemaDocument< ValueT, Allocator >::ValueType

Definition at line 1501 of file schema.h.

Constructor & Destructor Documentation

template<typename ValueT , typename Allocator = CrtAllocator>

GenericSchemaDocument< ValueT, Allocator >::GenericSchemaDocument	(	const ValueType &	document,
		const Ch *	uri = `0`,
		SizeType	uriLength = `0`,
		IRemoteSchemaDocumentProviderType *	remoteProvider = `0`,
		Allocator *	allocator = `0`
	)

inlineexplicit

Constructor.

Compile a JSON document into schema document.

Parameters

document	A JSON document as source.
uri	The base URI of this schema document for purposes of violation reporting.
uriLength	Length of `name`, in code points.
remoteProvider	An optional remote schema document provider for resolving remote reference. Can be null.
allocator	An optional allocator instance for allocating memory. Can be null.

Definition at line 1523 of file schema.h.

                                                                                          :
         remoteProvider_(remoteProvider),
         allocator_(allocator),
         ownAllocator_(),
         root_(),
         typeless_(),
         schemaMap_(allocator, kInitialSchemaMapSize),
         schemaRef_(allocator, kInitialSchemaRefSize)
     {
         if (!allocator_)
             ownAllocator_ = allocator_ = RAPIDJSON_NEW(Allocator)();
 
         Ch noUri[1] = {0};
         uri_.SetString(uri ? uri : noUri, uriLength, *allocator_);
 
         typeless_ = static_cast<SchemaType*>(allocator_->Malloc(sizeof(SchemaType)));
         new (typeless_) SchemaType(this, PointerType(), ValueType(kObjectType).Move(), ValueType(kObjectType).Move(), allocator_);
 
         // Generate root schema, it will call CreateSchema() to create sub-schemas,
         // And call AddRefSchema() if there are $ref.
         CreateSchemaRecursive(&root_, PointerType(), document, document);
 
         // Resolve $ref
         while (!schemaRef_.Empty()) {
             SchemaRefEntry* refEntry = schemaRef_.template Pop<SchemaRefEntry>(1);
             if (const SchemaType* s = GetSchema(refEntry->target)) {
                 if (refEntry->schema)
                     *refEntry->schema = s;
 
                 // Create entry in map if not exist
                 if (!GetSchema(refEntry->source)) {
                     new (schemaMap_.template Push<SchemaEntry>()) SchemaEntry(refEntry->source, const_cast<SchemaType*>(s), false, allocator_);
                 }
             }
             else if (refEntry->schema)
                 *refEntry->schema = typeless_;
 
             refEntry->~SchemaRefEntry();
         }
 
         RAPIDJSON_ASSERT(root_ != 0);
 
         schemaRef_.ShrinkToFit(); // Deallocate all memory for ref
     }

template<typename ValueT , typename Allocator = CrtAllocator>

GenericSchemaDocument< ValueT, Allocator >::~GenericSchemaDocument ( )

inline

Destructor.

Definition at line 1589 of file schema.h.

                              {
         while (!schemaMap_.Empty())
             schemaMap_.template Pop<SchemaEntry>(1)->~SchemaEntry();
 
         if (typeless_) {
             typeless_->~SchemaType();
             Allocator::Free(typeless_);
         }
 
         RAPIDJSON_DELETE(ownAllocator_);
     }

template<typename ValueT , typename Allocator = CrtAllocator>

GenericSchemaDocument< ValueT, Allocator >::GenericSchemaDocument ( const GenericSchemaDocument< ValueT, Allocator > & )

private

Prohibit copying.

Member Function Documentation

template<typename ValueT , typename Allocator = CrtAllocator>

void GenericSchemaDocument< ValueT, Allocator >::CreateSchema	(	const SchemaType **	schema,
		const PointerType &	pointer,
		const ValueType &	v,
		const ValueType &	document
	)

inlineprivate

Definition at line 1649 of file schema.h.

                                                                                                                             {
         RAPIDJSON_ASSERT(pointer.IsValid());
         if (v.IsObject()) {
             if (!HandleRefSchema(pointer, schema, v, document)) {
                 SchemaType* s = new (allocator_->Malloc(sizeof(SchemaType))) SchemaType(this, pointer, v, document, allocator_);
                 new (schemaMap_.template Push<SchemaEntry>()) SchemaEntry(pointer, s, true, allocator_);
                 if (schema)
                     *schema = s;
             }
         }
     }

template<typename ValueT , typename Allocator = CrtAllocator>

void GenericSchemaDocument< ValueT, Allocator >::CreateSchemaRecursive	(	const SchemaType **	schema,
		const PointerType &	pointer,
		const ValueType &	v,
		const ValueType &	document
	)

inlineprivate

Definition at line 1632 of file schema.h.

                                                                                                                                      {
         if (schema)
             *schema = typeless_;
 
         if (v.GetType() == kObjectType) {
             const SchemaType* s = GetSchema(pointer);
             if (!s)
                 CreateSchema(schema, pointer, v, document);
 
             for (typename ValueType::ConstMemberIterator itr = v.MemberBegin(); itr != v.MemberEnd(); ++itr)
                 CreateSchemaRecursive(0, pointer.Append(itr->name, allocator_), itr->value, document);
         }
         else if (v.GetType() == kArrayType)
             for (SizeType i = 0; i < v.Size(); i++)
                 CreateSchemaRecursive(0, pointer.Append(i, allocator_), v[i], document);
     }

template<typename ValueT , typename Allocator = CrtAllocator>

PointerType GenericSchemaDocument< ValueT, Allocator >::GetPointer ( const SchemaType * schema ) const

inlineprivate

Definition at line 1715 of file schema.h.

                                                            {
         for (const SchemaEntry* target = schemaMap_.template Bottom<SchemaEntry>(); target != schemaMap_.template End<SchemaEntry>(); ++target)
             if (schema == target->schema)
                 return target->pointer;
         return PointerType();
     }

template<typename ValueT , typename Allocator = CrtAllocator>

const SchemaType& GenericSchemaDocument< ValueT, Allocator >::GetRoot ( ) const

inline

Get the root schema.

Definition at line 1604 of file schema.h.

1604 { return *root_; }

GenericSchemaDocument::root_

const SchemaType * root_

Root schema.

Definition: schema.h:1730

template<typename ValueT , typename Allocator = CrtAllocator>

const SchemaType* GenericSchemaDocument< ValueT, Allocator >::GetSchema ( const PointerType & pointer ) const

inlineprivate

Definition at line 1708 of file schema.h.

                                                                   {
         for (const SchemaEntry* target = schemaMap_.template Bottom<SchemaEntry>(); target != schemaMap_.template End<SchemaEntry>(); ++target)
             if (pointer == target->pointer)
                 return target->schema;
         return 0;
     }

template<typename ValueT , typename Allocator = CrtAllocator>

const SchemaType* GenericSchemaDocument< ValueT, Allocator >::GetTypeless ( ) const

inlineprivate

Definition at line 1722 of file schema.h.

1722 { return typeless_; }

GenericSchemaDocument::typeless_

SchemaType * typeless_

Definition: schema.h:1731

template<typename ValueT , typename Allocator = CrtAllocator>

const URIType& GenericSchemaDocument< ValueT, Allocator >::GetURI ( ) const

inline

Definition at line 1601 of file schema.h.

1601 { return uri_; }

GenericSchemaDocument::uri_

URIType uri_

Definition: schema.h:1734

template<typename ValueT , typename Allocator = CrtAllocator>

bool GenericSchemaDocument< ValueT, Allocator >::HandleRefSchema	(	const PointerType &	source,
		const SchemaType **	schema,
		const ValueType &	v,
		const ValueType &	document
	)

inlineprivate

Definition at line 1661 of file schema.h.

                                                                                                                               {
         static const Ch kRefString[] = { '$', 'r', 'e', 'f', '\0' };
         static const ValueType kRefValue(kRefString, 4);
 
         typename ValueType::ConstMemberIterator itr = v.FindMember(kRefValue);
         if (itr == v.MemberEnd())
             return false;
 
         if (itr->value.IsString()) {
             SizeType len = itr->value.GetStringLength();
             if (len > 0) {
                 const Ch* s = itr->value.GetString();
                 SizeType i = 0;
                 while (i < len && s[i] != '#') // Find the first #
                     i++;
 
                 if (i > 0) { // Remote reference, resolve immediately
                     if (remoteProvider_) {
                         if (const GenericSchemaDocument* remoteDocument = remoteProvider_->GetRemoteDocument(s, i)) {
                             PointerType pointer(&s[i], len - i, allocator_);
                             if (pointer.IsValid()) {
                                 if (const SchemaType* sc = remoteDocument->GetSchema(pointer)) {
                                     if (schema)
                                         *schema = sc;
                                     new (schemaMap_.template Push<SchemaEntry>()) SchemaEntry(source, const_cast<SchemaType*>(sc), false, allocator_);
                                     return true;
                                 }
                             }
                         }
                     }
                 }
                 else if (s[i] == '#') { // Local reference, defer resolution
                     PointerType pointer(&s[i], len - i, allocator_);
                     if (pointer.IsValid()) {
                         if (const ValueType* nv = pointer.Get(document))
                             if (HandleRefSchema(source, schema, *nv, document))
                                 return true;
 
                         new (schemaRef_.template Push<SchemaRefEntry>()) SchemaRefEntry(source, pointer, schema, allocator_);
                         return true;
                     }
                 }
             }
         }
         return false;
     }

template<typename ValueT , typename Allocator = CrtAllocator>

GenericSchemaDocument& GenericSchemaDocument< ValueT, Allocator >::operator= ( const GenericSchemaDocument< ValueT, Allocator > & )

private

Prohibit assignment.

Friends And Related Function Documentation

template<typename ValueT , typename Allocator = CrtAllocator>

template<typename , typename , typename >

friend class GenericSchemaValidator

friend

Definition at line 1511 of file schema.h.

template<typename ValueT , typename Allocator = CrtAllocator>

friend class internal::Schema< GenericSchemaDocument >

friend

Definition at line 1509 of file schema.h.

Member Data Documentation

template<typename ValueT , typename Allocator = CrtAllocator>

Allocator* GenericSchemaDocument< ValueT, Allocator >::allocator_

private

Definition at line 1728 of file schema.h.

template<typename ValueT , typename Allocator = CrtAllocator>

const size_t GenericSchemaDocument< ValueT, Allocator >::kInitialSchemaMapSize = 64

staticprivate

Definition at line 1724 of file schema.h.

template<typename ValueT , typename Allocator = CrtAllocator>

const size_t GenericSchemaDocument< ValueT, Allocator >::kInitialSchemaRefSize = 64

staticprivate

Definition at line 1725 of file schema.h.

template<typename ValueT , typename Allocator = CrtAllocator>

Allocator* GenericSchemaDocument< ValueT, Allocator >::ownAllocator_

private

Definition at line 1729 of file schema.h.

template<typename ValueT , typename Allocator = CrtAllocator>

IRemoteSchemaDocumentProviderType* GenericSchemaDocument< ValueT, Allocator >::remoteProvider_

private

Definition at line 1727 of file schema.h.

template<typename ValueT , typename Allocator = CrtAllocator>

const SchemaType* GenericSchemaDocument< ValueT, Allocator >::root_

private

Root schema.

Definition at line 1730 of file schema.h.

template<typename ValueT , typename Allocator = CrtAllocator>

internal::Stack<Allocator> GenericSchemaDocument< ValueT, Allocator >::schemaMap_

private

Definition at line 1732 of file schema.h.

template<typename ValueT , typename Allocator = CrtAllocator>

internal::Stack<Allocator> GenericSchemaDocument< ValueT, Allocator >::schemaRef_

private

Definition at line 1733 of file schema.h.

template<typename ValueT , typename Allocator = CrtAllocator>

SchemaType* GenericSchemaDocument< ValueT, Allocator >::typeless_

private

Definition at line 1731 of file schema.h.

template<typename ValueT , typename Allocator = CrtAllocator>

URIType GenericSchemaDocument< ValueT, Allocator >::uri_

private

Definition at line 1734 of file schema.h.

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

art/rapidjson/fwd.h
art/rapidjson/schema.h

Classes

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Static Private Attributes

Friends

Detailed Description

template<typename ValueT, typename Allocator = CrtAllocator> class GenericSchemaDocument< ValueT, Allocator >

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation

template<typename ValueT, typename Allocator = CrtAllocator>
class GenericSchemaDocument< ValueT, Allocator >