| /* |
| * 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: XSSimpleTypeDefinition.hpp 568078 2007-08-21 11:43:25Z amassari $ |
| */ |
| |
| #if !defined(XSSIMPLETYPEDEFINITION_HPP) |
| #define XSSIMPLETYPEDEFINITION_HPP |
| |
| #include <xercesc/framework/psvi/XSTypeDefinition.hpp> |
| |
| XERCES_CPP_NAMESPACE_BEGIN |
| |
| /** |
| * This class represents a simpleType definition |
| * schema component. |
| * This is *always* owned by the validator /parser object from which |
| * it is obtained. |
| * |
| */ |
| |
| // forward declarations |
| class XSAnnotation; |
| class XSFacet; |
| class XSMultiValueFacet; |
| class DatatypeValidator; |
| |
| class XMLPARSER_EXPORT XSSimpleTypeDefinition : public XSTypeDefinition |
| { |
| public: |
| |
| // Variety definitions |
| enum VARIETY { |
| /** |
| * The variety is absent for the anySimpleType definition. |
| */ |
| VARIETY_ABSENT = 0, |
| /** |
| * <code>Atomic</code> type. |
| */ |
| VARIETY_ATOMIC = 1, |
| /** |
| * <code>List</code> type. |
| */ |
| VARIETY_LIST = 2, |
| /** |
| * <code>Union</code> type. |
| */ |
| VARIETY_UNION = 3 |
| }; |
| |
| // Facets |
| enum FACET { |
| /** |
| * No facets defined. |
| */ |
| FACET_NONE = 0, |
| /** |
| * 4.3.1 Length |
| */ |
| FACET_LENGTH = 1, |
| /** |
| * 4.3.2 minLength. |
| */ |
| FACET_MINLENGTH = 2, |
| /** |
| * 4.3.3 maxLength. |
| */ |
| FACET_MAXLENGTH = 4, |
| /** |
| * 4.3.4 pattern. |
| */ |
| FACET_PATTERN = 8, |
| /** |
| * 4.3.5 whitespace. |
| */ |
| FACET_WHITESPACE = 16, |
| /** |
| * 4.3.7 maxInclusive. |
| */ |
| FACET_MAXINCLUSIVE = 32, |
| /** |
| * 4.3.9 maxExclusive. |
| */ |
| FACET_MAXEXCLUSIVE = 64, |
| /** |
| * 4.3.9 minExclusive. |
| */ |
| FACET_MINEXCLUSIVE = 128, |
| /** |
| * 4.3.10 minInclusive. |
| */ |
| FACET_MININCLUSIVE = 256, |
| /** |
| * 4.3.11 totalDigits . |
| */ |
| FACET_TOTALDIGITS = 512, |
| /** |
| * 4.3.12 fractionDigits. |
| */ |
| FACET_FRACTIONDIGITS = 1024, |
| /** |
| * 4.3.5 enumeration. |
| */ |
| FACET_ENUMERATION = 2048 |
| }; |
| |
| // possible order relations |
| enum ORDERING { |
| /** |
| * A constant defined for the 'ordered' fundamental facet: Not ordered. |
| */ |
| ORDERED_FALSE = 0, |
| /** |
| * A constant defined for the 'ordered' fundamental facet: partially |
| * ordered. |
| */ |
| ORDERED_PARTIAL = 1, |
| /** |
| * A constant defined for the 'ordered' fundamental facet: total ordered. |
| */ |
| ORDERED_TOTAL = 2 |
| }; |
| |
| // Constructors and Destructor |
| // ----------------------------------------------------------------------- |
| /** @name Constructors */ |
| //@{ |
| |
| /** |
| * The default constructor |
| * |
| * @param datatypeValidator |
| * @param stVariety |
| * @param xsBaseType |
| * @param primitiveOrItemType |
| * @param memberTypes |
| * @param headAnnot |
| * @param xsModel |
| * @param manager The configurable memory manager |
| */ |
| XSSimpleTypeDefinition |
| ( |
| DatatypeValidator* const datatypeValidator |
| , VARIETY stVariety |
| , XSTypeDefinition* const xsBaseType |
| , XSSimpleTypeDefinition* const primitiveOrItemType |
| , XSSimpleTypeDefinitionList* const memberTypes |
| , XSAnnotation* headAnnot |
| , XSModel* const xsModel |
| , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager |
| ); |
| |
| //@}; |
| |
| /** @name Destructor */ |
| //@{ |
| ~XSSimpleTypeDefinition(); |
| //@} |
| |
| //--------------------- |
| /** @name XSSimpleTypeDefinition methods */ |
| |
| //@{ |
| |
| /** |
| * [variety]: one of {atomic, list, union} or absent |
| */ |
| VARIETY getVariety() const; |
| |
| /** |
| * If variety is <code>atomic</code> the primitive type definition (a |
| * built-in primitive datatype definition or the simple ur-type |
| * definition) is available, otherwise <code>null</code>. |
| */ |
| XSSimpleTypeDefinition *getPrimitiveType(); |
| |
| /** |
| * If variety is <code>list</code> the item type definition (an atomic or |
| * union simple type definition) is available, otherwise |
| * <code>null</code>. |
| */ |
| XSSimpleTypeDefinition *getItemType(); |
| |
| /** |
| * If variety is <code>union</code> the list of member type definitions (a |
| * non-empty sequence of simple type definitions) is available, |
| * otherwise <code>null</code>. |
| */ |
| XSSimpleTypeDefinitionList *getMemberTypes() const; |
| |
| /** |
| * [facets]: get all facets defined on this type. The value is a bit |
| * combination of FACET_XXX constants of all defined facets. |
| */ |
| int getDefinedFacets() const; |
| |
| /** |
| * Convenience method. [Facets]: check whether a facet is defined on this |
| * type. |
| * @param facetName The name of the facet. |
| * @return True if the facet is defined, false otherwise. |
| */ |
| bool isDefinedFacet(FACET facetName); |
| |
| /** |
| * [facets]: get all facets defined and fixed on this type. |
| */ |
| int getFixedFacets() const; |
| |
| /** |
| * Convenience method. [Facets]: check whether a facet is defined and |
| * fixed on this type. |
| * @param facetName The name of the facet. |
| * @return True if the facet is fixed, false otherwise. |
| */ |
| bool isFixedFacet(FACET facetName); |
| |
| /** |
| * Convenience method. Returns a value of a single constraining facet for |
| * this simple type definition. This method must not be used to retrieve |
| * values for <code>enumeration</code> and <code>pattern</code> facets. |
| * @param facetName The name of the facet, i.e. |
| * <code>FACET_LENGTH, FACET_TOTALDIGITS </code> (see |
| * <code>XSConstants</code>).To retrieve value for pattern or |
| * enumeration, see <code>enumeration</code> and <code>pattern</code>. |
| * @return A value of the facet specified in <code>facetName</code> for |
| * this simple type definition or <code>null</code>. |
| */ |
| const XMLCh *getLexicalFacetValue(FACET facetName); |
| |
| /** |
| * Returns a list of enumeration values. |
| */ |
| StringList *getLexicalEnumeration(); |
| |
| /** |
| * Returns a list of pattern values. |
| */ |
| StringList *getLexicalPattern(); |
| |
| /** |
| * Fundamental Facet: ordered |
| */ |
| ORDERING getOrdered() const; |
| |
| /** |
| * Fundamental Facet: cardinality. |
| */ |
| bool getFinite() const; |
| |
| /** |
| * Fundamental Facet: bounded. |
| */ |
| bool getBounded() const; |
| |
| /** |
| * Fundamental Facet: numeric. |
| */ |
| bool getNumeric() const; |
| |
| /** |
| * Optional. A set of [annotation]s. |
| */ |
| XSAnnotationList *getAnnotations(); |
| /** |
| * @return list of constraining facets. |
| * This method must not be used to retrieve |
| * values for <code>enumeration</code> and <code>pattern</code> facets. |
| */ |
| XSFacetList *getFacets(); |
| |
| /** |
| * @return list of enumeration and pattern facets. |
| */ |
| XSMultiValueFacetList *getMultiValueFacets(); |
| |
| /** |
| * The name of type <code>NCName</code> of this declaration as defined in |
| * XML Namespaces. |
| */ |
| const XMLCh* getName(); |
| |
| /** |
| * The [target namespace] of this object, or <code>null</code> if it is |
| * unspecified. |
| */ |
| const XMLCh* getNamespace(); |
| |
| /** |
| * A namespace schema information item corresponding to the target |
| * namespace of the component, if it's globally declared; or null |
| * otherwise. |
| */ |
| XSNamespaceItem *getNamespaceItem(); |
| |
| /** |
| * A boolean that specifies if the type definition is |
| * anonymous. Convenience attribute. |
| */ |
| bool getAnonymous() const; |
| |
| /** |
| * {base type definition}: either a simple type definition or a complex |
| * type definition. |
| */ |
| XSTypeDefinition *getBaseType(); |
| |
| /** |
| * Convenience method: check if this type is derived from the given |
| * <code>ancestorType</code>. |
| * @param ancestorType An ancestor type definition. |
| * @return Return true if this type is derived from |
| * <code>ancestorType</code>. |
| */ |
| bool derivedFromType(const XSTypeDefinition* const ancestorType); |
| |
| /** |
| * |
| */ |
| inline DatatypeValidator* getDatatypeValidator() const; |
| |
| //@} |
| |
| //---------------------------------- |
| /** methods needed by implementation */ |
| |
| //@{ |
| |
| |
| //@} |
| |
| private: |
| |
| // ----------------------------------------------------------------------- |
| // Unimplemented constructors and operators |
| // ----------------------------------------------------------------------- |
| XSSimpleTypeDefinition(const XSSimpleTypeDefinition&); |
| XSSimpleTypeDefinition & operator=(const XSSimpleTypeDefinition &); |
| |
| /** |
| * Helper method for construct |
| */ |
| void setFacetInfo |
| ( |
| int definedFacets |
| , int fixedFacets |
| , XSFacetList* const xsFacetList |
| , XSMultiValueFacetList* const xsMultiValueFacetList |
| , StringList* const patternList |
| ); |
| void setPrimitiveType(XSSimpleTypeDefinition* const toSet); |
| |
| friend class XSObjectFactory; |
| |
| protected: |
| |
| // ----------------------------------------------------------------------- |
| // data members |
| // ----------------------------------------------------------------------- |
| int fDefinedFacets; |
| int fFixedFacets; |
| VARIETY fVariety; |
| DatatypeValidator* fDatatypeValidator; |
| XSFacetList* fXSFacetList; |
| XSMultiValueFacetList* fXSMultiValueFacetList; |
| StringList* fPatternList; |
| XSSimpleTypeDefinition* fPrimitiveOrItemType; |
| XSSimpleTypeDefinitionList* fMemberTypes; |
| XSAnnotationList* fXSAnnotationList; |
| }; |
| |
| inline XSSimpleTypeDefinition::VARIETY XSSimpleTypeDefinition::getVariety() const |
| { |
| return fVariety; |
| } |
| |
| inline XSSimpleTypeDefinition* XSSimpleTypeDefinition::getPrimitiveType() |
| { |
| if (fVariety == VARIETY_ATOMIC) |
| return fPrimitiveOrItemType; |
| |
| return 0; |
| } |
| |
| inline XSSimpleTypeDefinition* XSSimpleTypeDefinition::getItemType() |
| { |
| if (fVariety == VARIETY_LIST) |
| return fPrimitiveOrItemType; |
| |
| return 0; |
| } |
| |
| inline XSSimpleTypeDefinitionList* XSSimpleTypeDefinition::getMemberTypes() const |
| { |
| return fMemberTypes; |
| } |
| |
| inline int XSSimpleTypeDefinition::getDefinedFacets() const |
| { |
| return fDefinedFacets; |
| } |
| |
| inline int XSSimpleTypeDefinition::getFixedFacets() const |
| { |
| return fFixedFacets; |
| } |
| |
| inline StringList* XSSimpleTypeDefinition::getLexicalPattern() |
| { |
| return fPatternList; |
| } |
| |
| inline XSFacetList* XSSimpleTypeDefinition::getFacets() |
| { |
| return fXSFacetList; |
| } |
| |
| inline XSMultiValueFacetList* XSSimpleTypeDefinition::getMultiValueFacets() |
| { |
| return fXSMultiValueFacetList; |
| } |
| |
| inline XSAnnotationList *XSSimpleTypeDefinition::getAnnotations() |
| { |
| return fXSAnnotationList; |
| } |
| |
| inline void |
| XSSimpleTypeDefinition::setPrimitiveType(XSSimpleTypeDefinition* const toSet) |
| { |
| fPrimitiveOrItemType = toSet; |
| } |
| |
| inline DatatypeValidator* |
| XSSimpleTypeDefinition::getDatatypeValidator() const |
| { |
| return fDatatypeValidator; |
| } |
| |
| XERCES_CPP_NAMESPACE_END |
| |
| #endif |
