You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@xerces.apache.org by pe...@apache.org on 2001/10/01 18:16:38 UTC
cvs commit: xml-xerces/c/src/validators/datatype DecimalDatatypeValidator.hpp DecimalDatatypeValidator.cpp
peiyongz 01/10/01 09:16:38
Modified: c/src/validators/datatype DecimalDatatypeValidator.hpp
DecimalDatatypeValidator.cpp
Log:
DTV Reorganization:derived from AbstractNumericValidator
Revision Changes Path
1.7 +50 -144 xml-xerces/c/src/validators/datatype/DecimalDatatypeValidator.hpp
Index: DecimalDatatypeValidator.hpp
===================================================================
RCS file: /home/cvs/xml-xerces/c/src/validators/datatype/DecimalDatatypeValidator.hpp,v
retrieving revision 1.6
retrieving revision 1.7
diff -u -r1.6 -r1.7
--- DecimalDatatypeValidator.hpp 2001/08/24 17:12:01 1.6
+++ DecimalDatatypeValidator.hpp 2001/10/01 16:16:38 1.7
@@ -55,17 +55,21 @@
*/
/*
- * $Id: DecimalDatatypeValidator.hpp,v 1.6 2001/08/24 17:12:01 knoaman Exp $
+ * $Id: DecimalDatatypeValidator.hpp,v 1.7 2001/10/01 16:16:38 peiyongz Exp $
+ * $Log: DecimalDatatypeValidator.hpp,v $
+ * Revision 1.7 2001/10/01 16:16:38 peiyongz
+ * DTV Reorganization:derived from AbstractNumericValidator
+ *
*/
#if !defined(DECIMAL_DATATYPEVALIDATOR_HPP)
#define DECIMAL_DATATYPEVALIDATOR_HPP
-#include <validators/datatype/DatatypeValidator.hpp>
+#include <validators/datatype/AbstractNumericValidator.hpp>
#include <util/RefVectorOf.hpp>
#include <util/XMLBigDecimal.hpp>
-class VALIDATORS_EXPORT DecimalDatatypeValidator : public DatatypeValidator
+class VALIDATORS_EXPORT DecimalDatatypeValidator : public AbstractNumericValidator
{
public:
@@ -87,24 +91,6 @@
//@}
// -----------------------------------------------------------------------
- // Validation methods
- // -----------------------------------------------------------------------
- /** @name Validation Function */
- //@{
-
- /**
- * validate that a string matches the boolean datatype
- * @param content A string containing the content to be validated
- *
- * @exception throws InvalidDatatypeException if the content is
- * is not valid.
- */
-
- void validate(const XMLCh* const content);
-
- //@}
-
- // -----------------------------------------------------------------------
// Compare methods
// -----------------------------------------------------------------------
/** @name Compare Function */
@@ -117,7 +103,7 @@
* @param content2
* @return
*/
- int compare(const XMLCh* const, const XMLCh* const);
+ virtual int compare(const XMLCh* const, const XMLCh* const);
//@}
@@ -129,51 +115,67 @@
, RefVectorOf<XMLCh>* const enums
, const int finalSet);
-private:
+protected:
- void checkContent( const XMLCh* const content, bool asBase);
-
- void init(DatatypeValidator* const baseValidator
- , RefHashTableOf<KVStringPair>* const facets
- , RefVectorOf<XMLCh>* const enums);
+// -----------------------------------------------------------------------
+// ctor provided to be used by derived classes
+// -----------------------------------------------------------------------
+ DecimalDatatypeValidator(DatatypeValidator* const baseValidator
+ , RefHashTableOf<KVStringPair>* const facets
+ , const int finalSet
+ , const ValidatorType type);
- void cleanUp();
+ inline void init(RefVectorOf<XMLCh>* const enums);
// -----------------------------------------------------------------------
-// Getter methods
+// Abstract interface from AbstractNumericFacetValidator
// -----------------------------------------------------------------------
+
+ virtual void assignAdditionalFacet(const XMLCh* const key
+ , const XMLCh* const value);
- unsigned int getTotalDigits() const;
+ virtual void inheritAdditionalFacet();
- unsigned int getFractionDigits() const;
+ virtual void checkAdditionalFacetConstraints() const;
- XMLBigDecimal* const getMaxInclusive() const;
+ virtual void checkAdditionalFacetConstraintsBase() const;
- XMLBigDecimal* const getMaxExclusive() const;
+ virtual int compareValues(const XMLNumber* const lValue
+ , const XMLNumber* const rValue);
- XMLBigDecimal* const getMinInclusive() const;
+ virtual void setMaxInclusive(const XMLCh* const);
- XMLBigDecimal* const getMinExclusive() const;
+ virtual void setMaxExclusive(const XMLCh* const);
- RefVectorOf<XMLBigDecimal>* getEnumeration() const;
+ virtual void setMinInclusive(const XMLCh* const);
+ virtual void setMinExclusive(const XMLCh* const);
+
+ virtual void setEnumeration();
+
// -----------------------------------------------------------------------
-// Setter methods
+// Abstract interface from AbstractNumericValidator
// -----------------------------------------------------------------------
- void setTotalDigits(unsigned int);
+ virtual void checkContent( const XMLCh* const content, bool asBase);
- void setFractionDigits(unsigned int);
+private:
- void setMaxInclusive(XMLBigDecimal* const);
+// -----------------------------------------------------------------------
+// Getter methods
+// -----------------------------------------------------------------------
- void setMaxExclusive(XMLBigDecimal* const);
+ inline unsigned int getTotalDigits() const;
- void setMinInclusive(XMLBigDecimal* const);
+ inline unsigned int getFractionDigits() const;
+
+// -----------------------------------------------------------------------
+// Setter methods
+// -----------------------------------------------------------------------
- void setMinExclusive(XMLBigDecimal* const);
+ inline void setTotalDigits(unsigned int);
- void setEnumeration(RefVectorOf<XMLBigDecimal>* );
+ inline void setFractionDigits(unsigned int);
// -----------------------------------------------------------------------
// Private data members
@@ -181,133 +183,40 @@
// -----------------------------------------------------------------------
unsigned int fTotalDigits;
unsigned int fFractionDigits;
- bool fEnumerationInherited;
-
- XMLBigDecimal* fMaxInclusive;
- XMLBigDecimal* fMaxExclusive;
- XMLBigDecimal* fMinInclusive;
- XMLBigDecimal* fMinExclusive;
- RefVectorOf<XMLBigDecimal>* fEnumeration; // save the actual value
-
};
-
-// -----------------------------------------------------------------------
-// Compare methods
-// -----------------------------------------------------------------------
-inline int DecimalDatatypeValidator::compare(const XMLCh* const lValue
- , const XMLCh* const rValue)
-{
- return XMLBigDecimal::compareValues(new XMLBigDecimal(lValue)
- , new XMLBigDecimal(rValue));
-}
-inline DatatypeValidator* DecimalDatatypeValidator::newInstance(
- RefHashTableOf<KVStringPair>* const facets
- , RefVectorOf<XMLCh>* const enums
- , const int finalSet)
+void DecimalDatatypeValidator::init(RefVectorOf<XMLCh>* const enums)
{
- return (DatatypeValidator*) new DecimalDatatypeValidator(this, facets, enums, finalSet);
+ AbstractNumericValidator::init(enums);
}
-inline void DecimalDatatypeValidator::validate( const XMLCh* const content)
-{
- checkContent(content, false);
-}
-
-inline void DecimalDatatypeValidator::cleanUp()
-{
- delete fMaxInclusive;
- delete fMaxExclusive;
- delete fMinInclusive;
- delete fMinExclusive;
-
- //~RefVectorOf will delete all adopted elements
- if (fEnumeration && !fEnumerationInherited)
- delete fEnumeration;
-}
-
// -----------------------------------------------------------------------
// Getter methods
// -----------------------------------------------------------------------
-inline unsigned int DecimalDatatypeValidator::getTotalDigits() const
+unsigned int DecimalDatatypeValidator::getTotalDigits() const
{
return fTotalDigits;
}
-inline unsigned int DecimalDatatypeValidator::getFractionDigits() const
+unsigned int DecimalDatatypeValidator::getFractionDigits() const
{
return fFractionDigits;
}
-inline XMLBigDecimal* const DecimalDatatypeValidator::getMaxInclusive() const
-{
- return fMaxInclusive;
-}
-
-inline XMLBigDecimal* const DecimalDatatypeValidator::getMaxExclusive() const
-{
- return fMaxExclusive;
-}
-
-inline XMLBigDecimal* const DecimalDatatypeValidator::getMinInclusive() const
-{
- return fMinInclusive;
-}
-
-inline XMLBigDecimal* const DecimalDatatypeValidator::getMinExclusive() const
-{
- return fMinExclusive;
-}
-
-inline RefVectorOf<XMLBigDecimal>* DecimalDatatypeValidator::getEnumeration() const
-{
- return fEnumeration;
-}
-
// -----------------------------------------------------------------------
// Setter methods
// -----------------------------------------------------------------------
-inline void DecimalDatatypeValidator::setTotalDigits(unsigned int newTotalDigits)
+void DecimalDatatypeValidator::setTotalDigits(unsigned int newTotalDigits)
{
fTotalDigits = newTotalDigits;
}
-inline void DecimalDatatypeValidator::setFractionDigits(unsigned int newFractionDigits)
+void DecimalDatatypeValidator::setFractionDigits(unsigned int newFractionDigits)
{
fFractionDigits = newFractionDigits;
-}
-
-inline void DecimalDatatypeValidator::setMaxInclusive(XMLBigDecimal* const newMaxInclusive)
-{
- if (fMaxInclusive) delete fMaxInclusive;
- fMaxInclusive = newMaxInclusive;
-}
-
-inline void DecimalDatatypeValidator::setMaxExclusive(XMLBigDecimal* const newMaxExclusive)
-{
- if (fMaxExclusive) delete fMaxExclusive;
- fMaxExclusive = newMaxExclusive;
-}
-
-inline void DecimalDatatypeValidator::setMinInclusive(XMLBigDecimal* const newMinInclusive)
-{
- if (fMinInclusive) delete fMinInclusive;
- fMinInclusive = newMinInclusive;
-}
-
-inline void DecimalDatatypeValidator::setMinExclusive(XMLBigDecimal* const newMinExclusive)
-{
- if (fMinExclusive) delete fMinExclusive;
- fMinExclusive = newMinExclusive;
-}
-
-inline void DecimalDatatypeValidator::setEnumeration(RefVectorOf<XMLBigDecimal>* newEnum)
-{
- if (fEnumeration) delete fEnumeration;
- fEnumeration = newEnum;
}
/**
1.16 +232 -894 xml-xerces/c/src/validators/datatype/DecimalDatatypeValidator.cpp
Index: DecimalDatatypeValidator.cpp
===================================================================
RCS file: /home/cvs/xml-xerces/c/src/validators/datatype/DecimalDatatypeValidator.cpp,v
retrieving revision 1.15
retrieving revision 1.16
diff -u -r1.15 -r1.16
--- DecimalDatatypeValidator.cpp 2001/09/20 13:11:42 1.15
+++ DecimalDatatypeValidator.cpp 2001/10/01 16:16:38 1.16
@@ -56,6 +56,9 @@
/*
* $Log: DecimalDatatypeValidator.cpp,v $
+ * Revision 1.16 2001/10/01 16:16:38 peiyongz
+ * DTV Reorganization:derived from AbstractNumericValidator
+ *
* Revision 1.15 2001/09/20 13:11:42 knoaman
* Regx + misc. fixes
*
@@ -118,906 +121,304 @@
// Constructors and Destructor
// ---------------------------------------------------------------------------
DecimalDatatypeValidator::DecimalDatatypeValidator()
-:DatatypeValidator(0, 0, 0, DatatypeValidator::Decimal)
+:AbstractNumericValidator(0, 0, 0, DatatypeValidator::Decimal)
, fTotalDigits(0)
, fFractionDigits(0)
-, fEnumerationInherited(false)
-, fMaxInclusive(0)
-, fMaxExclusive(0)
-, fMinInclusive(0)
-, fMinExclusive(0)
-, fEnumeration(0)
-{
-}
-
-DecimalDatatypeValidator::~DecimalDatatypeValidator()
-{
- cleanUp();
-}
+{}
DecimalDatatypeValidator::DecimalDatatypeValidator(
DatatypeValidator* const baseValidator
, RefHashTableOf<KVStringPair>* const facets
, RefVectorOf<XMLCh>* const enums
, const int finalSet)
-:DatatypeValidator(baseValidator, facets, finalSet, DatatypeValidator::Decimal)
+:AbstractNumericValidator(baseValidator, facets, finalSet, DatatypeValidator::Decimal)
, fTotalDigits(0)
, fFractionDigits(0)
-, fEnumerationInherited(false)
-, fMaxInclusive(0)
-, fMaxExclusive(0)
-, fMinInclusive(0)
-, fMinExclusive(0)
-, fEnumeration(0)
{
- try
- {
- init(baseValidator, facets, enums);
- }
+ init(enums);
+}
- catch (...)
- {
- cleanUp();
- throw;
- }
+DecimalDatatypeValidator::~DecimalDatatypeValidator()
+{}
+// -----------------------------------------------------------------------
+// Compare methods
+// -----------------------------------------------------------------------
+int DecimalDatatypeValidator::compare(const XMLCh* const lValue
+ , const XMLCh* const rValue)
+{
+ return XMLBigDecimal::compareValues(new XMLBigDecimal(lValue)
+ , new XMLBigDecimal(rValue));
}
-void DecimalDatatypeValidator::init(DatatypeValidator* const baseValidator
- , RefHashTableOf<KVStringPair>* const facets
- , RefVectorOf<XMLCh>* const enums)
+DatatypeValidator* DecimalDatatypeValidator::newInstance(
+ RefHashTableOf<KVStringPair>* const facets
+ , RefVectorOf<XMLCh>* const enums
+ , const int finalSet)
{
- // Set Facets if any defined
- if (facets)
- {
- XMLCh* key;
- XMLCh* value;
- RefVectorOf<XMLCh>* fStrEnumeration = enums; // save the literal value
- Janitor<RefVectorOf<XMLCh> > janStrEnum(fStrEnumeration);
+ return (DatatypeValidator*) new DecimalDatatypeValidator(this, facets, enums, finalSet);
+}
+
+// -----------------------------------------------------------------------
+// ctor provided to be used by derived classes
+// -----------------------------------------------------------------------
+DecimalDatatypeValidator::DecimalDatatypeValidator(DatatypeValidator* const baseValidator
+ , RefHashTableOf<KVStringPair>* const facets
+ , const int finalSet
+ , const ValidatorType type)
+:AbstractNumericValidator(baseValidator, facets, finalSet, type)
+, fTotalDigits(0)
+, fFractionDigits(0)
+{
+ //do not invoke init here !!!
+}
- if (enums)
+void DecimalDatatypeValidator::assignAdditionalFacet(const XMLCh* const key
+ , const XMLCh* const value)
+{
+ if (XMLString::compareString(key, SchemaSymbols::fgELT_TOTALDIGITS)==0)
+ {
+ int val;
+ try
+ {
+ val = XMLString::parseInt(value);
+ }
+ catch (NumberFormatException)
{
- setFacetsDefined(DatatypeValidator::FACET_ENUMERATION);
+ ThrowXML1(InvalidDatatypeFacetException, XMLExcepts::FACET_Invalid_TotalDigit, value);
}
- RefHashTableOfEnumerator<KVStringPair> e(facets);
+ // check 4.3.11.c0 must: totalDigits > 0
+ if ( val <= 0 )
+ ThrowXML1(InvalidDatatypeFacetException, XMLExcepts::FACET_NonNeg_TotalDigit, value);
- while (e.hasMoreElements())
+ setTotalDigits(val);
+ setFacetsDefined(DatatypeValidator::FACET_TOTALDIGITS);
+ }
+ else if (XMLString::compareString(key, SchemaSymbols::fgELT_FRACTIONDIGITS)==0)
+ {
+ int val;
+ try
{
- KVStringPair pair = e.nextElement();
- key = pair.getKey();
- value = pair.getValue();
-
- if (XMLString::compareString(key, SchemaSymbols::fgELT_PATTERN)==0)
- {
- setPattern(value);
- if (getPattern())
- setFacetsDefined(DatatypeValidator::FACET_PATTERN);
- // do not construct regex until needed
- }
- else if (XMLString::compareString(key, SchemaSymbols::fgELT_MAXINCLUSIVE)==0)
- {
- try
- {
- setMaxInclusive(new XMLBigDecimal(value));
- }
- catch (NumberFormatException)
- {
- ThrowXML1(InvalidDatatypeFacetException, XMLExcepts::FACET_Invalid_MaxIncl, value);
- }
- setFacetsDefined(DatatypeValidator::FACET_MAXINCLUSIVE);
- }
- else if (XMLString::compareString(key, SchemaSymbols::fgELT_MAXEXCLUSIVE)==0)
- {
- try
- {
- setMaxExclusive(new XMLBigDecimal(value));
- }
- catch (NumberFormatException)
- {
- ThrowXML1(InvalidDatatypeFacetException, XMLExcepts::FACET_Invalid_MaxExcl, value);
- }
- setFacetsDefined(DatatypeValidator::FACET_MAXEXCLUSIVE);
- }
- else if (XMLString::compareString(key, SchemaSymbols::fgELT_MININCLUSIVE)==0)
- {
- try
- {
- setMinInclusive(new XMLBigDecimal(value));
- }
- catch (NumberFormatException)
- {
- ThrowXML1(InvalidDatatypeFacetException, XMLExcepts::FACET_Invalid_MinIncl, value);
- }
- setFacetsDefined(DatatypeValidator::FACET_MININCLUSIVE);
- }
- else if (XMLString::compareString(key, SchemaSymbols::fgELT_MINEXCLUSIVE)==0)
- {
- try
- {
- setMinExclusive(new XMLBigDecimal(value));
- }
- catch (NumberFormatException)
- {
- ThrowXML1(InvalidDatatypeFacetException, XMLExcepts::FACET_Invalid_MinExcl, value);
- }
- setFacetsDefined(DatatypeValidator::FACET_MINEXCLUSIVE);
- }
- else if (XMLString::compareString(key, SchemaSymbols::fgELT_TOTALDIGITS)==0)
- {
- int val;
- try
- {
- val = XMLString::parseInt(value);
- }
- catch (NumberFormatException)
- {
- ThrowXML1(InvalidDatatypeFacetException, XMLExcepts::FACET_Invalid_TotalDigit, value);
- }
-
- // check 4.3.11.c0 must: totalDigits > 0
- if ( val <= 0 )
- ThrowXML1(InvalidDatatypeFacetException, XMLExcepts::FACET_NonNeg_TotalDigit, value);
+ val = XMLString::parseInt(value);
+ }
+ catch (NumberFormatException)
+ {
+ ThrowXML1(InvalidDatatypeFacetException, XMLExcepts::FACET_Invalid_FractDigit, value);
+ }
- setTotalDigits(val);
- setFacetsDefined(DatatypeValidator::FACET_TOTALDIGITS);
- }
- else if (XMLString::compareString(key, SchemaSymbols::fgELT_FRACTIONDIGITS)==0)
- {
- int val;
- try
- {
- val = XMLString::parseInt(value);
- }
- catch (NumberFormatException)
- {
- ThrowXML1(InvalidDatatypeFacetException, XMLExcepts::FACET_Invalid_FractDigit, value);
- }
-
- // check 4.3.12.c0 must: fractionDigits > 0
- if ( val < 0 )
- ThrowXML1(InvalidDatatypeFacetException, XMLExcepts::FACET_NonNeg_FractDigit, value);
+ // check 4.3.12.c0 must: fractionDigits > 0
+ if ( val < 0 )
+ ThrowXML1(InvalidDatatypeFacetException, XMLExcepts::FACET_NonNeg_FractDigit, value);
- setFractionDigits(val);
- setFacetsDefined(DatatypeValidator::FACET_FRACTIONDIGITS);
- }
- else if (XMLString::compareString(key, SchemaSymbols::fgATT_FIXED)==0)
- {
- unsigned int val;
- bool retStatus;
- try
- {
- retStatus = XMLString::textToBin(value, val);
- }
- catch (RuntimeException)
- {
- ThrowXML(InvalidDatatypeFacetException, XMLExcepts::FACET_internalError_fixed);
- }
-
- if (!retStatus)
- {
- ThrowXML(InvalidDatatypeFacetException, XMLExcepts::FACET_internalError_fixed);
- }
+ setFractionDigits(val);
+ setFacetsDefined(DatatypeValidator::FACET_FRACTIONDIGITS);
+ }
+ else
+ {
+ ThrowXML(InvalidDatatypeFacetException, XMLExcepts::FACET_Invalid_Tag);
+ }
+}
- setFixed(val);
- //no setFacetsDefined here
- }
- else
- {
- ThrowXML(InvalidDatatypeFacetException, XMLExcepts::FACET_Invalid_Tag);
- }
- }//while
+void DecimalDatatypeValidator::inheritAdditionalFacet()
+{
- /***
- Schema constraint: Part I -- self checking
- ***/
+ DecimalDatatypeValidator *numBase = (DecimalDatatypeValidator*) getBaseValidator();
- try {
+ if (!numBase)
+ return;
- if ( getFacetsDefined() != 0 )
- {
- // non co-existence checking
- // check 4.3.8.c1 error: maxInclusive + maxExclusive
- if ( ((getFacetsDefined() & DatatypeValidator::FACET_MAXEXCLUSIVE) != 0) &&
- ((getFacetsDefined() & DatatypeValidator::FACET_MAXINCLUSIVE) != 0) )
- ThrowXML(InvalidDatatypeFacetException, XMLExcepts::FACET_max_Incl_Excl);
-
- // non co-existence checking
- // check 4.3.9.c1 error: minInclusive + minExclusive
- if ( ((getFacetsDefined() & DatatypeValidator::FACET_MINEXCLUSIVE) != 0) &&
- ((getFacetsDefined() & DatatypeValidator::FACET_MININCLUSIVE) != 0) )
- ThrowXML(InvalidDatatypeFacetException, XMLExcepts::FACET_min_Incl_Excl);
-
- //
- // minExclusive < minInclusive <= maxInclusive < maxExclusive
- //
- // check 4.3.7.c1 must: minInclusive <= maxInclusive
- if ( ((getFacetsDefined() & DatatypeValidator::FACET_MAXINCLUSIVE) != 0) &&
- ((getFacetsDefined() & DatatypeValidator::FACET_MININCLUSIVE) != 0) )
- {
- if ( XMLBigDecimal::compareValues(getMinInclusive(), getMaxInclusive()) == 1 )
- {
- XMLCh* value1 = getMinInclusive()->toString();
- ArrayJanitor<XMLCh> jan1(value1);
- XMLCh* value2 = getMaxInclusive()->toString();
- ArrayJanitor<XMLCh> jan2(value2);
- ThrowXML2(InvalidDatatypeFacetException
- , XMLExcepts::FACET_maxIncl_minIncl
- , value2
- , value1);
- }
- }
-
- // check 4.3.8.c2 must: minExclusive <= maxExclusive ??? minExclusive < maxExclusive
- if ( ((getFacetsDefined() & DatatypeValidator::FACET_MAXEXCLUSIVE) != 0) &&
- ((getFacetsDefined() & DatatypeValidator::FACET_MINEXCLUSIVE) != 0) )
- {
- if ( XMLBigDecimal::compareValues(getMinExclusive(), getMaxExclusive()) == 1 )
- {
- XMLCh* value1 = getMinExclusive()->toString();
- ArrayJanitor<XMLCh> jan1(value1);
- XMLCh* value2 = getMaxExclusive()->toString();
- ArrayJanitor<XMLCh> jan2(value2);
- ThrowXML2(InvalidDatatypeFacetException
- , XMLExcepts::FACET_maxExcl_minExcl
- , value2
- , value1);
- }
- }
-
- // check 4.3.9.c2 must: minExclusive < maxInclusive
- if ( ((getFacetsDefined() & DatatypeValidator::FACET_MAXINCLUSIVE) != 0) &&
- ((getFacetsDefined() & DatatypeValidator::FACET_MINEXCLUSIVE) != 0) )
- {
- if ( XMLBigDecimal::compareValues(getMinExclusive(), getMaxInclusive()) != -1 )
- {
- XMLCh* value1 = getMinExclusive()->toString();
- ArrayJanitor<XMLCh> jan1(value1);
- XMLCh* value2 = getMaxInclusive()->toString();
- ArrayJanitor<XMLCh> jan2(value2);
- ThrowXML2(InvalidDatatypeFacetException
- , XMLExcepts::FACET_maxIncl_minExcl
- , value2
- , value1);
- }
- }
-
- // check 4.3.10.c1 must: minInclusive < maxExclusive
- if ( ((getFacetsDefined() & DatatypeValidator::FACET_MAXEXCLUSIVE) != 0) &&
- ((getFacetsDefined() & DatatypeValidator::FACET_MININCLUSIVE) != 0) )
- {
- if ( XMLBigDecimal::compareValues(getMinInclusive(), getMaxExclusive()) != -1 )
- {
- XMLCh* value1 = getMinInclusive()->toString();
- ArrayJanitor<XMLCh> jan1(value1);
- XMLCh* value2 = getMaxExclusive()->toString();
- ArrayJanitor<XMLCh> jan2(value2);
- ThrowXML2(InvalidDatatypeFacetException
- , XMLExcepts::FACET_maxExcl_minIncl
- , value2
- , value1);
- }
- }
-
- // check 4.3.12.c1 must: fractionDigits <= totalDigits
- if ( ((getFacetsDefined() & DatatypeValidator::FACET_FRACTIONDIGITS) != 0) &&
- ((getFacetsDefined() & DatatypeValidator::FACET_TOTALDIGITS) != 0) )
- {
- if ( fFractionDigits > fTotalDigits )
- {
- XMLString::binToText(getFractionDigits(), value1, BUF_LEN, 10);
- XMLString::binToText(getTotalDigits(), value2, BUF_LEN, 10);
+ // inherit totalDigits
+ if ((( numBase->getFacetsDefined() & DatatypeValidator::FACET_TOTALDIGITS) != 0) &&
+ (( getFacetsDefined() & DatatypeValidator::FACET_TOTALDIGITS) == 0) )
+ {
+ setTotalDigits(numBase->fTotalDigits);
+ setFacetsDefined(DatatypeValidator::FACET_TOTALDIGITS);
+ }
+
+ // inherit fractionDigits
+ if ((( numBase->getFacetsDefined() & DatatypeValidator::FACET_FRACTIONDIGITS) != 0) &&
+ (( getFacetsDefined() & DatatypeValidator::FACET_FRACTIONDIGITS) == 0) )
+ {
+ setFractionDigits(numBase->fFractionDigits);
+ setFacetsDefined(DatatypeValidator::FACET_FRACTIONDIGITS);
+ }
+}
- ThrowXML2(InvalidDatatypeFacetException
+void DecimalDatatypeValidator::checkAdditionalFacetConstraints() const
+{
+ // check 4.3.12.c1 must: fractionDigits <= totalDigits
+ if ( ((getFacetsDefined() & DatatypeValidator::FACET_FRACTIONDIGITS) != 0) &&
+ ((getFacetsDefined() & DatatypeValidator::FACET_TOTALDIGITS) != 0) )
+ {
+ if ( fFractionDigits > fTotalDigits )
+ {
+ XMLString::binToText(getFractionDigits(), value1, BUF_LEN, 10);
+ XMLString::binToText(getTotalDigits(), value2, BUF_LEN, 10);
+ ThrowXML2(InvalidDatatypeFacetException
, XMLExcepts::FACET_TotDigit_FractDigit
, value2
, value1);
- }
- }
-
- } // if getFacetsDefined
-
- /***
- Schema constraint: Part II -- self vs base
- ***/
-
- if ( baseValidator != 0 )
- {
- DecimalDatatypeValidator* numBase = (DecimalDatatypeValidator*)baseValidator;
-
- // this
- // minExclusive maxExclusive
- // minInclusive maxInclusive
- //
- // base
- // minExclusive maxExclusive
- // minInclusive maxExclusive
- //
- if ( getFacetsDefined() != 0 )
- {
- // check 4.3.7.c2 error:
- // maxInclusive > base.maxInclusive
- // maxInclusive >= base.maxExclusive
- // maxInclusive < base.minInclusive
- // maxInclusive <= base.minExclusive
- // maxInclusive != base.maxInclusive if (base.fixed)
- if ( ((getFacetsDefined() & DatatypeValidator::FACET_MAXINCLUSIVE) != 0) )
- {
- if ( ((numBase->getFacetsDefined() & DatatypeValidator::FACET_MAXINCLUSIVE) != 0) &&
- ( XMLBigDecimal::compareValues(getMaxInclusive(), numBase->getMaxInclusive()) == 1 ))
- {
- XMLCh* value1 = getMaxInclusive()->toString();
- ArrayJanitor<XMLCh> jan1(value1);
- XMLCh* value2 = numBase->getMaxInclusive()->toString();
- ArrayJanitor<XMLCh> jan2(value2);
- ThrowXML2(InvalidDatatypeFacetException
- , XMLExcepts::FACET_maxIncl_base_maxIncl
- , value1
- , value2);
- }
-
- if ( ((numBase->getFacetsDefined() & DatatypeValidator::FACET_MAXEXCLUSIVE) != 0) &&
- ( XMLBigDecimal::compareValues(getMaxInclusive(), numBase->getMaxExclusive()) != -1 ))
- {
- XMLCh* value1 = getMaxInclusive()->toString();
- ArrayJanitor<XMLCh> jan1(value1);
- XMLCh* value2 = numBase->getMaxExclusive()->toString();
- ArrayJanitor<XMLCh> jan2(value2);
- ThrowXML2(InvalidDatatypeFacetException
- , XMLExcepts::FACET_maxIncl_base_maxExcl
- , value1
- , value2);
- }
-
- if ( (( numBase->getFacetsDefined() & DatatypeValidator::FACET_MININCLUSIVE) != 0) &&
- ( XMLBigDecimal::compareValues(getMaxInclusive(), numBase->getMinInclusive()) == -1 ))
- {
- XMLCh* value1 = getMaxInclusive()->toString();
- ArrayJanitor<XMLCh> jan1(value1);
- XMLCh* value2 = numBase->getMinInclusive()->toString();
- ArrayJanitor<XMLCh> jan2(value2);
- ThrowXML2(InvalidDatatypeFacetException
- , XMLExcepts::FACET_maxIncl_base_minIncl
- , value1
- , value2);
- }
-
- if ( (( numBase->getFacetsDefined() & DatatypeValidator::FACET_MINEXCLUSIVE) != 0) &&
- ( XMLBigDecimal::compareValues(getMaxInclusive(), numBase->getMinExclusive() ) != 1 ))
- {
- XMLCh* value1 = getMaxInclusive()->toString();
- ArrayJanitor<XMLCh> jan1(value1);
- XMLCh* value2 = numBase->getMinExclusive()->toString();
- ArrayJanitor<XMLCh> jan2(value2);
- ThrowXML2(InvalidDatatypeFacetException
- , XMLExcepts::FACET_maxIncl_base_minExcl
- , value1
- , value2);
- }
-
- if ( ((numBase->getFacetsDefined() & DatatypeValidator::FACET_MAXINCLUSIVE) != 0) &&
- ((numBase->getFixed() & DatatypeValidator::FACET_MAXINCLUSIVE) != 0) &&
- ( XMLBigDecimal::compareValues(getMaxInclusive(), numBase->getMaxInclusive()) != 0 ))
- {
- XMLCh* value1 = getMaxInclusive()->toString();
- ArrayJanitor<XMLCh> jan1(value1);
- XMLCh* value2 = numBase->getMaxInclusive()->toString();
- ArrayJanitor<XMLCh> jan2(value2);
- ThrowXML2(InvalidDatatypeFacetException
- , XMLExcepts::FACET_maxIncl_base_fixed
- , value1
- , value2);
- }
- }
-
- // check 4.3.8.c3 error:
- // maxExclusive > base.maxExclusive
- // maxExclusive > base.maxInclusive
- // maxExclusive <= base.minInclusive
- // maxExclusive <= base.minExclusive
- // maxExclusive != base.maxExclusive if (base.fixed)
- if ( ((getFacetsDefined() & DatatypeValidator::FACET_MAXEXCLUSIVE) != 0) )
- {
- if ( (( numBase->getFacetsDefined() & DatatypeValidator::FACET_MAXEXCLUSIVE) != 0) &&
- ( XMLBigDecimal::compareValues(getMaxExclusive(), numBase->getMaxExclusive()) == 1 ))
- {
- XMLCh* value1 = getMaxExclusive()->toString();
- ArrayJanitor<XMLCh> jan1(value1);
- XMLCh* value2 = numBase->getMaxExclusive()->toString();
- ArrayJanitor<XMLCh> jan2(value2);
- ThrowXML2(InvalidDatatypeFacetException
- , XMLExcepts::FACET_maxExcl_base_maxExcl
- , value1
- , value2);
- }
-
- if ( (( numBase->getFacetsDefined() & DatatypeValidator::FACET_MAXINCLUSIVE) != 0) &&
- ( XMLBigDecimal::compareValues(getMaxExclusive(), numBase->getMaxInclusive()) == 1 ))
- {
- XMLCh* value1 = getMaxExclusive()->toString();
- ArrayJanitor<XMLCh> jan1(value1);
- XMLCh* value2 = numBase->getMaxInclusive()->toString();
- ArrayJanitor<XMLCh> jan2(value2);
- ThrowXML2(InvalidDatatypeFacetException
- , XMLExcepts::FACET_maxExcl_base_maxIncl
- , value1
- , value2);
- }
-
- if ( (( numBase->getFacetsDefined() & DatatypeValidator::FACET_MINEXCLUSIVE) != 0) &&
- ( XMLBigDecimal::compareValues(getMaxExclusive(), numBase->getMinExclusive() ) != 1 ))
- {
- XMLCh* value1 = getMaxExclusive()->toString();
- ArrayJanitor<XMLCh> jan1(value1);
- XMLCh* value2 = numBase->getMinExclusive()->toString();
- ArrayJanitor<XMLCh> jan2(value2);
- ThrowXML2(InvalidDatatypeFacetException
- , XMLExcepts::FACET_maxExcl_base_minExcl
- , value1
- , value2);
- }
-
- if ( (( numBase->getFacetsDefined() & DatatypeValidator::FACET_MININCLUSIVE) != 0) &&
- ( XMLBigDecimal::compareValues(getMaxExclusive(), numBase->getMinInclusive()) != 1 ))
- {
- XMLCh* value1 = getMaxExclusive()->toString();
- ArrayJanitor<XMLCh> jan1(value1);
- XMLCh* value2 = numBase->getMinInclusive()->toString();
- ArrayJanitor<XMLCh> jan2(value2);
- ThrowXML2(InvalidDatatypeFacetException
- , XMLExcepts::FACET_maxExcl_base_minExcl
- , value1
- , value2);
- }
-
- if ( (( numBase->getFacetsDefined() & DatatypeValidator::FACET_MAXEXCLUSIVE) != 0) &&
- (( numBase->getFixed() & DatatypeValidator::FACET_MAXEXCLUSIVE) != 0) &&
- ( XMLBigDecimal::compareValues(getMaxExclusive(), numBase->getMaxExclusive()) != 0 ))
- {
- XMLCh* value1 = getMaxExclusive()->toString();
- ArrayJanitor<XMLCh> jan1(value1);
- XMLCh* value2 = numBase->getMaxExclusive()->toString();
- ArrayJanitor<XMLCh> jan2(value2);
- ThrowXML2(InvalidDatatypeFacetException
- , XMLExcepts::FACET_maxExcl_base_fixed
- , value1
- , value2);
- }
- }
-
- // check 4.3.9.c3 error:
- // minExclusive < base.minExclusive
- // minExclusive > base.maxInclusive ??? minExclusive >= base.maxInclusive
- // minExclusive < base.minInclusive
- // minExclusive >= base.maxExclusive
- // minExclusive != base.minExclusive if (base.fixed)
- if ( ((getFacetsDefined() & DatatypeValidator::FACET_MINEXCLUSIVE) != 0) )
- {
- if ( (( numBase->getFacetsDefined() & DatatypeValidator::FACET_MINEXCLUSIVE) != 0) &&
- ( XMLBigDecimal::compareValues(getMinExclusive(), numBase->getMinExclusive() ) == -1 ))
- {
- XMLCh* value1 = getMinExclusive()->toString();
- ArrayJanitor<XMLCh> jan1(value1);
- XMLCh* value2 = numBase->getMinExclusive()->toString();
- ArrayJanitor<XMLCh> jan2(value2);
- ThrowXML2(InvalidDatatypeFacetException
- , XMLExcepts::FACET_minExcl_base_minExcl
- , value1
- , value2);
- }
-
- if ( (( numBase->getFacetsDefined() & DatatypeValidator::FACET_MAXINCLUSIVE) != 0) &&
- ( XMLBigDecimal::compareValues(getMinExclusive(), numBase->getMaxInclusive()) == 1 ))
- {
- XMLCh* value1 = getMinExclusive()->toString();
- ArrayJanitor<XMLCh> jan1(value1);
- XMLCh* value2 = numBase->getMaxInclusive()->toString();
- ArrayJanitor<XMLCh> jan2(value2);
- ThrowXML2(InvalidDatatypeFacetException
- , XMLExcepts::FACET_minExcl_base_maxIncl
- , value1
- , value2);
- }
-
- if ( (( numBase->getFacetsDefined() & DatatypeValidator::FACET_MININCLUSIVE) != 0) &&
- ( XMLBigDecimal::compareValues(getMinExclusive(), numBase->getMinInclusive()) == -1 ))
- {
- XMLCh* value1 = getMinExclusive()->toString();
- ArrayJanitor<XMLCh> jan1(value1);
- XMLCh* value2 = numBase->getMinInclusive()->toString();
- ArrayJanitor<XMLCh> jan2(value2);
- ThrowXML2(InvalidDatatypeFacetException
- , XMLExcepts::FACET_minExcl_base_minIncl
- , value1
- , value2);
- }
-
- if ( (( numBase->getFacetsDefined() & DatatypeValidator::FACET_MAXEXCLUSIVE) != 0) &&
- ( XMLBigDecimal::compareValues(getMinExclusive(), numBase->getMaxExclusive()) != -1 ))
- {
- XMLCh* value1 = getMinExclusive()->toString();
- ArrayJanitor<XMLCh> jan1(value1);
- XMLCh* value2 = numBase->getMaxExclusive()->toString();
- ArrayJanitor<XMLCh> jan2(value2);
- ThrowXML2(InvalidDatatypeFacetException
- , XMLExcepts::FACET_minExcl_base_maxExcl
- , value1
- , value2);
- }
+ }
+ }
- if ( (( numBase->getFacetsDefined() & DatatypeValidator::FACET_MINEXCLUSIVE) != 0) &&
- (( numBase->getFixed() & DatatypeValidator::FACET_MINEXCLUSIVE) != 0) &&
- ( XMLBigDecimal::compareValues(getMinExclusive(), numBase->getMinExclusive() ) != 0 ))
- {
- XMLCh* value1 = getMinExclusive()->toString();
- ArrayJanitor<XMLCh> jan1(value1);
- XMLCh* value2 = numBase->getMinExclusive()->toString();
- ArrayJanitor<XMLCh> jan2(value2);
- ThrowXML2(InvalidDatatypeFacetException
- , XMLExcepts::FACET_minExcl_base_fixed
- , value1
- , value2);
- }
- }
-
- // check 4.3.10.c2 error:
- // minInclusive < base.minInclusive
- // minInclusive > base.maxInclusive
- // minInclusive <= base.minExclusive
- // minInclusive >= base.maxExclusive
- // minInclusive != base.minInclusive if (base.fixed)
- if ( ((getFacetsDefined() & DatatypeValidator::FACET_MININCLUSIVE) != 0) )
- {
- if ( ((numBase->getFacetsDefined() & DatatypeValidator::FACET_MININCLUSIVE) != 0) &&
- ( XMLBigDecimal::compareValues(getMinInclusive(), numBase->getMinInclusive()) == -1 ))
- {
- XMLCh* value1 = getMinInclusive()->toString();
- ArrayJanitor<XMLCh> jan1(value1);
- XMLCh* value2 = numBase->getMinInclusive()->toString();
- ArrayJanitor<XMLCh> jan2(value2);
- ThrowXML2(InvalidDatatypeFacetException
- , XMLExcepts::FACET_minIncl_base_minIncl
- , value1
- , value2);
- }
+}
- if ( (( numBase->getFacetsDefined() & DatatypeValidator::FACET_MAXINCLUSIVE) != 0) &&
- ( XMLBigDecimal::compareValues(getMinInclusive(), numBase->getMaxInclusive()) == 1 ))
- {
- XMLCh* value1 = getMinInclusive()->toString();
- ArrayJanitor<XMLCh> jan1(value1);
- XMLCh* value2 = numBase->getMaxInclusive()->toString();
- ArrayJanitor<XMLCh> jan2(value2);
- ThrowXML2(InvalidDatatypeFacetException
- , XMLExcepts::FACET_minIncl_base_maxIncl
- , value1
- , value2);
- }
+void DecimalDatatypeValidator::checkAdditionalFacetConstraintsBase() const
+{
- if ( (( numBase->getFacetsDefined() & DatatypeValidator::FACET_MINEXCLUSIVE) != 0) &&
- ( XMLBigDecimal::compareValues(getMinInclusive(), numBase->getMinExclusive() ) != 1 ))
- {
- XMLCh* value1 = getMinInclusive()->toString();
- ArrayJanitor<XMLCh> jan1(value1);
- XMLCh* value2 = numBase->getMinExclusive()->toString();
- ArrayJanitor<XMLCh> jan2(value2);
- ThrowXML2(InvalidDatatypeFacetException
- , XMLExcepts::FACET_minIncl_base_minExcl
- , value1
- , value2);
- }
+ DecimalDatatypeValidator *numBase = (DecimalDatatypeValidator*) getBaseValidator();
- if ( (( numBase->getFacetsDefined() & DatatypeValidator::FACET_MAXEXCLUSIVE) != 0) &&
- ( XMLBigDecimal::compareValues(getMinInclusive(), numBase->getMaxExclusive()) != -1 ))
- {
- XMLCh* value1 = getMinInclusive()->toString();
- ArrayJanitor<XMLCh> jan1(value1);
- XMLCh* value2 = numBase->getMaxExclusive()->toString();
- ArrayJanitor<XMLCh> jan2(value2);
- ThrowXML2(InvalidDatatypeFacetException
- , XMLExcepts::FACET_minIncl_base_maxExcl
- , value1
- , value2);
- }
+ if (!numBase)
+ return;
- if ( ((numBase->getFacetsDefined() & DatatypeValidator::FACET_MININCLUSIVE) != 0) &&
- ((numBase->getFixed() & DatatypeValidator::FACET_MININCLUSIVE) != 0) &&
- ( XMLBigDecimal::compareValues(getMinInclusive(), numBase->getMinInclusive()) != 0 ))
- {
- XMLCh* value1 = getMinInclusive()->toString();
- ArrayJanitor<XMLCh> jan1(value1);
- XMLCh* value2 = numBase->getMinInclusive()->toString();
- ArrayJanitor<XMLCh> jan2(value2);
- ThrowXML2(InvalidDatatypeFacetException
- , XMLExcepts::FACET_minIncl_base_fixed
- , value1
- , value2);
- }
-
- }
+ int thisFacetsDefined = getFacetsDefined();
+ int baseFacetsDefined = numBase->getFacetsDefined();
- // check 4.3.11.c1 error: totalDigits > base.totalDigits
- // totalDigits != base.totalDigits if (base.fixed)
- if (( getFacetsDefined() & DatatypeValidator::FACET_TOTALDIGITS) != 0)
- {
- if ( (( numBase->getFacetsDefined() & DatatypeValidator::FACET_TOTALDIGITS) != 0) &&
- ( fTotalDigits > numBase->fTotalDigits ))
- {
- XMLString::binToText(fTotalDigits, value1, BUF_LEN, 10);
- XMLString::binToText(numBase->fTotalDigits, value2, BUF_LEN, 10);
- ThrowXML2(InvalidDatatypeFacetException
+ // check 4.3.11.c1 error: totalDigits > base.totalDigits
+ // totalDigits != base.totalDigits if (base.fixed)
+ if (( thisFacetsDefined & DatatypeValidator::FACET_TOTALDIGITS) != 0)
+ {
+ if ( (( baseFacetsDefined & DatatypeValidator::FACET_TOTALDIGITS) != 0) &&
+ ( fTotalDigits > numBase->fTotalDigits ))
+ {
+ XMLString::binToText(fTotalDigits, value1, BUF_LEN, 10);
+ XMLString::binToText(numBase->fTotalDigits, value2, BUF_LEN, 10);
+ ThrowXML2(InvalidDatatypeFacetException
, XMLExcepts::FACET_totalDigit_base_totalDigit
, value1
, value2);
- }
+ }
- if ( (( numBase->getFacetsDefined() & DatatypeValidator::FACET_TOTALDIGITS) != 0) &&
- (( numBase->getFixed() & DatatypeValidator::FACET_TOTALDIGITS) != 0) &&
- ( fTotalDigits != numBase->fTotalDigits ))
- {
- XMLString::binToText(fTotalDigits, value1, BUF_LEN, 10);
- XMLString::binToText(numBase->fTotalDigits, value2, BUF_LEN, 10);
- ThrowXML2(InvalidDatatypeFacetException
+ if ( (( baseFacetsDefined & DatatypeValidator::FACET_TOTALDIGITS) != 0) &&
+ (( numBase->getFixed() & DatatypeValidator::FACET_TOTALDIGITS) != 0) &&
+ ( fTotalDigits != numBase->fTotalDigits ))
+ {
+ XMLString::binToText(fTotalDigits, value1, BUF_LEN, 10);
+ XMLString::binToText(numBase->fTotalDigits, value2, BUF_LEN, 10);
+ ThrowXML2(InvalidDatatypeFacetException
, XMLExcepts::FACET_totalDigit_base_fixed
, value1
, value2);
- }
- }
+ }
+ }
- if (( getFacetsDefined() & DatatypeValidator::FACET_FRACTIONDIGITS) != 0)
- {
- // check question error: fractionDigits > base.fractionDigits ???
- if ( (( numBase->getFacetsDefined() & DatatypeValidator::FACET_FRACTIONDIGITS) != 0) &&
- ( fFractionDigits > numBase->fFractionDigits ))
- {
- XMLString::binToText(fFractionDigits, value1, BUF_LEN, 10);
- XMLString::binToText(numBase->fFractionDigits, value2, BUF_LEN, 10);
- ThrowXML2(InvalidDatatypeFacetException
+ if (( thisFacetsDefined & DatatypeValidator::FACET_FRACTIONDIGITS) != 0)
+ {
+ // check question error: fractionDigits > base.fractionDigits ???
+ if ( (( baseFacetsDefined & DatatypeValidator::FACET_FRACTIONDIGITS) != 0) &&
+ ( fFractionDigits > numBase->fFractionDigits ))
+ {
+ XMLString::binToText(fFractionDigits, value1, BUF_LEN, 10);
+ XMLString::binToText(numBase->fFractionDigits, value2, BUF_LEN, 10);
+ ThrowXML2(InvalidDatatypeFacetException
, XMLExcepts::FACET_fractDigit_base_fractDigit
, value1
, value2);
}
- // check question error: fractionDigits > base.totalDigits ???
- if ( (( numBase->getFacetsDefined() & DatatypeValidator::FACET_TOTALDIGITS) != 0) &&
- ( fFractionDigits > numBase->fTotalDigits ))
- {
- XMLString::binToText(fFractionDigits, value1, BUF_LEN, 10);
- XMLString::binToText(numBase->fTotalDigits, value2, BUF_LEN, 10);
- ThrowXML2(InvalidDatatypeFacetException
+ // check question error: fractionDigits > base.totalDigits ???
+ if ( (( baseFacetsDefined & DatatypeValidator::FACET_TOTALDIGITS) != 0) &&
+ ( fFractionDigits > numBase->fTotalDigits ))
+ {
+ XMLString::binToText(fFractionDigits, value1, BUF_LEN, 10);
+ XMLString::binToText(numBase->fTotalDigits, value2, BUF_LEN, 10);
+ ThrowXML2(InvalidDatatypeFacetException
, XMLExcepts::FACET_fractDigit_base_totalDigit
, value1
, value2);
- }
+ }
- // fractionDigits != base.fractionDigits if (base.fixed)
- if ( (( numBase->getFacetsDefined() & DatatypeValidator::FACET_FRACTIONDIGITS) != 0) &&
- (( numBase->getFixed() & DatatypeValidator::FACET_FRACTIONDIGITS) != 0) &&
- ( fFractionDigits != numBase->fFractionDigits ))
- {
- XMLString::binToText(fFractionDigits, value1, BUF_LEN, 10);
- XMLString::binToText(numBase->fFractionDigits, value2, BUF_LEN, 10);
- ThrowXML2(InvalidDatatypeFacetException
+ // fractionDigits != base.fractionDigits if (base.fixed)
+ if ( (( baseFacetsDefined & DatatypeValidator::FACET_FRACTIONDIGITS) != 0) &&
+ (( numBase->getFixed() & DatatypeValidator::FACET_FRACTIONDIGITS) != 0) &&
+ ( fFractionDigits != numBase->fFractionDigits ))
+ {
+ XMLString::binToText(fFractionDigits, value1, BUF_LEN, 10);
+ XMLString::binToText(numBase->fFractionDigits, value2, BUF_LEN, 10);
+ ThrowXML2(InvalidDatatypeFacetException
, XMLExcepts::FACET_fractDigit_base_fixed
, value1
, value2);
- }
- }
-
-
- // check question error: totalDigits conflicts with bounds ???
-
- // check 4.3.5.c0 must: enumeration values from the value space of base
- //
- // In fact, the values in the enumeration shall go through validation
- // of this class as well.
- // this->checkContent(value, false);
- //
- if ( ((getFacetsDefined() & DatatypeValidator::FACET_ENUMERATION) != 0) &&
- ( fStrEnumeration != 0 ))
- {
- int i;
- int enumLength = fStrEnumeration->size();
- try
- {
- for ( i = 0; i < enumLength; i++)
- {
- // ask parent do a complete check
- numBase->checkContent(fStrEnumeration->elementAt(i), false);
- // shall pass this->checkContent() as well
- checkContent(fStrEnumeration->elementAt(i), false);
- }
-
- }
-
- catch ( XMLException& )
- {
- ThrowXML1(InvalidDatatypeFacetException
- , XMLExcepts::FACET_enum_base
- , fStrEnumeration->elementAt(i));
- }
+ }
+ }
- //
- // we need to convert from fStrEnumeration to fEnumeration
- try
- {
- fEnumeration = new RefVectorOf<XMLBigDecimal>(enumLength, true);
- fEnumerationInherited = false;
- for ( i = 0; i < enumLength; i++)
- fEnumeration->insertElementAt(new XMLBigDecimal(fStrEnumeration->elementAt(i)), i);
+}
- }
- catch ( NumberFormatException& )
- {
- ThrowXML1(InvalidDatatypeFacetException
- , XMLExcepts::FACET_enum_base
- , fStrEnumeration->elementAt(i));
- }
+int DecimalDatatypeValidator::compareValues(const XMLNumber* const lValue
+ , const XMLNumber* const rValue)
+{
+ return XMLBigDecimal::compareValues((XMLBigDecimal*) lValue, (XMLBigDecimal*) rValue);
+}
- }
+void DecimalDatatypeValidator::setMaxInclusive(const XMLCh* const value)
+{
+ fMaxInclusive = new XMLBigDecimal(value);
+}
- //
- // maxInclusive
- // maxExclusive
- // minInclusive
- // minExclusive
- // shall come from the base's value space as well
- //
- if ((getFacetsDefined() & DatatypeValidator::FACET_MAXINCLUSIVE) != 0)
- {
- try
- {
- // ask parent do a complete check
- XMLCh* value1 = getMaxInclusive()->toString();
- ArrayJanitor<XMLCh> jan(value1);
- numBase->checkContent(value1, false);
- }
- catch ( XMLException& )
- {
- ThrowXML1(InvalidDatatypeFacetException
- , XMLExcepts::FACET_maxIncl_notFromBase
- , value1
- );
- }
- }
+void DecimalDatatypeValidator::setMaxExclusive(const XMLCh* const value)
+{
+ fMaxExclusive = new XMLBigDecimal(value);
+}
- if ((getFacetsDefined() & DatatypeValidator::FACET_MAXEXCLUSIVE) != 0)
- {
- try
- {
- // ask parent do a complete check
- XMLCh* value1 = getMaxExclusive()->toString();
- ArrayJanitor<XMLCh> jan(value1);
- numBase->checkContent(value1, false);
- }
- catch ( XMLException& )
- {
- ThrowXML1(InvalidDatatypeFacetException
- , XMLExcepts::FACET_maxExcl_notFromBase
- , value1
- );
- }
- }
+void DecimalDatatypeValidator::setMinInclusive(const XMLCh* const value)
+{
+ fMinInclusive = new XMLBigDecimal(value);
+}
- if ((getFacetsDefined() & DatatypeValidator::FACET_MININCLUSIVE) != 0)
- {
- try
- {
- // ask parent do a complete check
- XMLCh* value1 = getMinInclusive()->toString();
- ArrayJanitor<XMLCh> jan(value1);
- numBase->checkContent(value1, false);
- }
- catch ( XMLException& )
- {
- ThrowXML1(InvalidDatatypeFacetException
- , XMLExcepts::FACET_minIncl_notFromBase
- , value1
- );
- }
- }
+void DecimalDatatypeValidator::setMinExclusive(const XMLCh* const value)
+{
+ fMinExclusive = new XMLBigDecimal(value);
+}
- if ((getFacetsDefined() & DatatypeValidator::FACET_MINEXCLUSIVE) != 0)
- {
- try
- {
- // ask parent do a complete check
- XMLCh* value1 = getMinExclusive()->toString();
- ArrayJanitor<XMLCh> jan(value1);
- numBase->checkContent(value1, false);
- }
- catch ( XMLException& )
- {
- ThrowXML1(InvalidDatatypeFacetException
- , XMLExcepts::FACET_minExcl_notFromBase
- , value1
- );
- }
- }
+void DecimalDatatypeValidator::setEnumeration()
+{
+ // check 4.3.5.c0 must: enumeration values from the value space of base
+ //
+ // 1. shall be from base value space
+ // 2. shall be from current value space as well
+ // ( **shall go through boundsCheck() )
+ //
+ if (!fStrEnumeration)
+ return;
- }
+ int i = 0;
+ int enumLength = fStrEnumeration->size();
- } //if baseValidator
- }
- catch (XMLException &e)
+ DecimalDatatypeValidator *numBase = (DecimalDatatypeValidator*) getBaseValidator();
+ if (numBase)
+ {
+ try
{
- ThrowXML1(InvalidDatatypeFacetException, XMLExcepts::RethrowError, e.getMessage());
- }
-
- }// End of Facet setting
-
-
- /***
- Schema constraint: Part III -- inherit from base
- ***/
- if ( baseValidator )
- {
- DecimalDatatypeValidator* numBase = (DecimalDatatypeValidator*)baseValidator;
- // inherit enumeration
- if ((( numBase->getFacetsDefined() & DatatypeValidator::FACET_ENUMERATION) !=0) &&
- (( getFacetsDefined() & DatatypeValidator::FACET_ENUMERATION) == 0))
- {
- fEnumeration = numBase->getEnumeration();
- fEnumerationInherited = true;
- setFacetsDefined(DatatypeValidator::FACET_ENUMERATION);
- }
+ for ( i = 0; i < enumLength; i++)
+ {
+ numBase->checkContent(fStrEnumeration->elementAt(i), false);
+ }
+ }
+ catch (XMLException&)
+ {
+ ThrowXML1(InvalidDatatypeFacetException
+ , XMLExcepts::FACET_enum_base
+ , fStrEnumeration->elementAt(i));
- // inherit maxExclusive
- if ((( numBase->getFacetsDefined() & DatatypeValidator::FACET_MAXEXCLUSIVE) != 0) &&
- (( getFacetsDefined() & DatatypeValidator::FACET_MAXEXCLUSIVE) == 0) &&
- (( getFacetsDefined() & DatatypeValidator::FACET_MAXINCLUSIVE) == 0) )
- {
- setMaxExclusive(new XMLBigDecimal(*(numBase->getMaxExclusive())));
- setFacetsDefined(DatatypeValidator::FACET_MAXEXCLUSIVE);
- }
-
- // inherit maxInclusive
- if ((( numBase->getFacetsDefined() & DatatypeValidator::FACET_MAXINCLUSIVE) != 0) &&
- (( getFacetsDefined() & DatatypeValidator::FACET_MAXEXCLUSIVE) == 0) &&
- (( getFacetsDefined() & DatatypeValidator::FACET_MAXINCLUSIVE) == 0) )
- {
- setMaxInclusive(new XMLBigDecimal(*(numBase->getMaxInclusive())));
- setFacetsDefined(DatatypeValidator::FACET_MAXINCLUSIVE);
}
+ }
- // inherit minExclusive
- if ((( numBase->getFacetsDefined() & DatatypeValidator::FACET_MINEXCLUSIVE) != 0) &&
- (( getFacetsDefined() & DatatypeValidator::FACET_MINEXCLUSIVE) == 0) &&
- (( getFacetsDefined() & DatatypeValidator::FACET_MININCLUSIVE) == 0) )
- {
- setMinExclusive(new XMLBigDecimal(*(numBase->getMinExclusive())));
- setFacetsDefined(DatatypeValidator::FACET_MINEXCLUSIVE);
- }
-
- // inherit minExclusive
- if ((( numBase->getFacetsDefined() & DatatypeValidator::FACET_MININCLUSIVE) != 0) &&
- (( getFacetsDefined() & DatatypeValidator::FACET_MINEXCLUSIVE) == 0) &&
- (( getFacetsDefined() & DatatypeValidator::FACET_MININCLUSIVE) == 0) )
- {
- setMinInclusive(new XMLBigDecimal(*(numBase->getMinInclusive())));
- setFacetsDefined(DatatypeValidator::FACET_MININCLUSIVE);
- }
+ // We put the this->checkContent in a separate loop
+ // to not block original message with in that method.
+ //
+ for ( i = 0; i < enumLength; i++)
+ {
+ checkContent(fStrEnumeration->elementAt(i), false);
+ }
- // inherit totalDigits
- if ((( numBase->getFacetsDefined() & DatatypeValidator::FACET_TOTALDIGITS) != 0) &&
- (( getFacetsDefined() & DatatypeValidator::FACET_TOTALDIGITS) == 0) )
- {
- setTotalDigits(numBase->fTotalDigits);
- setFacetsDefined(DatatypeValidator::FACET_TOTALDIGITS);
- }
-
- // inherit fractionDigits
- if ((( numBase->getFacetsDefined() & DatatypeValidator::FACET_FRACTIONDIGITS) != 0) &&
- (( getFacetsDefined() & DatatypeValidator::FACET_FRACTIONDIGITS) == 0) )
- {
- setFractionDigits(numBase->fFractionDigits);
- setFacetsDefined(DatatypeValidator::FACET_FRACTIONDIGITS);
- }
+ fEnumeration = new RefVectorOf<XMLNumber>(enumLength, true);
+ fEnumerationInherited = false;
- // inherit "fixed" option
- setFixed(getFixed() | numBase->getFixed());
-
- }
+ for ( i = 0; i < enumLength; i++)
+ {
+ fEnumeration->insertElementAt(new XMLBigDecimal(fStrEnumeration->elementAt(i)), i);
+ }
}
@@ -1026,7 +427,7 @@
//validate against base validator if any
DecimalDatatypeValidator *pBase = (DecimalDatatypeValidator*) this->getBaseValidator();
- if (pBase !=0)
+ if (pBase)
pBase->checkContent(content, true);
// we check pattern first
@@ -1061,13 +462,13 @@
XMLBigDecimal theValue(content);
XMLBigDecimal *theData = &theValue;
- if (getEnumeration() != 0)
+ if (getEnumeration())
{
int i=0;
int enumLength = getEnumeration()->size();
for ( ; i < enumLength; i++)
{
- if (XMLBigDecimal::compareValues(theData, getEnumeration()->elementAt(i))==0)
+ if (XMLBigDecimal::compareValues(theData, (XMLBigDecimal*) getEnumeration()->elementAt(i))==0)
break;
}
@@ -1075,6 +476,7 @@
ThrowXML1(InvalidDatatypeValueException, XMLExcepts::VALUE_NotIn_Enumeration, content);
}
+ boundsCheck(theData);
if ( (getFacetsDefined() & DatatypeValidator::FACET_FRACTIONDIGITS) != 0 )
{
@@ -1108,70 +510,6 @@
}
}
- if ( (getFacetsDefined() & DatatypeValidator::FACET_MAXEXCLUSIVE) != 0 )
- {
- // must be < MaxExclusive
- if (XMLBigDecimal::compareValues(theData, getMaxExclusive()) != -1)
- {
- XMLCh* value1 = theData->toString();
- ArrayJanitor<XMLCh> jan1(value1);
- XMLCh* value2 = getMaxExclusive()->toString();
- ArrayJanitor<XMLCh> jan2(value2);
- ThrowXML2(InvalidDatatypeFacetException
- , XMLExcepts::VALUE_exceed_maxExcl
- , value1
- , value2);
- }
- }
-
- if ( (getFacetsDefined() & DatatypeValidator::FACET_MAXINCLUSIVE) != 0 )
- {
- // must be <= MaxInclusive
- if (XMLBigDecimal::compareValues(theData, getMaxInclusive()) == 1)
- {
- XMLCh* value1 = theData->toString();
- ArrayJanitor<XMLCh> jan1(value1);
- XMLCh* value2 = getMaxInclusive()->toString();
- ArrayJanitor<XMLCh> jan2(value2);
- ThrowXML2(InvalidDatatypeFacetException
- , XMLExcepts::VALUE_exceed_maxIncl
- , value1
- , value2);
-
- }
- }
-
- if ( (getFacetsDefined() & DatatypeValidator::FACET_MININCLUSIVE) != 0 )
- {
- // must be >= MinInclusive
- if (XMLBigDecimal::compareValues(theData, getMinInclusive()) == -1)
- {
- XMLCh* value1 = theData->toString();
- ArrayJanitor<XMLCh> jan1(value1);
- XMLCh* value2 = getMinInclusive()->toString();
- ArrayJanitor<XMLCh> jan2(value2);
- ThrowXML2(InvalidDatatypeFacetException
- , XMLExcepts::VALUE_exceed_minIncl
- , value1
- , value2);
- }
- }
-
- if ( (getFacetsDefined() & DatatypeValidator::FACET_MINEXCLUSIVE) != 0 )
- {
- // must be > MinExclusive
- if (XMLBigDecimal::compareValues(theData, getMinExclusive()) != 1)
- {
- XMLCh* value1 = theData->toString();
- ArrayJanitor<XMLCh> jan1(value1);
- XMLCh* value2 = getMinExclusive()->toString();
- ArrayJanitor<XMLCh> jan2(value2);
- ThrowXML2(InvalidDatatypeFacetException
- , XMLExcepts::VALUE_exceed_minExcl
- , value1
- , value2);
- }
- }
}
catch (XMLException &e)
{
---------------------------------------------------------------------
To unsubscribe, e-mail: xerces-cvs-unsubscribe@xml.apache.org
For additional commands, e-mail: xerces-cvs-help@xml.apache.org