void DecimalDatatypeValidator::inheritAdditionalFacet()
{
DecimalDatatypeValidator *numBase = (DecimalDatatypeValidator*) getBaseValidator();
if (!numBase)
return;
int thisFacetsDefined = getFacetsDefined();
int baseFacetsDefined = numBase->getFacetsDefined();
// inherit totalDigits
if ((( baseFacetsDefined & DatatypeValidator::FACET_TOTALDIGITS) != 0) &&
(( thisFacetsDefined & DatatypeValidator::FACET_TOTALDIGITS) == 0) )
{
setTotalDigits(numBase->fTotalDigits);
setFacetsDefined(DatatypeValidator::FACET_TOTALDIGITS);
}
// inherit fractionDigits
if ((( baseFacetsDefined & DatatypeValidator::FACET_FRACTIONDIGITS) != 0) &&
(( thisFacetsDefined & DatatypeValidator::FACET_FRACTIONDIGITS) == 0) )
{
setFractionDigits(numBase->fFractionDigits);
setFacetsDefined(DatatypeValidator::FACET_FRACTIONDIGITS);
}
}
void DecimalDatatypeValidator::assignAdditionalFacet(const XMLCh* const key
, const XMLCh* const value
, MemoryManager* const manager)
{
if (XMLString::equals(key, SchemaSymbols::fgELT_TOTALDIGITS))
{
int val;
try
{
val = XMLString::parseInt(value, manager);
}
catch (NumberFormatException&)
{
ThrowXMLwithMemMgr1(InvalidDatatypeFacetException, XMLExcepts::FACET_Invalid_TotalDigit, value, manager);
}
// check 4.3.11.c0 must: totalDigits > 0
if ( val <= 0 )
ThrowXMLwithMemMgr1(InvalidDatatypeFacetException, XMLExcepts::FACET_PosInt_TotalDigit, value, manager);
setTotalDigits(val);
setFacetsDefined(DatatypeValidator::FACET_TOTALDIGITS);
}
else if (XMLString::equals(key, SchemaSymbols::fgELT_FRACTIONDIGITS))
{
int val;
try
{
val = XMLString::parseInt(value, manager);
}
catch (NumberFormatException&)
{
ThrowXMLwithMemMgr1(InvalidDatatypeFacetException, XMLExcepts::FACET_Invalid_FractDigit, value, manager);
}
// check 4.3.12.c0 must: fractionDigits > 0
if ( val < 0 )
ThrowXMLwithMemMgr1(InvalidDatatypeFacetException, XMLExcepts::FACET_NonNeg_FractDigit, value, manager);
setFractionDigits(val);
setFacetsDefined(DatatypeValidator::FACET_FRACTIONDIGITS);
}
else
{
ThrowXMLwithMemMgr1(InvalidDatatypeFacetException
, XMLExcepts::FACET_Invalid_Tag
, key
, manager);
}
}
// ---------------------------------------------------------------------------
// Utilities
// ---------------------------------------------------------------------------
void StringDatatypeValidator::assignAdditionalFacet(const XMLCh* const key
, const XMLCh* const value
, MemoryManager* const manager)
{
if (XMLString::equals(key, SchemaSymbols::fgELT_WHITESPACE))
{
// whiteSpace = preserve | replace | collapse
if (XMLString::equals(value, SchemaSymbols::fgWS_PRESERVE))
setWhiteSpace(DatatypeValidator::PRESERVE);
else if (XMLString::equals(value, SchemaSymbols::fgWS_REPLACE))
setWhiteSpace(DatatypeValidator::REPLACE);
else if (XMLString::equals(value, SchemaSymbols::fgWS_COLLAPSE))
setWhiteSpace(DatatypeValidator::COLLAPSE);
else
ThrowXMLwithMemMgr1(InvalidDatatypeFacetException, XMLExcepts::FACET_Invalid_WS, value, manager);
//("whiteSpace value '" + ws + "' must be one of 'preserve', 'replace', 'collapse'.");
setFacetsDefined(DatatypeValidator::FACET_WHITESPACE);
}
else
{
ThrowXMLwithMemMgr1(InvalidDatatypeFacetException
, XMLExcepts::FACET_Invalid_Tag
, key
, manager);
}
}
XERCES_CPP_NAMESPACE_BEGIN
// ---------------------------------------------------------------------------
// Constructors and Destructor
// ---------------------------------------------------------------------------
BooleanDatatypeValidator::BooleanDatatypeValidator(
DatatypeValidator* const baseValidator
, RefHashTableOf<KVStringPair>* const facets
, RefArrayVectorOf<XMLCh>* const enums
, const int finalSet
, MemoryManager* const manager)
:DatatypeValidator(baseValidator, facets, finalSet, DatatypeValidator::Boolean, manager)
{
// Set Facets if any defined
if ( facets )
{
// Boolean shall NOT have enumeration
if (enums) {
delete enums;
ThrowXMLwithMemMgr1(InvalidDatatypeFacetException
, XMLExcepts::FACET_Invalid_Tag
, "enumeration"
, manager);
}
XMLCh* key;
XMLCh* value;
RefHashTableOfEnumerator<KVStringPair> e(facets, false, manager);
while (e.hasMoreElements())
{
KVStringPair pair = e.nextElement();
key = pair.getKey();
value = pair.getValue();
if (XMLString::equals(key, SchemaSymbols::fgELT_PATTERN))
{
setPattern(value);
setFacetsDefined(DatatypeValidator::FACET_PATTERN);
}
else
{
ThrowXMLwithMemMgr1(InvalidDatatypeFacetException
, XMLExcepts::FACET_Invalid_Tag
, key
, manager);
}
}
}// End of facet setting
}
void StringDatatypeValidator::inheritAdditionalFacet()
{
StringDatatypeValidator *pBaseValidator = (StringDatatypeValidator*) getBaseValidator();
if (!pBaseValidator)
return;
// inherit whitespace
if (((pBaseValidator->getFacetsDefined() & DatatypeValidator::FACET_WHITESPACE) !=0) &&
((getFacetsDefined() & DatatypeValidator::FACET_WHITESPACE) == 0))
{
setWhiteSpace(getBaseValidator()->getWSFacet());
setFacetsDefined(DatatypeValidator::FACET_WHITESPACE);
}
}
//
// P1. Enumeration
//
void AbstractNumericFacetValidator::init(RefArrayVectorOf<XMLCh>* const enums
, MemoryManager* const manager)
{
fStrEnumeration = enums; // save the literal value
// which is needed for getEnumString()
if (enums)
{
setFacetsDefined(DatatypeValidator::FACET_ENUMERATION);
}
assignFacet(manager);
inspectFacet(manager);
inspectFacetBase(manager);
inheritFacet();
}
//
// Assign facets
// assign common facets
// assign additional facet
//
void AbstractNumericFacetValidator::assignFacet(MemoryManager* const manager)
{
RefHashTableOf<KVStringPair>* facets = getFacets();
if (!facets) // no facets defined
return;
XMLCh* key;
RefHashTableOfEnumerator<KVStringPair> e(facets, false, manager);
while (e.hasMoreElements())
{
KVStringPair pair = e.nextElement();
key = pair.getKey();
XMLCh* value = pair.getValue();
if (XMLString::equals(key, SchemaSymbols::fgELT_PATTERN))
{
setPattern(value);
if (getPattern())
setFacetsDefined(DatatypeValidator::FACET_PATTERN);
// do not construct regex until needed
}
else if (XMLString::equals(key, SchemaSymbols::fgELT_MAXINCLUSIVE))
{
try
{
setMaxInclusive(value);
}
catch (NumberFormatException&)
{
ThrowXMLwithMemMgr1(InvalidDatatypeFacetException, XMLExcepts::FACET_Invalid_MaxIncl, value, manager);
}
setFacetsDefined(DatatypeValidator::FACET_MAXINCLUSIVE);
}
else if (XMLString::equals(key, SchemaSymbols::fgELT_MAXEXCLUSIVE))
{
try
{
setMaxExclusive(value);
}
catch (NumberFormatException&)
{
ThrowXMLwithMemMgr1(InvalidDatatypeFacetException, XMLExcepts::FACET_Invalid_MaxExcl, value, manager);
}
setFacetsDefined(DatatypeValidator::FACET_MAXEXCLUSIVE);
}
else if (XMLString::equals(key, SchemaSymbols::fgELT_MININCLUSIVE))
{
try
{
setMinInclusive(value);
}
catch (NumberFormatException&)
{
ThrowXMLwithMemMgr1(InvalidDatatypeFacetException, XMLExcepts::FACET_Invalid_MinIncl, value, manager);
}
setFacetsDefined(DatatypeValidator::FACET_MININCLUSIVE);
}
else if (XMLString::equals(key, SchemaSymbols::fgELT_MINEXCLUSIVE))
{
try
{
setMinExclusive(value);
}
catch (NumberFormatException&)
{
ThrowXMLwithMemMgr1(InvalidDatatypeFacetException, XMLExcepts::FACET_Invalid_MinExcl, value, manager);
}
setFacetsDefined(DatatypeValidator::FACET_MINEXCLUSIVE);
}
else if (XMLString::equals(key, SchemaSymbols::fgATT_FIXED))
{
unsigned int val;
bool retStatus;
try
{
retStatus = XMLString::textToBin(value, val, fMemoryManager);
}
catch (RuntimeException&)
{
ThrowXMLwithMemMgr(InvalidDatatypeFacetException, XMLExcepts::FACET_internalError_fixed, manager);
}
if (!retStatus)
{
ThrowXMLwithMemMgr(InvalidDatatypeFacetException, XMLExcepts::FACET_internalError_fixed, manager);
}
setFixed(val);
//no setFacetsDefined here
}
else
{
assignAdditionalFacet(key, value, manager);
}
}//while
}// end of assigneFacet()
void UnionDatatypeValidator::init(DatatypeValidator* const baseValidator
, RefHashTableOf<KVStringPair>* const facets
, RefArrayVectorOf<XMLCh>* const enums
, MemoryManager* const manager)
{
if (enums)
setEnumeration(enums, false);
// Set Facets if any defined
if (facets)
{
XMLCh* key;
XMLCh* value;
RefHashTableOfEnumerator<KVStringPair> e(facets, false, manager);
while (e.hasMoreElements())
{
KVStringPair pair = e.nextElement();
key = pair.getKey();
value = pair.getValue();
if (XMLString::equals(key, SchemaSymbols::fgELT_PATTERN))
{
setPattern(value);
if (getPattern())
setFacetsDefined(DatatypeValidator::FACET_PATTERN);
// do not construct regex until needed
}
else
{
ThrowXMLwithMemMgr1(InvalidDatatypeFacetException
, XMLExcepts::FACET_Invalid_Tag
, key
, manager);
}
}//while
/***
Schema constraint: Part I -- self checking
***/
// Nil
/***
Schema constraint: Part II base vs derived checking
***/
// check 4.3.5.c0 must: enumeration values from the value space of base
if ( ((getFacetsDefined() & DatatypeValidator::FACET_ENUMERATION) != 0) &&
(getEnumeration() !=0))
{
int i = 0;
int enumLength = getEnumeration()->size();
try
{
for ( ; i < enumLength; i++)
{
// ask parent do a complete check
//
// enum need NOT be passed this->checkContent()
// since there are no other facets for Union, parent
// checking is good enough.
//
baseValidator->validate(getEnumeration()->elementAt(i), (ValidationContext*)0, manager);
}
}
catch ( XMLException& )
{
ThrowXMLwithMemMgr1(InvalidDatatypeFacetException
, XMLExcepts::FACET_enum_base
, getEnumeration()->elementAt(i)
, manager);
}
}
}// End of Facet setting
/***
Inherit facets from base.facets
The reason of this inheriting (or copying values) is to ease
schema constraint checking, so that we need NOT trace back to our
very first base validator in the hierachy. Instead, we are pretty
sure checking against immediate base validator is enough.
***/
UnionDatatypeValidator *pBaseValidator = (UnionDatatypeValidator*) baseValidator;
// inherit enumeration
if (((pBaseValidator->getFacetsDefined() & DatatypeValidator::FACET_ENUMERATION) !=0) &&
((getFacetsDefined() & DatatypeValidator::FACET_ENUMERATION) == 0))
{
setEnumeration(pBaseValidator->getEnumeration(), true);
}
}
//
// Assign facets
// assign common facets
// assign additional facet
//
void AbstractStringValidator::assignFacet(MemoryManager* const manager)
{
RefHashTableOf<KVStringPair>* facets = getFacets();
if (!facets)
return;
XMLCh* key;
RefHashTableOfEnumerator<KVStringPair> e(facets, false, manager);
while (e.hasMoreElements())
{
KVStringPair pair = e.nextElement();
key = pair.getKey();
XMLCh* value = pair.getValue();
if (XMLString::equals(key, SchemaSymbols::fgELT_LENGTH))
{
int val;
try
{
val = XMLString::parseInt(value, manager);
}
catch (NumberFormatException&)
{
ThrowXMLwithMemMgr1(InvalidDatatypeFacetException, XMLExcepts::FACET_Invalid_Len, value, manager);
}
if ( val < 0 )
ThrowXMLwithMemMgr1(InvalidDatatypeFacetException, XMLExcepts::FACET_NonNeg_Len, value, manager);
setLength(val);
setFacetsDefined(DatatypeValidator::FACET_LENGTH);
}
else if (XMLString::equals(key, SchemaSymbols::fgELT_MINLENGTH))
{
int val;
try
{
val = XMLString::parseInt(value, manager);
}
catch (NumberFormatException&)
{
ThrowXMLwithMemMgr1(InvalidDatatypeFacetException, XMLExcepts::FACET_Invalid_minLen, value, manager);
}
if ( val < 0 )
ThrowXMLwithMemMgr1(InvalidDatatypeFacetException, XMLExcepts::FACET_NonNeg_minLen, value, manager);
setMinLength(val);
setFacetsDefined(DatatypeValidator::FACET_MINLENGTH);
}
else if (XMLString::equals(key, SchemaSymbols::fgELT_MAXLENGTH))
{
int val;
try
{
val = XMLString::parseInt(value, manager);
}
catch (NumberFormatException&)
{
ThrowXMLwithMemMgr1(InvalidDatatypeFacetException, XMLExcepts::FACET_Invalid_maxLen, value, manager);
}
if ( val < 0 )
ThrowXMLwithMemMgr1(InvalidDatatypeFacetException, XMLExcepts::FACET_NonNeg_maxLen, value, manager);
setMaxLength(val);
setFacetsDefined(DatatypeValidator::FACET_MAXLENGTH);
}
else if (XMLString::equals(key, SchemaSymbols::fgELT_PATTERN))
{
setPattern(value);
if (getPattern())
setFacetsDefined(DatatypeValidator::FACET_PATTERN);
// do not construct regex until needed
}
else if (XMLString::equals(key, SchemaSymbols::fgATT_FIXED))
{
unsigned int val;
bool retStatus;
try
{
retStatus = XMLString::textToBin(value, val, fMemoryManager);
}
catch (RuntimeException&)
{
ThrowXMLwithMemMgr(InvalidDatatypeFacetException, XMLExcepts::FACET_internalError_fixed, manager);
}
if (!retStatus)
{
ThrowXMLwithMemMgr(InvalidDatatypeFacetException, XMLExcepts::FACET_internalError_fixed, manager);
}
setFixed(val);
//no setFacetsDefined here
}
//
// else if (XMLString::equals(key, SchemaSymbols::fgELT_SPECIAL_TOKEN))
// TODO
//
// Note: whitespace is taken care of by TraverseSchema.
//
else
{
assignAdditionalFacet(key, value, manager);
}
}//while
}//end of assigneFacet()