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.xs;
22  
23  import com.sun.org.apache.xerces.internal.impl.dv.XSSimpleType;
24  import com.sun.org.apache.xerces.internal.xs.*;
25  import com.sun.org.apache.xerces.internal.impl.xs.models.XSCMValidator;
26  import com.sun.org.apache.xerces.internal.impl.xs.models.CMBuilder;
27  import com.sun.org.apache.xerces.internal.impl.xs.util.XSObjectListImpl;
28  import com.sun.org.apache.xerces.internal.impl.dv.xs.XSSimpleTypeDecl;
29  import org.w3c.dom.TypeInfo;
30  
31  /**
32   * The XML representation for a complexType
33   * schema component is a <complexType> element information item
34   *
35   * @xerces.internal
36   *
37   * @author Elena Litani, IBM
38   * @author Sandy Gao, IBM
39   * @version $Id: XSComplexTypeDecl.java,v 1.8 2010-11-01 04:39:55 joehw Exp $
40   */
41  public class XSComplexTypeDecl implements XSComplexTypeDefinition, TypeInfo {
42  
43      // name of the complexType
44      String fName = null;
45  
46      // target namespace of the complexType
47      String fTargetNamespace = null;
48  
49      // base type of the complexType
50      XSTypeDefinition fBaseType = null;
51  
52      // derivation method of the complexType
53      short fDerivedBy = XSConstants.DERIVATION_RESTRICTION;
54  
55      // final set of the complexType
56      short fFinal = XSConstants.DERIVATION_NONE;
57  
58      // block set (prohibited substitution) of the complexType
59      short fBlock = XSConstants.DERIVATION_NONE;
60  
61      // flags: whether is abstract; whether contains ID type;
62      //        whether it's an anonymous tpye
63      short fMiscFlags = 0;
64  
65      // the attribute group that holds the attribute uses and attribute wildcard
66      XSAttributeGroupDecl fAttrGrp = null;
67  
68      // the content type of the complexType
69      short fContentType = CONTENTTYPE_EMPTY;
70  
71      // if the content type is simple, then the corresponding simpleType
72      XSSimpleType fXSSimpleType = null;
73  
74      // if the content type is element or mixed, the particle
75      XSParticleDecl fParticle = null;
76  
77      // if there is a particle, the content model corresponding to that particle
78      volatile XSCMValidator fCMValidator = null;
79  
80      // the content model that's sufficient for computing UPA
81      XSCMValidator fUPACMValidator = null;
82  
83      // list of annotations affiliated with this type
84      XSObjectListImpl fAnnotations = null;
85  
86      // The namespace schema information item corresponding to the target namespace
87      // of the complex type definition, if it is globally declared; or null otherwise.
88      private XSNamespaceItem fNamespaceItem = null;
89  
90      // DOM Level 3 TypeInfo Derivation Method constants
91      static final int DERIVATION_ANY = 0;
92      static final int DERIVATION_RESTRICTION = 1;
93      static final int DERIVATION_EXTENSION = 2;
94      static final int DERIVATION_UNION = 4;
95      static final int DERIVATION_LIST = 8;
96  
97      public XSComplexTypeDecl() {
98          // do-nothing constructor for now.
99      }
100 
101     public void setValues(String name, String targetNamespace,
102             XSTypeDefinition baseType, short derivedBy, short schemaFinal,
103             short block, short contentType,
104             boolean isAbstract, XSAttributeGroupDecl attrGrp,
105             XSSimpleType simpleType, XSParticleDecl particle,
106             XSObjectListImpl annotations) {
107         fTargetNamespace = targetNamespace;
108         fBaseType = baseType;
109         fDerivedBy = derivedBy;
110         fFinal = schemaFinal;
111         fBlock = block;
112         fContentType = contentType;
113         if(isAbstract)
114             fMiscFlags |= CT_IS_ABSTRACT;
115         fAttrGrp = attrGrp;
116         fXSSimpleType = simpleType;
117         fParticle = particle;
118         fAnnotations = annotations;
119    }
120 
121    public void setName(String name) {
122         fName = name;
123    }
124 
125     public short getTypeCategory() {
126         return COMPLEX_TYPE;
127     }
128 
129     public String getTypeName() {
130         return fName;
131     }
132 
133     public short getFinalSet(){
134         return fFinal;
135     }
136 
137     public String getTargetNamespace(){
138         return fTargetNamespace;
139     }
140 
141     // flags for the misc flag
142     private static final short CT_IS_ABSTRACT = 1;
143     private static final short CT_HAS_TYPE_ID = 2;
144     private static final short CT_IS_ANONYMOUS = 4;
145 
146     // methods to get/set misc flag
147 
148     public boolean containsTypeID () {
149         return((fMiscFlags & CT_HAS_TYPE_ID) != 0);
150     }
151 
152     public void setIsAbstractType() {
153         fMiscFlags |= CT_IS_ABSTRACT;
154     }
155     public void setContainsTypeID() {
156         fMiscFlags |= CT_HAS_TYPE_ID;
157     }
158     public void setIsAnonymous() {
159         fMiscFlags |= CT_IS_ANONYMOUS;
160     }
161 
162     public XSCMValidator getContentModel(CMBuilder cmBuilder) {
163         // for complex type with empty or simple content,
164         // there is no content model validator
165         if (fContentType == XSComplexTypeDecl.CONTENTTYPE_SIMPLE ||
166             fContentType == XSComplexTypeDecl.CONTENTTYPE_EMPTY) {
167             return null;
168         }
169         if (fCMValidator == null)
170             synchronized (this) {
171                 if (fCMValidator == null) {
172                     fCMValidator = cmBuilder.getContentModel(this);
173                 }
174             }
175         return fCMValidator;
176     }
177 
178     // some utility methods:
179 
180     // return the attribute group for this complex type
181     public XSAttributeGroupDecl getAttrGrp() {
182         return fAttrGrp;
183     }
184 
185     public String toString() {
186         StringBuilder str = new StringBuilder(192);
187         appendTypeInfo(str);
188         return str.toString();
189     }
190 
191     void appendTypeInfo(StringBuilder str) {
192         String contentType[] = {"EMPTY", "SIMPLE", "ELEMENT", "MIXED"};
193         String derivedBy[] = {"EMPTY", "EXTENSION", "RESTRICTION"};
194 
195         str.append("Complex type name='").append(fTargetNamespace).append(',').append(getTypeName()).append("', ");
196         if (fBaseType != null) {
197             str.append(" base type name='").append(fBaseType.getName()).append("', ");
198         }
199         str.append(" content type='").append(contentType[fContentType]).append("', ");
200         str.append(" isAbstract='").append(getAbstract()).append("', ");
201         str.append(" hasTypeId='").append(containsTypeID()).append("', ");
202         str.append(" final='").append(fFinal).append("', ");
203         str.append(" block='").append(fBlock).append("', ");
204         if (fParticle != null) {
205             str.append(" particle='").append(fParticle.toString()).append("', ");
206         }
207         str.append(" derivedBy='").append(derivedBy[fDerivedBy]).append("'. ");
208 
209     }
210 
211     public boolean derivedFromType(XSTypeDefinition ancestor, short derivationMethod) {
212         // ancestor is null, retur false
213         if (ancestor == null)
214             return false;
215         // ancestor is anyType, return true
216         if (ancestor == SchemaGrammar.fAnyType)
217             return true;
218         // recursively get base, and compare it with ancestor
219         XSTypeDefinition type = this;
220         while (type != ancestor &&                     // compare with ancestor
221                type != SchemaGrammar.fAnySimpleType &&  // reached anySimpleType
222                type != SchemaGrammar.fAnyType) {        // reached anyType
223             type = type.getBaseType();
224         }
225 
226         return type == ancestor;
227     }
228 
229     public boolean derivedFrom(String ancestorNS, String ancestorName, short derivationMethod) {
230         // ancestor is null, retur false
231         if (ancestorName == null)
232             return false;
233         // ancestor is anyType, return true
234         if (ancestorNS != null &&
235             ancestorNS.equals(SchemaSymbols.URI_SCHEMAFORSCHEMA) &&
236             ancestorName.equals(SchemaSymbols.ATTVAL_ANYTYPE)) {
237             return true;
238         }
239 
240         // recursively get base, and compare it with ancestor
241         XSTypeDefinition type = this;
242         while (!(ancestorName.equals(type.getName()) &&
243                  ((ancestorNS == null && type.getNamespace() == null) ||
244                   (ancestorNS != null && ancestorNS.equals(type.getNamespace())))) &&   // compare with ancestor
245                type != SchemaGrammar.fAnySimpleType &&  // reached anySimpleType
246                type != SchemaGrammar.fAnyType) {        // reached anyType
247             type = (XSTypeDefinition)type.getBaseType();
248         }
249 
250         return type != SchemaGrammar.fAnySimpleType &&
251         type != SchemaGrammar.fAnyType;
252     }
253 
254     /**
255      * Checks if a type is derived from another given the the name, namespace
256      * and derivation method. See:
257      * http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core.html#TypeInfo-isDerivedFrom
258      *
259      * @param ancestorNS
260      *            The namspace of the ancestor type declaration
261      * @param ancestorName
262      *            The name of the ancestor type declaration
263      * @param derivationMethod
264      *            The derivation method
265      *
266      * @return boolean True if the ancestor type is derived from the reference
267      *         type by the specifiied derivation method.
268      */
269     public boolean isDOMDerivedFrom(String ancestorNS, String ancestorName,
270             int derivationMethod) {
271         // ancestor is null, retur false
272         if (ancestorName == null)
273             return false;
274 
275         // ancestor is anyType, return true
276         if (ancestorNS != null
277                 && ancestorNS.equals(SchemaSymbols.URI_SCHEMAFORSCHEMA)
278                 && ancestorName.equals(SchemaSymbols.ATTVAL_ANYTYPE)
279                 && (derivationMethod == DERIVATION_RESTRICTION
280                 && derivationMethod == DERIVATION_EXTENSION)) {
281             return true;
282         }
283 
284         // restriction
285         if ((derivationMethod & DERIVATION_RESTRICTION) != 0) {
286             if (isDerivedByRestriction(ancestorNS, ancestorName,
287                     derivationMethod, this)) {
288                 return true;
289             }
290         }
291 
292         // extension
293         if ((derivationMethod & DERIVATION_EXTENSION) != 0) {
294             if (isDerivedByExtension(ancestorNS, ancestorName,
295                     derivationMethod, this)) {
296                 return true;
297             }
298         }
299 
300         // list or union
301         if ((((derivationMethod & DERIVATION_LIST) != 0) || ((derivationMethod & DERIVATION_UNION) != 0))
302                 && ((derivationMethod & DERIVATION_RESTRICTION) == 0)
303                 && ((derivationMethod & DERIVATION_EXTENSION) == 0)) {
304 
305             if (ancestorNS.equals(SchemaSymbols.URI_SCHEMAFORSCHEMA)
306                     && ancestorName.equals(SchemaSymbols.ATTVAL_ANYTYPE)) {
307                 ancestorName = SchemaSymbols.ATTVAL_ANYSIMPLETYPE;
308             }
309 
310             if(!(fName.equals(SchemaSymbols.ATTVAL_ANYTYPE)
311                             && fTargetNamespace.equals(SchemaSymbols.URI_SCHEMAFORSCHEMA))){
312                 if (fBaseType != null && fBaseType instanceof XSSimpleTypeDecl) {
313 
314                     return ((XSSimpleTypeDecl) fBaseType).isDOMDerivedFrom(ancestorNS,
315                             ancestorName, derivationMethod);
316                 } else if (fBaseType != null
317                         && fBaseType instanceof XSComplexTypeDecl) {
318                     return ((XSComplexTypeDecl) fBaseType).isDOMDerivedFrom(
319                             ancestorNS, ancestorName, derivationMethod);
320                 }
321             }
322         }
323 
324         // If the value of the parameter is 0 i.e. no bit (corresponding to
325         // restriction, list, extension or union) is set to 1 for the
326         // derivationMethod parameter.
327         if (((derivationMethod  & DERIVATION_EXTENSION) == 0)
328                 && (((derivationMethod & DERIVATION_RESTRICTION) == 0)
329                         && ((derivationMethod & DERIVATION_LIST) == 0)
330                         && ((derivationMethod & DERIVATION_UNION) == 0))) {
331             return isDerivedByAny(ancestorNS, ancestorName, derivationMethod, this);
332         }
333 
334         return false;
335     }
336 
337     /**
338      * Checks if a type is derived from another by any combination of
339      * restriction, list ir union. See:
340      * http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core.html#TypeInfo-isDerivedFrom
341      *
342      * @param ancestorNS
343      *            The namspace of the ancestor type declaration
344      * @param ancestorName
345      *            The name of the ancestor type declaration
346      * @param derivationMethod
347      *            A short indication the method of derivation
348      * @param type
349      *            The reference type definition
350      *
351      * @return boolean True if the type is derived by any method for the
352      *         reference type
353      */
354     private boolean isDerivedByAny(String ancestorNS, String ancestorName,
355             int derivationMethod, XSTypeDefinition type) {
356         XSTypeDefinition oldType = null;
357         boolean derivedFrom = false;
358         while (type != null && type != oldType) {
359 
360             // If the ancestor type is reached or is the same as this type.
361             if ((ancestorName.equals(type.getName()))
362                     && ((ancestorNS == null && type.getNamespace() == null)
363                         || (ancestorNS != null && ancestorNS.equals(type.getNamespace())))) {
364                 derivedFrom = true;
365                 break;
366             }
367 
368             // Check if this type is derived from the base by restriction or
369             // extension
370             if (isDerivedByRestriction(ancestorNS, ancestorName,
371                     derivationMethod, type)) {
372                 return true;
373             } else if (!isDerivedByExtension(ancestorNS, ancestorName,
374                     derivationMethod, type)) {
375                 return true;
376             }
377             oldType = type;
378             type = type.getBaseType();
379         }
380 
381         return derivedFrom;
382     }
383 
384     /**
385      * Checks if a type is derived from another by restriction. See:
386      * http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core.html#TypeInfo-isDerivedFrom
387      *
388      * @param ancestorNS
389      *            The namspace of the ancestor type declaration
390      * @param ancestorName
391      *            The name of the ancestor type declaration
392      * @param derivationMethod
393      *            A short indication the method of derivation *
394      * @param type
395      *            The reference type definition
396      *
397      * @return boolean True if the type is derived by restriciton for the
398      *         reference type
399      */
400     private boolean isDerivedByRestriction(String ancestorNS,
401             String ancestorName, int derivationMethod, XSTypeDefinition type) {
402 
403         XSTypeDefinition oldType = null;
404         while (type != null && type != oldType) {
405 
406             // ancestor is anySimpleType, return false
407             if (ancestorNS != null
408                     && ancestorNS.equals(SchemaSymbols.URI_SCHEMAFORSCHEMA)
409                     && ancestorName.equals(SchemaSymbols.ATTVAL_ANYSIMPLETYPE)) {
410                 return false;
411             }
412 
413             // if the name and namespace of this type is the same as the
414             // ancestor return true
415             if ((ancestorName.equals(type.getName()))
416                     && (ancestorNS != null && ancestorNS.equals(type.getNamespace()))
417                             || ((type.getNamespace() == null && ancestorNS == null))) {
418 
419                 return true;
420             }
421 
422             // If the base type is a complexType with simpleContent
423             if (type instanceof XSSimpleTypeDecl) {
424                 if (ancestorNS.equals(SchemaSymbols.URI_SCHEMAFORSCHEMA)
425                         && ancestorName.equals(SchemaSymbols.ATTVAL_ANYTYPE)) {
426                     ancestorName = SchemaSymbols.ATTVAL_ANYSIMPLETYPE;
427                 }
428                 return ((XSSimpleTypeDecl) type).isDOMDerivedFrom(ancestorNS,
429                         ancestorName, derivationMethod);
430             } else {
431                 // If the base type is a complex type
432                 // Every derivation step till the base type should be
433                 // restriction. If not return false
434                 if (((XSComplexTypeDecl) type).getDerivationMethod() != XSConstants.DERIVATION_RESTRICTION) {
435                     return false;
436                 }
437             }
438             oldType = type;
439             type = type.getBaseType();
440 
441         }
442 
443         return false;
444     }
445 
446     /**
447      * Checks if a type is derived from another by extension. See:
448      * http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core.html#TypeInfo-isDerivedFrom
449      *
450      * @param ancestorNS
451      *            The namspace of the ancestor type declaration
452      * @param ancestorName
453      *            The name of the ancestor type declaration
454      * @param derivationMethod
455      *            A short indication the method of derivation
456      * @param type
457      *            The reference type definition
458      *
459      * @return boolean True if the type is derived by extension for the
460      *         reference type
461      */
462     private boolean isDerivedByExtension(String ancestorNS,
463             String ancestorName, int derivationMethod, XSTypeDefinition type) {
464 
465         boolean extension = false;
466         XSTypeDefinition oldType = null;
467         while (type != null && type != oldType) {
468             // If ancestor is anySimpleType return false.
469             if (ancestorNS != null
470                     && ancestorNS.equals(SchemaSymbols.URI_SCHEMAFORSCHEMA)
471                     && ancestorName.equals(SchemaSymbols.ATTVAL_ANYSIMPLETYPE)
472                     && SchemaSymbols.URI_SCHEMAFORSCHEMA.equals(type.getNamespace())
473                             && SchemaSymbols.ATTVAL_ANYTYPE.equals(type.getName())) {
474                 break;
475             }
476 
477             if ((ancestorName.equals(type.getName()))
478                     && ((ancestorNS == null && type.getNamespace() == null)
479                         || (ancestorNS != null && ancestorNS.equals(type.getNamespace())))) {
480                 // returns true if atleast one derivation step was extension
481                 return extension;
482             }
483 
484             // If the base type is a complexType with simpleContent
485             if (type instanceof XSSimpleTypeDecl) {
486                 if (ancestorNS.equals(SchemaSymbols.URI_SCHEMAFORSCHEMA)
487                         && ancestorName.equals(SchemaSymbols.ATTVAL_ANYTYPE)) {
488                     ancestorName = SchemaSymbols.ATTVAL_ANYSIMPLETYPE;
489                 }
490 
491                 // derivationMethod extension will always return false for a
492                 // simpleType,
493                 // we treat it like a restriction
494                 if ((derivationMethod & DERIVATION_EXTENSION) != 0) {
495                     return extension
496                     & ((XSSimpleTypeDecl) type).isDOMDerivedFrom(
497                             ancestorNS, ancestorName,
498                             (derivationMethod & DERIVATION_RESTRICTION));
499                 } else {
500                     return extension
501                     & ((XSSimpleTypeDecl) type).isDOMDerivedFrom(
502                             ancestorNS, ancestorName, derivationMethod);
503                 }
504 
505             } else {
506                 // If the base type is a complex type
507                 // At least one derivation step upto the ancestor type should be
508                 // extension.
509                 if (((XSComplexTypeDecl) type).getDerivationMethod() == XSConstants.DERIVATION_EXTENSION) {
510                     extension = extension | true;
511                 }
512             }
513             oldType = type;
514             type = type.getBaseType();
515         }
516 
517         return false;
518     }
519 
520 
521 
522     public void reset(){
523         fName = null;
524         fTargetNamespace = null;
525         fBaseType = null;
526         fDerivedBy = XSConstants.DERIVATION_RESTRICTION;
527         fFinal = XSConstants.DERIVATION_NONE;
528         fBlock = XSConstants.DERIVATION_NONE;
529 
530         fMiscFlags = 0;
531 
532         // reset attribute group
533         fAttrGrp.reset();
534         fContentType = CONTENTTYPE_EMPTY;
535         fXSSimpleType = null;
536         fParticle = null;
537         fCMValidator = null;
538         fUPACMValidator = null;
539         if(fAnnotations != null) {
540             // help out the garbage collector
541             fAnnotations.clearXSObjectList();
542         }
543         fAnnotations = null;
544     }
545 
546     /**
547      * Get the type of the object, i.e ELEMENT_DECLARATION.
548      */
549     public short getType() {
550         return XSConstants.TYPE_DEFINITION;
551     }
552 
553     /**
554      * The <code>name</code> of this <code>XSObject</code> depending on the
555      * <code>XSObject</code> type.
556      */
557     public String getName() {
558         return getAnonymous() ? null : fName;
559     }
560 
561     /**
562      * A boolean that specifies if the type definition is anonymous.
563      * Convenience attribute. This is a field is not part of
564      * XML Schema component model.
565      */
566     public boolean getAnonymous() {
567         return((fMiscFlags & CT_IS_ANONYMOUS) != 0);
568     }
569 
570     /**
571      * The namespace URI of this node, or <code>null</code> if it is
572      * unspecified.  defines how a namespace URI is attached to schema
573      * components.
574      */
575     public String getNamespace() {
576         return fTargetNamespace;
577     }
578 
579     /**
580      * {base type definition} Either a simple type definition or a complex
581      * type definition.
582      */
583     public XSTypeDefinition getBaseType() {
584         return fBaseType;
585     }
586 
587     /**
588      * {derivation method} Either extension or restriction. The valid constant
589      * value for this <code>XSConstants</code> EXTENTION, RESTRICTION.
590      */
591     public short getDerivationMethod() {
592         return fDerivedBy;
593     }
594 
595     /**
596      * {final} For complex type definition it is a subset of {extension,
597      * restriction}. For simple type definition it is a subset of
598      * {extension, list, restriction, union}.
599      * @param derivation  Extension, restriction, list, union constants
600      *   (defined in <code>XSConstants</code>).
601      * @return True if derivation is in the final set, otherwise false.
602      */
603     public boolean isFinal(short derivation) {
604         return (fFinal & derivation) != 0;
605     }
606 
607     /**
608      * {final} For complex type definition it is a subset of {extension, restriction}.
609      *
610      * @return A bit flag that represents:
611      *         {extension, restriction) or none for complexTypes;
612      *         {extension, list, restriction, union} or none for simpleTypes;
613      */
614     public short getFinal() {
615         return fFinal;
616     }
617 
618     /**
619      * {abstract} A boolean. Complex types for which {abstract} is true must
620      * not be used as the {type definition} for the validation of element
621      * information items.
622      */
623     public boolean getAbstract() {
624         return((fMiscFlags & CT_IS_ABSTRACT) != 0);
625     }
626 
627     /**
628      *  {attribute uses} A set of attribute uses.
629      */
630     public XSObjectList getAttributeUses() {
631         return fAttrGrp.getAttributeUses();
632     }
633 
634     /**
635      * {attribute wildcard} Optional. A wildcard.
636      */
637     public XSWildcard getAttributeWildcard() {
638         return fAttrGrp.getAttributeWildcard();
639     }
640 
641     /**
642      * {content type} One of empty, a simple type definition (see
643      * <code>simpleType</code>, or mixed, element-only (see
644      * <code>cmParticle</code>).
645      */
646     public short getContentType() {
647         return fContentType;
648     }
649 
650     /**
651      * A simple type definition corresponding to simple content model,
652      * otherwise <code>null</code>
653      */
654     public XSSimpleTypeDefinition getSimpleType() {
655         return fXSSimpleType;
656     }
657 
658     /**
659      * A particle for mixed or element-only content model, otherwise
660      * <code>null</code>
661      */
662     public XSParticle getParticle() {
663         return fParticle;
664     }
665 
666     /**
667      * {prohibited substitutions} A subset of {extension, restriction}.
668      * @param prohibited  extention or restriction constants (defined in
669      *   <code>XSConstants</code>).
670      * @return True if prohibited is a prohibited substitution, otherwise
671      *   false.
672      */
673     public boolean isProhibitedSubstitution(short prohibited) {
674         return (fBlock & prohibited) != 0;
675     }
676 
677     /**
678      * {prohibited substitutions}
679      *
680      * @return A bit flag corresponding to prohibited substitutions
681      */
682     public short getProhibitedSubstitutions() {
683         return fBlock;
684     }
685 
686     /**
687      * Optional. Annotation.
688      */
689     public XSObjectList getAnnotations() {
690         return (fAnnotations != null) ? fAnnotations : XSObjectListImpl.EMPTY_LIST;
691     }
692 
693     /**
694      * @see org.apache.xerces.xs.XSObject#getNamespaceItem()
695      */
696     public XSNamespaceItem getNamespaceItem() {
697         return fNamespaceItem;
698     }
699 
700     void setNamespaceItem(XSNamespaceItem namespaceItem) {
701         fNamespaceItem = namespaceItem;
702     }
703 
704     /* (non-Javadoc)
705      * @see org.apache.xerces.xs.XSComplexTypeDefinition#getAttributeUse(java.lang.String, java.lang.String)
706      */
707     public XSAttributeUse getAttributeUse(String namespace, String name) {
708          return fAttrGrp.getAttributeUse(namespace, name);
709     }
710 
711     public String getTypeNamespace() {
712         return getNamespace();
713     }
714 
715     public boolean isDerivedFrom(String typeNamespaceArg, String typeNameArg, int derivationMethod) {
716         return isDOMDerivedFrom(typeNamespaceArg, typeNameArg, derivationMethod);
717     }
718 
719 } // class XSComplexTypeDecl