void ListDatatypeValidator::inspectFacetBase(MemoryManager* const manager)
{
//
// we are pretty sure baseValidator is not null
//
if (getBaseValidator()->getType() == DatatypeValidator::List)
{
AbstractStringValidator::inspectFacetBase(manager);
}
else
{
// the first level ListDTV
// check 4.3.5.c0 must: enumeration values from the value space of base
if ( ((getFacetsDefined() & DatatypeValidator::FACET_ENUMERATION) != 0) &&
(getEnumeration() !=0) )
{
int i;
int enumLength = getEnumeration()->size();
try
{
for ( i = 0; i < enumLength; i++)
{
// ask the itemType for a complete check
BaseRefVectorOf<XMLCh>* tempList = XMLString::tokenizeString(getEnumeration()->elementAt(i), manager);
Janitor<BaseRefVectorOf<XMLCh> > jan(tempList);
int tokenNumber = tempList->size();
try
{
for ( int j = 0; j < tokenNumber; j++)
getBaseValidator()->validate(tempList->elementAt(j), (ValidationContext*)0, manager);
}
catch(const OutOfMemoryException&)
{
jan.release();
throw;
}
// enum shall pass this->checkContent() as well.
checkContent(getEnumeration()->elementAt(i), (ValidationContext*)0, false, manager);
}
}
catch ( XMLException& )
{
ThrowXMLwithMemMgr1(InvalidDatatypeFacetException
, XMLExcepts::FACET_enum_base
, getEnumeration()->elementAt(i)
, manager);
}
}
}
}// End of inspectFacetBase()
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);
}
}
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 ListDatatypeValidator::inheritFacet()
{
//iff the base validator is List, then we inherit
//
if (getBaseValidator()->getType() == DatatypeValidator::List)
{
AbstractStringValidator::inheritFacet();
}
}
void DoubleDatatypeValidator::setEnumeration(MemoryManager* const manager)
{
// 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;
XMLSize_t i = 0;
XMLSize_t enumLength = fStrEnumeration->size();
DoubleDatatypeValidator *numBase = (DoubleDatatypeValidator*) getBaseValidator();
if (numBase)
{
try
{
for ( i = 0; i < enumLength; i++)
{
numBase->checkContent(fStrEnumeration->elementAt(i), (ValidationContext*)0, false, manager);
}
}
catch (XMLException&)
{
ThrowXMLwithMemMgr1(InvalidDatatypeFacetException
, XMLExcepts::FACET_enum_base
, fStrEnumeration->elementAt(i)
, manager);
}
}
#if 0
// spec says that only base has to checkContent
// 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), (ValidationContext*)0, false, manager);
}
#endif
fEnumeration = new (manager) RefVectorOf<XMLNumber>(enumLength, true, manager);
fEnumerationInherited = false;
for ( i = 0; i < enumLength; i++)
{
fEnumeration->insertElementAt(new (manager) XMLDouble(fStrEnumeration->elementAt(i), manager), i);
}
}
void StringDatatypeValidator::checkAdditionalFacetConstraints(MemoryManager* const manager) const
{
StringDatatypeValidator *pBaseValidator = (StringDatatypeValidator*) getBaseValidator();
if (!pBaseValidator)
return;
short thisWSFacet = getWSFacet();
short baseWSFacet = pBaseValidator->getWSFacet();
// check 4.3.6.c1 error: whitespace
if (((getFacetsDefined() & DatatypeValidator::FACET_WHITESPACE) != 0) &&
((pBaseValidator->getFacetsDefined() & DatatypeValidator::FACET_WHITESPACE) != 0 ))
{
if ((baseWSFacet == DatatypeValidator::COLLAPSE) &&
((thisWSFacet == DatatypeValidator::PRESERVE) ||
(thisWSFacet == DatatypeValidator::REPLACE)))
ThrowXMLwithMemMgr(InvalidDatatypeFacetException, XMLExcepts::FACET_WS_collapse, manager);
if ((baseWSFacet == DatatypeValidator::REPLACE) &&
(thisWSFacet == DatatypeValidator::PRESERVE))
ThrowXMLwithMemMgr(InvalidDatatypeFacetException, XMLExcepts::FACET_WS_replace, manager);
if (((pBaseValidator->getFixed() & DatatypeValidator::FACET_WHITESPACE) !=0) &&
( thisWSFacet != baseWSFacet))
{
ThrowXMLwithMemMgr2(InvalidDatatypeFacetException
, XMLExcepts::FACET_whitespace_base_fixed
, getWSstring(thisWSFacet)
, getWSstring(baseWSFacet)
, manager);
}
}
}
//
// here content is a list of items
//
void ListDatatypeValidator::checkContent( BaseRefVectorOf<XMLCh>* tokenVector
, const XMLCh* const content
, ValidationContext* const context
, bool asBase
, MemoryManager* const manager)
{
DatatypeValidator* bv = getBaseValidator();
if (bv->getType() == DatatypeValidator::List)
((ListDatatypeValidator*)bv)->checkContent(tokenVector, content, context, true, manager);
else
{ // the ultimate itemType DTV
for (unsigned int i = 0; i < tokenVector->size(); i++)
bv->validate(tokenVector->elementAt(i), context, manager);
}
int thisFacetsDefined = getFacetsDefined();
// we check pattern first
if ( (thisFacetsDefined & DatatypeValidator::FACET_PATTERN ) != 0 )
{
// lazy construction
if (getRegex() == 0)
{
try {
setRegex(new (fMemoryManager) RegularExpression(getPattern(), SchemaSymbols::fgRegEx_XOption, fMemoryManager));
}
catch (XMLException &e)
{
ThrowXMLwithMemMgr1(InvalidDatatypeValueException, XMLExcepts::RethrowError, e.getMessage(), manager);
}
}
//check every item in the list as a whole
if (getRegex()->matches(content, manager) == false)
{
ThrowXMLwithMemMgr2(InvalidDatatypeValueException
, XMLExcepts::VALUE_NotMatch_Pattern
, content
, getPattern()
, manager);
}
}
// if this is a base validator, we only need to check pattern facet
// all other facet were inherited by the derived type
if (asBase)
return;
unsigned int tokenNumber = tokenVector->size();
if (((thisFacetsDefined & DatatypeValidator::FACET_MAXLENGTH) != 0) &&
(tokenNumber > getMaxLength()))
{
XMLCh value1[BUF_LEN+1];
XMLCh value2[BUF_LEN+1];
XMLString::binToText(tokenNumber, value1, BUF_LEN, 10, manager);
XMLString::binToText(getMaxLength(), value2, BUF_LEN, 10, manager);
ThrowXMLwithMemMgr3(InvalidDatatypeValueException
, XMLExcepts::VALUE_GT_maxLen
, getContent()
, value1
, value2
, manager);
}
if (((thisFacetsDefined & DatatypeValidator::FACET_MINLENGTH) != 0) &&
(tokenNumber < getMinLength()))
{
XMLCh value1[BUF_LEN+1];
XMLCh value2[BUF_LEN+1];
XMLString::binToText(tokenNumber, value1, BUF_LEN, 10, manager);
XMLString::binToText(getMinLength(), value2, BUF_LEN, 10, manager);
ThrowXMLwithMemMgr3(InvalidDatatypeValueException
, XMLExcepts::VALUE_LT_minLen
, getContent()
, value1
, value2
, manager);
}
if (((thisFacetsDefined & DatatypeValidator::FACET_LENGTH) != 0) &&
(tokenNumber != AbstractStringValidator::getLength()))
{
XMLCh value1[BUF_LEN+1];
XMLCh value2[BUF_LEN+1];
XMLString::binToText(tokenNumber, value1, BUF_LEN, 10, manager);
XMLString::binToText(AbstractStringValidator::getLength(), value2, BUF_LEN, 10, manager);
ThrowXMLwithMemMgr3(InvalidDatatypeValueException
, XMLExcepts::VALUE_NE_Len
, getContent()
, value1
, value2
, manager);
}
if ((thisFacetsDefined & DatatypeValidator::FACET_ENUMERATION) != 0 &&
(getEnumeration() != 0))
{
int i;
int enumLength = getEnumeration()->size();
for ( i = 0; i < enumLength; i++)
{
//optimization: we do a lexical comparision first
// this may be faster for string and its derived
if (XMLString::equals(getEnumeration()->elementAt(i), getContent()))
break; // a match found
// do a value space check
// this is needed for decimal (and probably other types
// such as datetime related)
// eg.
// tokenVector = "1 2 3.0 4" vs enumeration = "1 2 3 4.0"
//
if (valueSpaceCheck(tokenVector, getEnumeration()->elementAt(i), manager))
break;
}
if (i == enumLength)
ThrowXMLwithMemMgr1(InvalidDatatypeValueException, XMLExcepts::VALUE_NotIn_Enumeration, getContent(), manager);
} // enumeration
}
void DecimalDatatypeValidator::checkAdditionalFacetConstraintsBase(MemoryManager* const manager) const
{
DecimalDatatypeValidator *numBase = (DecimalDatatypeValidator*) getBaseValidator();
if (!numBase)
return;
int thisFacetsDefined = getFacetsDefined();
int baseFacetsDefined = numBase->getFacetsDefined();
// 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 ))
{
XMLCh value1[BUF_LEN+1];
XMLCh value2[BUF_LEN+1];
XMLString::binToText(fTotalDigits, value1, BUF_LEN, 10, manager);
XMLString::binToText(numBase->fTotalDigits, value2, BUF_LEN, 10, manager);
ThrowXMLwithMemMgr2(InvalidDatatypeFacetException
, XMLExcepts::FACET_totalDigit_base_totalDigit
, value1
, value2
, manager);
}
if ( (( baseFacetsDefined & DatatypeValidator::FACET_TOTALDIGITS) != 0) &&
(( numBase->getFixed() & DatatypeValidator::FACET_TOTALDIGITS) != 0) &&
( fTotalDigits != numBase->fTotalDigits ))
{
XMLCh value1[BUF_LEN+1];
XMLCh value2[BUF_LEN+1];
XMLString::binToText(fTotalDigits, value1, BUF_LEN, 10, manager);
XMLString::binToText(numBase->fTotalDigits, value2, BUF_LEN, 10, manager);
ThrowXMLwithMemMgr2(InvalidDatatypeFacetException
, XMLExcepts::FACET_totalDigit_base_fixed
, value1
, value2
, manager);
}
}
if (( thisFacetsDefined & DatatypeValidator::FACET_FRACTIONDIGITS) != 0)
{
// check question error: fractionDigits > base.fractionDigits ???
if ( (( baseFacetsDefined & DatatypeValidator::FACET_FRACTIONDIGITS) != 0) &&
( fFractionDigits > numBase->fFractionDigits ))
{
XMLCh value1[BUF_LEN+1];
XMLCh value2[BUF_LEN+1];
XMLString::binToText(fFractionDigits, value1, BUF_LEN, 10, manager);
XMLString::binToText(numBase->fFractionDigits, value2, BUF_LEN, 10, manager);
ThrowXMLwithMemMgr2(InvalidDatatypeFacetException
, XMLExcepts::FACET_fractDigit_base_fractDigit
, value1
, value2
, manager);
}
// check question error: fractionDigits > base.totalDigits ???
if ( (( baseFacetsDefined & DatatypeValidator::FACET_TOTALDIGITS) != 0) &&
( fFractionDigits > numBase->fTotalDigits ))
{
XMLCh value1[BUF_LEN+1];
XMLCh value2[BUF_LEN+1];
XMLString::binToText(fFractionDigits, value1, BUF_LEN, 10, manager);
XMLString::binToText(numBase->fTotalDigits, value2, BUF_LEN, 10, manager);
ThrowXMLwithMemMgr2(InvalidDatatypeFacetException
, XMLExcepts::FACET_fractDigit_base_totalDigit
, value1
, value2
, manager);
}
// fractionDigits != base.fractionDigits if (base.fixed)
if ( (( baseFacetsDefined & DatatypeValidator::FACET_FRACTIONDIGITS) != 0) &&
(( numBase->getFixed() & DatatypeValidator::FACET_FRACTIONDIGITS) != 0) &&
( fFractionDigits != numBase->fFractionDigits ))
{
XMLCh value1[BUF_LEN+1];
XMLCh value2[BUF_LEN+1];
XMLString::binToText(fFractionDigits, value1, BUF_LEN, 10, manager);
XMLString::binToText(numBase->fFractionDigits, value2, BUF_LEN, 10, manager);
ThrowXMLwithMemMgr2(InvalidDatatypeFacetException
, XMLExcepts::FACET_fractDigit_base_fixed
, value1
, value2
, manager);
}
}
}
//
// 1) the bottom level UnionDTV would check against
// pattern and enumeration as well
// 2) each UnionDTV(s) above the bottom level UnionDTV and
// below the native UnionDTV (the top level DTV)
// would check against pattern only.
// 3) the natvie Union DTV (the top level DTV) would invoke
// memberTypeValidator to validate
//
void UnionDatatypeValidator::checkContent(const XMLCh* const content
, ValidationContext* const context
, bool asBase
, MemoryManager* const manager)
{
DatatypeValidator* bv = getBaseValidator();
if (bv)
((UnionDatatypeValidator*)bv)->checkContent(content, context, true, manager);
else
{ // 3) native union type
// check content against each member type validator in Union
// report an error only in case content is not valid against all member datatypes.
//
bool memTypeValid = false;
for ( unsigned int i = 0; i < fMemberTypeValidators->size(); ++i )
{
if ( memTypeValid )
break;
try
{
fMemberTypeValidators->elementAt(i)->validate(content, context, manager);
memTypeValid = true;
//set the validator of the type actually used to validate the content
DatatypeValidator *dtv = fMemberTypeValidators->elementAt(i);
fValidatedDatatype = dtv;
// context will be null during schema construction
if(context)
context->setValidatingMemberType(dtv);
}
catch (XMLException&)
{
//absorbed
}
} // for
if ( !memTypeValid )
{
ThrowXMLwithMemMgr1(InvalidDatatypeValueException
, XMLExcepts::VALUE_no_match_memberType
, content
, manager);
//( "Content '"+content+"' does not match any union types" );
}
}
// 1) and 2). we check pattern first
if ( (getFacetsDefined() & DatatypeValidator::FACET_PATTERN ) != 0 )
{
if (getRegex()->matches(content, manager) == false)
{
ThrowXMLwithMemMgr2(InvalidDatatypeValueException
, XMLExcepts::VALUE_NotMatch_Pattern
, content
, getPattern()
, manager);
}
}
// if this is a base validator, we only need to check pattern facet
// all other facet were inherited by the derived type
if (asBase)
return;
if ((getFacetsDefined() & DatatypeValidator::FACET_ENUMERATION) != 0 &&
(getEnumeration() != 0))
{
// If the content match (compare equal) any enumeration with
// any of the member types, it is considerd valid.
//
RefVectorOf<DatatypeValidator>* memberDTV = getMemberTypeValidators();
RefArrayVectorOf<XMLCh>* tmpEnum = getEnumeration();
unsigned int memberTypeNumber = memberDTV->size();
unsigned int enumLength = tmpEnum->size();
for ( unsigned int memberIndex = 0; memberIndex < memberTypeNumber; ++memberIndex)
{
for ( unsigned int enumIndex = 0; enumIndex < enumLength; ++enumIndex)
{
try
{
if (memberDTV->elementAt(memberIndex)->compare(content, tmpEnum->elementAt(enumIndex), manager) == 0)
return;
}
catch (XMLException&)
{
//absorbed
}
} // for enumIndex
} // for memberIndex
ThrowXMLwithMemMgr1(InvalidDatatypeValueException, XMLExcepts::VALUE_NotIn_Enumeration, content, manager);
} // enumeration
}
