GenericSchemaDocument< ValueT, Allocator >

JSON schema document. More...

#include <fwd.h>

Collaboration diagram for GenericSchemaDocument< ValueT, Allocator >:

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

AllocatorType

typedef Allocator AllocatorType

Definition at line 1505 of file schema.h.

Ch

typedef EncodingType::Ch Ch

Definition at line 1507 of file schema.h.

EncodingType

typedef ValueType::EncodingType EncodingType

Definition at line 1506 of file schema.h.

IRemoteSchemaDocumentProviderType

typedef IGenericRemoteSchemaDocumentProvider<GenericSchemaDocument> IRemoteSchemaDocumentProviderType

Definition at line 1504 of file schema.h.

PointerType

typedef GenericPointer<ValueType, Allocator> PointerType

Definition at line 1509 of file schema.h.

SchemaType

typedef internal::Schema<GenericSchemaDocument> SchemaType

Definition at line 1508 of file schema.h.

URIType

typedef GenericValue<EncodingType, Allocator> URIType

Definition at line 1510 of file schema.h.

ValueType

typedef ValueT ValueType

Definition at line 1503 of file schema.h.

Constructor & Destructor Documentation

GenericSchemaDocument() [1/2]

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 1525 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
    }

~GenericSchemaDocument()

~GenericSchemaDocument ( )

inline

Destructor.

Definition at line 1591 of file schema.h.

                             {
        while (!schemaMap_.Empty())
            schemaMap_.template Pop<SchemaEntry>(1)->~SchemaEntry();

        if (typeless_) {
            typeless_->~SchemaType();
            Allocator::Free(typeless_);
        }

        RAPIDJSON_DELETE(ownAllocator_);
    }

GenericSchemaDocument() [2/2]

GenericSchemaDocument ( const GenericSchemaDocument< ValueT, Allocator > &  )

private

Prohibit copying.

Member Function Documentation

CreateSchema()

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

inlineprivate

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

CreateSchemaRecursive()

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

inlineprivate

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

Here is the call graph for this function:

GetPointer()

PointerType GetPointer ( const SchemaType *  schema ) const

inlineprivate

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

GetRoot()

const SchemaType& GetRoot ( ) const

inline

Get the root schema.

Definition at line 1606 of file schema.h.

{ return *root_; }

GetSchema()

const SchemaType* GetSchema ( const PointerType &  pointer ) const

inlineprivate

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

GetTypeless()

const SchemaType* GetTypeless ( ) const

inlineprivate

Definition at line 1724 of file schema.h.

{ return typeless_; }

GetURI()

const URIType& GetURI ( ) const

inline

Definition at line 1603 of file schema.h.

{ return uri_; }

HandleRefSchema()

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

inlineprivate

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

operator=()

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

private

Prohibit assignment.

Friends And Related Function Documentation

GenericSchemaValidator

friend class GenericSchemaValidator

friend

Definition at line 1513 of file schema.h.

internal::Schema< GenericSchemaDocument >

friend class internal::Schema< GenericSchemaDocument >

friend

Definition at line 1511 of file schema.h.

Member Data Documentation

allocator_

Allocator* allocator_

private

Definition at line 1730 of file schema.h.

kInitialSchemaMapSize

const size_t kInitialSchemaMapSize = 64

staticprivate

Definition at line 1726 of file schema.h.

kInitialSchemaRefSize

const size_t kInitialSchemaRefSize = 64

staticprivate

Definition at line 1727 of file schema.h.

ownAllocator_

Allocator* ownAllocator_

private

Definition at line 1731 of file schema.h.

remoteProvider_

IRemoteSchemaDocumentProviderType* remoteProvider_

private

Definition at line 1729 of file schema.h.

root_

const SchemaType* root_

private

Root schema.

Definition at line 1732 of file schema.h.

schemaMap_

internal::Stack<Allocator> schemaMap_

private

Definition at line 1734 of file schema.h.

schemaRef_

internal::Stack<Allocator> schemaRef_

private

Definition at line 1735 of file schema.h.

typeless_

SchemaType* typeless_

private

Definition at line 1733 of file schema.h.

uri_

URIType uri_

private

Definition at line 1736 of file schema.h.

---

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

• rapidjson/fwd.h
• rapidjson/schema.h