//Compile-time Facet Checking
internal virtual RestrictionFacets ConstructRestriction(DatatypeImplementation datatype, XmlSchemaObjectCollection facets, XmlNameTable nameTable) {
//Datatype is the type on which this method is called
RestrictionFacets derivedRestriction = new RestrictionFacets();
FacetsCompiler facetCompiler = new FacetsCompiler(datatype, derivedRestriction);
for (int i = 0; i < facets.Count; ++i) {
XmlSchemaFacet facet = (XmlSchemaFacet)facets[i];
if (facet.Value == null) {
throw new XmlSchemaException(Res.Sch_InvalidFacet, facet);
}
IXmlNamespaceResolver nsmgr = new SchemaNamespaceManager(facet);
switch(facet.FacetType) {
case FacetType.Length:
facetCompiler.CompileLengthFacet(facet);
break;
case FacetType.MinLength:
facetCompiler.CompileMinLengthFacet(facet);
break;
case FacetType.MaxLength:
facetCompiler.CompileMaxLengthFacet(facet);
break;
case FacetType.Pattern:
facetCompiler.CompilePatternFacet(facet as XmlSchemaPatternFacet);
break;
case FacetType.Enumeration:
facetCompiler.CompileEnumerationFacet(facet, nsmgr, nameTable);
break;
case FacetType.Whitespace:
facetCompiler.CompileWhitespaceFacet(facet);
break;
case FacetType.MinInclusive:
facetCompiler.CompileMinInclusiveFacet(facet);
break;
case FacetType.MinExclusive:
facetCompiler.CompileMinExclusiveFacet(facet);
break;
case FacetType.MaxInclusive:
facetCompiler.CompileMaxInclusiveFacet(facet);
break;
case FacetType.MaxExclusive:
facetCompiler.CompileMaxExclusiveFacet(facet);
break;
case FacetType.TotalDigits:
facetCompiler.CompileTotalDigitsFacet(facet);
break;
case FacetType.FractionDigits:
facetCompiler.CompileFractionDigitsFacet(facet);
break;
default:
throw new XmlSchemaException(Res.Sch_UnknownFacet, facet);
}
}
facetCompiler.FinishFacetCompile();
facetCompiler.CompileFacetCombinations();
return derivedRestriction;
}
private void CompileIdentityConstraint(XmlSchemaIdentityConstraint xi)
{
if (xi.IsProcessing)
{
xi.CompiledConstraint = CompiledIdentityConstraint.Empty;
base.SendValidationEvent("Sch_IdentityConstraintCircularRef", xi);
}
else if (xi.CompiledConstraint == null)
{
xi.IsProcessing = true;
CompiledIdentityConstraint constraint = null;
try
{
SchemaNamespaceManager nsmgr = new SchemaNamespaceManager(xi);
constraint = new CompiledIdentityConstraint(xi, nsmgr);
if (xi is XmlSchemaKeyref)
{
XmlSchemaIdentityConstraint constraint2 = (XmlSchemaIdentityConstraint) this.schema.IdentityConstraints[((XmlSchemaKeyref) xi).Refer];
if (constraint2 == null)
{
throw new XmlSchemaException("Sch_UndeclaredIdentityConstraint", ((XmlSchemaKeyref) xi).Refer.ToString(), xi);
}
this.CompileIdentityConstraint(constraint2);
if (constraint2.CompiledConstraint == null)
{
throw new XmlSchemaException("Sch_RefInvalidIdentityConstraint", ((XmlSchemaKeyref) xi).Refer.ToString(), xi);
}
if (constraint2.Fields.Count != xi.Fields.Count)
{
throw new XmlSchemaException("Sch_RefInvalidCardin", xi.QualifiedName.ToString(), xi);
}
if (constraint2.CompiledConstraint.Role == CompiledIdentityConstraint.ConstraintRole.Keyref)
{
throw new XmlSchemaException("Sch_ReftoKeyref", xi.QualifiedName.ToString(), xi);
}
}
xi.CompiledConstraint = constraint;
}
catch (XmlSchemaException exception)
{
if (exception.SourceSchemaObject == null)
{
exception.SetSource(xi);
}
base.SendValidationEvent(exception);
xi.CompiledConstraint = CompiledIdentityConstraint.Empty;
}
finally
{
xi.IsProcessing = false;
}
}
}
private void CompileIdentityConstraint (XmlSchemaIdentityConstraint xi) {
if (xi.IsProcessing) {
xi.CompiledConstraint = CompiledIdentityConstraint.Empty;
SendValidationEvent(Res.Sch_IdentityConstraintCircularRef, xi);
return;
}
if (xi.CompiledConstraint != null) {
return;
}
xi.IsProcessing = true;
CompiledIdentityConstraint compic = null;
try {
SchemaNamespaceManager xnmgr = new SchemaNamespaceManager(xi);
compic = new CompiledIdentityConstraint(xi, xnmgr);
if (xi is XmlSchemaKeyref) {
XmlSchemaIdentityConstraint ic = (XmlSchemaIdentityConstraint)this.identityConstraints[((XmlSchemaKeyref)xi).Refer];
if (ic == null) {
throw new XmlSchemaException(Res.Sch_UndeclaredIdentityConstraint, ((XmlSchemaKeyref)xi).Refer.ToString(), xi);
}
CompileIdentityConstraint(ic);
if (ic.CompiledConstraint == null) {
throw new XmlSchemaException(Res.Sch_RefInvalidIdentityConstraint, ((XmlSchemaKeyref)xi).Refer.ToString(), xi);
}
// keyref has the different cardinality with the key it referred
if (ic.Fields.Count != xi.Fields.Count) {
throw new XmlSchemaException(Res.Sch_RefInvalidCardin, xi.QualifiedName.ToString(), xi);
}
// keyref can only refer to key/unique
if (ic.CompiledConstraint.Role == CompiledIdentityConstraint.ConstraintRole.Keyref) {
throw new XmlSchemaException(Res.Sch_ReftoKeyref, xi.QualifiedName.ToString(), xi);
}
}
xi.CompiledConstraint = compic;
}
catch (XmlSchemaException e) {
if (e.SourceSchemaObject == null) {
e.SetSource(xi);
}
SendValidationEvent(e);
xi.CompiledConstraint = CompiledIdentityConstraint.Empty;
// empty is better than null here, stop quickly when circle referencing
}
finally {
xi.IsProcessing = false;
}
}
private RestrictionFacets ConstructRestriction(XmlSchemaObjectCollection facets, XmlNameTable nameTable) {
RestrictionFacets restriction = new RestrictionFacets();
RestrictionFlags thisFlags = this.restriction != null ? this.restriction.Flags : 0;
RestrictionFlags fixedFlags = this.restriction != null ? this.restriction.FixedFlags : 0;
RestrictionFlags validRestrictionFlags = ValidRestrictionFlags;
if (variety == XmlSchemaDatatypeVariety.List) {
validRestrictionFlags = RestrictionFlags.Length|RestrictionFlags.MinLength|RestrictionFlags.MaxLength|RestrictionFlags.Enumeration|RestrictionFlags.WhiteSpace;
if (minListSize == 0) {
validRestrictionFlags |= RestrictionFlags.Pattern;
}
}
StringBuilder regStr = new StringBuilder();
XmlSchemaFacet pattern_facet = null;
bool firstP = true;
foreach (XmlSchemaFacet facet in facets) {
if (facet.Value == null) {
throw new XmlSchemaException(Res.Sch_InvalidFacet, facet);
}
XmlNamespaceManager nsmgr = new SchemaNamespaceManager(facet);
if (facet is XmlSchemaLengthFacet) {
CheckFixedFlag(facet, fixedFlags, RestrictionFlags.Length);
CheckProhibitedFlag(facet, validRestrictionFlags, RestrictionFlags.Length, Res.Sch_LengthFacetProhibited);
CheckDupFlag(facet, restriction, RestrictionFlags.Length, Res.Sch_DupLengthFacet);
try {
restriction.Length = (int)(decimal)c_nonNegativeInteger.ParseAtomicValue(facet.Value, null, null);
}
catch (XmlSchemaException xse) {
if (xse.SourceSchemaObject == null) {
xse.SetSource(facet);
}
throw xse;
}
catch (Exception e) {
throw new XmlSchemaException(Res.Sch_LengthFacetInvalid, e.Message, facet);
}
if ((thisFlags & RestrictionFlags.Length) != 0) {
if (this.restriction.Length < restriction.Length) {
throw new XmlSchemaException(Res.Sch_LengthGtBaseLength, facet);
}
}
SetFlag(restriction, facet, RestrictionFlags.Length);
}
else if (facet is XmlSchemaMinLengthFacet) {
CheckFixedFlag(facet, fixedFlags, RestrictionFlags.MinLength);
CheckProhibitedFlag(facet, validRestrictionFlags, RestrictionFlags.MinLength, Res.Sch_MinLengthFacetProhibited);
CheckDupFlag(facet, restriction, RestrictionFlags.MinLength, Res.Sch_DupMinLengthFacet);
try {
restriction.MinLength = (int)(decimal)c_nonNegativeInteger.ParseAtomicValue(facet.Value, null, null);
}
catch (XmlSchemaException xse) {
if (xse.SourceSchemaObject == null) {
xse.SetSource(facet);
}
throw xse;
}
catch (Exception e) {
throw new XmlSchemaException(Res.Sch_MinLengthFacetInvalid, e.Message, facet);
}
if ((thisFlags & RestrictionFlags.MinLength) != 0) {
if (this.restriction.MinLength > restriction.MinLength) {
throw new XmlSchemaException(Res.Sch_MinLengthGtBaseMinLength, facet);
}
}
SetFlag(restriction, facet, RestrictionFlags.MinLength);
}
else if (facet is XmlSchemaMaxLengthFacet) {
CheckFixedFlag(facet, fixedFlags, RestrictionFlags.MaxLength);
CheckProhibitedFlag(facet, validRestrictionFlags, RestrictionFlags.MaxLength, Res.Sch_MaxLengthFacetProhibited);
CheckDupFlag(facet, restriction, RestrictionFlags.MaxLength, Res.Sch_DupMaxLengthFacet);
try {
restriction.MaxLength = (int)(decimal)c_nonNegativeInteger.ParseAtomicValue(facet.Value, null, null);
}
catch (XmlSchemaException xse) {
if (xse.SourceSchemaObject == null) {
xse.SetSource(facet);
}
throw xse;
}
catch (Exception e) {
throw new XmlSchemaException(Res.Sch_MaxLengthFacetInvalid, e.Message, facet);
}
if ((thisFlags & RestrictionFlags.MaxLength) != 0) {
if (this.restriction.MaxLength < restriction.MaxLength) {
throw new XmlSchemaException(Res.Sch_MaxLengthGtBaseMaxLength, facet);
}
}
SetFlag(restriction, facet, RestrictionFlags.MaxLength);
}
else if (facet is XmlSchemaPatternFacet) {
CheckProhibitedFlag(facet, validRestrictionFlags, RestrictionFlags.Pattern, Res.Sch_PatternFacetProhibited);
if(firstP == true) {
regStr.Append("(");
regStr.Append(facet.Value);
pattern_facet = new XmlSchemaPatternFacet();
pattern_facet = facet;
firstP = false;
}
else {
regStr.Append(")|(");
regStr.Append(facet.Value);
}
SetFlag(restriction, facet, RestrictionFlags.Pattern);
}
else if (facet is XmlSchemaEnumerationFacet) {
CheckProhibitedFlag(facet, validRestrictionFlags, RestrictionFlags.Enumeration, Res.Sch_EnumerationFacetProhibited);
if (restriction.Enumeration == null) {
restriction.Enumeration = new ArrayList();
}
try {
//restriction.Enumeration.Add(ParseAtomicValue(facet.Value, nameTable, nsmgr));
restriction.Enumeration.Add(ParseValue(facet.Value, nameTable, nsmgr));
}
catch (XmlSchemaException xse) {
if (xse.SourceSchemaObject == null) {
xse.SetSource(facet);
}
throw xse;
}
catch (Exception e) {
throw new XmlSchemaException(Res.Sch_EnumerationFacetInvalid, e.Message, facet);
}
SetFlag(restriction, facet, RestrictionFlags.Enumeration);
}
else if (facet is XmlSchemaWhiteSpaceFacet) {
CheckFixedFlag(facet, fixedFlags, RestrictionFlags.WhiteSpace);
CheckProhibitedFlag(facet, validRestrictionFlags, RestrictionFlags.WhiteSpace, Res.Sch_WhiteSpaceFacetProhibited);
CheckDupFlag(facet, restriction, RestrictionFlags.WhiteSpace, Res.Sch_DupWhiteSpaceFacet);
if (facet.Value == "preserve") {
restriction.WhiteSpace = XmlSchemaWhiteSpace.Preserve;
}
else if (facet.Value == "replace") {
restriction.WhiteSpace = XmlSchemaWhiteSpace.Replace;
}
else if (facet.Value == "collapse") {
restriction.WhiteSpace = XmlSchemaWhiteSpace.Collapse;
}
else {
throw new XmlSchemaException(Res.Sch_InvalidWhiteSpace, facet.Value, facet);
}
if (IsWhitespaceCollapseFixed && (restriction.WhiteSpace != XmlSchemaWhiteSpace.Collapse)) {
throw new XmlSchemaException(Res.Sch_InvalidWhiteSpace, facet.Value, facet);
}
if ((thisFlags & RestrictionFlags.WhiteSpace) != 0) {
if (
this.restriction.WhiteSpace == XmlSchemaWhiteSpace.Collapse &&
(restriction.WhiteSpace == XmlSchemaWhiteSpace.Replace || restriction.WhiteSpace == XmlSchemaWhiteSpace.Preserve)
) {
throw new XmlSchemaException(Res.Sch_WhiteSpaceRestriction1, facet);
}
if (
this.restriction.WhiteSpace == XmlSchemaWhiteSpace.Preserve &&
restriction.WhiteSpace == XmlSchemaWhiteSpace.Replace
) {
throw new XmlSchemaException(Res.Sch_WhiteSpaceRestriction2, facet);
}
}
SetFlag(restriction, facet, RestrictionFlags.WhiteSpace);
}
else if (facet is XmlSchemaMaxInclusiveFacet) {
CheckFixedFlag(facet, fixedFlags, RestrictionFlags.Length);
CheckProhibitedFlag(facet, validRestrictionFlags, RestrictionFlags.MaxInclusive, Res.Sch_MaxInclusiveFacetProhibited);
CheckDupFlag(facet, restriction, RestrictionFlags.MaxInclusive, Res.Sch_DupMaxInclusiveFacet);
try {
restriction.MaxInclusive = ParseAtomicValue(facet.Value, nameTable, nsmgr);
}
catch (XmlSchemaException xse) {
if (xse.SourceSchemaObject == null) {
xse.SetSource(facet);
}
throw xse;
}
catch (Exception e) {
throw new XmlSchemaException(Res.Sch_MaxInclusiveFacetInvalid, e.Message, facet);
}
CheckValue(restriction.MaxInclusive, facet, thisFlags);
SetFlag(restriction, facet, RestrictionFlags.MaxInclusive);
}
else if (facet is XmlSchemaMaxExclusiveFacet) {
CheckFixedFlag(facet, fixedFlags, RestrictionFlags.MaxExclusive);
CheckProhibitedFlag(facet, validRestrictionFlags, RestrictionFlags.MaxExclusive, Res.Sch_MaxExclusiveFacetProhibited);
CheckDupFlag(facet, restriction, RestrictionFlags.MaxExclusive, Res.Sch_DupMaxExclusiveFacet);
try {
restriction.MaxExclusive = ParseAtomicValue(facet.Value, nameTable, nsmgr);
}
catch (XmlSchemaException xse) {
if (xse.SourceSchemaObject == null) {
xse.SetSource(facet);
}
throw xse;
}
catch (Exception e) {
throw new XmlSchemaException(Res.Sch_MaxExclusiveFacetInvalid, e.Message, facet);
}
CheckValue(restriction.MaxExclusive, facet, thisFlags);
SetFlag(restriction, facet, RestrictionFlags.MaxExclusive);
}
else if (facet is XmlSchemaMinInclusiveFacet) {
CheckFixedFlag(facet, fixedFlags, RestrictionFlags.MinInclusive);
CheckProhibitedFlag(facet, validRestrictionFlags, RestrictionFlags.MinInclusive, Res.Sch_MinInclusiveFacetProhibited);
CheckDupFlag(facet, restriction, RestrictionFlags.MinInclusive, Res.Sch_DupMinInclusiveFacet);
try {
restriction.MinInclusive = ParseAtomicValue(facet.Value, nameTable, nsmgr);
}
catch (XmlSchemaException xse) {
if (xse.SourceSchemaObject == null) {
xse.SetSource(facet);
}
throw xse;
}
catch (Exception e) {
throw new XmlSchemaException(Res.Sch_MinInclusiveFacetInvalid, e.Message, facet);
}
CheckValue(restriction.MinInclusive, facet, thisFlags);
SetFlag(restriction, facet, RestrictionFlags.MinInclusive);
}
else if (facet is XmlSchemaMinExclusiveFacet) {
CheckFixedFlag(facet, fixedFlags, RestrictionFlags.MinExclusive);
CheckProhibitedFlag(facet, validRestrictionFlags, RestrictionFlags.MinExclusive, Res.Sch_MinExclusiveFacetProhibited);
CheckDupFlag(facet, restriction, RestrictionFlags.MinExclusive, Res.Sch_DupMinExclusiveFacet);
try {
restriction.MinExclusive = ParseAtomicValue(facet.Value, nameTable, nsmgr);
}
catch (XmlSchemaException xse) {
if (xse.SourceSchemaObject == null) {
xse.SetSource(facet);
}
throw xse;
}
catch (Exception e) {
throw new XmlSchemaException(Res.Sch_MinExclusiveFacetInvalid, e.Message, facet);
}
CheckValue(restriction.MinExclusive, facet, thisFlags);
SetFlag(restriction, facet, RestrictionFlags.MinExclusive);
}
else if (facet is XmlSchemaTotalDigitsFacet) {
CheckFixedFlag(facet, fixedFlags, RestrictionFlags.TotalDigits);
CheckProhibitedFlag(facet, validRestrictionFlags, RestrictionFlags.TotalDigits, Res.Sch_TotalDigitsFacetProhibited);
CheckDupFlag(facet, restriction, RestrictionFlags.TotalDigits, Res.Sch_DupTotalDigitsFacet);
try {
restriction.TotalDigits = (int)(decimal)c_positiveInteger.ParseAtomicValue(facet.Value, null, null);
}
catch (XmlSchemaException xse) {
if (xse.SourceSchemaObject == null) {
xse.SetSource(facet);
}
throw xse;
}
catch (Exception e) {
throw new XmlSchemaException(Res.Sch_TotalDigitsFacetInvalid, e.Message, facet);
}
SetFlag(restriction, facet, RestrictionFlags.TotalDigits);
}
else if (facet is XmlSchemaFractionDigitsFacet) {
CheckFixedFlag(facet, fixedFlags, RestrictionFlags.FractionDigits);
CheckProhibitedFlag(facet, validRestrictionFlags, RestrictionFlags.FractionDigits, Res.Sch_FractionDigitsFacetProhibited);
CheckDupFlag(facet, restriction, RestrictionFlags.FractionDigits, Res.Sch_DupFractionDigitsFacet);
try {
restriction.FractionDigits = (int)(decimal)c_nonNegativeInteger.ParseAtomicValue(facet.Value, null, null);
if ((restriction.FractionDigits != 0) && (this.GetType() != typeof(Datatype_decimal))) {
throw new XmlSchemaException(Res.Sch_FractionDigitsNotOnDecimal, facet);
}
}
catch (XmlSchemaException xse) {
if (xse.SourceSchemaObject == null) {
xse.SetSource(facet);
}
throw xse;
}
catch (Exception e) {
throw new XmlSchemaException(Res.Sch_FractionDigitsFacetInvalid, e.Message, facet);
}
SetFlag(restriction, facet, RestrictionFlags.FractionDigits);
}
else {
throw new XmlSchemaException(Res.Sch_UnknownFacet, facet);
}
}
//If facet is XMLSchemaPattern, then the String built inside the loop
//needs to be converted to a RegEx
if(firstP == false) {
if (restriction.Patterns == null) {
restriction.Patterns = new ArrayList();
}
try {
regStr.Append(")");
string tempStr = regStr.ToString();
if(tempStr.IndexOf("|") != -1) {
regStr.Insert(0,"(");
regStr.Append(")");
}
restriction.Patterns.Add(new Regex(Preprocess(regStr.ToString()), RegexOptions.None));
}catch (Exception e) {
throw new XmlSchemaException(Res.Sch_PatternFacetInvalid, e.Message, pattern_facet);
}
}
// Copy from the base
if (
(restriction.Flags & RestrictionFlags.Length) == 0 &&
(thisFlags & RestrictionFlags.Length) != 0
) {
restriction.Length = this.restriction.Length;
SetFlag(restriction, fixedFlags, RestrictionFlags.Length);
}
if (
(restriction.Flags & RestrictionFlags.MinLength) == 0 &&
(thisFlags & RestrictionFlags.MinLength) != 0
) {
restriction.MinLength = this.restriction.MinLength;
SetFlag(restriction, fixedFlags, RestrictionFlags.MinLength);
}
if (
(restriction.Flags & RestrictionFlags.MaxLength) == 0 &&
(thisFlags & RestrictionFlags.MaxLength) != 0
) {
restriction.MaxLength = this.restriction.MaxLength;
SetFlag(restriction, fixedFlags, RestrictionFlags.MaxLength);
}
if ((thisFlags & RestrictionFlags.Pattern) != 0) {
if (restriction.Patterns == null) {
restriction.Patterns = this.restriction.Patterns;
}
else {
restriction.Patterns.AddRange(this.restriction.Patterns);
}
SetFlag(restriction, fixedFlags, RestrictionFlags.Pattern);
}
if ((thisFlags & RestrictionFlags.Enumeration) != 0) {
if (restriction.Enumeration == null) {
restriction.Enumeration = this.restriction.Enumeration;
}
SetFlag(restriction, fixedFlags, RestrictionFlags.Enumeration);
}
if (
(restriction.Flags & RestrictionFlags.WhiteSpace) == 0 &&
(thisFlags & RestrictionFlags.WhiteSpace) != 0
) {
restriction.WhiteSpace = this.restriction.WhiteSpace;
SetFlag(restriction, fixedFlags, RestrictionFlags.WhiteSpace);
}
if (
(restriction.Flags & RestrictionFlags.MaxInclusive) == 0 &&
(thisFlags & RestrictionFlags.MaxInclusive) != 0
) {
restriction.MaxInclusive = this.restriction.MaxInclusive;
SetFlag(restriction, fixedFlags, RestrictionFlags.MaxInclusive);
}
if (
(restriction.Flags & RestrictionFlags.MaxExclusive) == 0 &&
(thisFlags & RestrictionFlags.MaxExclusive) != 0
) {
restriction.MaxExclusive = this.restriction.MaxExclusive;
SetFlag(restriction, fixedFlags, RestrictionFlags.MaxExclusive);
}
if (
(restriction.Flags & RestrictionFlags.MinInclusive) == 0 &&
(thisFlags & RestrictionFlags.MinInclusive) != 0
) {
restriction.MinInclusive = this.restriction.MinInclusive;
SetFlag(restriction, fixedFlags, RestrictionFlags.MinInclusive);
}
if (
(restriction.Flags & RestrictionFlags.MinExclusive) == 0 &&
(thisFlags & RestrictionFlags.MinExclusive) != 0
) {
restriction.MinExclusive = this.restriction.MinExclusive;
SetFlag(restriction, fixedFlags, RestrictionFlags.MinExclusive);
}
if (
(restriction.Flags & RestrictionFlags.TotalDigits) == 0 &&
(thisFlags & RestrictionFlags.TotalDigits) != 0
) {
restriction.MinExclusive = this.restriction.TotalDigits;
SetFlag(restriction, fixedFlags, RestrictionFlags.TotalDigits);
}
if (
(restriction.Flags & RestrictionFlags.FractionDigits) == 0 &&
(thisFlags & RestrictionFlags.FractionDigits) != 0
) {
restriction.FractionDigits = this.restriction.FractionDigits;
SetFlag(restriction, fixedFlags, RestrictionFlags.FractionDigits);
}
// Check combinations
if (
(restriction.Flags & RestrictionFlags.Length) != 0 &&
(restriction.Flags & (RestrictionFlags.MinLength|RestrictionFlags.MaxLength)) != 0
) {
throw new XmlSchemaException(Res.Sch_LengthAndMinMax);
}
if (
(restriction.Flags & RestrictionFlags.MinLength) != 0 &&
(restriction.Flags & RestrictionFlags.MaxLength) != 0
) {
if (restriction.MinLength > restriction.MaxLength) {
throw new XmlSchemaException(Res.Sch_MinLengthGtMaxLength);
}
}
if (
(restriction.Flags & RestrictionFlags.MaxInclusive) != 0 &&
(restriction.Flags & RestrictionFlags.MaxExclusive) != 0
) {
throw new XmlSchemaException(Res.Sch_MaxInclusiveExclusive);
}
if (
(restriction.Flags & RestrictionFlags.MinInclusive) != 0 &&
(restriction.Flags & RestrictionFlags.MinExclusive) != 0
) {
throw new XmlSchemaException(Res.Sch_MinInclusiveExclusive);
}
if (
(restriction.Flags & RestrictionFlags.MinInclusive) != 0 &&
(restriction.Flags & RestrictionFlags.MaxInclusive) != 0
) {
if (Compare(restriction.MinInclusive, restriction.MaxInclusive) > 0) {
throw new XmlSchemaException(Res.Sch_MinInclusiveGtMaxInclusive);
}
}
if (
(restriction.Flags & RestrictionFlags.MinInclusive) != 0 &&
(restriction.Flags & RestrictionFlags.MaxExclusive) != 0
) {
if (Compare(restriction.MinInclusive, restriction.MaxExclusive) > 0) {
throw new XmlSchemaException(Res.Sch_MinInclusiveGtMaxExclusive);
}
}
if (
(restriction.Flags & RestrictionFlags.MinExclusive) != 0 &&
(restriction.Flags & RestrictionFlags.MaxExclusive) != 0
) {
if (Compare(restriction.MinExclusive, restriction.MaxExclusive) > 0) {
throw new XmlSchemaException(Res.Sch_MinExclusiveGtMaxExclusive);
}
}
if (
(restriction.Flags & RestrictionFlags.MinExclusive) != 0 &&
(restriction.Flags & RestrictionFlags.MaxInclusive) != 0
) {
if (Compare(restriction.MinExclusive, restriction.MaxInclusive) > 0) {
throw new XmlSchemaException(Res.Sch_MinExclusiveGtMaxInclusive);
}
}
if ((restriction.Flags & (RestrictionFlags.TotalDigits|RestrictionFlags.FractionDigits)) == (RestrictionFlags.TotalDigits|RestrictionFlags.FractionDigits)) {
if (restriction.FractionDigits > restriction.TotalDigits) {
throw new XmlSchemaException(Res.Sch_FractionDigitsGtTotalDigits);
}
}
return restriction;
}
internal virtual RestrictionFacets ConstructRestriction(DatatypeImplementation datatype, XmlSchemaObjectCollection facets, XmlNameTable nameTable)
{
RestrictionFacets restriction = new RestrictionFacets();
FacetsCompiler compiler = new FacetsCompiler(datatype, restriction);
for (int i = 0; i < facets.Count; i++)
{
XmlSchemaFacet source = (XmlSchemaFacet) facets[i];
if (source.Value == null)
{
throw new XmlSchemaException("Sch_InvalidFacet", source);
}
IXmlNamespaceResolver nsmgr = new SchemaNamespaceManager(source);
switch (source.FacetType)
{
case FacetType.Length:
compiler.CompileLengthFacet(source);
break;
case FacetType.MinLength:
compiler.CompileMinLengthFacet(source);
break;
case FacetType.MaxLength:
compiler.CompileMaxLengthFacet(source);
break;
case FacetType.Pattern:
compiler.CompilePatternFacet(source as XmlSchemaPatternFacet);
break;
case FacetType.Whitespace:
compiler.CompileWhitespaceFacet(source);
break;
case FacetType.Enumeration:
compiler.CompileEnumerationFacet(source, nsmgr, nameTable);
break;
case FacetType.MinExclusive:
compiler.CompileMinExclusiveFacet(source);
break;
case FacetType.MinInclusive:
compiler.CompileMinInclusiveFacet(source);
break;
case FacetType.MaxExclusive:
compiler.CompileMaxExclusiveFacet(source);
break;
case FacetType.MaxInclusive:
compiler.CompileMaxInclusiveFacet(source);
break;
case FacetType.TotalDigits:
compiler.CompileTotalDigitsFacet(source);
break;
case FacetType.FractionDigits:
compiler.CompileFractionDigitsFacet(source);
break;
default:
throw new XmlSchemaException("Sch_UnknownFacet", source);
}
}
compiler.FinishFacetCompile();
compiler.CompileFacetCombinations();
return restriction;
}
internal virtual RestrictionFacets ConstructRestriction(DatatypeImplementation datatype, XmlSchemaObjectCollection facets, XmlNameTable nameTable)
{
RestrictionFacets restriction = new RestrictionFacets();
FacetsCompiler compiler = new FacetsCompiler(datatype, restriction);
for (int i = 0; i < facets.Count; i++)
{
XmlSchemaFacet source = (XmlSchemaFacet)facets[i];
if (source.Value == null)
{
throw new XmlSchemaException("Sch_InvalidFacet", source);
}
IXmlNamespaceResolver nsmgr = new SchemaNamespaceManager(source);
switch (source.FacetType)
{
case FacetType.Length:
compiler.CompileLengthFacet(source);
break;
case FacetType.MinLength:
compiler.CompileMinLengthFacet(source);
break;
case FacetType.MaxLength:
compiler.CompileMaxLengthFacet(source);
break;
case FacetType.Pattern:
compiler.CompilePatternFacet(source as XmlSchemaPatternFacet);
break;
case FacetType.Whitespace:
compiler.CompileWhitespaceFacet(source);
break;
case FacetType.Enumeration:
compiler.CompileEnumerationFacet(source, nsmgr, nameTable);
break;
case FacetType.MinExclusive:
compiler.CompileMinExclusiveFacet(source);
break;
case FacetType.MinInclusive:
compiler.CompileMinInclusiveFacet(source);
break;
case FacetType.MaxExclusive:
compiler.CompileMaxExclusiveFacet(source);
break;
case FacetType.MaxInclusive:
compiler.CompileMaxInclusiveFacet(source);
break;
case FacetType.TotalDigits:
compiler.CompileTotalDigitsFacet(source);
break;
case FacetType.FractionDigits:
compiler.CompileFractionDigitsFacet(source);
break;
default:
throw new XmlSchemaException("Sch_UnknownFacet", source);
}
}
compiler.FinishFacetCompile();
compiler.CompileFacetCombinations();
return(restriction);
}
