PSVIItem.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_PSVIITEM_HPP)
#define XERCESC_INCLUDE_GUARD_PSVIITEM_HPP
 
#include <xercesc/util/PlatformUtils.hpp>
 
XERCES_CPP_NAMESPACE_BEGIN
 
// forward declarations
class XSTypeDefinition; 
class XSSimpleTypeDefinition;
class XSValue;
 
class XMLPARSER_EXPORT PSVIItem : public XMemory
{
public:
 
    enum VALIDITY_STATE {
        VALIDITY_NOTKNOWN               = 0,
    
        VALIDITY_INVALID               = 1,
    
        VALIDITY_VALID                 = 2
    };
 
    enum ASSESSMENT_TYPE {
        VALIDATION_NONE                = 0,
    
        VALIDATION_PARTIAL             = 1,
    
        VALIDATION_FULL                = 2
    };
 
    //  Constructors and Destructor
    // -----------------------------------------------------------------------
 
    PSVIItem(MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);
 
 
    virtual ~PSVIItem();
 
    //---------------------
 
    const XMLCh *getValidationContext();
 
    VALIDITY_STATE getValidity() const;
 
    ASSESSMENT_TYPE getValidationAttempted() const;
 
    /***
    const XMLCh ** getErrorCodes();
    ****/
    
    const XMLCh *getSchemaNormalizedValue();
 
    virtual XSTypeDefinition *getTypeDefinition() = 0;
    
    virtual XSSimpleTypeDefinition *getMemberTypeDefinition() = 0;
    
    const XMLCh *getSchemaDefault();
 
    bool getIsSchemaSpecified() const;
 
    const XMLCh *getCanonicalRepresentation() const;
 
 
    virtual XSValue *getActualValue() const;
 
    //----------------------------------
 
    void setValidationAttempted(PSVIItem::ASSESSMENT_TYPE attemptType);
    void setValidity(PSVIItem::VALIDITY_STATE validity);
 
    void reset(
            const XMLCh* const validationContext
            , const XMLCh* const normalizedValue
            , const VALIDITY_STATE validityState
            , const ASSESSMENT_TYPE assessmentType
        );
private:
 
    // -----------------------------------------------------------------------
    //  Unimplemented constructors and operators
    // -----------------------------------------------------------------------
    PSVIItem(const PSVIItem&);
    PSVIItem & operator=(const PSVIItem &);
 
 
protected:
    // -----------------------------------------------------------------------
    //  data members
    // -----------------------------------------------------------------------
    // fMemoryManager:
    //  used for any memory allocations
    // fValidationContext
    //  corresponds to the schema [validation context] property
    // fNormalizedValue
    //  The schema normalized value (when present)
    // fDefaultValue
    //  default value specified in the schema, if any
    // fCanonicalValue
    //  canonicalized version of normalizedValue
    // fValidityState
    //  Whether this item is valid or not
    // fAssessmentType
    //  The kind of assessment that produced the given validity outcome
    // fIsSpecified
    //  Whether this item exists because a default was specified in the schema
    // fType
    //  type responsible for validating this item
    // fMemberType
    //  If fType is a union type, the member type that validated this item
    MemoryManager* const        fMemoryManager;
    const XMLCh*                fValidationContext;
    const XMLCh*                fNormalizedValue;
    const XMLCh*                fDefaultValue;
    XMLCh*                      fCanonicalValue;
    VALIDITY_STATE              fValidityState;
    ASSESSMENT_TYPE             fAssessmentType;
    bool                        fIsSpecified;
    XSTypeDefinition *          fType;
    XSSimpleTypeDefinition*     fMemberType;
};
 
inline PSVIItem::~PSVIItem() {}
 
inline const XMLCh *PSVIItem::getValidationContext() 
{
    return fValidationContext;
}
 
inline const XMLCh* PSVIItem::getSchemaNormalizedValue() 
{
    return fNormalizedValue;
}
 
inline const XMLCh* PSVIItem::getSchemaDefault() 
{
    return fDefaultValue;
}
 
inline const XMLCh* PSVIItem::getCanonicalRepresentation() const
{
    return fCanonicalValue;
}
 
inline PSVIItem::VALIDITY_STATE PSVIItem::getValidity() const
{
    return fValidityState;
}
 
inline bool PSVIItem::getIsSchemaSpecified() const
{
    return fIsSpecified;
}
 
inline PSVIItem::ASSESSMENT_TYPE PSVIItem::getValidationAttempted() const
{
    return fAssessmentType;
}
 
XERCES_CPP_NAMESPACE_END
 
#endif