XSSimpleTypeDefinition.hpp

Go to the documentation of this file.

/*
 * 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$
 */
 
#if !defined(XERCESC_INCLUDE_GUARD_XSSIMPLETYPEDEFINITION_HPP)
#define XERCESC_INCLUDE_GUARD_XSSIMPLETYPEDEFINITION_HPP
 
#include <xercesc/framework/psvi/XSTypeDefinition.hpp>
 
XERCES_CPP_NAMESPACE_BEGIN
 
// forward declarations
class XSAnnotation;
class XSFacet;
class XSMultiValueFacet;
class DatatypeValidator;
 
class XMLPARSER_EXPORT XSSimpleTypeDefinition : public XSTypeDefinition
{
public:
 
    // Variety definitions
    enum VARIETY {
        VARIETY_ABSENT            = 0,
        VARIETY_ATOMIC            = 1,
        VARIETY_LIST              = 2,
        VARIETY_UNION             = 3
    };
 
    // Facets
    enum FACET {
        FACET_NONE                = 0,
        FACET_LENGTH              = 1,
        FACET_MINLENGTH           = 2,
        FACET_MAXLENGTH           = 4,
        FACET_PATTERN             = 8,
        FACET_WHITESPACE          = 16,
        FACET_MAXINCLUSIVE        = 32,
        FACET_MAXEXCLUSIVE        = 64,
        FACET_MINEXCLUSIVE        = 128,
        FACET_MININCLUSIVE        = 256,
        FACET_TOTALDIGITS         = 512,
        FACET_FRACTIONDIGITS      = 1024,
        FACET_ENUMERATION         = 2048
    };
 
    // possible order relations
    enum ORDERING {
        ORDERED_FALSE             = 0,
        ORDERED_PARTIAL           = 1,
        ORDERED_TOTAL             = 2
    };
 
    //  Constructors and Destructor
    // -----------------------------------------------------------------------
 
    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
    );
 
 
    ~XSSimpleTypeDefinition();
 
    //---------------------
 
    VARIETY getVariety() const;
 
    XSSimpleTypeDefinition *getPrimitiveType();
 
    XSSimpleTypeDefinition *getItemType();
 
    XSSimpleTypeDefinitionList *getMemberTypes() const;
 
    int getDefinedFacets() const;
 
    bool isDefinedFacet(FACET facetName);
 
    int getFixedFacets() const;
 
    bool isFixedFacet(FACET facetName);
 
    const XMLCh *getLexicalFacetValue(FACET facetName);
 
    StringList *getLexicalEnumeration();
 
    StringList *getLexicalPattern();
 
    ORDERING getOrdered() const;
 
    bool getFinite() const;
 
    bool getBounded() const;
 
    bool getNumeric() const;
 
    XSAnnotationList *getAnnotations();
    XSFacetList *getFacets();
    
    XSMultiValueFacetList *getMultiValueFacets();
    
    const XMLCh* getName() const;
 
    const XMLCh* getNamespace() const;
 
    XSNamespaceItem *getNamespaceItem();
 
    bool getAnonymous() const;
 
    XSTypeDefinition *getBaseType();
 
    bool derivedFromType(const XSTypeDefinition* const ancestorType);
 
    inline DatatypeValidator* getDatatypeValidator() const;
 
 
    //----------------------------------
 
 
 
private:
 
    // -----------------------------------------------------------------------
    //  Unimplemented constructors and operators
    // -----------------------------------------------------------------------
    XSSimpleTypeDefinition(const XSSimpleTypeDefinition&);
    XSSimpleTypeDefinition & operator=(const XSSimpleTypeDefinition &);
 
    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