in src/xercesc/validators/datatype/AbstractNumericFacetValidator.cpp [341:726]
void AbstractNumericFacetValidator::inspectFacetBase(MemoryManager* const manager)
{
AbstractNumericFacetValidator* numBase = (AbstractNumericFacetValidator*) getBaseValidator();
int thisFacetsDefined = getFacetsDefined();
if ( (!thisFacetsDefined && !fEnumeration) ||
!numBase )
return;
int baseFacetsDefined = numBase->getFacetsDefined();
XMLNumber *thisMaxInclusive = getMaxInclusive();
XMLNumber *thisMaxExclusive = getMaxExclusive();
XMLNumber *thisMinInclusive = getMinInclusive();
XMLNumber *thisMinExclusive = getMinExclusive();
XMLNumber *baseMaxInclusive = numBase->getMaxInclusive();
XMLNumber *baseMaxExclusive = numBase->getMaxExclusive();
XMLNumber *baseMinInclusive = numBase->getMinInclusive();
XMLNumber *baseMinExclusive = numBase->getMinExclusive();
int baseFixed = numBase->getFixed();
// this
// minExclusive maxExclusive
// minInclusive maxInclusive
//
// base
// minExclusive maxExclusive
// minInclusive maxInclusive
//
// check 4.3.7.c2 error:
// maxInclusive > base.maxInclusive && maxInclusive != base.maxInclusive if (base.fixed)
// maxInclusive >= base.maxExclusive
// maxInclusive < base.minInclusive
// maxInclusive <= base.minExclusive
if ((thisFacetsDefined & DatatypeValidator::FACET_MAXINCLUSIVE) != 0)
{
if ((baseFacetsDefined & DatatypeValidator::FACET_MAXINCLUSIVE) != 0)
{
int result = compareValues(thisMaxInclusive, baseMaxInclusive);
if (((baseFixed & DatatypeValidator::FACET_MAXINCLUSIVE) != 0) &&
(result != 0 ))
{
REPORT_FACET_ERROR(thisMaxInclusive
, baseMaxInclusive
, XMLExcepts::FACET_maxIncl_base_fixed
, manager)
}
if (result == 1 || result == INDETERMINATE)
{
REPORT_FACET_ERROR(thisMaxInclusive
, baseMaxInclusive
, XMLExcepts::FACET_maxIncl_base_maxIncl
, manager)
}
}
if ((baseFacetsDefined & DatatypeValidator::FACET_MAXEXCLUSIVE) != 0)
{
int result = compareValues(thisMaxInclusive, baseMaxExclusive);
if (result != -1 )
{
REPORT_FACET_ERROR(thisMaxInclusive
, baseMaxExclusive
, XMLExcepts::FACET_maxIncl_base_maxExcl
, manager)
}
}
if ((baseFacetsDefined & DatatypeValidator::FACET_MININCLUSIVE) != 0)
{
int result = compareValues(thisMaxInclusive, baseMinInclusive);
if (result == -1 || result == INDETERMINATE)
{
REPORT_FACET_ERROR(thisMaxInclusive
, baseMinInclusive
, XMLExcepts::FACET_maxIncl_base_minIncl
, manager)
}
}
if ((baseFacetsDefined & DatatypeValidator::FACET_MINEXCLUSIVE) != 0)
{
int result = compareValues(thisMaxInclusive, baseMinExclusive);
if (result != 1 )
{
REPORT_FACET_ERROR(thisMaxInclusive
, baseMinExclusive
, XMLExcepts::FACET_maxIncl_base_minExcl
, manager)
}
}
}
// check 4.3.8.c3 error:
// maxExclusive > base.maxExclusive && maxExclusive != base.maxExclusive if (base.fixed)
// maxExclusive > base.maxInclusive
// maxExclusive <= base.minInclusive
// maxExclusive <= base.minExclusive
if ((thisFacetsDefined & DatatypeValidator::FACET_MAXEXCLUSIVE) != 0)
{
if (( baseFacetsDefined & DatatypeValidator::FACET_MAXEXCLUSIVE) != 0)
{
int result = compareValues(thisMaxExclusive, baseMaxExclusive);
if (((baseFixed & DatatypeValidator::FACET_MAXEXCLUSIVE) != 0) &&
(result != 0 ))
{
REPORT_FACET_ERROR(thisMaxExclusive
, baseMaxExclusive
, XMLExcepts::FACET_maxExcl_base_fixed
, manager)
}
if (result == 1 || result == INDETERMINATE)
{
REPORT_FACET_ERROR(thisMaxExclusive
, baseMaxExclusive
, XMLExcepts::FACET_maxExcl_base_maxExcl
, manager)
}
/**
* Schema Errata
* E2-16 maxExclusive
*
* derived type's maxExclusive must either be
* 1) equal to base' maxExclusive or
* 2) from the base type value space
*
*/
if (result != 0)
{
FROM_BASE_VALUE_SPACE(thisMaxExclusive
, DatatypeValidator::FACET_MAXEXCLUSIVE
, XMLExcepts::FACET_maxExcl_notFromBase
, manager)
}
}
else // base has no maxExclusive
{
FROM_BASE_VALUE_SPACE(thisMaxExclusive
, DatatypeValidator::FACET_MAXEXCLUSIVE
, XMLExcepts::FACET_maxExcl_notFromBase
, manager)
}
if (( baseFacetsDefined & DatatypeValidator::FACET_MAXINCLUSIVE) != 0)
{
int result = compareValues(thisMaxExclusive, baseMaxInclusive);
if (result == 1 || result == INDETERMINATE)
{
REPORT_FACET_ERROR(thisMaxExclusive
, baseMaxInclusive
, XMLExcepts::FACET_maxExcl_base_maxIncl
, manager)
}
}
if (( baseFacetsDefined & DatatypeValidator::FACET_MINEXCLUSIVE) != 0)
{
int result = compareValues(thisMaxExclusive, baseMinExclusive);
if (result != 1)
{
REPORT_FACET_ERROR(thisMaxExclusive
, baseMinExclusive
, XMLExcepts::FACET_maxExcl_base_minExcl
, manager)
}
}
if (( baseFacetsDefined & DatatypeValidator::FACET_MININCLUSIVE) != 0)
{
int result = compareValues(thisMaxExclusive, baseMinInclusive);
if (result != 1)
{
REPORT_FACET_ERROR(thisMaxExclusive
, baseMinInclusive
, XMLExcepts::FACET_maxExcl_base_minIncl
, manager)
}
}
}
// check 4.3.9.c3 error:
// minExclusive < base.minExclusive minExclusive != base.minExclusive if (base.fixed)
// minExclusive > base.maxInclusive ??? minExclusive >= base.maxInclusive
// minExclusive < base.minInclusive
// minExclusive >= base.maxExclusive
if ((thisFacetsDefined & DatatypeValidator::FACET_MINEXCLUSIVE) != 0)
{
if (( baseFacetsDefined & DatatypeValidator::FACET_MINEXCLUSIVE) != 0)
{
int result = compareValues(thisMinExclusive, baseMinExclusive);
if (((baseFixed & DatatypeValidator::FACET_MINEXCLUSIVE) != 0) &&
(result != 0 ))
{
REPORT_FACET_ERROR(thisMinExclusive
, baseMinExclusive
, XMLExcepts::FACET_minExcl_base_fixed
, manager)
}
if (result == -1 || result == INDETERMINATE)
{
REPORT_FACET_ERROR(thisMinExclusive
, baseMinExclusive
, XMLExcepts::FACET_minExcl_base_minExcl
, manager)
}
/**
* Schema Errata
* E2-16 maxExclusive
*
* derived type's minExclusive must either be
* 1) equal to base' minxExclusive or
* 2) from the base type value space
*
* Note: deduced from, not explicitly expressed in the Errata
*/
if (result != 0)
{
FROM_BASE_VALUE_SPACE(thisMinExclusive
, DatatypeValidator::FACET_MINEXCLUSIVE
, XMLExcepts::FACET_minExcl_notFromBase
, manager)
}
}
else // base has no minExclusive
{
FROM_BASE_VALUE_SPACE(thisMinExclusive
, DatatypeValidator::FACET_MINEXCLUSIVE
, XMLExcepts::FACET_minExcl_notFromBase
, manager)
}
if (( baseFacetsDefined & DatatypeValidator::FACET_MAXINCLUSIVE) != 0)
{
int result = compareValues(thisMinExclusive, baseMaxInclusive);
if (result == 1 || result == INDETERMINATE)
{
REPORT_FACET_ERROR(thisMinExclusive
, baseMaxInclusive
, XMLExcepts::FACET_minExcl_base_maxIncl
, manager)
}
}
if (( baseFacetsDefined & DatatypeValidator::FACET_MININCLUSIVE) != 0)
{
int result = compareValues(thisMinExclusive, baseMinInclusive);
if (result == -1 || result == INDETERMINATE)
{
REPORT_FACET_ERROR(thisMinExclusive
, baseMinInclusive
, XMLExcepts::FACET_minExcl_base_minIncl
, manager)
}
}
if (( baseFacetsDefined & DatatypeValidator::FACET_MAXEXCLUSIVE) != 0)
{
int result = compareValues(thisMinExclusive, baseMaxExclusive);
if (result != -1)
{
REPORT_FACET_ERROR(thisMinExclusive
, baseMaxExclusive
, XMLExcepts::FACET_minExcl_base_maxExcl
, manager)
}
}
}
// check 4.3.10.c2 error:
// minInclusive < base.minInclusive minInclusive != base.minInclusive if (base.fixed)
// minInclusive > base.maxInclusive
// minInclusive <= base.minExclusive
// minInclusive >= base.maxExclusive
if ((thisFacetsDefined & DatatypeValidator::FACET_MININCLUSIVE) != 0)
{
if ((baseFacetsDefined & DatatypeValidator::FACET_MININCLUSIVE) != 0)
{
int result = compareValues(thisMinInclusive, baseMinInclusive);
if (((baseFixed & DatatypeValidator::FACET_MININCLUSIVE) != 0) &&
(result != 0 ))
{
REPORT_FACET_ERROR(thisMinInclusive
, baseMinInclusive
, XMLExcepts::FACET_minIncl_base_fixed
, manager)
}
if (result == -1 || result == INDETERMINATE)
{
REPORT_FACET_ERROR(thisMinInclusive
, baseMinInclusive
, XMLExcepts::FACET_minIncl_base_minIncl
, manager)
}
}
if (( baseFacetsDefined & DatatypeValidator::FACET_MAXINCLUSIVE) != 0)
{
int result = compareValues(thisMinInclusive, baseMaxInclusive);
if (result == 1 || result == INDETERMINATE)
{
REPORT_FACET_ERROR(thisMinInclusive
, baseMaxInclusive
, XMLExcepts::FACET_minIncl_base_maxIncl
, manager)
}
}
if (( baseFacetsDefined & DatatypeValidator::FACET_MINEXCLUSIVE) != 0)
{
int result = compareValues(thisMinInclusive, baseMinExclusive);
if (result != 1)
{
REPORT_FACET_ERROR(thisMinInclusive
, baseMinExclusive
, XMLExcepts::FACET_minIncl_base_minExcl
, manager)
}
}
if (( baseFacetsDefined & DatatypeValidator::FACET_MAXEXCLUSIVE) != 0)
{
int result = compareValues(thisMinInclusive, baseMaxExclusive);
if (result != -1)
{
REPORT_FACET_ERROR(thisMinInclusive
, baseMaxExclusive
, XMLExcepts::FACET_minIncl_base_maxExcl
, manager)
}
}
}
checkAdditionalFacetConstraintsBase(manager);
// 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 ( ((thisFacetsDefined & DatatypeValidator::FACET_ENUMERATION) != 0) &&
( fStrEnumeration ))
{
setEnumeration(manager);
}
//
// maxInclusive, maxExclusive, minInclusive and minExclusive
// shall come from the base's value space as well
//
FROM_BASE_VALUE_SPACE(thisMaxInclusive
, DatatypeValidator::FACET_MAXINCLUSIVE
, XMLExcepts::FACET_maxIncl_notFromBase
, manager)
FROM_BASE_VALUE_SPACE(thisMinInclusive
, DatatypeValidator::FACET_MININCLUSIVE
, XMLExcepts::FACET_minIncl_notFromBase
, manager)
} //end of inspectFacetBase