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