/*

 * 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: PSVIItem.hpp 568078 2007-08-21 11:43:25Z amassari $

 */

#if !defined(PSVIITEM_HPP)

#define PSVIITEM_HPP

#include <xercesc/util/PlatformUtils.hpp>

XERCES_CPP_NAMESPACE_BEGIN

/**

 * Represent the PSVI contributions for one element or one attribute information item.

 * This is *always* owned by the validator /parser object from which

 * it is obtained.  It is designed to be subclassed; subclasses will

 * specify under what conditions it may be relied upon to have meaningful contents.

 */

// forward declarations

class XSTypeDefinition; 

class XSSimpleTypeDefinition;

class XSValue;

class XMLPARSER_EXPORT PSVIItem : public XMemory

{

public:

    enum VALIDITY_STATE {

	    /** Validity value indicating that validation has either not 

	    been performed or that a strict assessment of validity could 

	    not be performed  

	    */

	    VALIDITY_NOTKNOWN               = 0,

	    /** Validity value indicating that validation has been strictly

	     assessed and the element in question is invalid according to the 

	     rules of schema validation.

	    */

	    VALIDITY_INVALID               = 1,

	    /** Validity value indicating that validation has been strictly 

	     assessed and the element in question is valid according to the rules 

	     of schema validation.

	     */

	    VALIDITY_VALID                 = 2

    };

    enum ASSESSMENT_TYPE {

	    /** Validation status indicating that schema validation has been 

	     performed and the element in question has specifically been skipped.   

	     */

	    VALIDATION_NONE                = 0,

	    /** Validation status indicating that schema validation has been 

	    performed on the element in question under the rules of lax validation.

	    */

	    VALIDATION_PARTIAL             = 1,

	    /**  Validation status indicating that full schema validation has been 

	    performed on the element.  */

	    VALIDATION_FULL                = 2

    };

    //  Constructors and Destructor

    // -----------------------------------------------------------------------

    /** @name Constructors */

    //@{

    /**

      * The default constructor 

      *

      * @param  manager     The configurable memory manager

      */

    PSVIItem(MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);

    //@};

    /** @name Destructor */

    //@{

    virtual ~PSVIItem();

    //@}

    //---------------------

    /** @name PSVIItem methods */

    //@{

    /**

     * [validation context]

     * 

     * @return A string identifying the nearest ancestor element 

     *          information item with a [schema information] property

     *         (or this element item itself if it has such a property)

     *          (form to be determined)

     * @see <a href="http://www.w3.org/TR/xmlschema-1/#e-validation_context">XML Schema Part 1: Structures [validation context]</a>

     */

    const XMLCh *getValidationContext();

    /**

     * Determine the validity of the node with respect 

     * to the validation being attempted

     * 

     * @return return the [validity] property. Possible values are: 

     *         VALIDITY_UNKNOWN, VALIDITY_INVALID, VALIDITY_VALID

     */

    VALIDITY_STATE getValidity() const;

    /**

     * Determines the extent to which the item has been validated

     * 

     * @return return the [validation attempted] property. The possible values are 

     *         VALIDATION_NONE, VALIDATION_ORDERED_PARTIAL and VALIDATION_FULL

     */

    ASSESSMENT_TYPE getValidationAttempted() const;

    /**

     * A list of error codes generated from validation attempts. 

     * Need to find all the possible subclause reports that need reporting

     * 

     * @return list of error codes

     */

    /***

    const XMLCh ** getErrorCodes();

    ****/

    /**

     * [schema normalized value] 

     * 

     * @see <a href="http://www.w3.org/TR/xmlschema-1/#e-schema_normalized_value">XML Schema Part 1: Structures [schema normalized value]</a>

     * @return the normalized value of this item after validation

     */

    const XMLCh *getSchemaNormalizedValue();

    /**

     * An item isomorphic to the type definition used to validate this element.

     * 

     * @return  a type declaration

     */

    virtual XSTypeDefinition *getTypeDefinition() = 0;

    /**

     * If and only if that type definition is a simple type definition

     * with {variety} union, or a complex type definition whose {content type}

     * is a simple thype definition with {variety} union, then an item isomorphic

     * to that member of the union's {member type definitions} which actually

     * validated the element item's normalized value.

     * 

     * @return  a simple type declaration

     */

    virtual XSSimpleTypeDefinition *getMemberTypeDefinition() = 0;

    /**

     * [schema default]

     * 

     * @return The canonical lexical representation of the declaration's {value constraint} value.

     * @see <a href="http://www.w3.org/TR/xmlschema-1/#e-schema_default">XML Schema Part 1: Structures [schema default]</a>

     */

    const XMLCh *getSchemaDefault();

    /**

     * [schema specified] 

     * @see <a href="http://www.w3.org/TR/xmlschema-1/#e-schema_specified">XML Schema Part 1: Structures [schema specified]</a>

     * @return true - value was specified in schema, false - value comes from the infoset

     */

    bool getIsSchemaSpecified() const;

    /**

     * Return the canonical representation of this value.

     * Note that, formally, this is not a PSVI property.

     * @return string representing the canonical representation, if this item

     * was validated by a simple type definition for which canonical

     * representations of values are defined.

     */

    const XMLCh *getCanonicalRepresentation() const;

    //@}

    /**

     * 

     * Get actual value in the form of XSValue,

     * caller needs to delete the object returned.

     *

     * @return  an XSValue 

     */

    virtual XSValue *getActualValue() const;

    //----------------------------------

    /** methods needed by implementation */

    //@{

    void setValidationAttempted(PSVIItem::ASSESSMENT_TYPE attemptType);

    void setValidity(PSVIItem::VALIDITY_STATE validity);

    /** reset the object

     * @param validationContext  corresponds to schema validation context property

     * @param normalizedValue  corresponds to schema normalized value property

     * @param validityState  state of item's validity

     * @param assessmentType  type of assessment carried out on item

     */

    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