libs/xerces-static/xercesc/validators/schema/SchemaElementDecl.hpp
/*
* 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: SchemaElementDecl.hpp 676911 2008-07-15 13:27:32Z amassari $
*/
#if !defined(XERCESC_INCLUDE_GUARD_SCHEMAELEMENTDECL_HPP)
#define XERCESC_INCLUDE_GUARD_SCHEMAELEMENTDECL_HPP
#include <xercesc/util/QName.hpp>
#include <xercesc/validators/common/Grammar.hpp>
#include <xercesc/validators/schema/ComplexTypeInfo.hpp>
#include <xercesc/validators/schema/identity/IdentityConstraint.hpp>
#include <xercesc/validators/datatype/DatatypeValidator.hpp>
#include <xercesc/validators/schema/PSVIDefs.hpp>
XERCES_CPP_NAMESPACE_BEGIN
class ContentSpecNode;
class SchemaAttDefList;
//
// This class is a derivative of the basic element decl. This one implements
// the virtuals so that they work for a Schema.
//
class VALIDATORS_EXPORT SchemaElementDecl : public XMLElementDecl
{
public :
// -----------------------------------------------------------------------
// Class specific types
//
// ModelTypes
// Indicates the type of content model that an element has. This
// indicates how the content model is represented and validated.
// -----------------------------------------------------------------------
enum ModelTypes
{
Empty
, Any
, Mixed_Simple
, Mixed_Complex
, Children
, Simple
, ElementOnlyEmpty
, ModelTypes_Count
};
// -----------------------------------------------------------------------
// Constructors and Destructor
// -----------------------------------------------------------------------
SchemaElementDecl(MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);
SchemaElementDecl
(
const XMLCh* const prefix
, const XMLCh* const localPart
, const int uriId
, const ModelTypes modelType = Any
, const unsigned int enclosingScope = Grammar::TOP_LEVEL_SCOPE
, MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
);
SchemaElementDecl
(
const QName* const elementName
, const ModelTypes modelType = Any
, const unsigned int enclosingScope = Grammar::TOP_LEVEL_SCOPE
, MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
);
~SchemaElementDecl();
// -----------------------------------------------------------------------
// The virtual element decl interface
// -----------------------------------------------------------------------
virtual XMLAttDefList& getAttDefList() const;
virtual CharDataOpts getCharDataOpts() const;
virtual bool hasAttDefs() const;
virtual const ContentSpecNode* getContentSpec() const;
virtual ContentSpecNode* getContentSpec();
virtual void setContentSpec(ContentSpecNode* toAdopt);
virtual XMLContentModel* getContentModel();
virtual void setContentModel(XMLContentModel* const newModelToAdopt);
virtual const XMLCh* getFormattedContentModel () const;
// -----------------------------------------------------------------------
// Getter methods
// -----------------------------------------------------------------------
const SchemaAttDef* getAttDef(const XMLCh* const baseName, const int uriId) const;
SchemaAttDef* getAttDef(const XMLCh* const baseName, const int uriId);
const SchemaAttDef* getAttWildCard() const;
SchemaAttDef* getAttWildCard();
ModelTypes getModelType() const;
PSVIDefs::PSVIScope getPSVIScope() const;
DatatypeValidator* getDatatypeValidator() const;
unsigned int getEnclosingScope() const;
int getFinalSet() const;
int getBlockSet() const;
int getMiscFlags() const;
XMLCh* getDefaultValue() const;
ComplexTypeInfo* getComplexTypeInfo() const;
virtual bool isGlobalDecl() const;
SchemaElementDecl* getSubstitutionGroupElem() const;
// -----------------------------------------------------------------------
// Setter methods
// -----------------------------------------------------------------------
void setModelType(const SchemaElementDecl::ModelTypes toSet);
void setPSVIScope(const PSVIDefs::PSVIScope toSet);
void setDatatypeValidator(DatatypeValidator* newDatatypeValidator);
void setEnclosingScope(const unsigned int enclosingScope);
void setFinalSet(const int finalSet);
void setBlockSet(const int blockSet);
void setMiscFlags(const int flags);
void setDefaultValue(const XMLCh* const value);
void setComplexTypeInfo(ComplexTypeInfo* const typeInfo);
void setAttWildCard(SchemaAttDef* const attWildCard);
void setSubstitutionGroupElem(SchemaElementDecl* const elemDecl);
// -----------------------------------------------------------------------
// IC methods
// -----------------------------------------------------------------------
void addIdentityConstraint(IdentityConstraint* const ic);
XMLSize_t getIdentityConstraintCount() const;
IdentityConstraint* getIdentityConstraintAt(XMLSize_t index) const;
/***
* Support for Serialization/De-serialization
***/
DECL_XSERIALIZABLE(SchemaElementDecl)
virtual XMLElementDecl::objectType getObjectType() const;
private :
// -----------------------------------------------------------------------
// Unimplemented constructors and operators
// -----------------------------------------------------------------------
SchemaElementDecl(const SchemaElementDecl&);
SchemaElementDecl& operator=(const SchemaElementDecl&);
// -----------------------------------------------------------------------
// Private data members
//
// fModelType
// The content model type of this element. This tells us what kind
// of content model to create.
//
// fDatatypeValidator
// The DatatypeValidator used to validate this element type.
//
// fEnclosingScope
// The enclosing scope where this element is declared.
//
// fFinalSet
// The value set of the 'final' attribute.
//
// fBlockSet
// The value set of the 'block' attribute.
//
// fMiscFlags
// Stores 'abstract/nullable' values
//
// fDefaultValue
// The defalut/fixed value
//
// fComplexTypeInfo
// Stores complex type information
// (no need to delete - handled by schema grammar)
//
// fAttDefs
// The list of attributes that are faulted in for this element
// when ComplexTypeInfo does not exist. We want to keep track
// of these faulted in attributes to avoid duplicate redundant
// error.
//
// fIdentityConstraints
// Store information about an element identity constraints.
//
// fAttWildCard
// Store wildcard attribute in the case of an element with a type of
// 'anyType'.
//
// fSubstitutionGroupElem
// The substitution group element declaration.
// -----------------------------------------------------------------------
// -----------------------------------------------------------------------
ModelTypes fModelType;
PSVIDefs::PSVIScope fPSVIScope;
unsigned int fEnclosingScope;
int fFinalSet;
int fBlockSet;
int fMiscFlags;
XMLCh* fDefaultValue;
ComplexTypeInfo* fComplexTypeInfo;
RefHash2KeysTableOf<SchemaAttDef>* fAttDefs;
RefVectorOf<IdentityConstraint>* fIdentityConstraints;
SchemaAttDef* fAttWildCard;
SchemaElementDecl* fSubstitutionGroupElem;
DatatypeValidator* fDatatypeValidator;
};
// ---------------------------------------------------------------------------
// SchemaElementDecl: XMLElementDecl virtual interface implementation
// ---------------------------------------------------------------------------
inline ContentSpecNode* SchemaElementDecl::getContentSpec()
{
if (fComplexTypeInfo != 0) {
return fComplexTypeInfo->getContentSpec();
}
return 0;
}
inline const ContentSpecNode* SchemaElementDecl::getContentSpec() const
{
if (fComplexTypeInfo != 0) {
return fComplexTypeInfo->getContentSpec();
}
return 0;
}
inline void
SchemaElementDecl::setContentSpec(ContentSpecNode*)
{
//Handled by complexType
}
inline XMLContentModel* SchemaElementDecl::getContentModel()
{
if (fComplexTypeInfo != 0) {
return fComplexTypeInfo->getContentModel();
}
return 0;
}
inline void
SchemaElementDecl::setContentModel(XMLContentModel* const)
{
//Handled by complexType
}
// ---------------------------------------------------------------------------
// SchemaElementDecl: Getter methods
// ---------------------------------------------------------------------------
inline SchemaElementDecl::ModelTypes SchemaElementDecl::getModelType() const
{
if (fComplexTypeInfo) {
return (SchemaElementDecl::ModelTypes) fComplexTypeInfo->getContentType();
}
return fModelType;
}
inline PSVIDefs::PSVIScope SchemaElementDecl::getPSVIScope() const
{
return fPSVIScope;
}
inline DatatypeValidator* SchemaElementDecl::getDatatypeValidator() const
{
return fDatatypeValidator;
}
inline unsigned int SchemaElementDecl::getEnclosingScope() const
{
return fEnclosingScope;
}
inline int SchemaElementDecl::getFinalSet() const
{
return fFinalSet;
}
inline int SchemaElementDecl::getBlockSet() const
{
return fBlockSet;
}
inline int SchemaElementDecl::getMiscFlags() const
{
return fMiscFlags;
}
inline XMLCh* SchemaElementDecl::getDefaultValue() const
{
return fDefaultValue;
}
inline ComplexTypeInfo* SchemaElementDecl::getComplexTypeInfo() const
{
return fComplexTypeInfo;
}
inline const SchemaAttDef* SchemaElementDecl::getAttWildCard() const {
return fAttWildCard;
}
inline SchemaAttDef* SchemaElementDecl::getAttWildCard() {
return fAttWildCard;
}
inline bool SchemaElementDecl::isGlobalDecl() const {
return (fEnclosingScope == Grammar::TOP_LEVEL_SCOPE);
}
inline SchemaElementDecl*
SchemaElementDecl::getSubstitutionGroupElem() const {
return fSubstitutionGroupElem;
}
// ---------------------------------------------------------------------------
// SchemaElementDecl: Setter methods
// ---------------------------------------------------------------------------
inline void
SchemaElementDecl::setModelType(const SchemaElementDecl::ModelTypes toSet)
{
fModelType = toSet;
}
inline void
SchemaElementDecl::setPSVIScope(const PSVIDefs::PSVIScope toSet)
{
fPSVIScope = toSet;
}
inline void SchemaElementDecl::setDatatypeValidator(DatatypeValidator* newDatatypeValidator)
{
fDatatypeValidator = newDatatypeValidator;
}
inline void SchemaElementDecl::setEnclosingScope(const unsigned int newEnclosingScope)
{
fEnclosingScope = newEnclosingScope;
}
inline void SchemaElementDecl::setFinalSet(const int finalSet)
{
fFinalSet = finalSet;
}
inline void SchemaElementDecl::setBlockSet(const int blockSet)
{
fBlockSet = blockSet;
}
inline void SchemaElementDecl::setMiscFlags(const int flags)
{
fMiscFlags = flags;
}
inline void SchemaElementDecl::setDefaultValue(const XMLCh* const value)
{
if (fDefaultValue) {
getMemoryManager()->deallocate(fDefaultValue);//delete[] fDefaultValue;
}
fDefaultValue = XMLString::replicate(value, getMemoryManager());
}
inline void
SchemaElementDecl::setComplexTypeInfo(ComplexTypeInfo* const typeInfo)
{
fComplexTypeInfo = typeInfo;
}
inline void
SchemaElementDecl::setAttWildCard(SchemaAttDef* const attWildCard) {
if (fAttWildCard)
delete fAttWildCard;
fAttWildCard = attWildCard;
}
inline void
SchemaElementDecl::setSubstitutionGroupElem(SchemaElementDecl* const elemDecl) {
fSubstitutionGroupElem = elemDecl;
}
// ---------------------------------------------------------------------------
// SchemaElementDecl: IC methods
// ---------------------------------------------------------------------------
inline void
SchemaElementDecl::addIdentityConstraint(IdentityConstraint* const ic) {
if (!fIdentityConstraints) {
fIdentityConstraints = new (getMemoryManager()) RefVectorOf<IdentityConstraint>(16, true, getMemoryManager());
}
fIdentityConstraints->addElement(ic);
}
inline XMLSize_t SchemaElementDecl::getIdentityConstraintCount() const {
if (fIdentityConstraints) {
return fIdentityConstraints->size();
}
return 0;
}
inline IdentityConstraint*
SchemaElementDecl::getIdentityConstraintAt(XMLSize_t index) const {
if (fIdentityConstraints) {
return fIdentityConstraints->elementAt(index);
}
return 0;
}
XERCES_CPP_NAMESPACE_END
#endif