272 lines
8.2 KiB
C++
272 lines
8.2 KiB
C++
/*
|
|
* Licensed to the Apache Software Foundation (ASF) under one or more
|
|
* contributor license agreements. See the NOTICE file distributed with
|
|
* this work for additional information regarding copyright ownership.
|
|
* The ASF licenses this file to You under the Apache License, Version 2.0
|
|
* (the "License"); you may not use this file except in compliance with
|
|
* the License. You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
/*
|
|
* $Id: GrammarResolver.hpp 527149 2007-04-10 14:56:39Z amassari $
|
|
*/
|
|
|
|
#if !defined(XERCESC_INCLUDE_GUARD_GRAMMARRESOLVER_HPP)
|
|
#define XERCESC_INCLUDE_GUARD_GRAMMARRESOLVER_HPP
|
|
|
|
#include <xercesc/framework/XMLGrammarPool.hpp>
|
|
#include <xercesc/util/RefHashTableOf.hpp>
|
|
#include <xercesc/util/StringPool.hpp>
|
|
#include <xercesc/validators/common/Grammar.hpp>
|
|
|
|
XERCES_CPP_NAMESPACE_BEGIN
|
|
|
|
class DatatypeValidator;
|
|
class DatatypeValidatorFactory;
|
|
class XMLGrammarDescription;
|
|
|
|
/**
|
|
* This class embodies the representation of a Grammar pool Resolver.
|
|
* This class is called from the validator.
|
|
*
|
|
*/
|
|
|
|
class VALIDATORS_EXPORT GrammarResolver : public XMemory
|
|
{
|
|
public:
|
|
|
|
/** @name Constructor and Destructor */
|
|
//@{
|
|
/**
|
|
*
|
|
* Default Constructor
|
|
*/
|
|
GrammarResolver(
|
|
XMLGrammarPool* const gramPool
|
|
, MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
|
|
);
|
|
/**
|
|
* Destructor
|
|
*/
|
|
~GrammarResolver();
|
|
|
|
//@}
|
|
|
|
/** @name Getter methods */
|
|
//@{
|
|
/**
|
|
* Retrieve the DatatypeValidator
|
|
*
|
|
* @param uriStr the namespace URI
|
|
* @param typeName the type name
|
|
* @return the DatatypeValidator associated with namespace & type name
|
|
*/
|
|
DatatypeValidator* getDatatypeValidator(const XMLCh* const uriStr,
|
|
const XMLCh* const typeName);
|
|
|
|
/**
|
|
* Retrieve the DatatypeValidatorFactory used for built-in schema types
|
|
*
|
|
* @return the DatatypeValidator associated with namespace for XMLSchema
|
|
*/
|
|
DatatypeValidatorFactory* getBuiltinDatatypeValidatorFactory();
|
|
|
|
/**
|
|
* Retrieve the grammar that is associated with the specified namespace key
|
|
*
|
|
* @param gramDesc grammar description for the grammar
|
|
* @return Grammar abstraction associated with the grammar description
|
|
*/
|
|
Grammar* getGrammar( XMLGrammarDescription* const gramDesc ) ;
|
|
|
|
/**
|
|
* Retrieve the grammar that is associated with the specified namespace key
|
|
*
|
|
* @param namespaceKey Namespace key into Grammar pool
|
|
* @return Grammar abstraction associated with the NameSpace key.
|
|
*/
|
|
Grammar* getGrammar( const XMLCh* const namespaceKey ) ;
|
|
|
|
/**
|
|
* Get an enumeration of Grammar in the Grammar pool
|
|
*
|
|
* @return enumeration of Grammar in Grammar pool
|
|
*/
|
|
RefHashTableOfEnumerator<Grammar> getGrammarEnumerator() const;
|
|
|
|
/**
|
|
* Get an enumeration of the referenced Grammars
|
|
*
|
|
* @return enumeration of referenced Grammars
|
|
*/
|
|
RefHashTableOfEnumerator<Grammar> getReferencedGrammarEnumerator() const;
|
|
|
|
/**
|
|
* Get an enumeration of the cached Grammars in the Grammar pool
|
|
*
|
|
* @return enumeration of the cached Grammars in Grammar pool
|
|
*/
|
|
RefHashTableOfEnumerator<Grammar> getCachedGrammarEnumerator() const;
|
|
|
|
/**
|
|
* Get a string pool of schema grammar element/attribute names/prefixes
|
|
* (used by TraverseSchema)
|
|
*
|
|
* @return a string pool of schema grammar element/attribute names/prefixes
|
|
*/
|
|
XMLStringPool* getStringPool();
|
|
|
|
/**
|
|
* Is the specified Namespace key in Grammar pool?
|
|
*
|
|
* @param nameSpaceKey Namespace key
|
|
* @return True if Namespace key association is in the Grammar pool.
|
|
*/
|
|
bool containsNameSpace( const XMLCh* const nameSpaceKey );
|
|
|
|
inline XMLGrammarPool* getGrammarPool() const;
|
|
|
|
inline MemoryManager* getGrammarPoolMemoryManager() const;
|
|
|
|
//@}
|
|
|
|
/** @name Setter methods */
|
|
//@{
|
|
|
|
/**
|
|
* Set the 'Grammar caching' flag
|
|
*/
|
|
void cacheGrammarFromParse(const bool newState);
|
|
|
|
/**
|
|
* Set the 'Use cached grammar' flag
|
|
*/
|
|
void useCachedGrammarInParse(const bool newState);
|
|
|
|
//@}
|
|
|
|
|
|
/** @name GrammarResolver methods */
|
|
//@{
|
|
/**
|
|
* Add the Grammar with Namespace Key associated to the Grammar Pool.
|
|
* The Grammar will be owned by the Grammar Pool.
|
|
*
|
|
* @param grammarToAdopt Grammar abstraction used by validator.
|
|
*/
|
|
void putGrammar(Grammar* const grammarToAdopt );
|
|
|
|
/**
|
|
* Returns the Grammar with Namespace Key associated from the Grammar Pool
|
|
* The Key entry is removed from the table (grammar is not deleted if
|
|
* adopted - now owned by caller).
|
|
*
|
|
* @param nameSpaceKey Key to associate with Grammar abstraction
|
|
*/
|
|
Grammar* orphanGrammar(const XMLCh* const nameSpaceKey);
|
|
|
|
/**
|
|
* Cache the grammars in fGrammarBucket to fCachedGrammarRegistry.
|
|
* If a grammar with the same key is already cached, an exception is
|
|
* thrown and none of the grammars will be cached.
|
|
*/
|
|
void cacheGrammars();
|
|
|
|
/**
|
|
* Reset internal Namespace/Grammar registry.
|
|
*/
|
|
void reset();
|
|
void resetCachedGrammar();
|
|
|
|
/**
|
|
* Returns an XSModel, either from the GrammarPool or by creating one
|
|
*/
|
|
XSModel* getXSModel();
|
|
|
|
|
|
ValueVectorOf<SchemaGrammar*>* getGrammarsToAddToXSModel();
|
|
|
|
//@}
|
|
|
|
private:
|
|
// -----------------------------------------------------------------------
|
|
// Unimplemented constructors and operators
|
|
// -----------------------------------------------------------------------
|
|
GrammarResolver(const GrammarResolver&);
|
|
GrammarResolver& operator=(const GrammarResolver&);
|
|
|
|
// -----------------------------------------------------------------------
|
|
// Private data members
|
|
//
|
|
// fStringPool The string pool used by TraverseSchema to store
|
|
// element/attribute names and prefixes.
|
|
// Always owned by Grammar pool implementation
|
|
//
|
|
// fGrammarBucket The parsed Grammar Pool, if no caching option.
|
|
//
|
|
// fGrammarFromPool Referenced Grammar Set, not owned
|
|
//
|
|
// fGrammarPool The Grammar Set either plugged or created.
|
|
//
|
|
// fDataTypeReg DatatypeValidatorFactory registery
|
|
//
|
|
// fMemoryManager Pluggable memory manager for dynamic memory
|
|
// allocation/deallocation
|
|
// -----------------------------------------------------------------------
|
|
bool fCacheGrammar;
|
|
bool fUseCachedGrammar;
|
|
bool fGrammarPoolFromExternalApplication;
|
|
XMLStringPool* fStringPool;
|
|
RefHashTableOf<Grammar>* fGrammarBucket;
|
|
RefHashTableOf<Grammar>* fGrammarFromPool;
|
|
DatatypeValidatorFactory* fDataTypeReg;
|
|
MemoryManager* fMemoryManager;
|
|
XMLGrammarPool* fGrammarPool;
|
|
XSModel* fXSModel;
|
|
XSModel* fGrammarPoolXSModel;
|
|
ValueVectorOf<SchemaGrammar*>* fGrammarsToAddToXSModel;
|
|
};
|
|
|
|
inline XMLStringPool* GrammarResolver::getStringPool() {
|
|
|
|
return fStringPool;
|
|
}
|
|
|
|
|
|
inline void GrammarResolver::useCachedGrammarInParse(const bool aValue)
|
|
{
|
|
fUseCachedGrammar = aValue;
|
|
}
|
|
|
|
inline XMLGrammarPool* GrammarResolver::getGrammarPool() const
|
|
{
|
|
return fGrammarPool;
|
|
}
|
|
|
|
inline MemoryManager* GrammarResolver::getGrammarPoolMemoryManager() const
|
|
{
|
|
return fGrammarPool->getMemoryManager();
|
|
}
|
|
|
|
inline ValueVectorOf<SchemaGrammar*>* GrammarResolver::getGrammarsToAddToXSModel()
|
|
{
|
|
return fGrammarsToAddToXSModel;
|
|
}
|
|
|
|
inline DatatypeValidatorFactory* GrammarResolver::getBuiltinDatatypeValidatorFactory()
|
|
{
|
|
return fDataTypeReg;
|
|
}
|
|
|
|
XERCES_CPP_NAMESPACE_END
|
|
|
|
#endif
|