Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.xerces.impl.xs.traversers;
import java.util.Locale;
import java.util.Vector;
import org.apache.xerces.impl.Constants;
import org.apache.xerces.impl.dv.ValidatedInfo;
import org.apache.xerces.impl.dv.XSSimpleType;
import org.apache.xerces.impl.xs.SchemaGrammar;
import org.apache.xerces.impl.xs.SchemaSymbols;
import org.apache.xerces.impl.xs.XSAnnotationImpl;
import org.apache.xerces.impl.xs.XSComplexTypeDecl;
import org.apache.xerces.impl.xs.XSElementDecl;
import org.apache.xerces.impl.xs.XSParticleDecl;
import org.apache.xerces.impl.xs.util.XInt;
import org.apache.xerces.impl.xs.util.XSObjectListImpl;
import org.apache.xerces.util.DOMUtil;
import org.apache.xerces.util.NamespaceSupport;
import org.apache.xerces.util.SymbolTable;
import org.apache.xerces.util.XMLChar;
import org.apache.xerces.xni.QName;
import org.apache.xerces.xs.XSConstants;
import org.apache.xerces.xs.XSObject;
import org.apache.xerces.xs.XSObjectList;
import org.apache.xerces.xs.XSTypeDefinition;
import org.w3c.dom.Attr;
import org.w3c.dom.Element;
/**
* The element declaration schema component traverser.
*
* Content: (annotation?, ((simpleType | complexType)?, alternative*, (unique | key | keyref)*))
*
*
* @xerces.internal
*
* @author Sandy Gao, IBM
*
* @version $Id: XSDElementTraverser.java 1172656 2011-09-19 15:12:32Z knoaman $
*/
class XSDElementTraverser extends XSDAbstractTraverser {
protected final XSElementDecl fTempElementDecl = new XSElementDecl();
// this controls what happens when a local element is encountered.
// We may not encounter all local elements when first parsing.
boolean fDeferTraversingLocalElements;
XSDElementTraverser (XSDHandler handler,
XSAttributeChecker gAttrCheck) {
super(handler, gAttrCheck);
}
/**
* Traverse a locally declared element (or an element reference).
*
* To handle the recursive cases efficiently, we delay the traversal
* and return an empty particle node. We'll fill in this particle node
* later after we've done with all the global declarations.
* This method causes a number of data structures in the schema handler to be filled in.
*
* @param elmDecl
* @param schemaDoc
* @param grammar
* @return the particle
*/
XSParticleDecl traverseLocal(Element elmDecl,
XSDocumentInfo schemaDoc,
SchemaGrammar grammar,
int allContextFlags,
XSObject parent) {
XSParticleDecl particle = null;
if (fSchemaHandler.fDeclPool !=null) {
particle = fSchemaHandler.fDeclPool.getParticleDecl();
} else {
particle = new XSParticleDecl();
}
if (fDeferTraversingLocalElements) {
// The only thing we care about now is whether this element has
// minOccurs=0. This affects (if the element appears in a complex
// type) whether a type has emptiable content.
particle.fType = XSParticleDecl.PARTICLE_ELEMENT;
Attr attr = elmDecl.getAttributeNode(SchemaSymbols.ATT_MINOCCURS);
if (attr != null) {
String min = attr.getValue();
try {
int m = Integer.parseInt(XMLChar.trim(min));
if (m >= 0)
particle.fMinOccurs = m;
}
catch (NumberFormatException ex) {
}
}
fSchemaHandler.fillInLocalElemInfo(elmDecl, schemaDoc, allContextFlags, parent, particle);
} else {
traverseLocal(particle, elmDecl, schemaDoc, grammar, allContextFlags, parent, null);
// If it's an empty particle, return null.
if (particle.fType == XSParticleDecl.PARTICLE_EMPTY)
particle = null;
}
return particle;
}
/**
* Traverse a locally declared element (or an element reference).
*
* This is the real traversal method. It's called after we've done with
* all the global declarations.
*
* @param index
*/
protected void traverseLocal(XSParticleDecl particle,
Element elmDecl,
XSDocumentInfo schemaDoc,
SchemaGrammar grammar,
int allContextFlags,
XSObject parent,
String[] localNSDecls) {
if (localNSDecls != null) {
schemaDoc.fNamespaceSupport.setEffectiveContext(localNSDecls);
}
// General Attribute Checking
Object[] attrValues = fAttrChecker.checkAttributes(elmDecl, false, schemaDoc);
QName refAtt = (QName) attrValues[XSAttributeChecker.ATTIDX_REF];
XInt minAtt = (XInt) attrValues[XSAttributeChecker.ATTIDX_MINOCCURS];
XInt maxAtt = (XInt) attrValues[XSAttributeChecker.ATTIDX_MAXOCCURS];
XSElementDecl element = null;
XSAnnotationImpl annotation = null;
if (elmDecl.getAttributeNode(SchemaSymbols.ATT_REF) != null) {
if (refAtt != null) {
element = (XSElementDecl)fSchemaHandler.getGlobalDecl(schemaDoc, XSDHandler.ELEMENT_TYPE, refAtt, elmDecl);
Element child = DOMUtil.getFirstChildElement(elmDecl);
if (child != null && DOMUtil.getLocalName(child).equals(SchemaSymbols.ELT_ANNOTATION)) {
annotation = traverseAnnotationDecl(child, attrValues, false, schemaDoc);
child = DOMUtil.getNextSiblingElement(child);
}
else {
String text = DOMUtil.getSyntheticAnnotation(elmDecl);
if (text != null) {
annotation = traverseSyntheticAnnotation(elmDecl, text, attrValues, false, schemaDoc);
}
}
// Element Declaration Representation OK
// 2 If the item's parent is not , then all of the following must be true:
// 2.1 One of ref or name must be present, but not both.
// 2.2 If ref is present, then all of , , , , , nillable, default, fixed, form, block and type must be absent, i.e. only minOccurs, maxOccurs, id are allowed in addition to ref, along with .
if (child != null) {
reportSchemaError("src-element.2.2", new Object[]{refAtt.rawname, DOMUtil.getLocalName(child)}, child);
}
} else {
element = null;
}
} else {
element = traverseNamedElement(elmDecl, attrValues, schemaDoc, grammar, false, parent);
}
particle.fMinOccurs = minAtt.intValue();
particle.fMaxOccurs = maxAtt.intValue();
if (element != null) {
particle.fType = XSParticleDecl.PARTICLE_ELEMENT;
particle.fValue = element;
}
else {
particle.fType = XSParticleDecl.PARTICLE_EMPTY;
}
if (refAtt != null) {
XSObjectList annotations;
if (annotation != null) {
annotations = new XSObjectListImpl();
((XSObjectListImpl) annotations).addXSObject(annotation);
} else {
annotations = XSObjectListImpl.EMPTY_LIST;
}
particle.fAnnotations = annotations;
} else {
particle.fAnnotations = ((element != null) ? element.fAnnotations
: XSObjectListImpl.EMPTY_LIST);
}
Long defaultVals = (Long)attrValues[XSAttributeChecker.ATTIDX_FROMDEFAULT];
checkOccurrences(particle, SchemaSymbols.ELT_ELEMENT,
(Element)elmDecl.getParentNode(), allContextFlags,
defaultVals.longValue());
fAttrChecker.returnAttrArray(attrValues, schemaDoc);
}
/**
* Traverse a globally declared element.
*
* @param elmDecl
* @param schemaDoc
* @param grammar
* @return the element declaration
*/
XSElementDecl traverseGlobal(Element elmDecl,
XSDocumentInfo schemaDoc,
SchemaGrammar grammar) {
// General Attribute Checking'
Object[] attrValues = fAttrChecker.checkAttributes(elmDecl, true, schemaDoc);
XSElementDecl element = traverseNamedElement(elmDecl, attrValues, schemaDoc, grammar, true, null);
fAttrChecker.returnAttrArray(attrValues, schemaDoc);
return element;
}
/**
* Traverse a globally declared element.
*
* @param elmDecl
* @param attrValues
* @param schemaDoc
* @param grammar
* @param isGlobal
* @return the element declaration
*/
XSElementDecl traverseNamedElement(Element elmDecl,
Object[] attrValues,
XSDocumentInfo schemaDoc,
SchemaGrammar grammar,
boolean isGlobal,
XSObject parent) {
Boolean abstractAtt = (Boolean) attrValues[XSAttributeChecker.ATTIDX_ABSTRACT];
XInt blockAtt = (XInt) attrValues[XSAttributeChecker.ATTIDX_BLOCK];
String defaultAtt = (String) attrValues[XSAttributeChecker.ATTIDX_DEFAULT];
XInt finalAtt = (XInt) attrValues[XSAttributeChecker.ATTIDX_FINAL];
String fixedAtt = (String) attrValues[XSAttributeChecker.ATTIDX_FIXED];
XInt formAtt = (XInt) attrValues[XSAttributeChecker.ATTIDX_FORM];
String nameAtt = (String) attrValues[XSAttributeChecker.ATTIDX_NAME];
Boolean nillableAtt = (Boolean) attrValues[XSAttributeChecker.ATTIDX_NILLABLE];
Vector subGroupAtt = (Vector) attrValues[XSAttributeChecker.ATTIDX_SUBSGROUP];
String targetNsAtt = (String) attrValues[XSAttributeChecker.ATTIDX_TARGETNAMESPACE];
QName typeAtt = (QName) attrValues[XSAttributeChecker.ATTIDX_TYPE];
// Step 1: get declaration information
XSElementDecl element = null;
if (fSchemaHandler.fDeclPool !=null) {
element = fSchemaHandler.fDeclPool.getElementDecl();
} else {
element = new XSElementDecl();
}
// get 'name'
if (nameAtt != null)
element.fName = fSymbolTable.addSymbol(nameAtt);
// get 'target namespace'
if (isGlobal) {
element.fTargetNamespace = schemaDoc.fTargetNamespace;
element.setIsGlobal();
}
else {
// Sanity check, parent should not be null
if (parent != null) {
if (parent instanceof XSComplexTypeDecl || fSchemaHandler.fSchemaVersion == Constants.SCHEMA_VERSION_1_1) {
element.setIsLocal(parent);
}
}
if (targetNsAtt!=null) {
// XML Schema 1.1, set the target namespace to be the value of the targetNamespace attribute if one is defined
targetNsAtt = fSymbolTable.addSymbol(targetNsAtt);
element.fTargetNamespace = targetNsAtt;
} else if (formAtt != null) {
if (formAtt.intValue() == SchemaSymbols.FORM_QUALIFIED)
element.fTargetNamespace = schemaDoc.fTargetNamespace;
else
element.fTargetNamespace = null;
} else if (schemaDoc.fAreLocalElementsQualified) {
element.fTargetNamespace = schemaDoc.fTargetNamespace;
} else {
element.fTargetNamespace = null;
}
}
// get 'block', 'final', 'nillable', 'abstract'
element.fBlock = blockAtt == null ? schemaDoc.fBlockDefault : blockAtt.shortValue();
element.fFinal = finalAtt == null ? schemaDoc.fFinalDefault : finalAtt.shortValue();
// discard valid Block/Final 'Default' values that are invalid for Block/Final
element.fBlock &= (XSConstants.DERIVATION_EXTENSION | XSConstants.DERIVATION_RESTRICTION | XSConstants.DERIVATION_SUBSTITUTION);
element.fFinal &= (XSConstants.DERIVATION_EXTENSION | XSConstants.DERIVATION_RESTRICTION);
if (nillableAtt.booleanValue())
element.setIsNillable();
if (abstractAtt != null && abstractAtt.booleanValue())
element.setIsAbstract();
// get 'value constraint'
if (fixedAtt != null) {
element.fDefault = new ValidatedInfo();
element.fDefault.normalizedValue = fixedAtt;
element.setConstraintType(XSConstants.VC_FIXED);
} else if (defaultAtt != null) {
element.fDefault = new ValidatedInfo();
element.fDefault.normalizedValue = defaultAtt;
element.setConstraintType(XSConstants.VC_DEFAULT);
} else {
element.setConstraintType(XSConstants.VC_NONE);
}
// get 'substitutionGroup affiliation'
if (subGroupAtt != null && !subGroupAtt.isEmpty()) {
Vector elemDecl = new Vector();
for (int i=0; i 0) {
element.fSubGroup = (XSElementDecl[])elemDecl.toArray(new XSElementDecl[validSubgroupElemDeclSize]);
}
}
// get 'annotation'
Element child = DOMUtil.getFirstChildElement(elmDecl);
XSAnnotationImpl annotation = null;
if(child != null && DOMUtil.getLocalName(child).equals(SchemaSymbols.ELT_ANNOTATION)) {
annotation = traverseAnnotationDecl(child, attrValues, false, schemaDoc);
child = DOMUtil.getNextSiblingElement(child);
}
else {
String text = DOMUtil.getSyntheticAnnotation(elmDecl);
if (text != null) {
annotation = traverseSyntheticAnnotation(elmDecl, text, attrValues, false, schemaDoc);
}
}
XSObjectList annotations;
if (annotation != null) {
annotations = new XSObjectListImpl();
((XSObjectListImpl)annotations).addXSObject (annotation);
} else {
annotations = XSObjectListImpl.EMPTY_LIST;
}
element.fAnnotations = annotations;
// get 'type definition'
XSTypeDefinition elementType = null;
boolean haveAnonType = false;
// Handle Anonymous type if there is one
if (child != null) {
String childName = DOMUtil.getLocalName(child);
if (childName.equals(SchemaSymbols.ELT_COMPLEXTYPE)) {
elementType = fSchemaHandler.fComplexTypeTraverser.traverseLocal(child, schemaDoc, grammar, element);
haveAnonType = true;
child = DOMUtil.getNextSiblingElement(child);
}
else if (childName.equals(SchemaSymbols.ELT_SIMPLETYPE)) {
elementType = fSchemaHandler.fSimpleTypeTraverser.traverseLocal(child, schemaDoc, grammar, element);
haveAnonType = true;
child = DOMUtil.getNextSiblingElement(child);
}
}
// Handler type attribute
if (elementType == null && typeAtt != null) {
elementType = (XSTypeDefinition)fSchemaHandler.getGlobalDecl(schemaDoc, XSDHandler.TYPEDECL_TYPE, typeAtt, elmDecl);
if (elementType == null) {
element.fUnresolvedTypeName = typeAtt;
}
}
// Get it from the substitutionGroup declaration
if (elementType == null && element.fSubGroup != null) {
elementType = element.fSubGroup[0].fType;
}
if (elementType == null) {
elementType = SchemaGrammar.getXSAnyType(fSchemaHandler.fSchemaVersion);
}
element.fType = elementType;
// get 'identity constraint'
// see if there's something here; it had better be key, keyref or unique.
if (child != null) {
String childName = DOMUtil.getLocalName(child);
// if XML Schema 1.1, check for alternative types first
if (fSchemaHandler.fSchemaVersion == Constants.SCHEMA_VERSION_1_1) {
while (childName.equals(SchemaSymbols.ELT_ALTERNATIVE)) {
fSchemaHandler.fTypeAlternativeTraverser.traverse(child, element, schemaDoc, grammar);
child = DOMUtil.getNextSiblingElement(child);
if (child != null) {
childName = DOMUtil.getLocalName(child);
}
else {
if (!element.isTypeTableOK()) {
reportSchemaError("src-element.5", new Object[]{nameAtt}, elmDecl);
}
element.setDefaultTypeDefinition();
if (element.getDefaultTypeDefinition() != null) {
element.getDefaultTypeDefinition().setNamespaceContext(new NamespaceSupport(schemaDoc.fNamespaceSupport));
}
break;
}
}
}
while (child != null &&
(childName.equals(SchemaSymbols.ELT_KEY) ||
childName.equals(SchemaSymbols.ELT_KEYREF) ||
childName.equals(SchemaSymbols.ELT_UNIQUE))) {
// if the identity constraint contains the ref attribute,
// defer traversal until all the named identity constraints have been traversed
if (DOMUtil.getAttr(child, SchemaSymbols.ATT_REF) != null) {
fSchemaHandler.storeIdentityConstraintReferral(child, schemaDoc, element);
}
else if (childName.equals(SchemaSymbols.ELT_KEY) ||
childName.equals(SchemaSymbols.ELT_UNIQUE)) {
// need to set / to hidden before traversing it,
// because it has global scope
DOMUtil.setHidden(child, fSchemaHandler.fHiddenNodes);
fSchemaHandler.fUniqueOrKeyTraverser.traverse(child, element, schemaDoc, grammar);
if(DOMUtil.getAttrValue(child, SchemaSymbols.ATT_NAME).length() != 0 ) {
fSchemaHandler.checkForDuplicateNames(
(schemaDoc.fTargetNamespace == null) ? ","+DOMUtil.getAttrValue(child, SchemaSymbols.ATT_NAME)
: schemaDoc.fTargetNamespace+","+ DOMUtil.getAttrValue(child, SchemaSymbols.ATT_NAME),
XSDHandler.ATTRIBUTE_TYPE, fSchemaHandler.getIDRegistry(), fSchemaHandler.getIDRegistry_sub(),
child, schemaDoc);
}
} else if (childName.equals(SchemaSymbols.ELT_KEYREF)) {
fSchemaHandler.storeKeyRef(child, schemaDoc, element);
}
child = DOMUtil.getNextSiblingElement(child);
if (child != null) {
childName = DOMUtil.getLocalName(child);
}
}
}
// Step 3: check against schema for schemas
// required attributes
if (nameAtt == null) {
if (isGlobal)
reportSchemaError("s4s-att-must-appear", new Object[]{SchemaSymbols.ELT_ELEMENT, SchemaSymbols.ATT_NAME}, elmDecl);
else
reportSchemaError("src-element.2.1", null, elmDecl);
nameAtt = NO_NAME;
}
// element
if (child != null) {
if (fSchemaHandler.fSchemaVersion == Constants.SCHEMA_VERSION_1_1) {
reportSchemaError("s4s-elt-must-match.1", new Object[]{nameAtt, "(annotation?, (simpleType | complexType)?, alternative*, (unique | key | keyref)*))", DOMUtil.getLocalName(child)}, child);
}
else {
reportSchemaError("s4s-elt-must-match.1", new Object[]{nameAtt, "(annotation?, (simpleType | complexType)?, (unique | key | keyref)*))", DOMUtil.getLocalName(child)}, child);
}
}
// Step 4: check 3.3.3 constraints
// src-element
// 1 default and fixed must not both be present.
if (defaultAtt != null && fixedAtt != null) {
reportSchemaError("src-element.1", new Object[]{nameAtt}, elmDecl);
}
// 2 If the item's parent is not , then all of the following must be true:
// 2.1 One of ref or name must be present, but not both.
// This is checked in XSAttributeChecker
// 2.2 If ref is present, then all of , , , , , nillable, default, fixed, form, block and type must be absent, i.e. only minOccurs, maxOccurs, id are allowed in addition to ref, along with .
// Attributes are checked in XSAttributeChecker, elements are checked in "traverse" method
// 3 type and either or are mutually exclusive.
if (haveAnonType && (typeAtt != null)) {
reportSchemaError("src-element.3", new Object[]{nameAtt}, elmDecl);
}
// 4 If the targetNamespace attribute is present, then all of the following are true:
if (targetNsAtt != null) {
// 4.2 The form attribute must not be present.
if (formAtt != null) {
reportSchemaError ("src-element.4.2", new Object[] {nameAtt}, elmDecl);
}
// 4.3 If the ancestor does not have a targetNamespace [attribute] or its 'actual value' is different from the 'actual value' of targetNamespace of :
String schemaTns = schemaDoc.fTargetNamespace;
if (schemaTns==null || targetNsAtt!=schemaTns) {
// 4.3.1 must have as an ancestor
if (parent==null || !(parent instanceof XSComplexTypeDecl)) {
reportSchemaError ("src-element.4.3.1", new Object[] {nameAtt}, elmDecl);
}
// 4.3.2 There must be a ancestor between the and the nearest ancestor, and the 'actual value' of the base [attribute] of does not 'match' the name of 'xs:anyType'.
else if ((((XSComplexTypeDecl)parent).getDerivationMethod() != XSConstants.DERIVATION_RESTRICTION) || (((XSComplexTypeDecl)parent).getBaseType() == SchemaGrammar.getXSAnyType(fSchemaHandler.fSchemaVersion))) {
reportSchemaError ("src-element.4.3.2", new Object[] {nameAtt}, elmDecl);
}
}
}
// Step 5: check 3.3.6 constraints
// check for NOTATION type
// Only for XML Schema 1.0
if (fSchemaHandler.fSchemaVersion < Constants.SCHEMA_VERSION_1_1) {
checkNotationType(nameAtt, elementType, elmDecl);
}
// e-props-correct
// 2 If there is a {value constraint}, the canonical lexical representation of its value must be valid with respect to the {type definition} as defined in Element Default Valid (Immediate) (3.3.6).
if (element.fDefault != null) {
fValidationState.setNamespaceSupport(schemaDoc.fNamespaceSupport);
fValidationState.setDatatypeXMLVersion(schemaDoc.fDatatypeXMLVersion);
if (fSchemaHandler.fXSConstraints.ElementDefaultValidImmediate(element.fType, element.fDefault.normalizedValue, fValidationState, element.fDefault) == null) {
reportSchemaError ("e-props-correct.2", new Object[]{nameAtt, element.fDefault.normalizedValue}, elmDecl);
element.fDefault = null;
element.setConstraintType(XSConstants.VC_NONE);
}
}
// 4 If there is an {substitution group affiliation}, the {type definition} of the element declaration must be validly derived from the {type definition} of the {substitution group affiliation}, given the value of the {substitution group exclusions} of the {substitution group affiliation}, as defined in Type Derivation OK (Complex) (3.4.6) (if the {type definition} is complex) or as defined in Type Derivation OK (Simple) (3.14.6) (if the {type definition} is simple).
if (element.fSubGroup != null) {
for (int i=0; i< element.fSubGroup.length; i++) {
if (!fSchemaHandler.fXSConstraints.checkTypeDerivationOk(element.fType, element.fSubGroup[i].fType, element.fSubGroup[i].fFinal)) {
reportSchemaError ("e-props-correct.4", new Object[]{nameAtt, ((QName)subGroupAtt.get(i)).prefix +":"+((QName)subGroupAtt.get(i)).localpart}, elmDecl);
//TODO: remove the subGroup from the list?????
}
}
}
// Only applies to XML Schema 1.0
//
// 5 If the {type definition} or {type definition}'s {content type} is or is derived from ID then there must not be a {value constraint}.
if (fSchemaHandler.fSchemaVersion < Constants.SCHEMA_VERSION_1_1 && element.fDefault != null) {
if ((elementType.getTypeCategory() == XSTypeDefinition.SIMPLE_TYPE &&
((XSSimpleType)elementType).isIDType()) ||
(elementType.getTypeCategory() == XSTypeDefinition.COMPLEX_TYPE &&
((XSComplexTypeDecl)elementType).containsTypeID())) {
reportSchemaError ("e-props-correct.5", new Object[]{element.fName}, elmDecl);
element.fDefault = null;
element.setConstraintType(XSConstants.VC_NONE);
}
}
// Element without a name. Return null.
if (element.fName == null)
return null;
// Step 5: register the element decl to the grammar
if (isGlobal) {
grammar.addGlobalElementDeclAll(element);
if (grammar.getGlobalElementDecl(element.fName) == null) {
grammar.addGlobalElementDecl(element);
}
// we also add the element to the tolerate duplicates list as well
final String loc = fSchemaHandler.schemaDocument2SystemId(schemaDoc);
final XSElementDecl element2 = grammar.getGlobalElementDecl(element.fName, loc);
if (element2 == null) {
grammar.addGlobalElementDecl(element, loc);
}
// if we are tolerating duplicates, and we found a duplicate declaration
// use the duplicate one instead
if (fSchemaHandler.fTolerateDuplicates) {
if (element2 != null) {
element = element2;
}
fSchemaHandler.addGlobalElementDecl(element);
}
}
return element;
}
void reset(SymbolTable symbolTable, boolean validateAnnotations, Locale locale) {
super.reset(symbolTable, validateAnnotations, locale);
fDeferTraversingLocalElements = true;
} // reset()
}
