1 /* 2 * Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved. 3 * @LastModified: Nov 2017 4 */ 5 /* 6 * Licensed to the Apache Software Foundation (ASF) under one or more 7 * contributor license agreements. See the NOTICE file distributed with 8 * this work for additional information regarding copyright ownership. 9 * The ASF licenses this file to You under the Apache License, Version 2.0 10 * (the "License"); you may not use this file except in compliance with 11 * the License. You may obtain a copy of the License at 12 * 13 * http://www.apache.org/licenses/LICENSE-2.0 14 * 15 * Unless required by applicable law or agreed to in writing, software 16 * distributed under the License is distributed on an "AS IS" BASIS, 17 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 18 * See the License for the specific language governing permissions and 19 * limitations under the License. 20 */ 21 22 package com.sun.org.apache.xerces.internal.impl.dv.xs; 23 24 import com.sun.org.apache.xerces.internal.impl.Constants; 25 import com.sun.org.apache.xerces.internal.impl.dv.DatatypeException; 26 import com.sun.org.apache.xerces.internal.impl.dv.InvalidDatatypeFacetException; 27 import com.sun.org.apache.xerces.internal.impl.dv.InvalidDatatypeValueException; 28 import com.sun.org.apache.xerces.internal.impl.dv.ValidatedInfo; 29 import com.sun.org.apache.xerces.internal.impl.dv.ValidationContext; 30 import com.sun.org.apache.xerces.internal.impl.dv.XSFacets; 31 import com.sun.org.apache.xerces.internal.impl.dv.XSSimpleType; 32 import com.sun.org.apache.xerces.internal.impl.xpath.regex.ParseException; 33 import com.sun.org.apache.xerces.internal.impl.xpath.regex.RegularExpression; 34 import com.sun.org.apache.xerces.internal.impl.xs.SchemaSymbols; 35 import com.sun.org.apache.xerces.internal.impl.xs.util.ObjectListImpl; 36 import com.sun.org.apache.xerces.internal.impl.xs.util.ShortListImpl; 37 import com.sun.org.apache.xerces.internal.impl.xs.util.StringListImpl; 38 import com.sun.org.apache.xerces.internal.impl.xs.util.XSObjectListImpl; 39 import com.sun.org.apache.xerces.internal.util.XMLChar; 40 import com.sun.org.apache.xerces.internal.xni.NamespaceContext; 41 import com.sun.org.apache.xerces.internal.xs.ShortList; 42 import com.sun.org.apache.xerces.internal.xs.StringList; 43 import com.sun.org.apache.xerces.internal.xs.XSAnnotation; 44 import com.sun.org.apache.xerces.internal.xs.XSConstants; 45 import com.sun.org.apache.xerces.internal.xs.XSFacet; 46 import com.sun.org.apache.xerces.internal.xs.XSMultiValueFacet; 47 import com.sun.org.apache.xerces.internal.xs.XSNamespaceItem; 48 import com.sun.org.apache.xerces.internal.xs.XSObject; 49 import com.sun.org.apache.xerces.internal.xs.XSObjectList; 50 import com.sun.org.apache.xerces.internal.xs.XSSimpleTypeDefinition; 51 import com.sun.org.apache.xerces.internal.xs.XSTypeDefinition; 52 import com.sun.org.apache.xerces.internal.xs.datatypes.ObjectList; 53 import java.math.BigInteger; 54 import java.util.AbstractList; 55 import java.util.ArrayList; 56 import java.util.List; 57 import java.util.Locale; 58 import java.util.StringTokenizer; 59 import org.w3c.dom.TypeInfo; 60 61 /** 62 * @xerces.internal 63 * 64 * @author Sandy Gao, IBM 65 * @author Neeraj Bajaj, Sun Microsystems, inc. 66 * 67 */ 68 public class XSSimpleTypeDecl implements XSSimpleType, TypeInfo { 69 70 protected static final short DV_STRING = PRIMITIVE_STRING; 71 protected static final short DV_BOOLEAN = PRIMITIVE_BOOLEAN; 72 protected static final short DV_DECIMAL = PRIMITIVE_DECIMAL; 73 protected static final short DV_FLOAT = PRIMITIVE_FLOAT; 74 protected static final short DV_DOUBLE = PRIMITIVE_DOUBLE; 75 protected static final short DV_DURATION = PRIMITIVE_DURATION; 76 protected static final short DV_DATETIME = PRIMITIVE_DATETIME; 77 protected static final short DV_TIME = PRIMITIVE_TIME; 78 protected static final short DV_DATE = PRIMITIVE_DATE; 79 protected static final short DV_GYEARMONTH = PRIMITIVE_GYEARMONTH; 80 protected static final short DV_GYEAR = PRIMITIVE_GYEAR; 81 protected static final short DV_GMONTHDAY = PRIMITIVE_GMONTHDAY; 82 protected static final short DV_GDAY = PRIMITIVE_GDAY; 83 protected static final short DV_GMONTH = PRIMITIVE_GMONTH; 84 protected static final short DV_HEXBINARY = PRIMITIVE_HEXBINARY; 85 protected static final short DV_BASE64BINARY = PRIMITIVE_BASE64BINARY; 86 protected static final short DV_ANYURI = PRIMITIVE_ANYURI; 87 protected static final short DV_QNAME = PRIMITIVE_QNAME; 88 protected static final short DV_PRECISIONDECIMAL = PRIMITIVE_PRECISIONDECIMAL; 89 protected static final short DV_NOTATION = PRIMITIVE_NOTATION; 90 91 protected static final short DV_ANYSIMPLETYPE = 0; 92 protected static final short DV_ID = DV_NOTATION + 1; 93 protected static final short DV_IDREF = DV_NOTATION + 2; 94 protected static final short DV_ENTITY = DV_NOTATION + 3; 95 protected static final short DV_INTEGER = DV_NOTATION + 4; 96 protected static final short DV_LIST = DV_NOTATION + 5; 97 protected static final short DV_UNION = DV_NOTATION + 6; 98 protected static final short DV_YEARMONTHDURATION = DV_NOTATION + 7; 99 protected static final short DV_DAYTIMEDURATION = DV_NOTATION + 8; 100 protected static final short DV_ANYATOMICTYPE = DV_NOTATION + 9; 101 102 private static final TypeValidator[] gDVs = { 103 new AnySimpleDV(), 104 new StringDV(), 105 new BooleanDV(), 106 new DecimalDV(), 107 new FloatDV(), 108 new DoubleDV(), 109 new DurationDV(), 110 new DateTimeDV(), 111 new TimeDV(), 112 new DateDV(), 113 new YearMonthDV(), 114 new YearDV(), 115 new MonthDayDV(), 116 new DayDV(), 117 new MonthDV(), 118 new HexBinaryDV(), 119 new Base64BinaryDV(), 120 new AnyURIDV(), 121 new QNameDV(), 122 new PrecisionDecimalDV(), // XML Schema 1.1 type 123 new QNameDV(), // notation use the same one as qname 124 new IDDV(), 125 new IDREFDV(), 126 new EntityDV(), 127 new IntegerDV(), 128 new ListDV(), 129 new UnionDV(), 130 new YearMonthDurationDV(), // XML Schema 1.1 type 131 new DayTimeDurationDV(), // XML Schema 1.1 type 132 new AnyAtomicDV() // XML Schema 1.1 type 133 }; 134 135 static final short NORMALIZE_NONE = 0; 136 static final short NORMALIZE_TRIM = 1; 137 static final short NORMALIZE_FULL = 2; 138 static final short[] fDVNormalizeType = { 139 NORMALIZE_NONE, //AnySimpleDV(), 140 NORMALIZE_FULL, //StringDV(), 141 NORMALIZE_TRIM, //BooleanDV(), 142 NORMALIZE_TRIM, //DecimalDV(), 143 NORMALIZE_TRIM, //FloatDV(), 144 NORMALIZE_TRIM, //DoubleDV(), 145 NORMALIZE_TRIM, //DurationDV(), 146 NORMALIZE_TRIM, //DateTimeDV(), 147 NORMALIZE_TRIM, //TimeDV(), 148 NORMALIZE_TRIM, //DateDV(), 149 NORMALIZE_TRIM, //YearMonthDV(), 150 NORMALIZE_TRIM, //YearDV(), 151 NORMALIZE_TRIM, //MonthDayDV(), 152 NORMALIZE_TRIM, //DayDV(), 153 NORMALIZE_TRIM, //MonthDV(), 154 NORMALIZE_TRIM, //HexBinaryDV(), 155 NORMALIZE_NONE, //Base64BinaryDV(), // Base64 know how to deal with spaces 156 NORMALIZE_TRIM, //AnyURIDV(), 157 NORMALIZE_TRIM, //QNameDV(), 158 NORMALIZE_TRIM, //PrecisionDecimalDV() (Schema 1.1) 159 NORMALIZE_TRIM, //QNameDV(), // notation 160 NORMALIZE_TRIM, //IDDV(), 161 NORMALIZE_TRIM, //IDREFDV(), 162 NORMALIZE_TRIM, //EntityDV(), 163 NORMALIZE_TRIM, //IntegerDV(), 164 NORMALIZE_FULL, //ListDV(), 165 NORMALIZE_NONE, //UnionDV(), 166 NORMALIZE_TRIM, //YearMonthDurationDV() (Schema 1.1) 167 NORMALIZE_TRIM, //DayTimeDurationDV() (Schema 1.1) 168 NORMALIZE_NONE, //AnyAtomicDV() (Schema 1.1) 169 }; 170 171 static final short SPECIAL_PATTERN_NONE = 0; 172 static final short SPECIAL_PATTERN_NMTOKEN = 1; 173 static final short SPECIAL_PATTERN_NAME = 2; 174 static final short SPECIAL_PATTERN_NCNAME = 3; 175 176 static final String[] SPECIAL_PATTERN_STRING = { 177 "NONE", "NMTOKEN", "Name", "NCName" 178 }; 179 180 static final String[] WS_FACET_STRING = { 181 "preserve", "replace", "collapse" 182 }; 183 184 static final String URI_SCHEMAFORSCHEMA = "http://www.w3.org/2001/XMLSchema"; 185 static final String ANY_TYPE = "anyType"; 186 187 // XML Schema 1.1 type constants 188 public static final short YEARMONTHDURATION_DT = 46; 189 public static final short DAYTIMEDURATION_DT = 47; 190 public static final short PRECISIONDECIMAL_DT = 48; 191 public static final short ANYATOMICTYPE_DT = 49; 192 193 // DOM Level 3 TypeInfo Derivation Method constants 194 static final int DERIVATION_ANY = 0; 195 static final int DERIVATION_RESTRICTION = 1; 196 static final int DERIVATION_EXTENSION = 2; 197 static final int DERIVATION_UNION = 4; 198 static final int DERIVATION_LIST = 8; 199 200 static final ValidationContext fEmptyContext = new ValidationContext() { 201 public boolean needFacetChecking() { 202 return true; 203 } 204 public boolean needExtraChecking() { 205 return false; 206 } 207 public boolean needToNormalize() { 208 return true; 209 } 210 public boolean useNamespaces () { 211 return true; 212 } 213 public boolean isEntityDeclared (String name) { 214 return false; 215 } 216 public boolean isEntityUnparsed (String name) { 217 return false; 218 } 219 public boolean isIdDeclared (String name) { 220 return false; 221 } 222 public void addId(String name) { 223 } 224 public void addIdRef(String name) { 225 } 226 public String getSymbol (String symbol) { 227 return symbol.intern(); 228 } 229 public String getURI(String prefix) { 230 return null; 231 } 232 public Locale getLocale() { 233 return Locale.getDefault(); 234 } 235 }; 236 237 protected static TypeValidator[] getGDVs() { 238 return gDVs.clone(); 239 } 240 private TypeValidator[] fDVs = gDVs; 241 protected void setDVs(TypeValidator[] dvs) { 242 fDVs = dvs; 243 } 244 245 // this will be true if this is a static XSSimpleTypeDecl 246 // and hence must remain immutable (i.e., applyFacets 247 // may not be permitted to have any effect). 248 private boolean fIsImmutable = false; 249 250 private XSSimpleTypeDecl fItemType; 251 private XSSimpleTypeDecl[] fMemberTypes; 252 // The most specific built-in type kind. 253 private short fBuiltInKind; 254 255 private String fTypeName; 256 private String fTargetNamespace; 257 private short fFinalSet = 0; 258 private XSSimpleTypeDecl fBase; 259 private short fVariety = -1; 260 private short fValidationDV = -1; 261 262 private short fFacetsDefined = 0; 263 private short fFixedFacet = 0; 264 265 //for constraining facets 266 private short fWhiteSpace = 0; 267 private int fLength = -1; 268 private int fMinLength = -1; 269 private int fMaxLength = -1; 270 private int fTotalDigits = -1; 271 private int fFractionDigits = -1; 272 private List<RegularExpression> fPattern; 273 private List<String> fPatternStr; 274 private ValidatedInfo[] fEnumeration; 275 private int fEnumerationSize; 276 private ShortList fEnumerationTypeList; 277 private ObjectList fEnumerationItemTypeList; 278 private StringList fLexicalPattern; 279 private StringList fLexicalEnumeration; 280 private ObjectList fActualEnumeration; 281 private Object fMaxInclusive; 282 private Object fMaxExclusive; 283 private Object fMinExclusive; 284 private Object fMinInclusive; 285 286 // annotations for constraining facets 287 public XSAnnotation lengthAnnotation; 288 public XSAnnotation minLengthAnnotation; 289 public XSAnnotation maxLengthAnnotation; 290 public XSAnnotation whiteSpaceAnnotation; 291 public XSAnnotation totalDigitsAnnotation; 292 public XSAnnotation fractionDigitsAnnotation; 293 public XSObjectListImpl patternAnnotations; 294 public XSObjectList enumerationAnnotations; 295 public XSAnnotation maxInclusiveAnnotation; 296 public XSAnnotation maxExclusiveAnnotation; 297 public XSAnnotation minInclusiveAnnotation; 298 public XSAnnotation minExclusiveAnnotation; 299 300 // facets as objects 301 private XSObjectListImpl fFacets; 302 303 // enumeration and pattern facets 304 private XSObjectListImpl fMultiValueFacets; 305 306 // simpleType annotations 307 private XSObjectList fAnnotations = null; 308 309 private short fPatternType = SPECIAL_PATTERN_NONE; 310 311 // for fundamental facets 312 private short fOrdered; 313 private boolean fFinite; 314 private boolean fBounded; 315 private boolean fNumeric; 316 317 // The namespace schema information item corresponding to the target namespace 318 // of the simple type definition, if it is globally declared; or null otherwise. 319 private XSNamespaceItem fNamespaceItem = null; 320 321 // default constructor 322 public XSSimpleTypeDecl(){} 323 324 //Create a new built-in primitive types (and id/idref/entity/integer/yearMonthDuration) 325 protected XSSimpleTypeDecl(XSSimpleTypeDecl base, String name, short validateDV, 326 short ordered, boolean bounded, boolean finite, 327 boolean numeric, boolean isImmutable, short builtInKind) { 328 fIsImmutable = isImmutable; 329 fBase = base; 330 fTypeName = name; 331 fTargetNamespace = URI_SCHEMAFORSCHEMA; 332 // To simplify the code for anySimpleType, we treat it as an atomic type 333 fVariety = VARIETY_ATOMIC; 334 fValidationDV = validateDV; 335 fFacetsDefined = FACET_WHITESPACE; 336 if (validateDV == DV_ANYSIMPLETYPE || 337 validateDV == DV_ANYATOMICTYPE || 338 validateDV == DV_STRING) { 339 fWhiteSpace = WS_PRESERVE; 340 } 341 else { 342 fWhiteSpace = WS_COLLAPSE; 343 fFixedFacet = FACET_WHITESPACE; 344 } 345 this.fOrdered = ordered; 346 this.fBounded = bounded; 347 this.fFinite = finite; 348 this.fNumeric = numeric; 349 fAnnotations = null; 350 351 // Specify the build in kind for this primitive type 352 fBuiltInKind = builtInKind; 353 } 354 355 //Create a new simple type for restriction for built-in types 356 protected XSSimpleTypeDecl(XSSimpleTypeDecl base, String name, String uri, short finalSet, boolean isImmutable, 357 XSObjectList annotations, short builtInKind) { 358 this(base, name, uri, finalSet, isImmutable, annotations); 359 // Specify the build in kind for this built-in type 360 fBuiltInKind = builtInKind; 361 } 362 363 //Create a new simple type for restriction. 364 protected XSSimpleTypeDecl(XSSimpleTypeDecl base, String name, String uri, short finalSet, boolean isImmutable, 365 XSObjectList annotations) { 366 fBase = base; 367 fTypeName = name; 368 fTargetNamespace = uri; 369 fFinalSet = finalSet; 370 fAnnotations = annotations; 371 372 fVariety = fBase.fVariety; 373 fValidationDV = fBase.fValidationDV; 374 switch (fVariety) { 375 case VARIETY_ATOMIC: 376 break; 377 case VARIETY_LIST: 378 fItemType = fBase.fItemType; 379 break; 380 case VARIETY_UNION: 381 fMemberTypes = fBase.fMemberTypes; 382 break; 383 } 384 385 // always inherit facets from the base. 386 // in case a type is created, but applyFacets is not called 387 fLength = fBase.fLength; 388 fMinLength = fBase.fMinLength; 389 fMaxLength = fBase.fMaxLength; 390 fPattern = fBase.fPattern; 391 fPatternStr = fBase.fPatternStr; 392 fEnumeration = fBase.fEnumeration; 393 fEnumerationSize = fBase.fEnumerationSize; 394 fWhiteSpace = fBase.fWhiteSpace; 395 fMaxExclusive = fBase.fMaxExclusive; 396 fMaxInclusive = fBase.fMaxInclusive; 397 fMinExclusive = fBase.fMinExclusive; 398 fMinInclusive = fBase.fMinInclusive; 399 fTotalDigits = fBase.fTotalDigits; 400 fFractionDigits = fBase.fFractionDigits; 401 fPatternType = fBase.fPatternType; 402 fFixedFacet = fBase.fFixedFacet; 403 fFacetsDefined = fBase.fFacetsDefined; 404 405 // always inherit facet annotations in case applyFacets is not called. 406 lengthAnnotation = fBase.lengthAnnotation; 407 minLengthAnnotation = fBase.minLengthAnnotation; 408 maxLengthAnnotation = fBase.maxLengthAnnotation; 409 patternAnnotations = fBase.patternAnnotations; 410 enumerationAnnotations = fBase.enumerationAnnotations; 411 whiteSpaceAnnotation = fBase.whiteSpaceAnnotation; 412 maxExclusiveAnnotation = fBase.maxExclusiveAnnotation; 413 maxInclusiveAnnotation = fBase.maxInclusiveAnnotation; 414 minExclusiveAnnotation = fBase.minExclusiveAnnotation; 415 minInclusiveAnnotation = fBase.minInclusiveAnnotation; 416 totalDigitsAnnotation = fBase.totalDigitsAnnotation; 417 fractionDigitsAnnotation = fBase.fractionDigitsAnnotation; 418 419 //we also set fundamental facets information in case applyFacets is not called. 420 calcFundamentalFacets(); 421 fIsImmutable = isImmutable; 422 423 // Inherit from the base type 424 fBuiltInKind = base.fBuiltInKind; 425 } 426 427 //Create a new simple type for list. 428 protected XSSimpleTypeDecl(String name, String uri, short finalSet, XSSimpleTypeDecl itemType, boolean isImmutable, 429 XSObjectList annotations) { 430 fBase = fAnySimpleType; 431 fTypeName = name; 432 fTargetNamespace = uri; 433 fFinalSet = finalSet; 434 fAnnotations = annotations; 435 436 fVariety = VARIETY_LIST; 437 fItemType = itemType; 438 fValidationDV = DV_LIST; 439 fFacetsDefined = FACET_WHITESPACE; 440 fFixedFacet = FACET_WHITESPACE; 441 fWhiteSpace = WS_COLLAPSE; 442 443 //setting fundamental facets 444 calcFundamentalFacets(); 445 fIsImmutable = isImmutable; 446 447 // Values of this type are lists 448 fBuiltInKind = XSConstants.LIST_DT; 449 } 450 451 //Create a new simple type for union. 452 protected XSSimpleTypeDecl(String name, String uri, short finalSet, XSSimpleTypeDecl[] memberTypes, 453 XSObjectList annotations) { 454 fBase = fAnySimpleType; 455 fTypeName = name; 456 fTargetNamespace = uri; 457 fFinalSet = finalSet; 458 fAnnotations = annotations; 459 460 fVariety = VARIETY_UNION; 461 fMemberTypes = memberTypes; 462 fValidationDV = DV_UNION; 463 // even for union, we set whitespace to something 464 // this will never be used, but we can use fFacetsDefined to check 465 // whether applyFacets() is allwwed: it's not allowed 466 // if fFacetsDefined != 0 467 fFacetsDefined = FACET_WHITESPACE; 468 fWhiteSpace = WS_COLLAPSE; 469 470 //setting fundamental facets 471 calcFundamentalFacets(); 472 // none of the schema-defined types are unions, so just set 473 // fIsImmutable to false. 474 fIsImmutable = false; 475 476 // No value can be of this type, so it's unavailable. 477 fBuiltInKind = XSConstants.UNAVAILABLE_DT; 478 } 479 480 //set values for restriction. 481 protected XSSimpleTypeDecl setRestrictionValues(XSSimpleTypeDecl base, String name, String uri, short finalSet, 482 XSObjectList annotations) { 483 //decline to do anything if the object is immutable. 484 if(fIsImmutable) return null; 485 fBase = base; 486 fAnonymous = false; 487 fTypeName = name; 488 fTargetNamespace = uri; 489 fFinalSet = finalSet; 490 fAnnotations = annotations; 491 492 fVariety = fBase.fVariety; 493 fValidationDV = fBase.fValidationDV; 494 switch (fVariety) { 495 case VARIETY_ATOMIC: 496 break; 497 case VARIETY_LIST: 498 fItemType = fBase.fItemType; 499 break; 500 case VARIETY_UNION: 501 fMemberTypes = fBase.fMemberTypes; 502 break; 503 } 504 505 // always inherit facets from the base. 506 // in case a type is created, but applyFacets is not called 507 fLength = fBase.fLength; 508 fMinLength = fBase.fMinLength; 509 fMaxLength = fBase.fMaxLength; 510 fPattern = fBase.fPattern; 511 fPatternStr = fBase.fPatternStr; 512 fEnumeration = fBase.fEnumeration; 513 fEnumerationSize = fBase.fEnumerationSize; 514 fWhiteSpace = fBase.fWhiteSpace; 515 fMaxExclusive = fBase.fMaxExclusive; 516 fMaxInclusive = fBase.fMaxInclusive; 517 fMinExclusive = fBase.fMinExclusive; 518 fMinInclusive = fBase.fMinInclusive; 519 fTotalDigits = fBase.fTotalDigits; 520 fFractionDigits = fBase.fFractionDigits; 521 fPatternType = fBase.fPatternType; 522 fFixedFacet = fBase.fFixedFacet; 523 fFacetsDefined = fBase.fFacetsDefined; 524 525 //we also set fundamental facets information in case applyFacets is not called. 526 calcFundamentalFacets(); 527 528 // Inherit from the base type 529 fBuiltInKind = base.fBuiltInKind; 530 531 return this; 532 } 533 534 //set values for list. 535 protected XSSimpleTypeDecl setListValues(String name, String uri, short finalSet, XSSimpleTypeDecl itemType, 536 XSObjectList annotations) { 537 //decline to do anything if the object is immutable. 538 if(fIsImmutable) return null; 539 fBase = fAnySimpleType; 540 fAnonymous = false; 541 fTypeName = name; 542 fTargetNamespace = uri; 543 fFinalSet = finalSet; 544 fAnnotations = annotations; 545 546 fVariety = VARIETY_LIST; 547 fItemType = itemType; 548 fValidationDV = DV_LIST; 549 fFacetsDefined = FACET_WHITESPACE; 550 fFixedFacet = FACET_WHITESPACE; 551 fWhiteSpace = WS_COLLAPSE; 552 553 //setting fundamental facets 554 calcFundamentalFacets(); 555 556 // Values of this type are lists 557 fBuiltInKind = XSConstants.LIST_DT; 558 559 return this; 560 } 561 562 //set values for union. 563 protected XSSimpleTypeDecl setUnionValues(String name, String uri, short finalSet, XSSimpleTypeDecl[] memberTypes, 564 XSObjectList annotations) { 565 //decline to do anything if the object is immutable. 566 if(fIsImmutable) return null; 567 fBase = fAnySimpleType; 568 fAnonymous = false; 569 fTypeName = name; 570 fTargetNamespace = uri; 571 fFinalSet = finalSet; 572 fAnnotations = annotations; 573 574 fVariety = VARIETY_UNION; 575 fMemberTypes = memberTypes; 576 fValidationDV = DV_UNION; 577 // even for union, we set whitespace to something 578 // this will never be used, but we can use fFacetsDefined to check 579 // whether applyFacets() is allwwed: it's not allowed 580 // if fFacetsDefined != 0 581 fFacetsDefined = FACET_WHITESPACE; 582 fWhiteSpace = WS_COLLAPSE; 583 584 //setting fundamental facets 585 calcFundamentalFacets(); 586 587 // No value can be of this type, so it's unavailable. 588 fBuiltInKind = XSConstants.UNAVAILABLE_DT; 589 590 return this; 591 } 592 593 public short getType () { 594 return XSConstants.TYPE_DEFINITION; 595 } 596 597 public short getTypeCategory () { 598 return SIMPLE_TYPE; 599 } 600 601 public String getName() { 602 return getAnonymous()?null:fTypeName; 603 } 604 605 public String getTypeName() { 606 return fTypeName; 607 } 608 609 public String getNamespace() { 610 return fTargetNamespace; 611 } 612 613 public short getFinal(){ 614 return fFinalSet; 615 } 616 617 public boolean isFinal(short derivation) { 618 return (fFinalSet & derivation) != 0; 619 } 620 621 public XSTypeDefinition getBaseType(){ 622 return fBase; 623 } 624 625 public boolean getAnonymous() { 626 return fAnonymous || (fTypeName == null); 627 } 628 629 public short getVariety(){ 630 // for anySimpleType, return absent variaty 631 return fValidationDV == DV_ANYSIMPLETYPE ? VARIETY_ABSENT : fVariety; 632 } 633 634 public boolean isIDType(){ 635 switch (fVariety) { 636 case VARIETY_ATOMIC: 637 return fValidationDV == DV_ID; 638 case VARIETY_LIST: 639 return fItemType.isIDType(); 640 case VARIETY_UNION: 641 for (int i = 0; i < fMemberTypes.length; i++) { 642 if (fMemberTypes[i].isIDType()) 643 return true; 644 } 645 } 646 return false; 647 } 648 649 public short getWhitespace() throws DatatypeException{ 650 if (fVariety == VARIETY_UNION) { 651 throw new DatatypeException("dt-whitespace", new Object[]{fTypeName}); 652 } 653 return fWhiteSpace; 654 } 655 656 public short getPrimitiveKind() { 657 if (fVariety == VARIETY_ATOMIC && fValidationDV != DV_ANYSIMPLETYPE) { 658 if (fValidationDV == DV_ID || fValidationDV == DV_IDREF || fValidationDV == DV_ENTITY) { 659 return DV_STRING; 660 } 661 else if (fValidationDV == DV_INTEGER) { 662 return DV_DECIMAL; 663 } 664 else if (Constants.SCHEMA_1_1_SUPPORT && (fValidationDV == DV_YEARMONTHDURATION || fValidationDV == DV_DAYTIMEDURATION)) { 665 return DV_DURATION; 666 } 667 else { 668 return fValidationDV; 669 } 670 } 671 else { 672 // REVISIT: error situation. runtime exception? 673 return (short)0; 674 } 675 } 676 677 /** 678 * Returns the closest built-in type category this type represents or 679 * derived from. For example, if this simple type is a built-in derived 680 * type integer the <code>INTEGER_DV</code> is returned. 681 */ 682 public short getBuiltInKind() { 683 return this.fBuiltInKind; 684 } 685 686 /** 687 * If variety is <code>atomic</code> the primitive type definition (a 688 * built-in primitive datatype definition or the simple ur-type 689 * definition) is available, otherwise <code>null</code>. 690 */ 691 public XSSimpleTypeDefinition getPrimitiveType() { 692 if (fVariety == VARIETY_ATOMIC && fValidationDV != DV_ANYSIMPLETYPE) { 693 XSSimpleTypeDecl pri = this; 694 // recursively get base, until we reach anySimpleType 695 while (pri.fBase != fAnySimpleType) 696 pri = pri.fBase; 697 return pri; 698 } 699 else { 700 // REVISIT: error situation. runtime exception? 701 return null; 702 } 703 } 704 705 /** 706 * If variety is <code>list</code> the item type definition (an atomic or 707 * union simple type definition) is available, otherwise 708 * <code>null</code>. 709 */ 710 public XSSimpleTypeDefinition getItemType() { 711 if (fVariety == VARIETY_LIST) { 712 return fItemType; 713 } 714 else { 715 // REVISIT: error situation. runtime exception? 716 return null; 717 } 718 } 719 720 /** 721 * If variety is <code>union</code> the list of member type definitions (a 722 * non-empty sequence of simple type definitions) is available, 723 * otherwise an empty <code>XSObjectList</code>. 724 */ 725 public XSObjectList getMemberTypes() { 726 if (fVariety == VARIETY_UNION) { 727 return new XSObjectListImpl(fMemberTypes, fMemberTypes.length); 728 } 729 else { 730 return XSObjectListImpl.EMPTY_LIST; 731 } 732 } 733 734 /** 735 * If <restriction> is chosen 736 */ 737 public void applyFacets(XSFacets facets, short presentFacet, short fixedFacet, ValidationContext context) 738 throws InvalidDatatypeFacetException { 739 if (context == null) { 740 context = fEmptyContext; 741 } 742 applyFacets(facets, presentFacet, fixedFacet, SPECIAL_PATTERN_NONE, context); 743 } 744 745 /** 746 * built-in derived types by restriction 747 */ 748 void applyFacets1(XSFacets facets, short presentFacet, short fixedFacet) { 749 750 try { 751 applyFacets(facets, presentFacet, fixedFacet, SPECIAL_PATTERN_NONE, fDummyContext); 752 } catch (InvalidDatatypeFacetException e) { 753 // should never gets here, internel error 754 throw new RuntimeException("internal error"); 755 } 756 // we've now applied facets; so lock this object: 757 fIsImmutable = true; 758 } 759 760 /** 761 * built-in derived types by restriction 762 */ 763 void applyFacets1(XSFacets facets, short presentFacet, short fixedFacet, short patternType) { 764 765 try { 766 applyFacets(facets, presentFacet, fixedFacet, patternType, fDummyContext); 767 } catch (InvalidDatatypeFacetException e) { 768 // should never gets here, internel error 769 throw new RuntimeException("internal error"); 770 } 771 // we've now applied facets; so lock this object: 772 fIsImmutable = true; 773 } 774 775 /** 776 * If <restriction> is chosen, or built-in derived types by restriction 777 */ 778 void applyFacets(XSFacets facets, short presentFacet, short fixedFacet, short patternType, ValidationContext context) 779 throws InvalidDatatypeFacetException { 780 781 // if the object is immutable, should not apply facets... 782 if(fIsImmutable) return; 783 ValidatedInfo tempInfo = new ValidatedInfo(); 784 785 // clear facets. because we always inherit facets in the constructor 786 // REVISIT: in fact, we don't need to clear them. 787 // we can convert 5 string values (4 bounds + 1 enum) to actual values, 788 // store them somewhere, then do facet checking at once, instead of 789 // going through the following steps. (lots of checking are redundant: 790 // for example, ((presentFacet & FACET_XXX) != 0)) 791 792 fFacetsDefined = 0; 793 fFixedFacet = 0; 794 795 int result = 0 ; 796 797 // step 1: parse present facets 798 short allowedFacet = fDVs[fValidationDV].getAllowedFacets(); 799 800 // length 801 if ((presentFacet & FACET_LENGTH) != 0) { 802 if ((allowedFacet & FACET_LENGTH) == 0) { 803 reportError("cos-applicable-facets", new Object[]{"length", fTypeName}); 804 } else { 805 fLength = facets.length; 806 lengthAnnotation = facets.lengthAnnotation; 807 fFacetsDefined |= FACET_LENGTH; 808 if ((fixedFacet & FACET_LENGTH) != 0) 809 fFixedFacet |= FACET_LENGTH; 810 } 811 } 812 // minLength 813 if ((presentFacet & FACET_MINLENGTH) != 0) { 814 if ((allowedFacet & FACET_MINLENGTH) == 0) { 815 reportError("cos-applicable-facets", new Object[]{"minLength", fTypeName}); 816 } else { 817 fMinLength = facets.minLength; 818 minLengthAnnotation = facets.minLengthAnnotation; 819 fFacetsDefined |= FACET_MINLENGTH; 820 if ((fixedFacet & FACET_MINLENGTH) != 0) 821 fFixedFacet |= FACET_MINLENGTH; 822 } 823 } 824 // maxLength 825 if ((presentFacet & FACET_MAXLENGTH) != 0) { 826 if ((allowedFacet & FACET_MAXLENGTH) == 0) { 827 reportError("cos-applicable-facets", new Object[]{"maxLength", fTypeName}); 828 } else { 829 fMaxLength = facets.maxLength; 830 maxLengthAnnotation = facets.maxLengthAnnotation; 831 fFacetsDefined |= FACET_MAXLENGTH; 832 if ((fixedFacet & FACET_MAXLENGTH) != 0) 833 fFixedFacet |= FACET_MAXLENGTH; 834 } 835 } 836 // pattern 837 if ((presentFacet & FACET_PATTERN) != 0) { 838 if ((allowedFacet & FACET_PATTERN) == 0) { 839 reportError("cos-applicable-facets", new Object[]{"pattern", fTypeName}); 840 } else { 841 patternAnnotations = facets.patternAnnotations; 842 RegularExpression regex = null; 843 try { 844 regex = new RegularExpression(facets.pattern, "X", context.getLocale()); 845 } catch (Exception e) { 846 reportError("InvalidRegex", new Object[]{facets.pattern, e.getLocalizedMessage()}); 847 } 848 if (regex != null) { 849 fPattern = new ArrayList<>(); 850 fPattern.add(regex); 851 fPatternStr = new ArrayList<>(); 852 fPatternStr.add(facets.pattern); 853 fFacetsDefined |= FACET_PATTERN; 854 if ((fixedFacet & FACET_PATTERN) != 0) 855 fFixedFacet |= FACET_PATTERN; 856 } 857 } 858 } 859 860 // whiteSpace 861 if ((presentFacet & FACET_WHITESPACE) != 0) { 862 if ((allowedFacet & FACET_WHITESPACE) == 0) { 863 reportError("cos-applicable-facets", new Object[]{"whiteSpace", fTypeName}); 864 } else { 865 fWhiteSpace = facets.whiteSpace; 866 whiteSpaceAnnotation = facets.whiteSpaceAnnotation; 867 fFacetsDefined |= FACET_WHITESPACE; 868 if ((fixedFacet & FACET_WHITESPACE) != 0) 869 fFixedFacet |= FACET_WHITESPACE; 870 } 871 } 872 // enumeration 873 if ((presentFacet & FACET_ENUMERATION) != 0) { 874 if ((allowedFacet & FACET_ENUMERATION) == 0) { 875 reportError("cos-applicable-facets", new Object[]{"enumeration", fTypeName}); 876 } else { 877 List<String> enumVals = facets.enumeration; 878 int size = enumVals.size(); 879 fEnumeration = new ValidatedInfo[size]; 880 List<NamespaceContext> enumNSDecls = facets.enumNSDecls; 881 ValidationContextImpl ctx = new ValidationContextImpl(context); 882 enumerationAnnotations = facets.enumAnnotations; 883 fEnumerationSize = 0; 884 for (int i = 0; i < size; i++) { 885 if (enumNSDecls != null) 886 ctx.setNSContext(enumNSDecls.get(i)); 887 try { 888 ValidatedInfo info = getActualEnumValue(enumVals.get(i), ctx, null); 889 // check 4.3.5.c0 must: enumeration values from the value space of base 890 fEnumeration[fEnumerationSize++] = info; 891 } catch (InvalidDatatypeValueException ide) { 892 reportError("enumeration-valid-restriction", new Object[]{enumVals.get(i), this.getBaseType().getName()}); 893 } 894 } 895 fFacetsDefined |= FACET_ENUMERATION; 896 if ((fixedFacet & FACET_ENUMERATION) != 0) 897 fFixedFacet |= FACET_ENUMERATION; 898 } 899 } 900 901 // maxInclusive 902 if ((presentFacet & FACET_MAXINCLUSIVE) != 0) { 903 if ((allowedFacet & FACET_MAXINCLUSIVE) == 0) { 904 reportError("cos-applicable-facets", new Object[]{"maxInclusive", fTypeName}); 905 } else { 906 maxInclusiveAnnotation = facets.maxInclusiveAnnotation; 907 try { 908 fMaxInclusive = fBase.getActualValue(facets.maxInclusive, context, tempInfo, true); 909 fFacetsDefined |= FACET_MAXINCLUSIVE; 910 if ((fixedFacet & FACET_MAXINCLUSIVE) != 0) 911 fFixedFacet |= FACET_MAXINCLUSIVE; 912 } catch (InvalidDatatypeValueException ide) { 913 reportError(ide.getKey(), ide.getArgs()); 914 reportError("FacetValueFromBase", new Object[]{fTypeName, facets.maxInclusive, 915 "maxInclusive", fBase.getName()}); 916 } 917 918 // check against fixed value in base 919 if (((fBase.fFacetsDefined & FACET_MAXINCLUSIVE) != 0)) { 920 if ((fBase.fFixedFacet & FACET_MAXINCLUSIVE) != 0) { 921 if (fDVs[fValidationDV].compare(fMaxInclusive, fBase.fMaxInclusive) != 0) 922 reportError( "FixedFacetValue", new Object[]{"maxInclusive", fMaxInclusive, fBase.fMaxInclusive, fTypeName}); 923 } 924 } 925 // maxInclusive from base 926 try { 927 fBase.validate(context, tempInfo); 928 } catch (InvalidDatatypeValueException ide) { 929 reportError(ide.getKey(), ide.getArgs()); 930 reportError("FacetValueFromBase", new Object[]{fTypeName, facets.maxInclusive, 931 "maxInclusive", fBase.getName()}); 932 } 933 } 934 } 935 936 // maxExclusive 937 boolean needCheckBase = true; 938 if ((presentFacet & FACET_MAXEXCLUSIVE) != 0) { 939 if ((allowedFacet & FACET_MAXEXCLUSIVE) == 0) { 940 reportError("cos-applicable-facets", new Object[]{"maxExclusive", fTypeName}); 941 } else { 942 maxExclusiveAnnotation = facets.maxExclusiveAnnotation; 943 try { 944 fMaxExclusive = fBase.getActualValue(facets.maxExclusive, context, tempInfo, true); 945 fFacetsDefined |= FACET_MAXEXCLUSIVE; 946 if ((fixedFacet & FACET_MAXEXCLUSIVE) != 0) 947 fFixedFacet |= FACET_MAXEXCLUSIVE; 948 } catch (InvalidDatatypeValueException ide) { 949 reportError(ide.getKey(), ide.getArgs()); 950 reportError("FacetValueFromBase", new Object[]{fTypeName, facets.maxExclusive, 951 "maxExclusive", fBase.getName()}); 952 } 953 954 // check against fixed value in base 955 if (((fBase.fFacetsDefined & FACET_MAXEXCLUSIVE) != 0)) { 956 result = fDVs[fValidationDV].compare(fMaxExclusive, fBase.fMaxExclusive); 957 if ((fBase.fFixedFacet & FACET_MAXEXCLUSIVE) != 0 && result != 0) { 958 reportError( "FixedFacetValue", new Object[]{"maxExclusive", facets.maxExclusive, fBase.fMaxExclusive, fTypeName}); 959 } 960 if (result == 0) { 961 needCheckBase = false; 962 } 963 } 964 // maxExclusive from base 965 if (needCheckBase) { 966 try { 967 fBase.validate(context, tempInfo); 968 } catch (InvalidDatatypeValueException ide) { 969 reportError(ide.getKey(), ide.getArgs()); 970 reportError("FacetValueFromBase", new Object[]{fTypeName, facets.maxExclusive, 971 "maxExclusive", fBase.getName()}); 972 } 973 } 974 // If maxExclusive == base.maxExclusive, then we only need to check 975 // maxExclusive <= base.maxInclusive 976 else if (((fBase.fFacetsDefined & FACET_MAXINCLUSIVE) != 0)) { 977 if (fDVs[fValidationDV].compare(fMaxExclusive, fBase.fMaxInclusive) > 0) { 978 reportError( "maxExclusive-valid-restriction.2", new Object[]{facets.maxExclusive, fBase.fMaxInclusive}); 979 } 980 } 981 } 982 } 983 // minExclusive 984 needCheckBase = true; 985 if ((presentFacet & FACET_MINEXCLUSIVE) != 0) { 986 if ((allowedFacet & FACET_MINEXCLUSIVE) == 0) { 987 reportError("cos-applicable-facets", new Object[]{"minExclusive", fTypeName}); 988 } else { 989 minExclusiveAnnotation = facets.minExclusiveAnnotation; 990 try { 991 fMinExclusive = fBase.getActualValue(facets.minExclusive, context, tempInfo, true); 992 fFacetsDefined |= FACET_MINEXCLUSIVE; 993 if ((fixedFacet & FACET_MINEXCLUSIVE) != 0) 994 fFixedFacet |= FACET_MINEXCLUSIVE; 995 } catch (InvalidDatatypeValueException ide) { 996 reportError(ide.getKey(), ide.getArgs()); 997 reportError("FacetValueFromBase", new Object[]{fTypeName, facets.minExclusive, 998 "minExclusive", fBase.getName()}); 999 } 1000 1001 // check against fixed value in base 1002 if (((fBase.fFacetsDefined & FACET_MINEXCLUSIVE) != 0)) { 1003 result = fDVs[fValidationDV].compare(fMinExclusive, fBase.fMinExclusive); 1004 if ((fBase.fFixedFacet & FACET_MINEXCLUSIVE) != 0 && result != 0) { 1005 reportError( "FixedFacetValue", new Object[]{"minExclusive", facets.minExclusive, fBase.fMinExclusive, fTypeName}); 1006 } 1007 if (result == 0) { 1008 needCheckBase = false; 1009 } 1010 } 1011 // minExclusive from base 1012 if (needCheckBase) { 1013 try { 1014 fBase.validate(context, tempInfo); 1015 } catch (InvalidDatatypeValueException ide) { 1016 reportError(ide.getKey(), ide.getArgs()); 1017 reportError("FacetValueFromBase", new Object[]{fTypeName, facets.minExclusive, 1018 "minExclusive", fBase.getName()}); 1019 } 1020 } 1021 // If minExclusive == base.minExclusive, then we only need to check 1022 // minExclusive >= base.minInclusive 1023 else if (((fBase.fFacetsDefined & FACET_MININCLUSIVE) != 0)) { 1024 if (fDVs[fValidationDV].compare(fMinExclusive, fBase.fMinInclusive) < 0) { 1025 reportError( "minExclusive-valid-restriction.3", new Object[]{facets.minExclusive, fBase.fMinInclusive}); 1026 } 1027 } 1028 } 1029 } 1030 // minInclusive 1031 if ((presentFacet & FACET_MININCLUSIVE) != 0) { 1032 if ((allowedFacet & FACET_MININCLUSIVE) == 0) { 1033 reportError("cos-applicable-facets", new Object[]{"minInclusive", fTypeName}); 1034 } else { 1035 minInclusiveAnnotation = facets.minInclusiveAnnotation; 1036 try { 1037 fMinInclusive = fBase.getActualValue(facets.minInclusive, context, tempInfo, true); 1038 fFacetsDefined |= FACET_MININCLUSIVE; 1039 if ((fixedFacet & FACET_MININCLUSIVE) != 0) 1040 fFixedFacet |= FACET_MININCLUSIVE; 1041 } catch (InvalidDatatypeValueException ide) { 1042 reportError(ide.getKey(), ide.getArgs()); 1043 reportError("FacetValueFromBase", new Object[]{fTypeName, facets.minInclusive, 1044 "minInclusive", fBase.getName()}); 1045 } 1046 1047 // check against fixed value in base 1048 if (((fBase.fFacetsDefined & FACET_MININCLUSIVE) != 0)) { 1049 if ((fBase.fFixedFacet & FACET_MININCLUSIVE) != 0) { 1050 if (fDVs[fValidationDV].compare(fMinInclusive, fBase.fMinInclusive) != 0) 1051 reportError( "FixedFacetValue", new Object[]{"minInclusive", facets.minInclusive, fBase.fMinInclusive, fTypeName}); 1052 } 1053 } 1054 // minInclusive from base 1055 try { 1056 fBase.validate(context, tempInfo); 1057 } catch (InvalidDatatypeValueException ide) { 1058 reportError(ide.getKey(), ide.getArgs()); 1059 reportError("FacetValueFromBase", new Object[]{fTypeName, facets.minInclusive, 1060 "minInclusive", fBase.getName()}); 1061 } 1062 } 1063 } 1064 1065 // totalDigits 1066 if ((presentFacet & FACET_TOTALDIGITS) != 0) { 1067 if ((allowedFacet & FACET_TOTALDIGITS) == 0) { 1068 reportError("cos-applicable-facets", new Object[]{"totalDigits", fTypeName}); 1069 } else { 1070 totalDigitsAnnotation = facets.totalDigitsAnnotation; 1071 fTotalDigits = facets.totalDigits; 1072 fFacetsDefined |= FACET_TOTALDIGITS; 1073 if ((fixedFacet & FACET_TOTALDIGITS) != 0) 1074 fFixedFacet |= FACET_TOTALDIGITS; 1075 } 1076 } 1077 // fractionDigits 1078 if ((presentFacet & FACET_FRACTIONDIGITS) != 0) { 1079 if ((allowedFacet & FACET_FRACTIONDIGITS) == 0) { 1080 reportError("cos-applicable-facets", new Object[]{"fractionDigits", fTypeName}); 1081 } else { 1082 fFractionDigits = facets.fractionDigits; 1083 fractionDigitsAnnotation = facets.fractionDigitsAnnotation; 1084 fFacetsDefined |= FACET_FRACTIONDIGITS; 1085 if ((fixedFacet & FACET_FRACTIONDIGITS) != 0) 1086 fFixedFacet |= FACET_FRACTIONDIGITS; 1087 } 1088 } 1089 1090 // token type: internal use, so do less checking 1091 if (patternType != SPECIAL_PATTERN_NONE) { 1092 fPatternType = patternType; 1093 } 1094 1095 // step 2: check facets against each other: length, bounds 1096 if(fFacetsDefined != 0) { 1097 1098 // check 4.3.2.c1 must: minLength <= maxLength 1099 if(((fFacetsDefined & FACET_MINLENGTH ) != 0 ) && ((fFacetsDefined & FACET_MAXLENGTH) != 0)) 1100 { 1101 if(fMinLength > fMaxLength) 1102 reportError("minLength-less-than-equal-to-maxLength", new Object[]{Integer.toString(fMinLength), Integer.toString(fMaxLength), fTypeName}); 1103 } 1104 1105 // check 4.3.8.c1 error: maxInclusive + maxExclusive 1106 if (((fFacetsDefined & FACET_MAXEXCLUSIVE) != 0) && ((fFacetsDefined & FACET_MAXINCLUSIVE) != 0)) { 1107 reportError( "maxInclusive-maxExclusive", new Object[]{fMaxInclusive, fMaxExclusive, fTypeName}); 1108 } 1109 1110 // check 4.3.9.c1 error: minInclusive + minExclusive 1111 if (((fFacetsDefined & FACET_MINEXCLUSIVE) != 0) && ((fFacetsDefined & FACET_MININCLUSIVE) != 0)) { 1112 reportError("minInclusive-minExclusive", new Object[]{fMinInclusive, fMinExclusive, fTypeName}); 1113 } 1114 1115 // check 4.3.7.c1 must: minInclusive <= maxInclusive 1116 if (((fFacetsDefined & FACET_MAXINCLUSIVE) != 0) && ((fFacetsDefined & FACET_MININCLUSIVE) != 0)) { 1117 result = fDVs[fValidationDV].compare(fMinInclusive, fMaxInclusive); 1118 if (result != -1 && result != 0) 1119 reportError("minInclusive-less-than-equal-to-maxInclusive", new Object[]{fMinInclusive, fMaxInclusive, fTypeName}); 1120 } 1121 1122 // check 4.3.8.c2 must: minExclusive <= maxExclusive ??? minExclusive < maxExclusive 1123 if (((fFacetsDefined & FACET_MAXEXCLUSIVE) != 0) && ((fFacetsDefined & FACET_MINEXCLUSIVE) != 0)) { 1124 result = fDVs[fValidationDV].compare(fMinExclusive, fMaxExclusive); 1125 if (result != -1 && result != 0) 1126 reportError( "minExclusive-less-than-equal-to-maxExclusive", new Object[]{fMinExclusive, fMaxExclusive, fTypeName}); 1127 } 1128 1129 // check 4.3.9.c2 must: minExclusive < maxInclusive 1130 if (((fFacetsDefined & FACET_MAXINCLUSIVE) != 0) && ((fFacetsDefined & FACET_MINEXCLUSIVE) != 0)) { 1131 if (fDVs[fValidationDV].compare(fMinExclusive, fMaxInclusive) != -1) 1132 reportError( "minExclusive-less-than-maxInclusive", new Object[]{fMinExclusive, fMaxInclusive, fTypeName}); 1133 } 1134 1135 // check 4.3.10.c1 must: minInclusive < maxExclusive 1136 if (((fFacetsDefined & FACET_MAXEXCLUSIVE) != 0) && ((fFacetsDefined & FACET_MININCLUSIVE) != 0)) { 1137 if (fDVs[fValidationDV].compare(fMinInclusive, fMaxExclusive) != -1) 1138 reportError( "minInclusive-less-than-maxExclusive", new Object[]{fMinInclusive, fMaxExclusive, fTypeName}); 1139 } 1140 1141 // check 4.3.12.c1 must: fractionDigits <= totalDigits 1142 if (((fFacetsDefined & FACET_FRACTIONDIGITS) != 0) && 1143 ((fFacetsDefined & FACET_TOTALDIGITS) != 0)) { 1144 if (fFractionDigits > fTotalDigits) 1145 reportError( "fractionDigits-totalDigits", new Object[]{Integer.toString(fFractionDigits), Integer.toString(fTotalDigits), fTypeName}); 1146 } 1147 1148 // step 3: check facets against base 1149 // check 4.3.1.c1 error: length & (fBase.maxLength | fBase.minLength) 1150 if((fFacetsDefined & FACET_LENGTH) != 0 ){ 1151 if ((fBase.fFacetsDefined & FACET_MINLENGTH) != 0 && 1152 fLength < fBase.fMinLength) { 1153 // length, fBase.minLength and fBase.maxLength defined 1154 reportError("length-minLength-maxLength.1.1", new Object[]{fTypeName, Integer.toString(fLength), Integer.toString(fBase.fMinLength)}); 1155 } 1156 if ((fBase.fFacetsDefined & FACET_MAXLENGTH) != 0 && 1157 fLength > fBase.fMaxLength) { 1158 // length and fBase.maxLength defined 1159 reportError("length-minLength-maxLength.2.1", new Object[]{fTypeName, Integer.toString(fLength), Integer.toString(fBase.fMaxLength)}); 1160 } 1161 if ( (fBase.fFacetsDefined & FACET_LENGTH) != 0 ) { 1162 // check 4.3.1.c2 error: length != fBase.length 1163 if ( fLength != fBase.fLength ) 1164 reportError( "length-valid-restriction", new Object[]{Integer.toString(fLength), Integer.toString(fBase.fLength), fTypeName}); 1165 } 1166 } 1167 1168 // check 4.3.1.c1 error: fBase.length & (maxLength | minLength) 1169 if((fBase.fFacetsDefined & FACET_LENGTH) != 0 || (fFacetsDefined & FACET_LENGTH) != 0){ 1170 if ((fFacetsDefined & FACET_MINLENGTH) != 0){ 1171 if (fBase.fLength < fMinLength) { 1172 // fBase.length, minLength and maxLength defined 1173 reportError("length-minLength-maxLength.1.1", new Object[]{fTypeName, Integer.toString(fBase.fLength), Integer.toString(fMinLength)}); 1174 } 1175 if ((fBase.fFacetsDefined & FACET_MINLENGTH) == 0){ 1176 reportError("length-minLength-maxLength.1.2.a", new Object[]{fTypeName}); 1177 } 1178 if (fMinLength != fBase.fMinLength){ 1179 reportError("length-minLength-maxLength.1.2.b", new Object[]{fTypeName, Integer.toString(fMinLength), Integer.toString(fBase.fMinLength)}); 1180 } 1181 } 1182 if ((fFacetsDefined & FACET_MAXLENGTH) != 0){ 1183 if (fBase.fLength > fMaxLength) { 1184 // fBase.length, minLength and maxLength defined 1185 reportError("length-minLength-maxLength.2.1", new Object[]{fTypeName, Integer.toString(fBase.fLength), Integer.toString(fMaxLength)}); 1186 } 1187 if ((fBase.fFacetsDefined & FACET_MAXLENGTH) == 0){ 1188 reportError("length-minLength-maxLength.2.2.a", new Object[]{fTypeName}); 1189 } 1190 if (fMaxLength != fBase.fMaxLength){ 1191 reportError("length-minLength-maxLength.2.2.b", new Object[]{fTypeName, Integer.toString(fMaxLength), Integer.toString(fBase.fBase.fMaxLength)}); 1192 } 1193 } 1194 } 1195 1196 // check 4.3.2.c1 must: minLength <= fBase.maxLength 1197 if ( ((fFacetsDefined & FACET_MINLENGTH ) != 0 ) ) { 1198 if ( (fBase.fFacetsDefined & FACET_MAXLENGTH ) != 0 ) { 1199 if ( fMinLength > fBase.fMaxLength ) { 1200 reportError("minLength-less-than-equal-to-maxLength", new Object[]{Integer.toString(fMinLength), Integer.toString(fBase.fMaxLength), fTypeName}); 1201 } 1202 } 1203 else if ( (fBase.fFacetsDefined & FACET_MINLENGTH) != 0 ) { 1204 if ( (fBase.fFixedFacet & FACET_MINLENGTH) != 0 && fMinLength != fBase.fMinLength ) { 1205 reportError( "FixedFacetValue", new Object[]{"minLength", Integer.toString(fMinLength), Integer.toString(fBase.fMinLength), fTypeName}); 1206 } 1207 1208 // check 4.3.2.c2 error: minLength < fBase.minLength 1209 if ( fMinLength < fBase.fMinLength ) { 1210 reportError( "minLength-valid-restriction", new Object[]{Integer.toString(fMinLength), Integer.toString(fBase.fMinLength), fTypeName}); 1211 } 1212 } 1213 } 1214 1215 1216 // check 4.3.2.c1 must: maxLength < fBase.minLength 1217 if ( ((fFacetsDefined & FACET_MAXLENGTH ) != 0 ) && ((fBase.fFacetsDefined & FACET_MINLENGTH ) != 0 )) { 1218 if ( fMaxLength < fBase.fMinLength) { 1219 reportError("minLength-less-than-equal-to-maxLength", new Object[]{Integer.toString(fBase.fMinLength), Integer.toString(fMaxLength)}); 1220 } 1221 } 1222 1223 // check 4.3.3.c1 error: maxLength > fBase.maxLength 1224 if ( (fFacetsDefined & FACET_MAXLENGTH) != 0 ) { 1225 if ( (fBase.fFacetsDefined & FACET_MAXLENGTH) != 0 ){ 1226 if(( (fBase.fFixedFacet & FACET_MAXLENGTH) != 0 )&& fMaxLength != fBase.fMaxLength ) { 1227 reportError( "FixedFacetValue", new Object[]{"maxLength", Integer.toString(fMaxLength), Integer.toString(fBase.fMaxLength), fTypeName}); 1228 } 1229 if ( fMaxLength > fBase.fMaxLength ) { 1230 reportError( "maxLength-valid-restriction", new Object[]{Integer.toString(fMaxLength), Integer.toString(fBase.fMaxLength), fTypeName}); 1231 } 1232 } 1233 } 1234 1235 /* // check 4.3.7.c2 error: 1236 // maxInclusive > fBase.maxInclusive 1237 // maxInclusive >= fBase.maxExclusive 1238 // maxInclusive < fBase.minInclusive 1239 // maxInclusive <= fBase.minExclusive 1240 1241 if (((fFacetsDefined & FACET_MAXINCLUSIVE) != 0)) { 1242 if (((fBase.fFacetsDefined & FACET_MAXINCLUSIVE) != 0)) { 1243 result = fDVs[fValidationDV].compare(fMaxInclusive, fBase.fMaxInclusive); 1244 if ((fBase.fFixedFacet & FACET_MAXINCLUSIVE) != 0 && result != 0) { 1245 reportError( "FixedFacetValue", new Object[]{"maxInclusive", fMaxInclusive, fBase.fMaxInclusive, fTypeName}); 1246 } 1247 if (result != -1 && result != 0) { 1248 reportError( "maxInclusive-valid-restriction.1", new Object[]{fMaxInclusive, fBase.fMaxInclusive, fTypeName}); 1249 } 1250 } 1251 if (((fBase.fFacetsDefined & FACET_MAXEXCLUSIVE) != 0) && 1252 fDVs[fValidationDV].compare(fMaxInclusive, fBase.fMaxExclusive) != -1){ 1253 reportError( "maxInclusive-valid-restriction.1", new Object[]{fMaxInclusive, fBase.fMaxExclusive, fTypeName}); 1254 } 1255 1256 if ((( fBase.fFacetsDefined & FACET_MININCLUSIVE) != 0)) { 1257 result = fDVs[fValidationDV].compare(fMaxInclusive, fBase.fMinInclusive); 1258 if (result != 1 && result != 0) { 1259 reportError( "maxInclusive-valid-restriction.1", new Object[]{fMaxInclusive, fBase.fMinInclusive, fTypeName}); 1260 } 1261 } 1262 1263 if ((( fBase.fFacetsDefined & FACET_MINEXCLUSIVE) != 0) && 1264 fDVs[fValidationDV].compare(fMaxInclusive, fBase.fMinExclusive ) != 1) 1265 reportError( "maxInclusive-valid-restriction.1", new Object[]{fMaxInclusive, fBase.fMinExclusive, fTypeName}); 1266 } 1267 1268 // check 4.3.8.c3 error: 1269 // maxExclusive > fBase.maxExclusive 1270 // maxExclusive > fBase.maxInclusive 1271 // maxExclusive <= fBase.minInclusive 1272 // maxExclusive <= fBase.minExclusive 1273 if (((fFacetsDefined & FACET_MAXEXCLUSIVE) != 0)) { 1274 if ((( fBase.fFacetsDefined & FACET_MAXEXCLUSIVE) != 0)) { 1275 result= fDVs[fValidationDV].compare(fMaxExclusive, fBase.fMaxExclusive); 1276 if ((fBase.fFixedFacet & FACET_MAXEXCLUSIVE) != 0 && result != 0) { 1277 reportError( "FixedFacetValue", new Object[]{"maxExclusive", fMaxExclusive, fBase.fMaxExclusive, fTypeName}); 1278 } 1279 if (result != -1 && result != 0) { 1280 reportError( "maxExclusive-valid-restriction.1", new Object[]{fMaxExclusive, fBase.fMaxExclusive, fTypeName}); 1281 } 1282 } 1283 1284 if ((( fBase.fFacetsDefined & FACET_MAXINCLUSIVE) != 0)) { 1285 result= fDVs[fValidationDV].compare(fMaxExclusive, fBase.fMaxInclusive); 1286 if (result != -1 && result != 0) { 1287 reportError( "maxExclusive-valid-restriction.2", new Object[]{fMaxExclusive, fBase.fMaxInclusive, fTypeName}); 1288 } 1289 } 1290 1291 if ((( fBase.fFacetsDefined & FACET_MINEXCLUSIVE) != 0) && 1292 fDVs[fValidationDV].compare(fMaxExclusive, fBase.fMinExclusive ) != 1) 1293 reportError( "maxExclusive-valid-restriction.3", new Object[]{fMaxExclusive, fBase.fMinExclusive, fTypeName}); 1294 1295 if ((( fBase.fFacetsDefined & FACET_MININCLUSIVE) != 0) && 1296 fDVs[fValidationDV].compare(fMaxExclusive, fBase.fMinInclusive) != 1) 1297 reportError( "maxExclusive-valid-restriction.4", new Object[]{fMaxExclusive, fBase.fMinInclusive, fTypeName}); 1298 } 1299 1300 // check 4.3.9.c3 error: 1301 // minExclusive < fBase.minExclusive 1302 // minExclusive > fBase.maxInclusive 1303 // minExclusive < fBase.minInclusive 1304 // minExclusive >= fBase.maxExclusive 1305 if (((fFacetsDefined & FACET_MINEXCLUSIVE) != 0)) { 1306 if ((( fBase.fFacetsDefined & FACET_MINEXCLUSIVE) != 0)) { 1307 result= fDVs[fValidationDV].compare(fMinExclusive, fBase.fMinExclusive); 1308 if ((fBase.fFixedFacet & FACET_MINEXCLUSIVE) != 0 && result != 0) { 1309 reportError( "FixedFacetValue", new Object[]{"minExclusive", fMinExclusive, fBase.fMinExclusive, fTypeName}); 1310 } 1311 if (result != 1 && result != 0) { 1312 reportError( "minExclusive-valid-restriction.1", new Object[]{fMinExclusive, fBase.fMinExclusive, fTypeName}); 1313 } 1314 } 1315 1316 if ((( fBase.fFacetsDefined & FACET_MAXINCLUSIVE) != 0)) { 1317 result=fDVs[fValidationDV].compare(fMinExclusive, fBase.fMaxInclusive); 1318 1319 if (result != -1 && result != 0) { 1320 reportError( "minExclusive-valid-restriction.2", new Object[]{fMinExclusive, fBase.fMaxInclusive, fTypeName}); 1321 } 1322 } 1323 1324 if ((( fBase.fFacetsDefined & FACET_MININCLUSIVE) != 0)) { 1325 result = fDVs[fValidationDV].compare(fMinExclusive, fBase.fMinInclusive); 1326 1327 if (result != 1 && result != 0) { 1328 reportError( "minExclusive-valid-restriction.3", new Object[]{fMinExclusive, fBase.fMinInclusive, fTypeName}); 1329 } 1330 } 1331 1332 if ((( fBase.fFacetsDefined & FACET_MAXEXCLUSIVE) != 0) && 1333 fDVs[fValidationDV].compare(fMinExclusive, fBase.fMaxExclusive) != -1) 1334 reportError( "minExclusive-valid-restriction.4", new Object[]{fMinExclusive, fBase.fMaxExclusive, fTypeName}); 1335 } 1336 1337 // check 4.3.10.c2 error: 1338 // minInclusive < fBase.minInclusive 1339 // minInclusive > fBase.maxInclusive 1340 // minInclusive <= fBase.minExclusive 1341 // minInclusive >= fBase.maxExclusive 1342 if (((fFacetsDefined & FACET_MININCLUSIVE) != 0)) { 1343 if (((fBase.fFacetsDefined & FACET_MININCLUSIVE) != 0)) { 1344 result = fDVs[fValidationDV].compare(fMinInclusive, fBase.fMinInclusive); 1345 1346 if ((fBase.fFixedFacet & FACET_MININCLUSIVE) != 0 && result != 0) { 1347 reportError( "FixedFacetValue", new Object[]{"minInclusive", fMinInclusive, fBase.fMinInclusive, fTypeName}); 1348 } 1349 if (result != 1 && result != 0) { 1350 reportError( "minInclusive-valid-restriction.1", new Object[]{fMinInclusive, fBase.fMinInclusive, fTypeName}); 1351 } 1352 } 1353 if ((( fBase.fFacetsDefined & FACET_MAXINCLUSIVE) != 0)) { 1354 result=fDVs[fValidationDV].compare(fMinInclusive, fBase.fMaxInclusive); 1355 if (result != -1 && result != 0) { 1356 reportError( "minInclusive-valid-restriction.2", new Object[]{fMinInclusive, fBase.fMaxInclusive, fTypeName}); 1357 } 1358 } 1359 if ((( fBase.fFacetsDefined & FACET_MINEXCLUSIVE) != 0) && 1360 fDVs[fValidationDV].compare(fMinInclusive, fBase.fMinExclusive ) != 1) 1361 reportError( "minInclusive-valid-restriction.3", new Object[]{fMinInclusive, fBase.fMinExclusive, fTypeName}); 1362 if ((( fBase.fFacetsDefined & FACET_MAXEXCLUSIVE) != 0) && 1363 fDVs[fValidationDV].compare(fMinInclusive, fBase.fMaxExclusive) != -1) 1364 reportError( "minInclusive-valid-restriction.4", new Object[]{fMinInclusive, fBase.fMaxExclusive, fTypeName}); 1365 } 1366 */ 1367 // check 4.3.11.c1 error: totalDigits > fBase.totalDigits 1368 if (((fFacetsDefined & FACET_TOTALDIGITS) != 0)) { 1369 if ((( fBase.fFacetsDefined & FACET_TOTALDIGITS) != 0)) { 1370 if ((fBase.fFixedFacet & FACET_TOTALDIGITS) != 0 && fTotalDigits != fBase.fTotalDigits) { 1371 reportError("FixedFacetValue", new Object[]{"totalDigits", Integer.toString(fTotalDigits), Integer.toString(fBase.fTotalDigits), fTypeName}); 1372 } 1373 if (fTotalDigits > fBase.fTotalDigits) { 1374 reportError( "totalDigits-valid-restriction", new Object[]{Integer.toString(fTotalDigits), Integer.toString(fBase.fTotalDigits), fTypeName}); 1375 } 1376 } 1377 } 1378 1379 // check 4.3.12.c1 must: fractionDigits <= base.totalDigits 1380 if ((fFacetsDefined & FACET_FRACTIONDIGITS) != 0) { 1381 if ((fBase.fFacetsDefined & FACET_TOTALDIGITS) != 0) { 1382 if (fFractionDigits > fBase.fTotalDigits) 1383 reportError( "fractionDigits-totalDigits", new Object[]{Integer.toString(fFractionDigits), Integer.toString(fTotalDigits), fTypeName}); 1384 } 1385 } 1386 1387 // check 4.3.12.c2 error: fractionDigits > fBase.fractionDigits 1388 // check fixed value for fractionDigits 1389 if (((fFacetsDefined & FACET_FRACTIONDIGITS) != 0)) { 1390 if ((( fBase.fFacetsDefined & FACET_FRACTIONDIGITS) != 0)) { 1391 if (((fBase.fFixedFacet & FACET_FRACTIONDIGITS) != 0 && fFractionDigits != fBase.fFractionDigits) || 1392 (fValidationDV == DV_INTEGER && fFractionDigits != 0)) { 1393 reportError("FixedFacetValue", new Object[]{"fractionDigits", Integer.toString(fFractionDigits), Integer.toString(fBase.fFractionDigits), fTypeName}); 1394 } 1395 if (fFractionDigits > fBase.fFractionDigits) { 1396 reportError( "fractionDigits-valid-restriction", new Object[]{Integer.toString(fFractionDigits), Integer.toString(fBase.fFractionDigits), fTypeName}); 1397 } 1398 } 1399 else if (fValidationDV == DV_INTEGER && fFractionDigits != 0) { 1400 reportError("FixedFacetValue", new Object[]{"fractionDigits", Integer.toString(fFractionDigits), "0", fTypeName}); 1401 } 1402 } 1403 1404 // check 4.3.6.c1 error: 1405 // (whiteSpace = preserve || whiteSpace = replace) && fBase.whiteSpace = collapese or 1406 // whiteSpace = preserve && fBase.whiteSpace = replace 1407 1408 if ( (fFacetsDefined & FACET_WHITESPACE) != 0 && (fBase.fFacetsDefined & FACET_WHITESPACE) != 0 ){ 1409 if ( (fBase.fFixedFacet & FACET_WHITESPACE) != 0 && fWhiteSpace != fBase.fWhiteSpace ) { 1410 reportError( "FixedFacetValue", new Object[]{"whiteSpace", whiteSpaceValue(fWhiteSpace), whiteSpaceValue(fBase.fWhiteSpace), fTypeName}); 1411 } 1412 1413 if ( fWhiteSpace == WS_PRESERVE && fBase.fWhiteSpace == WS_COLLAPSE ){ 1414 reportError( "whiteSpace-valid-restriction.1", new Object[]{fTypeName, "preserve"}); 1415 } 1416 if ( fWhiteSpace == WS_REPLACE && fBase.fWhiteSpace == WS_COLLAPSE ){ 1417 reportError( "whiteSpace-valid-restriction.1", new Object[]{fTypeName, "replace"}); 1418 } 1419 if ( fWhiteSpace == WS_PRESERVE && fBase.fWhiteSpace == WS_REPLACE ){ 1420 reportError( "whiteSpace-valid-restriction.2", new Object[]{fTypeName}); 1421 } 1422 } 1423 }//fFacetsDefined != null 1424 1425 // step 4: inherit other facets from base (including fTokeyType) 1426 1427 // inherit length 1428 if ( (fFacetsDefined & FACET_LENGTH) == 0 && (fBase.fFacetsDefined & FACET_LENGTH) != 0 ) { 1429 fFacetsDefined |= FACET_LENGTH; 1430 fLength = fBase.fLength; 1431 lengthAnnotation = fBase.lengthAnnotation; 1432 } 1433 // inherit minLength 1434 if ( (fFacetsDefined & FACET_MINLENGTH) == 0 && (fBase.fFacetsDefined & FACET_MINLENGTH) != 0 ) { 1435 fFacetsDefined |= FACET_MINLENGTH; 1436 fMinLength = fBase.fMinLength; 1437 minLengthAnnotation = fBase.minLengthAnnotation; 1438 } 1439 // inherit maxLength 1440 if ((fFacetsDefined & FACET_MAXLENGTH) == 0 && (fBase.fFacetsDefined & FACET_MAXLENGTH) != 0 ) { 1441 fFacetsDefined |= FACET_MAXLENGTH; 1442 fMaxLength = fBase.fMaxLength; 1443 maxLengthAnnotation = fBase.maxLengthAnnotation; 1444 } 1445 // inherit pattern 1446 if ( (fBase.fFacetsDefined & FACET_PATTERN) != 0 ) { 1447 if ((fFacetsDefined & FACET_PATTERN) == 0) { 1448 fFacetsDefined |= FACET_PATTERN; 1449 fPattern = fBase.fPattern; 1450 fPatternStr = fBase.fPatternStr; 1451 patternAnnotations = fBase.patternAnnotations; 1452 } 1453 else { 1454 for (int i = fBase.fPattern.size()-1; i >= 0; --i) { 1455 fPattern.add(fBase.fPattern.get(i)); 1456 fPatternStr.add(fBase.fPatternStr.get(i)); 1457 } 1458 if (fBase.patternAnnotations != null) { 1459 if (patternAnnotations != null) { 1460 for (int i = fBase.patternAnnotations.getLength()-1; i >= 0; --i) { 1461 patternAnnotations.addXSObject(fBase.patternAnnotations.item(i)); 1462 } 1463 } 1464 else { 1465 patternAnnotations = fBase.patternAnnotations; 1466 } 1467 } 1468 } 1469 } 1470 // inherit whiteSpace 1471 if ( (fFacetsDefined & FACET_WHITESPACE) == 0 && (fBase.fFacetsDefined & FACET_WHITESPACE) != 0 ) { 1472 fFacetsDefined |= FACET_WHITESPACE; 1473 fWhiteSpace = fBase.fWhiteSpace; 1474 whiteSpaceAnnotation = fBase.whiteSpaceAnnotation; 1475 } 1476 // inherit enumeration 1477 if ((fFacetsDefined & FACET_ENUMERATION) == 0 && (fBase.fFacetsDefined & FACET_ENUMERATION) != 0) { 1478 fFacetsDefined |= FACET_ENUMERATION; 1479 fEnumeration = fBase.fEnumeration; 1480 fEnumerationSize = fBase.fEnumerationSize; 1481 enumerationAnnotations = fBase.enumerationAnnotations; 1482 } 1483 // inherit maxExclusive 1484 if ((( fBase.fFacetsDefined & FACET_MAXEXCLUSIVE) != 0) && 1485 !((fFacetsDefined & FACET_MAXEXCLUSIVE) != 0) && !((fFacetsDefined & FACET_MAXINCLUSIVE) != 0)) { 1486 fFacetsDefined |= FACET_MAXEXCLUSIVE; 1487 fMaxExclusive = fBase.fMaxExclusive; 1488 maxExclusiveAnnotation = fBase.maxExclusiveAnnotation; 1489 } 1490 // inherit maxInclusive 1491 if ((( fBase.fFacetsDefined & FACET_MAXINCLUSIVE) != 0) && 1492 !((fFacetsDefined & FACET_MAXEXCLUSIVE) != 0) && !((fFacetsDefined & FACET_MAXINCLUSIVE) != 0)) { 1493 fFacetsDefined |= FACET_MAXINCLUSIVE; 1494 fMaxInclusive = fBase.fMaxInclusive; 1495 maxInclusiveAnnotation = fBase.maxInclusiveAnnotation; 1496 } 1497 // inherit minExclusive 1498 if ((( fBase.fFacetsDefined & FACET_MINEXCLUSIVE) != 0) && 1499 !((fFacetsDefined & FACET_MINEXCLUSIVE) != 0) && !((fFacetsDefined & FACET_MININCLUSIVE) != 0)) { 1500 fFacetsDefined |= FACET_MINEXCLUSIVE; 1501 fMinExclusive = fBase.fMinExclusive; 1502 minExclusiveAnnotation = fBase.minExclusiveAnnotation; 1503 } 1504 // inherit minExclusive 1505 if ((( fBase.fFacetsDefined & FACET_MININCLUSIVE) != 0) && 1506 !((fFacetsDefined & FACET_MINEXCLUSIVE) != 0) && !((fFacetsDefined & FACET_MININCLUSIVE) != 0)) { 1507 fFacetsDefined |= FACET_MININCLUSIVE; 1508 fMinInclusive = fBase.fMinInclusive; 1509 minInclusiveAnnotation = fBase.minInclusiveAnnotation; 1510 } 1511 // inherit totalDigits 1512 if ((( fBase.fFacetsDefined & FACET_TOTALDIGITS) != 0) && 1513 !((fFacetsDefined & FACET_TOTALDIGITS) != 0)) { 1514 fFacetsDefined |= FACET_TOTALDIGITS; 1515 fTotalDigits = fBase.fTotalDigits; 1516 totalDigitsAnnotation = fBase.totalDigitsAnnotation; 1517 } 1518 // inherit fractionDigits 1519 if ((( fBase.fFacetsDefined & FACET_FRACTIONDIGITS) != 0) 1520 && !((fFacetsDefined & FACET_FRACTIONDIGITS) != 0)) { 1521 fFacetsDefined |= FACET_FRACTIONDIGITS; 1522 fFractionDigits = fBase.fFractionDigits; 1523 fractionDigitsAnnotation = fBase.fractionDigitsAnnotation; 1524 } 1525 //inherit tokeytype 1526 if ((fPatternType == SPECIAL_PATTERN_NONE ) && (fBase.fPatternType != SPECIAL_PATTERN_NONE)) { 1527 fPatternType = fBase.fPatternType ; 1528 } 1529 1530 // step 5: mark fixed values 1531 fFixedFacet |= fBase.fFixedFacet; 1532 1533 //step 6: setting fundamental facets 1534 calcFundamentalFacets(); 1535 1536 } //applyFacets() 1537 1538 /** 1539 * validate a value, and return the compiled form 1540 */ 1541 public Object validate(String content, ValidationContext context, ValidatedInfo validatedInfo) throws InvalidDatatypeValueException { 1542 1543 if (context == null) 1544 context = fEmptyContext; 1545 1546 if (validatedInfo == null) 1547 validatedInfo = new ValidatedInfo(); 1548 else 1549 validatedInfo.memberType = null; 1550 1551 // first normalize string value, and convert it to actual value 1552 boolean needNormalize = context==null||context.needToNormalize(); 1553 Object ob = getActualValue(content, context, validatedInfo, needNormalize); 1554 1555 validate(context, validatedInfo); 1556 1557 return ob; 1558 1559 } 1560 1561 protected ValidatedInfo getActualEnumValue(String lexical, ValidationContext ctx, ValidatedInfo info) 1562 throws InvalidDatatypeValueException { 1563 return fBase.validateWithInfo(lexical, ctx, info); 1564 } 1565 1566 /** 1567 * validate a value, and return the compiled form 1568 */ 1569 public ValidatedInfo validateWithInfo(String content, ValidationContext context, ValidatedInfo validatedInfo) throws InvalidDatatypeValueException { 1570 1571 if (context == null) 1572 context = fEmptyContext; 1573 1574 if (validatedInfo == null) 1575 validatedInfo = new ValidatedInfo(); 1576 else 1577 validatedInfo.memberType = null; 1578 1579 // first normalize string value, and convert it to actual value 1580 boolean needNormalize = context==null||context.needToNormalize(); 1581 getActualValue(content, context, validatedInfo, needNormalize); 1582 1583 validate(context, validatedInfo); 1584 1585 return validatedInfo; 1586 1587 } 1588 1589 /** 1590 * validate a value, and return the compiled form 1591 */ 1592 public Object validate(Object content, ValidationContext context, ValidatedInfo validatedInfo) throws InvalidDatatypeValueException { 1593 1594 if (context == null) 1595 context = fEmptyContext; 1596 1597 if (validatedInfo == null) 1598 validatedInfo = new ValidatedInfo(); 1599 else 1600 validatedInfo.memberType = null; 1601 1602 // first normalize string value, and convert it to actual value 1603 boolean needNormalize = context==null||context.needToNormalize(); 1604 Object ob = getActualValue(content, context, validatedInfo, needNormalize); 1605 1606 validate(context, validatedInfo); 1607 1608 return ob; 1609 1610 } 1611 1612 /** 1613 * validate an actual value against this DV 1614 * 1615 * @param context the validation context 1616 * @param validatedInfo used to provide the actual value and member types 1617 */ 1618 public void validate(ValidationContext context, ValidatedInfo validatedInfo) 1619 throws InvalidDatatypeValueException { 1620 1621 if (context == null) 1622 context = fEmptyContext; 1623 1624 // then validate the actual value against the facets 1625 if (context.needFacetChecking() && 1626 (fFacetsDefined != 0 && fFacetsDefined != FACET_WHITESPACE)) { 1627 checkFacets(validatedInfo); 1628 } 1629 1630 // now check extra rules: for ID/IDREF/ENTITY 1631 if (context.needExtraChecking()) { 1632 checkExtraRules(context, validatedInfo); 1633 } 1634 1635 } 1636 1637 private void checkFacets(ValidatedInfo validatedInfo) throws InvalidDatatypeValueException { 1638 1639 Object ob = validatedInfo.actualValue; 1640 String content = validatedInfo.normalizedValue; 1641 short type = validatedInfo.actualValueType; 1642 ShortList itemType = validatedInfo.itemValueTypes; 1643 1644 // For QName and NOTATION types, we don't check length facets 1645 if (fValidationDV != DV_QNAME && fValidationDV != DV_NOTATION) { 1646 int length = fDVs[fValidationDV].getDataLength(ob); 1647 1648 // maxLength 1649 if ( (fFacetsDefined & FACET_MAXLENGTH) != 0 ) { 1650 if ( length > fMaxLength ) { 1651 throw new InvalidDatatypeValueException("cvc-maxLength-valid", 1652 new Object[]{content, Integer.toString(length), Integer.toString(fMaxLength), fTypeName}); 1653 } 1654 } 1655 1656 //minLength 1657 if ( (fFacetsDefined & FACET_MINLENGTH) != 0 ) { 1658 if ( length < fMinLength ) { 1659 throw new InvalidDatatypeValueException("cvc-minLength-valid", 1660 new Object[]{content, Integer.toString(length), Integer.toString(fMinLength), fTypeName}); 1661 } 1662 } 1663 1664 //length 1665 if ( (fFacetsDefined & FACET_LENGTH) != 0 ) { 1666 if ( length != fLength ) { 1667 throw new InvalidDatatypeValueException("cvc-length-valid", 1668 new Object[]{content, Integer.toString(length), Integer.toString(fLength), fTypeName}); 1669 } 1670 } 1671 } 1672 1673 //enumeration 1674 if ( ((fFacetsDefined & FACET_ENUMERATION) != 0 ) ) { 1675 boolean present = false; 1676 final int enumSize = fEnumerationSize; 1677 final short primitiveType1 = convertToPrimitiveKind(type); 1678 for (int i = 0; i < enumSize; i++) { 1679 final short primitiveType2 = convertToPrimitiveKind(fEnumeration[i].actualValueType); 1680 if ((primitiveType1 == primitiveType2 || 1681 primitiveType1 == XSConstants.ANYSIMPLETYPE_DT && primitiveType2 == XSConstants.STRING_DT || 1682 primitiveType1 == XSConstants.STRING_DT && primitiveType2 == XSConstants.ANYSIMPLETYPE_DT) 1683 && fEnumeration[i].actualValue.equals(ob)) { 1684 if (primitiveType1 == XSConstants.LIST_DT || primitiveType1 == XSConstants.LISTOFUNION_DT) { 1685 ShortList enumItemType = fEnumeration[i].itemValueTypes; 1686 final int typeList1Length = itemType != null ? itemType.getLength() : 0; 1687 final int typeList2Length = enumItemType != null ? enumItemType.getLength() : 0; 1688 if (typeList1Length == typeList2Length) { 1689 int j; 1690 for (j = 0; j < typeList1Length; ++j) { 1691 final short primitiveItem1 = convertToPrimitiveKind(itemType.item(j)); 1692 final short primitiveItem2 = convertToPrimitiveKind(enumItemType.item(j)); 1693 if (primitiveItem1 != primitiveItem2) { 1694 if (primitiveItem1 == XSConstants.ANYSIMPLETYPE_DT && primitiveItem2 == XSConstants.STRING_DT || 1695 primitiveItem1 == XSConstants.STRING_DT && primitiveItem2 == XSConstants.ANYSIMPLETYPE_DT) { 1696 continue; 1697 } 1698 break; 1699 } 1700 } 1701 if (j == typeList1Length) { 1702 present = true; 1703 break; 1704 } 1705 } 1706 } 1707 else { 1708 present = true; 1709 break; 1710 } 1711 } 1712 } 1713 if(!present){ 1714 StringBuffer sb = new StringBuffer(); 1715 appendEnumString(sb); 1716 throw new InvalidDatatypeValueException("cvc-enumeration-valid", 1717 new Object [] {content, sb.toString()}); 1718 } 1719 } 1720 1721 //fractionDigits 1722 if ((fFacetsDefined & FACET_FRACTIONDIGITS) != 0) { 1723 int scale = fDVs[fValidationDV].getFractionDigits(ob); 1724 if (scale > fFractionDigits) { 1725 throw new InvalidDatatypeValueException("cvc-fractionDigits-valid", 1726 new Object[] {content, Integer.toString(scale), Integer.toString(fFractionDigits)}); 1727 } 1728 } 1729 1730 //totalDigits 1731 if ((fFacetsDefined & FACET_TOTALDIGITS)!=0) { 1732 int totalDigits = fDVs[fValidationDV].getTotalDigits(ob); 1733 if (totalDigits > fTotalDigits) { 1734 throw new InvalidDatatypeValueException("cvc-totalDigits-valid", 1735 new Object[] {content, Integer.toString(totalDigits), Integer.toString(fTotalDigits)}); 1736 } 1737 } 1738 1739 int compare; 1740 1741 //maxinclusive 1742 if ( (fFacetsDefined & FACET_MAXINCLUSIVE) != 0 ) { 1743 compare = fDVs[fValidationDV].compare(ob, fMaxInclusive); 1744 if (compare != -1 && compare != 0) { 1745 throw new InvalidDatatypeValueException("cvc-maxInclusive-valid", 1746 new Object[] {content, fMaxInclusive, fTypeName}); 1747 } 1748 } 1749 1750 //maxExclusive 1751 if ( (fFacetsDefined & FACET_MAXEXCLUSIVE) != 0 ) { 1752 compare = fDVs[fValidationDV].compare(ob, fMaxExclusive ); 1753 if (compare != -1) { 1754 throw new InvalidDatatypeValueException("cvc-maxExclusive-valid", 1755 new Object[] {content, fMaxExclusive, fTypeName}); 1756 } 1757 } 1758 1759 //minInclusive 1760 if ( (fFacetsDefined & FACET_MININCLUSIVE) != 0 ) { 1761 compare = fDVs[fValidationDV].compare(ob, fMinInclusive); 1762 if (compare != 1 && compare != 0) { 1763 throw new InvalidDatatypeValueException("cvc-minInclusive-valid", 1764 new Object[] {content, fMinInclusive, fTypeName}); 1765 } 1766 } 1767 1768 //minExclusive 1769 if ( (fFacetsDefined & FACET_MINEXCLUSIVE) != 0 ) { 1770 compare = fDVs[fValidationDV].compare(ob, fMinExclusive); 1771 if (compare != 1) { 1772 throw new InvalidDatatypeValueException("cvc-minExclusive-valid", 1773 new Object[] {content, fMinExclusive, fTypeName}); 1774 } 1775 } 1776 1777 } 1778 1779 private void checkExtraRules(ValidationContext context, ValidatedInfo validatedInfo) throws InvalidDatatypeValueException { 1780 1781 Object ob = validatedInfo.actualValue; 1782 1783 if (fVariety == VARIETY_ATOMIC) { 1784 1785 fDVs[fValidationDV].checkExtraRules(ob, context); 1786 1787 } else if (fVariety == VARIETY_LIST) { 1788 1789 ListDV.ListData values = (ListDV.ListData)ob; 1790 XSSimpleType memberType = validatedInfo.memberType; 1791 int len = values.getLength(); 1792 try { 1793 if (fItemType.fVariety == VARIETY_UNION) { 1794 XSSimpleTypeDecl[] memberTypes = (XSSimpleTypeDecl[])validatedInfo.memberTypes; 1795 for (int i = len-1; i >= 0; i--) { 1796 validatedInfo.actualValue = values.item(i); 1797 validatedInfo.memberType = memberTypes[i]; 1798 fItemType.checkExtraRules(context, validatedInfo); 1799 } 1800 } else { // (fVariety == VARIETY_ATOMIC) 1801 for (int i = len-1; i >= 0; i--) { 1802 validatedInfo.actualValue = values.item(i); 1803 fItemType.checkExtraRules(context, validatedInfo); 1804 } 1805 } 1806 } 1807 finally { 1808 validatedInfo.actualValue = values; 1809 validatedInfo.memberType = memberType; 1810 } 1811 1812 } else { // (fVariety == VARIETY_UNION) 1813 1814 ((XSSimpleTypeDecl)validatedInfo.memberType).checkExtraRules(context, validatedInfo); 1815 1816 } 1817 1818 }// checkExtraRules() 1819 1820 //we can still return object for internal use. 1821 private Object getActualValue(Object content, ValidationContext context, 1822 ValidatedInfo validatedInfo, boolean needNormalize) 1823 throws InvalidDatatypeValueException{ 1824 1825 String nvalue; 1826 if (needNormalize) { 1827 nvalue = normalize(content, fWhiteSpace); 1828 } else { 1829 nvalue = content.toString(); 1830 } 1831 if ( (fFacetsDefined & FACET_PATTERN ) != 0 ) { 1832 RegularExpression regex; 1833 for (int idx = fPattern.size()-1; idx >= 0; idx--) { 1834 regex = fPattern.get(idx); 1835 if (!regex.matches(nvalue)){ 1836 throw new InvalidDatatypeValueException("cvc-pattern-valid", 1837 new Object[]{content, 1838 fPatternStr.get(idx), 1839 1840 fTypeName}); 1841 } 1842 } 1843 } 1844 1845 if (fVariety == VARIETY_ATOMIC) { 1846 1847 // validate special kinds of token, in place of old pattern matching 1848 if (fPatternType != SPECIAL_PATTERN_NONE) { 1849 1850 boolean seenErr = false; 1851 if (fPatternType == SPECIAL_PATTERN_NMTOKEN) { 1852 // PATTERN "\\c+" 1853 seenErr = !XMLChar.isValidNmtoken(nvalue); 1854 } 1855 else if (fPatternType == SPECIAL_PATTERN_NAME) { 1856 // PATTERN "\\i\\c*" 1857 seenErr = !XMLChar.isValidName(nvalue); 1858 } 1859 else if (fPatternType == SPECIAL_PATTERN_NCNAME) { 1860 // PATTERN "[\\i-[:]][\\c-[:]]*" 1861 seenErr = !XMLChar.isValidNCName(nvalue); 1862 } 1863 if (seenErr) { 1864 throw new InvalidDatatypeValueException("cvc-datatype-valid.1.2.1", 1865 new Object[]{nvalue, SPECIAL_PATTERN_STRING[fPatternType]}); 1866 } 1867 } 1868 1869 validatedInfo.normalizedValue = nvalue; 1870 Object avalue = fDVs[fValidationDV].getActualValue(nvalue, context); 1871 validatedInfo.actualValue = avalue; 1872 validatedInfo.actualValueType = fBuiltInKind; 1873 validatedInfo.actualType = this; 1874 1875 return avalue; 1876 1877 } else if (fVariety == VARIETY_LIST) { 1878 1879 StringTokenizer parsedList = new StringTokenizer(nvalue, " "); 1880 int countOfTokens = parsedList.countTokens() ; 1881 Object[] avalue = new Object[countOfTokens]; 1882 boolean isUnion = fItemType.getVariety() == VARIETY_UNION; 1883 short[] itemTypes = new short[isUnion ? countOfTokens : 1]; 1884 if (!isUnion) 1885 itemTypes[0] = fItemType.fBuiltInKind; 1886 XSSimpleTypeDecl[] memberTypes = new XSSimpleTypeDecl[countOfTokens]; 1887 for(int i = 0 ; i < countOfTokens ; i ++){ 1888 // we can't call fItemType.validate(), otherwise checkExtraRules() 1889 // will be called twice: once in fItemType.validate, once in 1890 // validate method of this type. 1891 // so we take two steps to get the actual value: 1892 // 1. fItemType.getActualValue() 1893 // 2. fItemType.chekcFacets() 1894 avalue[i] = fItemType.getActualValue(parsedList.nextToken(), context, validatedInfo, false); 1895 if (context.needFacetChecking() && 1896 (fItemType.fFacetsDefined != 0 && fItemType.fFacetsDefined != FACET_WHITESPACE)) { 1897 fItemType.checkFacets(validatedInfo); 1898 } 1899 memberTypes[i] = (XSSimpleTypeDecl)validatedInfo.memberType; 1900 if (isUnion) 1901 itemTypes[i] = memberTypes[i].fBuiltInKind; 1902 } 1903 1904 ListDV.ListData v = new ListDV.ListData(avalue); 1905 validatedInfo.actualValue = v; 1906 validatedInfo.actualValueType = isUnion ? XSConstants.LISTOFUNION_DT : XSConstants.LIST_DT; 1907 validatedInfo.memberType = null; 1908 validatedInfo.memberTypes = memberTypes; 1909 validatedInfo.itemValueTypes = new ShortListImpl(itemTypes, itemTypes.length); 1910 validatedInfo.normalizedValue = nvalue; 1911 // Need to set it here or it will become the item type 1912 validatedInfo.actualType = this; 1913 1914 return v; 1915 1916 } else { // (fVariety == VARIETY_UNION) 1917 final Object _content = (fMemberTypes.length > 1 && content != null) ? content.toString() : content; 1918 for (int i = 0; i < fMemberTypes.length; i++) { 1919 try { 1920 // we can't call fMemberType[i].validate(), otherwise checkExtraRules() 1921 // will be called twice: once in fMemberType[i].validate, once in 1922 // validate method of this type. 1923 // so we take two steps to get the actual value: 1924 // 1. fMemberType[i].getActualValue() 1925 // 2. fMemberType[i].chekcFacets() 1926 Object aValue = fMemberTypes[i].getActualValue(_content, context, validatedInfo, true); 1927 if (context.needFacetChecking() && 1928 (fMemberTypes[i].fFacetsDefined != 0 && fMemberTypes[i].fFacetsDefined != FACET_WHITESPACE)) { 1929 fMemberTypes[i].checkFacets(validatedInfo); 1930 } 1931 validatedInfo.memberType = fMemberTypes[i]; 1932 // Need to set it here or it will become the member type 1933 validatedInfo.actualType = this; 1934 return aValue; 1935 } catch(InvalidDatatypeValueException invalidValue) { 1936 } 1937 } 1938 StringBuffer typesBuffer = new StringBuffer(); 1939 XSSimpleTypeDecl decl; 1940 for(int i = 0;i < fMemberTypes.length; i++) { 1941 if(i != 0) 1942 typesBuffer.append(" | "); 1943 decl = fMemberTypes[i]; 1944 if(decl.fTargetNamespace != null) { 1945 typesBuffer.append('{'); 1946 typesBuffer.append(decl.fTargetNamespace); 1947 typesBuffer.append('}'); 1948 } 1949 typesBuffer.append(decl.fTypeName); 1950 if(decl.fEnumeration != null) { 1951 typesBuffer.append(" : "); 1952 decl.appendEnumString(typesBuffer); 1953 } 1954 } 1955 throw new InvalidDatatypeValueException("cvc-datatype-valid.1.2.3", 1956 new Object[]{content, fTypeName, typesBuffer.toString()}); 1957 } 1958 1959 }//getActualValue() 1960 1961 public boolean isEqual(Object value1, Object value2) { 1962 if (value1 == null) { 1963 return false; 1964 } 1965 return value1.equals(value2); 1966 }//isEqual() 1967 1968 // determine whether the two values are identical 1969 public boolean isIdentical (Object value1, Object value2) { 1970 if (value1 == null) { 1971 return false; 1972 } 1973 return fDVs[fValidationDV].isIdentical(value1, value2); 1974 }//isIdentical() 1975 1976 // normalize the string according to the whiteSpace facet 1977 public static String normalize(String content, short ws) { 1978 int len = content == null ? 0 : content.length(); 1979 if (len == 0 || ws == WS_PRESERVE) 1980 return content; 1981 1982 StringBuffer sb = new StringBuffer(); 1983 if (ws == WS_REPLACE) { 1984 char ch; 1985 // when it's replace, just replace #x9, #xa, #xd by #x20 1986 for (int i = 0; i < len; i++) { 1987 ch = content.charAt(i); 1988 if (ch != 0x9 && ch != 0xa && ch != 0xd) 1989 sb.append(ch); 1990 else 1991 sb.append((char)0x20); 1992 } 1993 } else { 1994 char ch; 1995 int i; 1996 boolean isLeading = true; 1997 // when it's collapse 1998 for (i = 0; i < len; i++) { 1999 ch = content.charAt(i); 2000 // append real characters, so we passed leading ws 2001 if (ch != 0x9 && ch != 0xa && ch != 0xd && ch != 0x20) { 2002 sb.append(ch); 2003 isLeading = false; 2004 } 2005 else { 2006 // for whitespaces, we skip all following ws 2007 for (; i < len-1; i++) { 2008 ch = content.charAt(i+1); 2009 if (ch != 0x9 && ch != 0xa && ch != 0xd && ch != 0x20) 2010 break; 2011 } 2012 // if it's not a leading or tailing ws, then append a space 2013 if (i < len - 1 && !isLeading) 2014 sb.append((char)0x20); 2015 } 2016 } 2017 } 2018 2019 return sb.toString(); 2020 } 2021 2022 // normalize the string according to the whiteSpace facet 2023 protected String normalize(Object content, short ws) { 2024 if (content == null) 2025 return null; 2026 2027 // If pattern is not defined, we can skip some of the normalization. 2028 // Otherwise we have to normalize the data for correct result of 2029 // pattern validation. 2030 if ( (fFacetsDefined & FACET_PATTERN ) == 0 ) { 2031 short norm_type = fDVNormalizeType[fValidationDV]; 2032 if (norm_type == NORMALIZE_NONE) { 2033 return content.toString(); 2034 } 2035 else if (norm_type == NORMALIZE_TRIM) { 2036 return XMLChar.trim(content.toString()); 2037 } 2038 } 2039 2040 if (!(content instanceof StringBuffer)) { 2041 String strContent = content.toString(); 2042 return normalize(strContent, ws); 2043 } 2044 2045 StringBuffer sb = (StringBuffer)content; 2046 int len = sb.length(); 2047 if (len == 0) 2048 return ""; 2049 if (ws == WS_PRESERVE) 2050 return sb.toString(); 2051 2052 if (ws == WS_REPLACE) { 2053 char ch; 2054 // when it's replace, just replace #x9, #xa, #xd by #x20 2055 for (int i = 0; i < len; i++) { 2056 ch = sb.charAt(i); 2057 if (ch == 0x9 || ch == 0xa || ch == 0xd) 2058 sb.setCharAt(i, (char)0x20); 2059 } 2060 } else { 2061 char ch; 2062 int i, j = 0; 2063 boolean isLeading = true; 2064 // when it's collapse 2065 for (i = 0; i < len; i++) { 2066 ch = sb.charAt(i); 2067 // append real characters, so we passed leading ws 2068 if (ch != 0x9 && ch != 0xa && ch != 0xd && ch != 0x20) { 2069 sb.setCharAt(j++, ch); 2070 isLeading = false; 2071 } 2072 else { 2073 // for whitespaces, we skip all following ws 2074 for (; i < len-1; i++) { 2075 ch = sb.charAt(i+1); 2076 if (ch != 0x9 && ch != 0xa && ch != 0xd && ch != 0x20) 2077 break; 2078 } 2079 // if it's not a leading or tailing ws, then append a space 2080 if (i < len - 1 && !isLeading) 2081 sb.setCharAt(j++, (char)0x20); 2082 } 2083 } 2084 sb.setLength(j); 2085 } 2086 2087 return sb.toString(); 2088 } 2089 2090 void reportError(String key, Object[] args) throws InvalidDatatypeFacetException { 2091 throw new InvalidDatatypeFacetException(key, args); 2092 } 2093 2094 2095 private String whiteSpaceValue(short ws){ 2096 return WS_FACET_STRING[ws]; 2097 } 2098 2099 /** 2100 * Fundamental Facet: ordered. 2101 */ 2102 public short getOrdered() { 2103 return fOrdered; 2104 } 2105 2106 /** 2107 * Fundamental Facet: bounded. 2108 */ 2109 public boolean getBounded(){ 2110 return fBounded; 2111 } 2112 2113 /** 2114 * Fundamental Facet: cardinality. 2115 */ 2116 public boolean getFinite(){ 2117 return fFinite; 2118 } 2119 2120 /** 2121 * Fundamental Facet: numeric. 2122 */ 2123 public boolean getNumeric(){ 2124 return fNumeric; 2125 } 2126 2127 /** 2128 * Convenience method. [Facets]: check whether a facet is defined on this 2129 * type. 2130 * @param facetName The name of the facet. 2131 * @return True if the facet is defined, false otherwise. 2132 */ 2133 public boolean isDefinedFacet(short facetName) { 2134 if (fValidationDV == DV_ANYSIMPLETYPE || 2135 fValidationDV == DV_ANYATOMICTYPE) { 2136 return false; 2137 } 2138 if ((fFacetsDefined & facetName) != 0) { 2139 return true; 2140 } 2141 if (fPatternType != SPECIAL_PATTERN_NONE) { 2142 return facetName == FACET_PATTERN; 2143 } 2144 if (fValidationDV == DV_INTEGER) { 2145 return facetName == FACET_PATTERN || facetName == FACET_FRACTIONDIGITS; 2146 } 2147 return false; 2148 } 2149 2150 /** 2151 * [facets]: all facets defined on this type. The value is a bit 2152 * combination of FACET_XXX constants of all defined facets. 2153 */ 2154 public short getDefinedFacets() { 2155 if (fValidationDV == DV_ANYSIMPLETYPE || 2156 fValidationDV == DV_ANYATOMICTYPE) { 2157 return FACET_NONE; 2158 } 2159 if (fPatternType != SPECIAL_PATTERN_NONE) { 2160 return (short)(fFacetsDefined | FACET_PATTERN); 2161 } 2162 if (fValidationDV == DV_INTEGER) { 2163 return (short)(fFacetsDefined | FACET_PATTERN | FACET_FRACTIONDIGITS); 2164 } 2165 return fFacetsDefined; 2166 } 2167 2168 /** 2169 * Convenience method. [Facets]: check whether a facet is defined and 2170 * fixed on this type. 2171 * @param facetName The name of the facet. 2172 * @return True if the facet is fixed, false otherwise. 2173 */ 2174 public boolean isFixedFacet(short facetName) { 2175 if ((fFixedFacet & facetName) != 0) 2176 return true; 2177 if (fValidationDV == DV_INTEGER) 2178 return facetName == FACET_FRACTIONDIGITS; 2179 return false; 2180 } 2181 2182 /** 2183 * [facets]: all defined facets for this type which are fixed. 2184 */ 2185 public short getFixedFacets() { 2186 if (fValidationDV == DV_INTEGER) 2187 return (short)(fFixedFacet | FACET_FRACTIONDIGITS); 2188 return fFixedFacet; 2189 } 2190 2191 /** 2192 * Convenience method. Returns a value of a single constraining facet for 2193 * this simple type definition. This method must not be used to retrieve 2194 * values for <code>enumeration</code> and <code>pattern</code> facets. 2195 * @param facetName The name of the facet, i.e. 2196 * <code>FACET_LENGTH, FACET_TOTALDIGITS </code> (see 2197 * <code>XSConstants</code>). To retrieve the value for a pattern or 2198 * an enumeration, see <code>enumeration</code> and 2199 * <code>pattern</code>. 2200 * @return A value of the facet specified in <code>facetName</code> for 2201 * this simple type definition or <code>null</code>. 2202 */ 2203 public String getLexicalFacetValue(short facetName) { 2204 switch (facetName) { 2205 case FACET_LENGTH: 2206 return (fLength == -1)?null:Integer.toString(fLength); 2207 case FACET_MINLENGTH: 2208 return (fMinLength == -1)?null:Integer.toString(fMinLength); 2209 case FACET_MAXLENGTH: 2210 return (fMaxLength == -1)?null:Integer.toString(fMaxLength); 2211 case FACET_WHITESPACE: 2212 if (fValidationDV == DV_ANYSIMPLETYPE || 2213 fValidationDV == DV_ANYATOMICTYPE) { 2214 return null; 2215 } 2216 return WS_FACET_STRING[fWhiteSpace]; 2217 case FACET_MAXINCLUSIVE: 2218 return (fMaxInclusive == null)?null:fMaxInclusive.toString(); 2219 case FACET_MAXEXCLUSIVE: 2220 return (fMaxExclusive == null)?null:fMaxExclusive.toString(); 2221 case FACET_MINEXCLUSIVE: 2222 return (fMinExclusive == null)?null:fMinExclusive.toString(); 2223 case FACET_MININCLUSIVE: 2224 return (fMinInclusive == null)?null:fMinInclusive.toString(); 2225 case FACET_TOTALDIGITS: 2226 return (fTotalDigits == -1)?null:Integer.toString(fTotalDigits); 2227 case FACET_FRACTIONDIGITS: 2228 if (fValidationDV == DV_INTEGER) { 2229 return "0"; 2230 } 2231 return (fFractionDigits == -1)?null:Integer.toString(fFractionDigits); 2232 } 2233 return null; 2234 } 2235 2236 /** 2237 * A list of enumeration values if it exists, otherwise an empty 2238 * <code>StringList</code>. 2239 */ 2240 public StringList getLexicalEnumeration() { 2241 if (fLexicalEnumeration == null){ 2242 if (fEnumeration == null) 2243 return StringListImpl.EMPTY_LIST; 2244 int size = fEnumerationSize; 2245 String[] strs = new String[size]; 2246 for (int i = 0; i < size; i++) 2247 strs[i] = fEnumeration[i].normalizedValue; 2248 fLexicalEnumeration = new StringListImpl(strs, size); 2249 } 2250 return fLexicalEnumeration; 2251 } 2252 2253 /** 2254 * A list of actual enumeration values if it exists, otherwise an empty 2255 * <code>ObjectList</code>. 2256 */ 2257 public ObjectList getActualEnumeration() { 2258 if (fActualEnumeration == null) { 2259 fActualEnumeration = new AbstractObjectList() { 2260 public int getLength() { 2261 return (fEnumeration != null) ? fEnumerationSize : 0; 2262 } 2263 public boolean contains(Object item) { 2264 if (fEnumeration == null) { 2265 return false; 2266 } 2267 for (int i = 0; i < fEnumerationSize; i++) { 2268 if (fEnumeration[i].getActualValue().equals(item)) { 2269 return true; 2270 } 2271 } 2272 return false; 2273 } 2274 public Object item(int index) { 2275 if (index < 0 || index >= getLength()) { 2276 return null; 2277 } 2278 return fEnumeration[index].getActualValue(); 2279 } 2280 }; 2281 } 2282 return fActualEnumeration; 2283 } 2284 2285 /** 2286 * A list of enumeration type values (as a list of ShortList objects) if it exists, otherwise returns 2287 * null 2288 */ 2289 public ObjectList getEnumerationItemTypeList() { 2290 if (fEnumerationItemTypeList == null) { 2291 if (fEnumeration == null) { 2292 return null; 2293 } 2294 fEnumerationItemTypeList = new AbstractObjectList() { 2295 public int getLength() { 2296 return (fEnumeration != null) ? fEnumerationSize : 0; 2297 } 2298 public boolean contains(Object item) { 2299 if (fEnumeration == null || !(item instanceof ShortList)) 2300 return false; 2301 for (int i = 0;i < fEnumerationSize; i++) 2302 if (fEnumeration[i].itemValueTypes == item) 2303 return true; 2304 return false; 2305 } 2306 public Object item(int index) { 2307 if (index < 0 || index >= getLength()) { 2308 return null; 2309 } 2310 return fEnumeration[index].itemValueTypes; 2311 } 2312 }; 2313 } 2314 return fEnumerationItemTypeList; 2315 } 2316 2317 public ShortList getEnumerationTypeList() { 2318 if (fEnumerationTypeList == null) { 2319 if (fEnumeration == null) { 2320 return ShortListImpl.EMPTY_LIST; 2321 } 2322 short[] list = new short[fEnumerationSize]; 2323 for (int i = 0; i < fEnumerationSize; i++) { 2324 list[i] = fEnumeration[i].actualValueType; 2325 } 2326 fEnumerationTypeList = new ShortListImpl(list, fEnumerationSize); 2327 } 2328 return fEnumerationTypeList; 2329 } 2330 2331 /** 2332 * A list of pattern values if it exists, otherwise an empty 2333 * <code>StringList</code>. 2334 */ 2335 public StringList getLexicalPattern() { 2336 if (fPatternType == SPECIAL_PATTERN_NONE && fValidationDV != DV_INTEGER && fPatternStr == null) 2337 return StringListImpl.EMPTY_LIST; 2338 if (fLexicalPattern == null){ 2339 int size = fPatternStr == null ? 0 : fPatternStr.size(); 2340 String[] strs; 2341 if (fPatternType == SPECIAL_PATTERN_NMTOKEN) { 2342 strs = new String[size+1]; 2343 strs[size] = "\\c+"; 2344 } 2345 else if (fPatternType == SPECIAL_PATTERN_NAME) { 2346 strs = new String[size+1]; 2347 strs[size] = "\\i\\c*"; 2348 } 2349 else if (fPatternType == SPECIAL_PATTERN_NCNAME) { 2350 strs = new String[size+2]; 2351 strs[size] = "\\i\\c*"; 2352 strs[size+1] = "[\\i-[:]][\\c-[:]]*"; 2353 } 2354 else if (fValidationDV == DV_INTEGER) { 2355 strs = new String[size+1]; 2356 strs[size] = "[\\-+]?[0-9]+"; 2357 } 2358 else { 2359 strs = new String[size]; 2360 } 2361 for (int i = 0; i < size; i++) 2362 strs[i] = fPatternStr.get(i); 2363 fLexicalPattern = new StringListImpl(strs, strs.length); 2364 } 2365 return fLexicalPattern; 2366 } 2367 2368 /** 2369 * [annotations]: a set of annotations for this simple type component if 2370 * it exists, otherwise an empty <code>XSObjectList</code>. 2371 */ 2372 public XSObjectList getAnnotations() { 2373 return (fAnnotations != null) ? fAnnotations : XSObjectListImpl.EMPTY_LIST; 2374 } 2375 2376 private void calcFundamentalFacets() { 2377 setOrdered(); 2378 setNumeric(); 2379 setBounded(); 2380 setCardinality(); 2381 } 2382 2383 private void setOrdered(){ 2384 2385 // When {variety} is atomic, {value} is inherited from {value} of {base type definition}. For all "primitive" types {value} is as specified in the table in Fundamental Facets (C.1). 2386 if(fVariety == VARIETY_ATOMIC){ 2387 this.fOrdered = fBase.fOrdered; 2388 } 2389 2390 // When {variety} is list, {value} is false. 2391 else if(fVariety == VARIETY_LIST){ 2392 this.fOrdered = ORDERED_FALSE; 2393 } 2394 2395 // When {variety} is union, the {value} is partial unless one of the following: 2396 // 1. If every member of {member type definitions} is derived from a common ancestor other than the simple ur-type, then {value} is the same as that ancestor's ordered facet. 2397 // 2. If every member of {member type definitions} has a {value} of false for the ordered facet, then {value} is false. 2398 else if(fVariety == VARIETY_UNION){ 2399 int length = fMemberTypes.length; 2400 // REVISIT: is the length possible to be 0? 2401 if (length == 0) { 2402 this.fOrdered = ORDERED_PARTIAL; 2403 return; 2404 } 2405 // we need to process the first member type before entering the loop 2406 short ancestorId = getPrimitiveDV(fMemberTypes[0].fValidationDV); 2407 boolean commonAnc = ancestorId != DV_ANYSIMPLETYPE; 2408 boolean allFalse = fMemberTypes[0].fOrdered == ORDERED_FALSE; 2409 // for the other member types, check whether the value is false 2410 // and whether they have the same ancestor as the first one 2411 for (int i = 1; i < fMemberTypes.length && (commonAnc || allFalse); i++) { 2412 if (commonAnc) 2413 commonAnc = ancestorId == getPrimitiveDV(fMemberTypes[i].fValidationDV); 2414 if (allFalse) 2415 allFalse = fMemberTypes[i].fOrdered == ORDERED_FALSE; 2416 } 2417 if (commonAnc) { 2418 // REVISIT: all member types should have the same ordered value 2419 // just use the first one. Can we assume this? 2420 this.fOrdered = fMemberTypes[0].fOrdered; 2421 } else if (allFalse) { 2422 this.fOrdered = ORDERED_FALSE; 2423 } else { 2424 this.fOrdered = ORDERED_PARTIAL; 2425 } 2426 } 2427 2428 }//setOrdered 2429 2430 private void setNumeric(){ 2431 if(fVariety == VARIETY_ATOMIC){ 2432 this.fNumeric = fBase.fNumeric; 2433 } 2434 else if(fVariety == VARIETY_LIST){ 2435 this.fNumeric = false; 2436 } 2437 else if(fVariety == VARIETY_UNION){ 2438 XSSimpleType[] memberTypes = fMemberTypes; 2439 for(int i = 0 ; i < memberTypes.length ; i++){ 2440 if(!memberTypes[i].getNumeric() ){ 2441 this.fNumeric = false; 2442 return; 2443 } 2444 } 2445 this.fNumeric = true; 2446 } 2447 2448 }//setNumeric 2449 2450 private void setBounded(){ 2451 if(fVariety == VARIETY_ATOMIC){ 2452 if( (((this.fFacetsDefined & FACET_MININCLUSIVE) != 0) || ((this.fFacetsDefined & FACET_MINEXCLUSIVE) != 0)) 2453 && (((this.fFacetsDefined & FACET_MAXINCLUSIVE) != 0) || ((this.fFacetsDefined & FACET_MAXEXCLUSIVE) != 0)) ){ 2454 this.fBounded = true; 2455 } 2456 else{ 2457 this.fBounded = false; 2458 } 2459 } 2460 else if(fVariety == VARIETY_LIST){ 2461 if( ((this.fFacetsDefined & FACET_LENGTH) != 0 ) || ( ((this.fFacetsDefined & FACET_MINLENGTH) != 0 ) 2462 && ((this.fFacetsDefined & FACET_MAXLENGTH) != 0 )) ){ 2463 this.fBounded = true; 2464 } 2465 else{ 2466 this.fBounded = false; 2467 } 2468 2469 } 2470 else if(fVariety == VARIETY_UNION){ 2471 2472 XSSimpleTypeDecl [] memberTypes = this.fMemberTypes; 2473 short ancestorId = 0 ; 2474 2475 if(memberTypes.length > 0){ 2476 ancestorId = getPrimitiveDV(memberTypes[0].fValidationDV); 2477 } 2478 2479 for(int i = 0 ; i < memberTypes.length ; i++){ 2480 if(!memberTypes[i].getBounded() || (ancestorId != getPrimitiveDV(memberTypes[i].fValidationDV)) ){ 2481 this.fBounded = false; 2482 return; 2483 } 2484 } 2485 this.fBounded = true; 2486 } 2487 2488 }//setBounded 2489 2490 private boolean specialCardinalityCheck(){ 2491 if( (fBase.fValidationDV == XSSimpleTypeDecl.DV_DATE) || (fBase.fValidationDV == XSSimpleTypeDecl.DV_GYEARMONTH) 2492 || (fBase.fValidationDV == XSSimpleTypeDecl.DV_GYEAR) || (fBase.fValidationDV == XSSimpleTypeDecl.DV_GMONTHDAY) 2493 || (fBase.fValidationDV == XSSimpleTypeDecl.DV_GDAY) || (fBase.fValidationDV == XSSimpleTypeDecl.DV_GMONTH) ){ 2494 return true; 2495 } 2496 return false; 2497 2498 } //specialCardinalityCheck() 2499 2500 private void setCardinality(){ 2501 if(fVariety == VARIETY_ATOMIC){ 2502 if(fBase.fFinite){ 2503 this.fFinite = true; 2504 } 2505 else {// (!fBase.fFinite) 2506 if ( ((this.fFacetsDefined & FACET_LENGTH) != 0 ) || ((this.fFacetsDefined & FACET_MAXLENGTH) != 0 ) 2507 || ((this.fFacetsDefined & FACET_TOTALDIGITS) != 0 ) ){ 2508 this.fFinite = true; 2509 } 2510 else if( (((this.fFacetsDefined & FACET_MININCLUSIVE) != 0 ) || ((this.fFacetsDefined & FACET_MINEXCLUSIVE) != 0 )) 2511 && (((this.fFacetsDefined & FACET_MAXINCLUSIVE) != 0 ) || ((this.fFacetsDefined & FACET_MAXEXCLUSIVE) != 0 )) ){ 2512 if( ((this.fFacetsDefined & FACET_FRACTIONDIGITS) != 0 ) || specialCardinalityCheck()){ 2513 this.fFinite = true; 2514 } 2515 else{ 2516 this.fFinite = false; 2517 } 2518 } 2519 else{ 2520 this.fFinite = false; 2521 } 2522 } 2523 } 2524 else if(fVariety == VARIETY_LIST){ 2525 if( ((this.fFacetsDefined & FACET_LENGTH) != 0 ) || ( ((this.fFacetsDefined & FACET_MINLENGTH) != 0 ) 2526 && ((this.fFacetsDefined & FACET_MAXLENGTH) != 0 )) ){ 2527 this.fFinite = true; 2528 } 2529 else{ 2530 this.fFinite = false; 2531 } 2532 2533 } 2534 else if(fVariety == VARIETY_UNION){ 2535 XSSimpleType [] memberTypes = fMemberTypes; 2536 for(int i = 0 ; i < memberTypes.length ; i++){ 2537 if(!(memberTypes[i].getFinite()) ){ 2538 this.fFinite = false; 2539 return; 2540 } 2541 } 2542 this.fFinite = true; 2543 } 2544 2545 }//setCardinality 2546 2547 private short getPrimitiveDV(short validationDV){ 2548 2549 if (validationDV == DV_ID || validationDV == DV_IDREF || validationDV == DV_ENTITY){ 2550 return DV_STRING; 2551 } 2552 else if (validationDV == DV_INTEGER) { 2553 return DV_DECIMAL; 2554 } 2555 else if (Constants.SCHEMA_1_1_SUPPORT && (validationDV == DV_YEARMONTHDURATION || validationDV == DV_DAYTIMEDURATION)) { 2556 return DV_DURATION; 2557 } 2558 else { 2559 return validationDV; 2560 } 2561 2562 }//getPrimitiveDV() 2563 2564 public boolean derivedFromType(XSTypeDefinition ancestor, short derivation) { 2565 // REVISIT: implement according to derivation 2566 2567 // ancestor is null, return false 2568 if (ancestor == null) { 2569 return false; 2570 } 2571 // extract the actual XSTypeDefinition if the given ancestor is a delegate. 2572 while (ancestor instanceof XSSimpleTypeDelegate) { 2573 ancestor = ((XSSimpleTypeDelegate) ancestor).type; 2574 } 2575 // ancestor is anyType, return true 2576 // anyType is the only type whose base type is itself 2577 if (ancestor.getBaseType() == ancestor) { 2578 return true; 2579 } 2580 // recursively get base, and compare it with ancestor 2581 XSTypeDefinition type = this; 2582 while (type != ancestor && // compare with ancestor 2583 type != fAnySimpleType) { // reached anySimpleType 2584 type = type.getBaseType(); 2585 } 2586 return type == ancestor; 2587 } 2588 2589 public boolean derivedFrom(String ancestorNS, String ancestorName, short derivation) { 2590 // REVISIT: implement according to derivation 2591 2592 // ancestor is null, retur false 2593 if (ancestorName == null) 2594 return false; 2595 // ancestor is anyType, return true 2596 if (URI_SCHEMAFORSCHEMA.equals(ancestorNS) && 2597 ANY_TYPE.equals(ancestorName)) { 2598 return true; 2599 } 2600 2601 // recursively get base, and compare it with ancestor 2602 XSTypeDefinition type = this; 2603 while (!(ancestorName.equals(type.getName()) && 2604 ((ancestorNS == null && type.getNamespace() == null) || 2605 (ancestorNS != null && ancestorNS.equals(type.getNamespace())))) && // compare with ancestor 2606 type != fAnySimpleType) { // reached anySimpleType 2607 type = type.getBaseType(); 2608 } 2609 2610 return type != fAnySimpleType; 2611 } 2612 2613 /** 2614 * Checks if a type is derived from another by restriction, given the name 2615 * and namespace. See: 2616 * http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core.html#TypeInfo-isDerivedFrom 2617 * 2618 * @param ancestorNS 2619 * The namspace of the ancestor type declaration 2620 * @param ancestorName 2621 * The name of the ancestor type declaration 2622 * @param derivationMethod 2623 * The derivation method 2624 * 2625 * @return boolean True if the ancestor type is derived from the reference type by the specifiied derivation method. 2626 */ 2627 public boolean isDOMDerivedFrom(String ancestorNS, String ancestorName, int derivationMethod) { 2628 2629 // ancestor is null, return false 2630 if (ancestorName == null) 2631 return false; 2632 2633 // ancestor is anyType, return true 2634 if (SchemaSymbols.URI_SCHEMAFORSCHEMA.equals(ancestorNS) 2635 && SchemaSymbols.ATTVAL_ANYTYPE.equals(ancestorName) 2636 && (((derivationMethod & DERIVATION_RESTRICTION) != 0) 2637 || (derivationMethod == DERIVATION_ANY))) { 2638 return true; 2639 } 2640 2641 // restriction 2642 if ((derivationMethod & DERIVATION_RESTRICTION) != 0) { 2643 if (isDerivedByRestriction(ancestorNS, ancestorName, this)) { 2644 return true; 2645 } 2646 } 2647 2648 // list 2649 if ((derivationMethod & DERIVATION_LIST) != 0) { 2650 if (isDerivedByList(ancestorNS, ancestorName, this)) { 2651 return true; 2652 } 2653 } 2654 2655 // union 2656 if ((derivationMethod & DERIVATION_UNION) != 0) { 2657 if (isDerivedByUnion(ancestorNS, ancestorName, this)) { 2658 return true; 2659 } 2660 } 2661 2662 // extension 2663 if (((derivationMethod & DERIVATION_EXTENSION) != 0) 2664 && (((derivationMethod & DERIVATION_RESTRICTION) == 0) 2665 && ((derivationMethod & DERIVATION_LIST) == 0) 2666 && ((derivationMethod & DERIVATION_UNION) == 0))) { 2667 return false; 2668 } 2669 2670 // If the value of the parameter is 0 i.e. no bit (corresponding to 2671 // restriction, list, extension or union) is set to 1 for the 2672 // derivationMethod parameter. 2673 if (((derivationMethod & DERIVATION_EXTENSION) == 0) 2674 && (((derivationMethod & DERIVATION_RESTRICTION) == 0) 2675 && ((derivationMethod & DERIVATION_LIST) == 0) 2676 && ((derivationMethod & DERIVATION_UNION) == 0))) { 2677 return isDerivedByAny(ancestorNS, ancestorName, this); 2678 } 2679 2680 return false; 2681 } 2682 2683 2684 /** 2685 * Checks if a type is derived from another by any combination of restriction, list ir union. See: 2686 * http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core.html#TypeInfo-isDerivedFrom 2687 * 2688 * @param ancestorNS 2689 * The namspace of the ancestor type declaration 2690 * @param ancestorName 2691 * The name of the ancestor type declaration 2692 * @param type 2693 * The reference type definition 2694 * 2695 * @return boolean True if the type is derived by restriciton for the reference type 2696 */ 2697 private boolean isDerivedByAny(String ancestorNS, String ancestorName, 2698 XSTypeDefinition type) { 2699 2700 boolean derivedFrom = false; 2701 XSTypeDefinition oldType = null; 2702 // for each base, item or member type 2703 while (type != null && type != oldType) { 2704 2705 // If the ancestor type is reached or is the same as this type. 2706 if ((ancestorName.equals(type.getName())) 2707 && ((ancestorNS == null && type.getNamespace() == null) 2708 || (ancestorNS != null && ancestorNS.equals(type.getNamespace())))) { 2709 derivedFrom = true; 2710 break; 2711 } 2712 2713 // check if derived by restriction or list or union 2714 if (isDerivedByRestriction(ancestorNS, ancestorName, type)) { 2715 return true; 2716 } else if (isDerivedByList(ancestorNS, ancestorName, type)) { 2717 return true; 2718 } else if (isDerivedByUnion(ancestorNS, ancestorName, type)) { 2719 return true; 2720 } 2721 oldType = type; 2722 // get the base, item or member type depending on the variety 2723 if (((XSSimpleTypeDecl) type).getVariety() == VARIETY_ABSENT 2724 || ((XSSimpleTypeDecl) type).getVariety() == VARIETY_ATOMIC) { 2725 type = type.getBaseType(); 2726 } else if (((XSSimpleTypeDecl) type).getVariety() == VARIETY_UNION) { 2727 for (int i = 0; i < ((XSSimpleTypeDecl) type).getMemberTypes().getLength(); i++) { 2728 return isDerivedByAny(ancestorNS, ancestorName, 2729 (XSTypeDefinition) ((XSSimpleTypeDecl) type) 2730 .getMemberTypes().item(i)); 2731 } 2732 } else if (((XSSimpleTypeDecl) type).getVariety() == VARIETY_LIST) { 2733 type = ((XSSimpleTypeDecl) type).getItemType(); 2734 } 2735 } 2736 2737 return derivedFrom; 2738 } 2739 2740 /** 2741 * DOM Level 3 2742 * Checks if a type is derived from another by restriction. See: 2743 * http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core.html#TypeInfo-isDerivedFrom 2744 * 2745 * @param ancestorNS 2746 * The namspace of the ancestor type declaration 2747 * @param ancestorName 2748 * The name of the ancestor type declaration 2749 * @param type 2750 * The reference type definition 2751 * 2752 * @return boolean True if the type is derived by restriciton for the 2753 * reference type 2754 */ 2755 private boolean isDerivedByRestriction (String ancestorNS, String ancestorName, XSTypeDefinition type) { 2756 XSTypeDefinition oldType = null; 2757 while (type != null && type != oldType) { 2758 if ((ancestorName.equals(type.getName())) 2759 && ((ancestorNS != null && ancestorNS.equals(type.getNamespace())) 2760 || (type.getNamespace() == null && ancestorNS == null))) { 2761 2762 return true; 2763 } 2764 oldType = type; 2765 type = type.getBaseType(); 2766 } 2767 2768 return false; 2769 } 2770 2771 /** 2772 * Checks if a type is derived from another by list. See: 2773 * http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core.html#TypeInfo-isDerivedFrom 2774 * 2775 * @param ancestorNS 2776 * The namspace of the ancestor type declaration 2777 * @param ancestorName 2778 * The name of the ancestor type declaration 2779 * @param type 2780 * The reference type definition 2781 * 2782 * @return boolean True if the type is derived by list for the reference type 2783 */ 2784 private boolean isDerivedByList (String ancestorNS, String ancestorName, XSTypeDefinition type) { 2785 // If the variety is union 2786 if (type !=null && ((XSSimpleTypeDefinition)type).getVariety() == VARIETY_LIST) { 2787 2788 // get the {item type} 2789 XSTypeDefinition itemType = ((XSSimpleTypeDefinition)type).getItemType(); 2790 2791 // T2 is the {item type definition} 2792 if (itemType != null) { 2793 2794 // T2 is derived from the other type definition by DERIVATION_RESTRICTION 2795 if (isDerivedByRestriction(ancestorNS, ancestorName, itemType)) { 2796 return true; 2797 } 2798 } 2799 } 2800 return false; 2801 } 2802 2803 /** 2804 * Checks if a type is derived from another by union. See: 2805 * http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core.html#TypeInfo-isDerivedFrom 2806 * 2807 * @param ancestorNS 2808 * The namspace of the ancestor type declaration 2809 * @param ancestorName 2810 * The name of the ancestor type declaration 2811 * @param type 2812 * The reference type definition 2813 * 2814 * @return boolean True if the type is derived by union for the reference type 2815 */ 2816 private boolean isDerivedByUnion (String ancestorNS, String ancestorName, XSTypeDefinition type) { 2817 2818 // If the variety is union 2819 if (type !=null && ((XSSimpleTypeDefinition)type).getVariety() == VARIETY_UNION) { 2820 2821 // get member types 2822 XSObjectList memberTypes = ((XSSimpleTypeDefinition)type).getMemberTypes(); 2823 2824 for (int i = 0; i < memberTypes.getLength(); i++) { 2825 // One of the {member type definitions} is T2. 2826 if (memberTypes.item(i) != null) { 2827 // T2 is derived from the other type definition by DERIVATION_RESTRICTION 2828 if (isDerivedByRestriction(ancestorNS, ancestorName,(XSSimpleTypeDefinition)memberTypes.item(i))) { 2829 return true; 2830 } 2831 } 2832 } 2833 } 2834 return false; 2835 } 2836 2837 2838 static final XSSimpleTypeDecl fAnySimpleType = new XSSimpleTypeDecl(null, "anySimpleType", DV_ANYSIMPLETYPE, ORDERED_FALSE, false, true, false, true, XSConstants.ANYSIMPLETYPE_DT); 2839 2840 static final XSSimpleTypeDecl fAnyAtomicType = new XSSimpleTypeDecl(fAnySimpleType, "anyAtomicType", DV_ANYATOMICTYPE, ORDERED_FALSE, false, true, false, true, XSSimpleTypeDecl.ANYATOMICTYPE_DT); 2841 2842 /** 2843 * Validation context used to validate facet values. 2844 */ 2845 static final ValidationContext fDummyContext = new ValidationContext() { 2846 public boolean needFacetChecking() { 2847 return true; 2848 } 2849 2850 public boolean needExtraChecking() { 2851 return false; 2852 } 2853 public boolean needToNormalize() { 2854 return false; 2855 } 2856 public boolean useNamespaces() { 2857 return true; 2858 } 2859 2860 public boolean isEntityDeclared(String name) { 2861 return false; 2862 } 2863 2864 public boolean isEntityUnparsed(String name) { 2865 return false; 2866 } 2867 2868 public boolean isIdDeclared(String name) { 2869 return false; 2870 } 2871 2872 public void addId(String name) { 2873 } 2874 2875 public void addIdRef(String name) { 2876 } 2877 2878 public String getSymbol (String symbol) { 2879 return symbol.intern(); 2880 } 2881 2882 public String getURI(String prefix) { 2883 return null; 2884 } 2885 2886 public Locale getLocale() { 2887 return Locale.getDefault(); 2888 } 2889 }; 2890 2891 private boolean fAnonymous = false; 2892 2893 /** 2894 * A wrapper of ValidationContext, to provide a way of switching to a 2895 * different Namespace declaration context. 2896 */ 2897 static final class ValidationContextImpl implements ValidationContext { 2898 2899 final ValidationContext fExternal; 2900 2901 ValidationContextImpl(ValidationContext external) { 2902 fExternal = external; 2903 } 2904 2905 NamespaceContext fNSContext; 2906 void setNSContext(NamespaceContext nsContext) { 2907 fNSContext = nsContext; 2908 } 2909 2910 public boolean needFacetChecking() { 2911 return fExternal.needFacetChecking(); 2912 } 2913 2914 public boolean needExtraChecking() { 2915 return fExternal.needExtraChecking(); 2916 } 2917 public boolean needToNormalize() { 2918 return fExternal.needToNormalize(); 2919 } 2920 // schema validation is predicated upon namespaces 2921 public boolean useNamespaces() { 2922 return true; 2923 } 2924 2925 public boolean isEntityDeclared (String name) { 2926 return fExternal.isEntityDeclared(name); 2927 } 2928 2929 public boolean isEntityUnparsed (String name) { 2930 return fExternal.isEntityUnparsed(name); 2931 } 2932 2933 public boolean isIdDeclared (String name) { 2934 return fExternal.isIdDeclared(name); 2935 } 2936 2937 public void addId(String name) { 2938 fExternal.addId(name); 2939 } 2940 2941 public void addIdRef(String name) { 2942 fExternal.addIdRef(name); 2943 } 2944 2945 public String getSymbol (String symbol) { 2946 return fExternal.getSymbol(symbol); 2947 } 2948 2949 public String getURI(String prefix) { 2950 if (fNSContext == null) { 2951 return fExternal.getURI(prefix); 2952 } 2953 else { 2954 return fNSContext.getURI(prefix); 2955 } 2956 } 2957 2958 public Locale getLocale() { 2959 return fExternal.getLocale(); 2960 } 2961 } 2962 2963 public void reset(){ 2964 2965 // if it's immutable, can't be reset: 2966 if (fIsImmutable) return; 2967 fItemType = null; 2968 fMemberTypes = null; 2969 2970 fTypeName = null; 2971 fTargetNamespace = null; 2972 fFinalSet = 0; 2973 fBase = null; 2974 fVariety = -1; 2975 fValidationDV = -1; 2976 2977 fFacetsDefined = 0; 2978 fFixedFacet = 0; 2979 2980 //for constraining facets 2981 fWhiteSpace = 0; 2982 fLength = -1; 2983 fMinLength = -1; 2984 fMaxLength = -1; 2985 fTotalDigits = -1; 2986 fFractionDigits = -1; 2987 fPattern = null; 2988 fPatternStr = null; 2989 fEnumeration = null; 2990 fLexicalPattern = null; 2991 fLexicalEnumeration = null; 2992 fActualEnumeration = null; 2993 fEnumerationTypeList = null; 2994 fEnumerationItemTypeList = null; 2995 fMaxInclusive = null; 2996 fMaxExclusive = null; 2997 fMinExclusive = null; 2998 fMinInclusive = null; 2999 lengthAnnotation = null; 3000 minLengthAnnotation = null; 3001 maxLengthAnnotation = null; 3002 whiteSpaceAnnotation = null; 3003 totalDigitsAnnotation = null; 3004 fractionDigitsAnnotation = null; 3005 patternAnnotations = null; 3006 enumerationAnnotations = null; 3007 maxInclusiveAnnotation = null; 3008 maxExclusiveAnnotation = null; 3009 minInclusiveAnnotation = null; 3010 minExclusiveAnnotation = null; 3011 3012 fPatternType = SPECIAL_PATTERN_NONE; 3013 fAnnotations = null; 3014 fFacets = null; 3015 3016 // REVISIT: reset for fundamental facets 3017 } 3018 3019 /** 3020 * @see com.sun.org.apache.xerces.internal.xs.XSObject#getNamespaceItem() 3021 */ 3022 public XSNamespaceItem getNamespaceItem() { 3023 return fNamespaceItem; 3024 } 3025 3026 public void setNamespaceItem(XSNamespaceItem namespaceItem) { 3027 fNamespaceItem = namespaceItem; 3028 } 3029 3030 /** 3031 * @see java.lang.Object#toString() 3032 */ 3033 public String toString() { 3034 return this.fTargetNamespace+"," +this.fTypeName; 3035 } 3036 3037 /** 3038 * A list of constraining facets if it exists, otherwise an empty 3039 * <code>XSObjectList</code>. Note: This method must not be used to 3040 * retrieve values for <code>enumeration</code> and <code>pattern</code> 3041 * facets. 3042 */ 3043 public XSObjectList getFacets() { 3044 if (fFacets == null && 3045 (fFacetsDefined != 0 || fValidationDV == DV_INTEGER)) { 3046 3047 XSFacetImpl[] facets = new XSFacetImpl[10]; 3048 int count = 0; 3049 if ((fFacetsDefined & FACET_WHITESPACE) != 0 && 3050 fValidationDV != DV_ANYSIMPLETYPE && 3051 fValidationDV != DV_ANYATOMICTYPE) { 3052 facets[count] = 3053 new XSFacetImpl( 3054 FACET_WHITESPACE, 3055 WS_FACET_STRING[fWhiteSpace], 3056 0, 3057 null, 3058 (fFixedFacet & FACET_WHITESPACE) != 0, 3059 whiteSpaceAnnotation); 3060 count++; 3061 } 3062 if (fLength != -1) { 3063 facets[count] = 3064 new XSFacetImpl( 3065 FACET_LENGTH, 3066 Integer.toString(fLength), 3067 fLength, 3068 null, 3069 (fFixedFacet & FACET_LENGTH) != 0, 3070 lengthAnnotation); 3071 count++; 3072 } 3073 if (fMinLength != -1) { 3074 facets[count] = 3075 new XSFacetImpl( 3076 FACET_MINLENGTH, 3077 Integer.toString(fMinLength), 3078 fMinLength, 3079 null, 3080 (fFixedFacet & FACET_MINLENGTH) != 0, 3081 minLengthAnnotation); 3082 count++; 3083 } 3084 if (fMaxLength != -1) { 3085 facets[count] = 3086 new XSFacetImpl( 3087 FACET_MAXLENGTH, 3088 Integer.toString(fMaxLength), 3089 fMaxLength, 3090 null, 3091 (fFixedFacet & FACET_MAXLENGTH) != 0, 3092 maxLengthAnnotation); 3093 count++; 3094 } 3095 if (fTotalDigits != -1) { 3096 facets[count] = 3097 new XSFacetImpl( 3098 FACET_TOTALDIGITS, 3099 Integer.toString(fTotalDigits), 3100 fTotalDigits, 3101 null, 3102 (fFixedFacet & FACET_TOTALDIGITS) != 0, 3103 totalDigitsAnnotation); 3104 count++; 3105 } 3106 if (fValidationDV == DV_INTEGER) { 3107 facets[count] = 3108 new XSFacetImpl( 3109 FACET_FRACTIONDIGITS, 3110 "0", 3111 0, 3112 null, 3113 true, 3114 fractionDigitsAnnotation); 3115 count++; 3116 } 3117 else if (fFractionDigits != -1) { 3118 facets[count] = 3119 new XSFacetImpl( 3120 FACET_FRACTIONDIGITS, 3121 Integer.toString(fFractionDigits), 3122 fFractionDigits, 3123 null, 3124 (fFixedFacet & FACET_FRACTIONDIGITS) != 0, 3125 fractionDigitsAnnotation); 3126 count++; 3127 } 3128 if (fMaxInclusive != null) { 3129 facets[count] = 3130 new XSFacetImpl( 3131 FACET_MAXINCLUSIVE, 3132 fMaxInclusive.toString(), 3133 0, 3134 fMaxInclusive, 3135 (fFixedFacet & FACET_MAXINCLUSIVE) != 0, 3136 maxInclusiveAnnotation); 3137 count++; 3138 } 3139 if (fMaxExclusive != null) { 3140 facets[count] = 3141 new XSFacetImpl( 3142 FACET_MAXEXCLUSIVE, 3143 fMaxExclusive.toString(), 3144 0, 3145 fMaxExclusive, 3146 (fFixedFacet & FACET_MAXEXCLUSIVE) != 0, 3147 maxExclusiveAnnotation); 3148 count++; 3149 } 3150 if (fMinExclusive != null) { 3151 facets[count] = 3152 new XSFacetImpl( 3153 FACET_MINEXCLUSIVE, 3154 fMinExclusive.toString(), 3155 0, 3156 fMinExclusive, 3157 (fFixedFacet & FACET_MINEXCLUSIVE) != 0, 3158 minExclusiveAnnotation); 3159 count++; 3160 } 3161 if (fMinInclusive != null) { 3162 facets[count] = 3163 new XSFacetImpl( 3164 FACET_MININCLUSIVE, 3165 fMinInclusive.toString(), 3166 0, 3167 fMinInclusive, 3168 (fFixedFacet & FACET_MININCLUSIVE) != 0, 3169 minInclusiveAnnotation); 3170 count++; 3171 } 3172 fFacets = (count > 0) ? new XSObjectListImpl(facets, count) : XSObjectListImpl.EMPTY_LIST; 3173 } 3174 return (fFacets != null) ? fFacets : XSObjectListImpl.EMPTY_LIST; 3175 } 3176 3177 public XSObject getFacet(int facetType) { 3178 if (facetType == FACET_ENUMERATION || facetType == FACET_PATTERN) { 3179 XSObjectList list = getMultiValueFacets(); 3180 for (int i = 0; i < list.getLength(); i++) { 3181 XSMultiValueFacet f = (XSMultiValueFacet)list.item(i); 3182 if (f.getFacetKind() == facetType) { 3183 return f; 3184 } 3185 } 3186 } 3187 else { 3188 XSObjectList list = getFacets(); 3189 for (int i = 0; i < list.getLength(); i++) { 3190 XSFacet f = (XSFacet)list.item(i); 3191 if (f.getFacetKind() == facetType) { 3192 return f; 3193 } 3194 } 3195 } 3196 return null; 3197 } 3198 3199 /** 3200 * A list of enumeration and pattern constraining facets if it exists, 3201 * otherwise an empty <code>XSObjectList</code>. 3202 */ 3203 public XSObjectList getMultiValueFacets() { 3204 if (fMultiValueFacets == null && 3205 ((fFacetsDefined & FACET_ENUMERATION) != 0 || 3206 (fFacetsDefined & FACET_PATTERN) != 0 || 3207 fPatternType != SPECIAL_PATTERN_NONE || 3208 fValidationDV == DV_INTEGER)) { 3209 3210 XSMVFacetImpl[] facets = new XSMVFacetImpl[2]; 3211 int count = 0; 3212 if ((fFacetsDefined & FACET_PATTERN) != 0 || 3213 fPatternType != SPECIAL_PATTERN_NONE || 3214 fValidationDV == DV_INTEGER) { 3215 facets[count] = 3216 new XSMVFacetImpl( 3217 FACET_PATTERN, 3218 this.getLexicalPattern(), 3219 null, 3220 patternAnnotations); 3221 count++; 3222 } 3223 if (fEnumeration != null) { 3224 facets[count] = 3225 new XSMVFacetImpl( 3226 FACET_ENUMERATION, 3227 this.getLexicalEnumeration(), 3228 new ObjectListImpl(fEnumeration, fEnumerationSize), 3229 enumerationAnnotations); 3230 count++; 3231 } 3232 fMultiValueFacets = new XSObjectListImpl(facets, count); 3233 } 3234 return (fMultiValueFacets != null) ? 3235 fMultiValueFacets : XSObjectListImpl.EMPTY_LIST; 3236 } 3237 3238 public Object getMinInclusiveValue() { 3239 return fMinInclusive; 3240 } 3241 3242 public Object getMinExclusiveValue() { 3243 return fMinExclusive; 3244 } 3245 3246 public Object getMaxInclusiveValue() { 3247 return fMaxInclusive; 3248 } 3249 3250 public Object getMaxExclusiveValue() { 3251 return fMaxExclusive; 3252 } 3253 3254 public void setAnonymous(boolean anon) { 3255 fAnonymous = anon; 3256 } 3257 3258 private static final class XSFacetImpl implements XSFacet { 3259 final short kind; 3260 final String svalue; 3261 final int ivalue; 3262 Object avalue; 3263 final boolean fixed; 3264 final XSObjectList annotations; 3265 3266 public XSFacetImpl(short kind, String svalue, int ivalue, Object avalue, boolean fixed, XSAnnotation annotation) { 3267 this.kind = kind; 3268 this.svalue = svalue; 3269 this.ivalue = ivalue; 3270 this.avalue = avalue; 3271 this.fixed = fixed; 3272 3273 if (annotation != null) { 3274 this.annotations = new XSObjectListImpl(); 3275 ((XSObjectListImpl)this.annotations).addXSObject(annotation); 3276 } 3277 else { 3278 this.annotations = XSObjectListImpl.EMPTY_LIST; 3279 } 3280 } 3281 3282 /* 3283 * (non-Javadoc) 3284 * 3285 * @see com.sun.org.apache.xerces.internal.xs.XSFacet#getAnnotation() 3286 */ 3287 /** 3288 * Optional. Annotation. 3289 */ 3290 public XSAnnotation getAnnotation() { 3291 return (XSAnnotation) annotations.item(0); 3292 } 3293 3294 /* 3295 * (non-Javadoc) 3296 * 3297 * @see com.sun.org.apache.xerces.internal.xs.XSFacet#getAnnotations() 3298 */ 3299 /** 3300 * Optional. Annotations. 3301 */ 3302 public XSObjectList getAnnotations() { 3303 return annotations; 3304 } 3305 3306 /* (non-Javadoc) 3307 * @see com.sun.org.apache.xerces.internal.xs.XSFacet#getFacetKind() 3308 */ 3309 public short getFacetKind() { 3310 return kind; 3311 } 3312 3313 /* (non-Javadoc) 3314 * @see com.sun.org.apache.xerces.internal.xs.XSFacet#getLexicalFacetValue() 3315 */ 3316 public String getLexicalFacetValue() { 3317 return svalue; 3318 } 3319 3320 public Object getActualFacetValue() { 3321 if (avalue == null) { 3322 if (kind == FACET_WHITESPACE) { 3323 avalue = svalue; 3324 } 3325 else { 3326 // Must a facet with an integer value. Use BigInteger. 3327 avalue = BigInteger.valueOf(ivalue); 3328 } 3329 } 3330 return avalue; 3331 } 3332 3333 public int getIntFacetValue() { 3334 return ivalue; 3335 } 3336 3337 /* (non-Javadoc) 3338 * @see com.sun.org.apache.xerces.internal.xs.XSFacet#isFixed() 3339 */ 3340 public boolean getFixed() { 3341 return fixed; 3342 } 3343 3344 /* (non-Javadoc) 3345 * @see com.sun.org.apache.xerces.internal.xs.XSObject#getName() 3346 */ 3347 public String getName() { 3348 return null; 3349 } 3350 3351 /* (non-Javadoc) 3352 * @see com.sun.org.apache.xerces.internal.xs.XSObject#getNamespace() 3353 */ 3354 public String getNamespace() { 3355 return null; 3356 } 3357 3358 /* (non-Javadoc) 3359 * @see com.sun.org.apache.xerces.internal.xs.XSObject#getNamespaceItem() 3360 */ 3361 public XSNamespaceItem getNamespaceItem() { 3362 // REVISIT: implement 3363 return null; 3364 } 3365 3366 /* (non-Javadoc) 3367 * @see com.sun.org.apache.xerces.internal.xs.XSObject#getType() 3368 */ 3369 public short getType() { 3370 return XSConstants.FACET; 3371 } 3372 3373 } 3374 3375 private static final class XSMVFacetImpl implements XSMultiValueFacet { 3376 final short kind; 3377 final XSObjectList annotations; 3378 final StringList svalues; 3379 final ObjectList avalues; 3380 3381 public XSMVFacetImpl(short kind, StringList svalues, ObjectList avalues, XSObjectList annotations) { 3382 this.kind = kind; 3383 this.svalues = svalues; 3384 this.avalues = avalues; 3385 this.annotations = (annotations != null) ? annotations : XSObjectListImpl.EMPTY_LIST; 3386 } 3387 3388 /* (non-Javadoc) 3389 * @see com.sun.org.apache.xerces.internal.xs.XSFacet#getFacetKind() 3390 */ 3391 public short getFacetKind() { 3392 return kind; 3393 } 3394 3395 /* (non-Javadoc) 3396 * @see com.sun.org.apache.xerces.internal.xs.XSMultiValueFacet#getAnnotations() 3397 */ 3398 public XSObjectList getAnnotations() { 3399 return annotations; 3400 } 3401 3402 /* (non-Javadoc) 3403 * @see com.sun.org.apache.xerces.internal.xs.XSMultiValueFacet#getLexicalFacetValues() 3404 */ 3405 public StringList getLexicalFacetValues() { 3406 return svalues; 3407 } 3408 3409 public ObjectList getEnumerationValues() { 3410 return avalues; 3411 } 3412 3413 /* (non-Javadoc) 3414 * @see com.sun.org.apache.xerces.internal.xs.XSObject#getName() 3415 */ 3416 public String getName() { 3417 return null; 3418 } 3419 3420 /* (non-Javadoc) 3421 * @see com.sun.org.apache.xerces.internal.xs.XSObject#getNamespace() 3422 */ 3423 public String getNamespace() { 3424 return null; 3425 } 3426 3427 /* (non-Javadoc) 3428 * @see com.sun.org.apache.xerces.internal.xs.XSObject#getNamespaceItem() 3429 */ 3430 public XSNamespaceItem getNamespaceItem() { 3431 // REVISIT: implement 3432 return null; 3433 } 3434 3435 /* (non-Javadoc) 3436 * @see com.sun.org.apache.xerces.internal.xs.XSObject#getType() 3437 */ 3438 public short getType() { 3439 return XSConstants.MULTIVALUE_FACET; 3440 } 3441 } 3442 3443 private static abstract class AbstractObjectList extends AbstractList<Object> implements ObjectList { 3444 public Object get(int index) { 3445 if (index >= 0 && index < getLength()) { 3446 return item(index); 3447 } 3448 throw new IndexOutOfBoundsException("Index: " + index); 3449 } 3450 public int size() { 3451 return getLength(); 3452 } 3453 } 3454 3455 public String getTypeNamespace() { 3456 return getNamespace(); 3457 } 3458 3459 public boolean isDerivedFrom(String typeNamespaceArg, String typeNameArg, int derivationMethod) { 3460 return isDOMDerivedFrom(typeNamespaceArg, typeNameArg, derivationMethod); 3461 } 3462 3463 private short convertToPrimitiveKind(short valueType) { 3464 /** Primitive datatypes. */ 3465 if (valueType <= XSConstants.NOTATION_DT) { 3466 return valueType; 3467 } 3468 /** Types derived from string. */ 3469 if (valueType <= XSConstants.ENTITY_DT) { 3470 return XSConstants.STRING_DT; 3471 } 3472 /** Types derived from decimal. */ 3473 if (valueType <= XSConstants.POSITIVEINTEGER_DT) { 3474 return XSConstants.DECIMAL_DT; 3475 } 3476 /** Other types. */ 3477 return valueType; 3478 } 3479 3480 private void appendEnumString(StringBuffer sb) { 3481 sb.append('['); 3482 for (int i = 0; i < fEnumerationSize; i++) { 3483 if (i != 0) { 3484 sb.append(", "); 3485 } 3486 sb.append(fEnumeration[i].actualValue); 3487 } 3488 sb.append(']'); 3489 } 3490 } // class XSSimpleTypeDecl