| /** |
| * Copyright (c) 2002-2007 IBM Corporation and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * IBM - Initial API and implementation |
| */ |
| package org.eclipse.xsd.impl; |
| |
| |
| import java.text.MessageFormat; |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.ListIterator; |
| import java.util.Map; |
| import java.util.StringTokenizer; |
| |
| import org.w3c.dom.Element; |
| import org.w3c.dom.Node; |
| |
| import org.eclipse.emf.common.notify.Notification; |
| import org.eclipse.emf.common.notify.NotificationChain; |
| import org.eclipse.emf.common.util.BasicEList; |
| import org.eclipse.emf.common.util.EList; |
| import org.eclipse.emf.common.util.UniqueEList; |
| import org.eclipse.emf.ecore.EAttribute; |
| import org.eclipse.emf.ecore.EClass; |
| import org.eclipse.emf.ecore.EReference; |
| import org.eclipse.emf.ecore.InternalEObject; |
| import org.eclipse.emf.ecore.impl.ENotificationImpl; |
| import org.eclipse.emf.ecore.util.EDataTypeUniqueEList; |
| import org.eclipse.emf.ecore.util.EObjectContainmentEList; |
| import org.eclipse.emf.ecore.util.EObjectEList; |
| import org.eclipse.emf.ecore.util.EcoreEList; |
| import org.eclipse.emf.ecore.util.InternalEList; |
| |
| import org.eclipse.xsd.XSDAnnotation; |
| import org.eclipse.xsd.XSDBoundedFacet; |
| import org.eclipse.xsd.XSDCardinality; |
| import org.eclipse.xsd.XSDCardinalityFacet; |
| import org.eclipse.xsd.XSDComplexTypeDefinition; |
| import org.eclipse.xsd.XSDComponent; |
| import org.eclipse.xsd.XSDConcreteComponent; |
| import org.eclipse.xsd.XSDConstrainingFacet; |
| import org.eclipse.xsd.XSDDerivationMethod; |
| import org.eclipse.xsd.XSDDiagnostic; |
| import org.eclipse.xsd.XSDDiagnosticSeverity; |
| import org.eclipse.xsd.XSDEnumerationFacet; |
| import org.eclipse.xsd.XSDFacet; |
| import org.eclipse.xsd.XSDFactory; |
| import org.eclipse.xsd.XSDFeature; |
| import org.eclipse.xsd.XSDFractionDigitsFacet; |
| import org.eclipse.xsd.XSDFundamentalFacet; |
| import org.eclipse.xsd.XSDLengthFacet; |
| import org.eclipse.xsd.XSDMaxExclusiveFacet; |
| import org.eclipse.xsd.XSDMaxFacet; |
| import org.eclipse.xsd.XSDMaxInclusiveFacet; |
| import org.eclipse.xsd.XSDMaxLengthFacet; |
| import org.eclipse.xsd.XSDMinExclusiveFacet; |
| import org.eclipse.xsd.XSDMinFacet; |
| import org.eclipse.xsd.XSDMinInclusiveFacet; |
| import org.eclipse.xsd.XSDMinLengthFacet; |
| import org.eclipse.xsd.XSDNumericFacet; |
| import org.eclipse.xsd.XSDOrdered; |
| import org.eclipse.xsd.XSDOrderedFacet; |
| import org.eclipse.xsd.XSDPackage; |
| import org.eclipse.xsd.XSDParticle; |
| import org.eclipse.xsd.XSDPatternFacet; |
| import org.eclipse.xsd.XSDPlugin; |
| import org.eclipse.xsd.XSDProhibitedSubstitutions; |
| import org.eclipse.xsd.XSDRedefine; |
| import org.eclipse.xsd.XSDSchema; |
| import org.eclipse.xsd.XSDSimpleFinal; |
| import org.eclipse.xsd.XSDSimpleTypeDefinition; |
| import org.eclipse.xsd.XSDTotalDigitsFacet; |
| import org.eclipse.xsd.XSDTypeDefinition; |
| import org.eclipse.xsd.XSDVariety; |
| import org.eclipse.xsd.XSDWhiteSpaceFacet; |
| import org.eclipse.xsd.impl.type.XSDAnySimpleType; |
| import org.eclipse.xsd.impl.type.XSDTypeRegister; |
| import org.eclipse.xsd.util.XSDConstants; |
| |
| |
| /** |
| * <!-- begin-user-doc --> |
| * An implementation of the model object '<em><b>Simple Type Definition</b></em>'. |
| * <!-- end-user-doc --> |
| * <p> |
| * The following features are implemented: |
| * <ul> |
| * <li>{@link org.eclipse.xsd.impl.XSDSimpleTypeDefinitionImpl#getVariety <em>Variety</em>}</li> |
| * <li>{@link org.eclipse.xsd.impl.XSDSimpleTypeDefinitionImpl#getFinal <em>Final</em>}</li> |
| * <li>{@link org.eclipse.xsd.impl.XSDSimpleTypeDefinitionImpl#getLexicalFinal <em>Lexical Final</em>}</li> |
| * <li>{@link org.eclipse.xsd.impl.XSDSimpleTypeDefinitionImpl#getValidFacets <em>Valid Facets</em>}</li> |
| * <li>{@link org.eclipse.xsd.impl.XSDSimpleTypeDefinitionImpl#getContents <em>Contents</em>}</li> |
| * <li>{@link org.eclipse.xsd.impl.XSDSimpleTypeDefinitionImpl#getFacetContents <em>Facet Contents</em>}</li> |
| * <li>{@link org.eclipse.xsd.impl.XSDSimpleTypeDefinitionImpl#getFacets <em>Facets</em>}</li> |
| * <li>{@link org.eclipse.xsd.impl.XSDSimpleTypeDefinitionImpl#getMemberTypeDefinitions <em>Member Type Definitions</em>}</li> |
| * <li>{@link org.eclipse.xsd.impl.XSDSimpleTypeDefinitionImpl#getFundamentalFacets <em>Fundamental Facets</em>}</li> |
| * <li>{@link org.eclipse.xsd.impl.XSDSimpleTypeDefinitionImpl#getBaseTypeDefinition <em>Base Type Definition</em>}</li> |
| * <li>{@link org.eclipse.xsd.impl.XSDSimpleTypeDefinitionImpl#getPrimitiveTypeDefinition <em>Primitive Type Definition</em>}</li> |
| * <li>{@link org.eclipse.xsd.impl.XSDSimpleTypeDefinitionImpl#getItemTypeDefinition <em>Item Type Definition</em>}</li> |
| * <li>{@link org.eclipse.xsd.impl.XSDSimpleTypeDefinitionImpl#getRootTypeDefinition <em>Root Type Definition</em>}</li> |
| * <li>{@link org.eclipse.xsd.impl.XSDSimpleTypeDefinitionImpl#getMinFacet <em>Min Facet</em>}</li> |
| * <li>{@link org.eclipse.xsd.impl.XSDSimpleTypeDefinitionImpl#getMaxFacet <em>Max Facet</em>}</li> |
| * <li>{@link org.eclipse.xsd.impl.XSDSimpleTypeDefinitionImpl#getMaxInclusiveFacet <em>Max Inclusive Facet</em>}</li> |
| * <li>{@link org.eclipse.xsd.impl.XSDSimpleTypeDefinitionImpl#getMinInclusiveFacet <em>Min Inclusive Facet</em>}</li> |
| * <li>{@link org.eclipse.xsd.impl.XSDSimpleTypeDefinitionImpl#getMinExclusiveFacet <em>Min Exclusive Facet</em>}</li> |
| * <li>{@link org.eclipse.xsd.impl.XSDSimpleTypeDefinitionImpl#getMaxExclusiveFacet <em>Max Exclusive Facet</em>}</li> |
| * <li>{@link org.eclipse.xsd.impl.XSDSimpleTypeDefinitionImpl#getLengthFacet <em>Length Facet</em>}</li> |
| * <li>{@link org.eclipse.xsd.impl.XSDSimpleTypeDefinitionImpl#getWhiteSpaceFacet <em>White Space Facet</em>}</li> |
| * <li>{@link org.eclipse.xsd.impl.XSDSimpleTypeDefinitionImpl#getEnumerationFacets <em>Enumeration Facets</em>}</li> |
| * <li>{@link org.eclipse.xsd.impl.XSDSimpleTypeDefinitionImpl#getPatternFacets <em>Pattern Facets</em>}</li> |
| * <li>{@link org.eclipse.xsd.impl.XSDSimpleTypeDefinitionImpl#getCardinalityFacet <em>Cardinality Facet</em>}</li> |
| * <li>{@link org.eclipse.xsd.impl.XSDSimpleTypeDefinitionImpl#getNumericFacet <em>Numeric Facet</em>}</li> |
| * <li>{@link org.eclipse.xsd.impl.XSDSimpleTypeDefinitionImpl#getMaxLengthFacet <em>Max Length Facet</em>}</li> |
| * <li>{@link org.eclipse.xsd.impl.XSDSimpleTypeDefinitionImpl#getMinLengthFacet <em>Min Length Facet</em>}</li> |
| * <li>{@link org.eclipse.xsd.impl.XSDSimpleTypeDefinitionImpl#getTotalDigitsFacet <em>Total Digits Facet</em>}</li> |
| * <li>{@link org.eclipse.xsd.impl.XSDSimpleTypeDefinitionImpl#getFractionDigitsFacet <em>Fraction Digits Facet</em>}</li> |
| * <li>{@link org.eclipse.xsd.impl.XSDSimpleTypeDefinitionImpl#getOrderedFacet <em>Ordered Facet</em>}</li> |
| * <li>{@link org.eclipse.xsd.impl.XSDSimpleTypeDefinitionImpl#getBoundedFacet <em>Bounded Facet</em>}</li> |
| * <li>{@link org.eclipse.xsd.impl.XSDSimpleTypeDefinitionImpl#getEffectiveMaxFacet <em>Effective Max Facet</em>}</li> |
| * <li>{@link org.eclipse.xsd.impl.XSDSimpleTypeDefinitionImpl#getEffectiveWhiteSpaceFacet <em>Effective White Space Facet</em>}</li> |
| * <li>{@link org.eclipse.xsd.impl.XSDSimpleTypeDefinitionImpl#getEffectiveMaxLengthFacet <em>Effective Max Length Facet</em>}</li> |
| * <li>{@link org.eclipse.xsd.impl.XSDSimpleTypeDefinitionImpl#getEffectiveFractionDigitsFacet <em>Effective Fraction Digits Facet</em>}</li> |
| * <li>{@link org.eclipse.xsd.impl.XSDSimpleTypeDefinitionImpl#getEffectivePatternFacet <em>Effective Pattern Facet</em>}</li> |
| * <li>{@link org.eclipse.xsd.impl.XSDSimpleTypeDefinitionImpl#getEffectiveEnumerationFacet <em>Effective Enumeration Facet</em>}</li> |
| * <li>{@link org.eclipse.xsd.impl.XSDSimpleTypeDefinitionImpl#getEffectiveTotalDigitsFacet <em>Effective Total Digits Facet</em>}</li> |
| * <li>{@link org.eclipse.xsd.impl.XSDSimpleTypeDefinitionImpl#getEffectiveMinLengthFacet <em>Effective Min Length Facet</em>}</li> |
| * <li>{@link org.eclipse.xsd.impl.XSDSimpleTypeDefinitionImpl#getEffectiveLengthFacet <em>Effective Length Facet</em>}</li> |
| * <li>{@link org.eclipse.xsd.impl.XSDSimpleTypeDefinitionImpl#getEffectiveMinFacet <em>Effective Min Facet</em>}</li> |
| * <li>{@link org.eclipse.xsd.impl.XSDSimpleTypeDefinitionImpl#getSyntheticFacets <em>Synthetic Facets</em>}</li> |
| * </ul> |
| * </p> |
| * |
| * @generated |
| */ |
| public class XSDSimpleTypeDefinitionImpl |
| extends XSDTypeDefinitionImpl |
| implements XSDSimpleTypeDefinition |
| { |
| /** |
| * The default value of the '{@link #getVariety() <em>Variety</em>}' attribute. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @see #getVariety() |
| * @generated |
| * @ordered |
| */ |
| protected static final XSDVariety VARIETY_EDEFAULT = XSDVariety.ATOMIC_LITERAL; |
| |
| /** |
| * The offset of the flags representing the value of the '{@link #getVariety() <em>Variety</em>}' attribute. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| * @ordered |
| */ |
| protected static final int VARIETY_EFLAG_OFFSET = 8; |
| |
| /** |
| * The flags representing the default value of the '{@link #getVariety() <em>Variety</em>}' attribute. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| * @ordered |
| */ |
| protected static final int VARIETY_EFLAG_DEFAULT = VARIETY_EDEFAULT.ordinal() << VARIETY_EFLAG_OFFSET; |
| |
| /** |
| * The array of enumeration values for '{@link XSDVariety Variety}' |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| * @ordered |
| */ |
| private static final XSDVariety[] VARIETY_EFLAG_VALUES = XSDVariety.values(); |
| |
| /** |
| * The flags representing the value of the '{@link #getVariety() <em>Variety</em>}' attribute. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @see #getVariety() |
| * @generated |
| * @ordered |
| */ |
| protected static final int VARIETY_EFLAG = 0x3 << VARIETY_EFLAG_OFFSET; |
| |
| /** |
| * The flag representing whether the Variety attribute has been set. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| * @ordered |
| */ |
| protected static final int VARIETY_ESETFLAG = 1 << 10; |
| |
| /** |
| * The cached value of the '{@link #getFinal() <em>Final</em>}' attribute list. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @see #getFinal() |
| * @generated |
| * @ordered |
| */ |
| protected EList<XSDSimpleFinal> final_; |
| |
| /** |
| * The cached value of the '{@link #getLexicalFinal() <em>Lexical Final</em>}' attribute list. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @see #getLexicalFinal() |
| * @generated |
| * @ordered |
| */ |
| protected EList<XSDSimpleFinal> lexicalFinal; |
| |
| /** |
| * The cached value of the '{@link #getValidFacets() <em>Valid Facets</em>}' attribute list. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @see #getValidFacets() |
| * @generated |
| * @ordered |
| */ |
| protected EList<String> validFacets; |
| |
| /** |
| * The cached value of the '{@link #getContents() <em>Contents</em>}' containment reference list. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @see #getContents() |
| * @generated |
| * @ordered |
| */ |
| protected EList<XSDSimpleTypeDefinition> contents; |
| |
| /** |
| * The cached value of the '{@link #getFacetContents() <em>Facet Contents</em>}' containment reference list. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @see #getFacetContents() |
| * @generated NOT |
| * @ordered |
| */ |
| protected EcoreEList<XSDConstrainingFacet> facetContents = null; |
| |
| /** |
| * The cached value of the '{@link #getFacets() <em>Facets</em>}' reference list. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @see #getFacets() |
| * @generated NOT |
| * @ordered |
| */ |
| protected EcoreEList<XSDConstrainingFacet> facets = null; |
| |
| /** |
| * The cached value of the '{@link #getMemberTypeDefinitions() <em>Member Type Definitions</em>}' reference list. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @see #getMemberTypeDefinitions() |
| * @generated |
| * @ordered |
| */ |
| protected EList<XSDSimpleTypeDefinition> memberTypeDefinitions; |
| |
| /** |
| * The cached value of the '{@link #getFundamentalFacets() <em>Fundamental Facets</em>}' containment reference list. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @see #getFundamentalFacets() |
| * @generated |
| * @ordered |
| */ |
| protected EList<XSDFundamentalFacet> fundamentalFacets; |
| |
| /** |
| * The cached value of the '{@link #getBaseTypeDefinition() <em>Base Type Definition</em>}' reference. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @see #getBaseTypeDefinition() |
| * @generated |
| * @ordered |
| */ |
| protected XSDSimpleTypeDefinition baseTypeDefinition; |
| |
| /** |
| * The cached value of the '{@link #getPrimitiveTypeDefinition() <em>Primitive Type Definition</em>}' reference. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @see #getPrimitiveTypeDefinition() |
| * @generated |
| * @ordered |
| */ |
| protected XSDSimpleTypeDefinition primitiveTypeDefinition; |
| |
| /** |
| * The cached value of the '{@link #getItemTypeDefinition() <em>Item Type Definition</em>}' reference. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @see #getItemTypeDefinition() |
| * @generated |
| * @ordered |
| */ |
| protected XSDSimpleTypeDefinition itemTypeDefinition; |
| |
| /** |
| * The cached value of the '{@link #getSyntheticFacets() <em>Synthetic Facets</em>}' containment reference list. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @see #getSyntheticFacets() |
| * @generated |
| * @ordered |
| */ |
| protected EList<XSDFacet> syntheticFacets; |
| |
| public static XSDSimpleTypeDefinition createSimpleTypeDefinition(Node node) |
| { |
| switch (XSDConstants.nodeType(node)) |
| { |
| case XSDConstants.SIMPLETYPE_ELEMENT: |
| case XSDConstants.SIMPLECONTENT_ELEMENT: |
| { |
| XSDSimpleTypeDefinition xsdSimpleTypeDefinition = XSDFactory.eINSTANCE.createXSDSimpleTypeDefinition(); |
| xsdSimpleTypeDefinition.setElement((Element)node); |
| return xsdSimpleTypeDefinition; |
| } |
| } |
| |
| return null; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| protected XSDSimpleTypeDefinitionImpl() |
| { |
| super(); |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| @Override |
| protected EClass eStaticClass() |
| { |
| return XSDPackage.Literals.XSD_SIMPLE_TYPE_DEFINITION; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public XSDVariety getVariety() |
| { |
| return VARIETY_EFLAG_VALUES[(eFlags & VARIETY_EFLAG) >>> VARIETY_EFLAG_OFFSET]; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public void setVariety(XSDVariety newVariety) |
| { |
| XSDVariety oldVariety = VARIETY_EFLAG_VALUES[(eFlags & VARIETY_EFLAG) >>> VARIETY_EFLAG_OFFSET]; |
| if (newVariety == null) newVariety = VARIETY_EDEFAULT; |
| eFlags = eFlags & ~VARIETY_EFLAG | newVariety.ordinal() << VARIETY_EFLAG_OFFSET; |
| boolean oldVarietyESet = (eFlags & VARIETY_ESETFLAG) != 0; |
| eFlags |= VARIETY_ESETFLAG; |
| if (eNotificationRequired()) |
| eNotify(new ENotificationImpl(this, Notification.SET, XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__VARIETY, oldVariety, newVariety, !oldVarietyESet)); |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public void unsetVariety() |
| { |
| XSDVariety oldVariety = VARIETY_EFLAG_VALUES[(eFlags & VARIETY_EFLAG) >>> VARIETY_EFLAG_OFFSET]; |
| boolean oldVarietyESet = (eFlags & VARIETY_ESETFLAG) != 0; |
| eFlags = eFlags & ~VARIETY_EFLAG | VARIETY_EFLAG_DEFAULT; |
| eFlags &= ~VARIETY_ESETFLAG; |
| if (eNotificationRequired()) |
| eNotify(new ENotificationImpl(this, Notification.UNSET, XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__VARIETY, oldVariety, VARIETY_EDEFAULT, oldVarietyESet)); |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public boolean isSetVariety() |
| { |
| return (eFlags & VARIETY_ESETFLAG) != 0; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public EList<XSDSimpleFinal> getFinal() |
| { |
| if (final_ == null) |
| { |
| final_ = new EDataTypeUniqueEList<XSDSimpleFinal>(XSDSimpleFinal.class, this, XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__FINAL); |
| } |
| return final_; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public EList<XSDSimpleFinal> getLexicalFinal() |
| { |
| if (lexicalFinal == null) |
| { |
| lexicalFinal = new EDataTypeUniqueEList.Unsettable<XSDSimpleFinal>(XSDSimpleFinal.class, this, XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__LEXICAL_FINAL); |
| } |
| return lexicalFinal; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public void unsetLexicalFinal() |
| { |
| if (lexicalFinal != null) ((InternalEList.Unsettable<?>)lexicalFinal).unset(); |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public boolean isSetLexicalFinal() |
| { |
| return lexicalFinal != null && ((InternalEList.Unsettable<?>)lexicalFinal).isSet(); |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public EList<String> getValidFacets() |
| { |
| if (validFacets == null) |
| { |
| validFacets = new EDataTypeUniqueEList<String>(String.class, this, XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__VALID_FACETS); |
| } |
| return validFacets; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public EList<XSDSimpleTypeDefinition> getContents() |
| { |
| if (contents == null) |
| { |
| contents = new EObjectContainmentEList<XSDSimpleTypeDefinition>(XSDSimpleTypeDefinition.class, this, XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__CONTENTS); |
| } |
| return contents; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public EList<XSDConstrainingFacet> getFacetContents() |
| { |
| if (facetContents == null) |
| { |
| facetContents = new EObjectContainmentEList<XSDConstrainingFacet>(XSDConstrainingFacet.class, this, XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__FACET_CONTENTS); |
| } |
| return facetContents; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public EList<XSDConstrainingFacet> getFacets() |
| { |
| if (facets == null) |
| { |
| facets = new EObjectEList<XSDConstrainingFacet>(XSDConstrainingFacet.class, this, XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__FACETS); |
| } |
| return facets; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public EList<XSDSimpleTypeDefinition> getMemberTypeDefinitions() |
| { |
| if (memberTypeDefinitions == null) |
| { |
| memberTypeDefinitions = new EObjectEList<XSDSimpleTypeDefinition>(XSDSimpleTypeDefinition.class, this, XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__MEMBER_TYPE_DEFINITIONS); |
| } |
| return memberTypeDefinitions; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public EList<XSDFundamentalFacet> getFundamentalFacets() |
| { |
| if (fundamentalFacets == null) |
| { |
| fundamentalFacets = new EObjectContainmentEList<XSDFundamentalFacet>(XSDFundamentalFacet.class, this, XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__FUNDAMENTAL_FACETS); |
| } |
| return fundamentalFacets; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public XSDSimpleTypeDefinition getBaseTypeDefinition() |
| { |
| return baseTypeDefinition; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public void setBaseTypeDefinition(XSDSimpleTypeDefinition newBaseTypeDefinition) |
| { |
| XSDSimpleTypeDefinition oldBaseTypeDefinition = baseTypeDefinition; |
| baseTypeDefinition = newBaseTypeDefinition; |
| if (eNotificationRequired()) |
| eNotify(new ENotificationImpl(this, Notification.SET, XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__BASE_TYPE_DEFINITION, oldBaseTypeDefinition, baseTypeDefinition)); |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public XSDSimpleTypeDefinition getPrimitiveTypeDefinition() |
| { |
| return primitiveTypeDefinition; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public void setPrimitiveTypeDefinition(XSDSimpleTypeDefinition newPrimitiveTypeDefinition) |
| { |
| XSDSimpleTypeDefinition oldPrimitiveTypeDefinition = primitiveTypeDefinition; |
| primitiveTypeDefinition = newPrimitiveTypeDefinition; |
| if (eNotificationRequired()) |
| eNotify(new ENotificationImpl(this, Notification.SET, XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__PRIMITIVE_TYPE_DEFINITION, oldPrimitiveTypeDefinition, primitiveTypeDefinition)); |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public XSDSimpleTypeDefinition getItemTypeDefinition() |
| { |
| return itemTypeDefinition; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public void setItemTypeDefinition(XSDSimpleTypeDefinition newItemTypeDefinition) |
| { |
| XSDSimpleTypeDefinition oldItemTypeDefinition = itemTypeDefinition; |
| itemTypeDefinition = newItemTypeDefinition; |
| if (eNotificationRequired()) |
| eNotify(new ENotificationImpl(this, Notification.SET, XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__ITEM_TYPE_DEFINITION, oldItemTypeDefinition, itemTypeDefinition)); |
| } |
| |
| @Override |
| public Element createElement() |
| { |
| XSDComplexTypeDefinition xsdComplexTypeDefinition = |
| getContainer() instanceof XSDComplexTypeDefinition ? |
| (XSDComplexTypeDefinition)getContainer() : |
| null; |
| |
| Element newElement = |
| createElement |
| (xsdComplexTypeDefinition != null ? |
| XSDConstants.SIMPLECONTENT_ELEMENT : |
| XSDConstants.SIMPLETYPE_ELEMENT); |
| setElement(newElement); |
| |
| Element childElement = createChildElement(); |
| newElement.appendChild(childElement); |
| return newElement; |
| } |
| |
| protected Element createChildElement() |
| { |
| return createElement(getRequiredChildElementNodeType()); |
| } |
| |
| protected int getRequiredChildElementNodeType() |
| { |
| XSDComplexTypeDefinition xsdComplexTypeDefinition = |
| getContainer() instanceof XSDComplexTypeDefinition ? |
| (XSDComplexTypeDefinition)getContainer() : |
| null; |
| |
| XSDSimpleTypeDefinition theBaseTypeDefinition = getBaseTypeDefinition(); |
| if (getItemTypeDefinition() != null && (theBaseTypeDefinition == null || XSDConstants.isURType(theBaseTypeDefinition))) |
| { |
| return XSDConstants.LIST_ELEMENT; |
| } |
| else if (!getMemberTypeDefinitions().isEmpty() && (theBaseTypeDefinition == null || XSDConstants.isURType(theBaseTypeDefinition))) |
| { |
| return XSDConstants.UNION_ELEMENT; |
| } |
| else |
| { |
| return |
| xsdComplexTypeDefinition == null || XSDDerivationMethod.EXTENSION_LITERAL != xsdComplexTypeDefinition.getDerivationMethod() ? |
| XSDConstants.RESTRICTION_ELEMENT : |
| XSDConstants.EXTENSION_ELEMENT; |
| } |
| } |
| |
| @Override |
| protected void patch() |
| { |
| super.patch(); |
| |
| if (!(getContainer() instanceof XSDComplexTypeDefinition)) |
| { |
| XSDSimpleTypeDefinition theBaseTypeDefinition = getBaseTypeDefinition(); |
| if (theBaseTypeDefinition != null && (forceResolve || theBaseTypeDefinition.getContainer() == null)) |
| { |
| theBaseTypeDefinition = resolveSimpleTypeDefinition(theBaseTypeDefinition.getTargetNamespace(), theBaseTypeDefinition.getName()); |
| } |
| theBaseTypeDefinition = handleNewBaseTypeDefinition(theBaseTypeDefinition); |
| if (theBaseTypeDefinition == null || !theBaseTypeDefinition.isSetVariety() || theBaseTypeDefinition.getVariety() != getVariety()) |
| { |
| XSDSimpleTypeDefinition theItemTypeDefinition = getItemTypeDefinition(); |
| if (theItemTypeDefinition != null) |
| { |
| if (forceResolve || theItemTypeDefinition.getContainer() == null) |
| { |
| XSDSimpleTypeDefinition newItemTypeDefinition = |
| resolveSimpleTypeDefinition(theItemTypeDefinition.getTargetNamespace(), theItemTypeDefinition.getName()); |
| if ((forceResolve || newItemTypeDefinition.getContainer() != null) && newItemTypeDefinition != theItemTypeDefinition) |
| { |
| setItemTypeDefinition(newItemTypeDefinition); |
| } |
| } |
| } |
| else |
| { |
| for (ListIterator<XSDSimpleTypeDefinition> theMemberTypeDefinitions = getMemberTypeDefinitions().listIterator(); |
| theMemberTypeDefinitions.hasNext(); ) |
| { |
| XSDSimpleTypeDefinition theMemberTypeDefinition = theMemberTypeDefinitions.next(); |
| if (forceResolve || theMemberTypeDefinition.getContainer() == null) |
| { |
| XSDSimpleTypeDefinition newMemberTypeDefinition = |
| resolveSimpleTypeDefinition(theMemberTypeDefinition.getTargetNamespace(), theMemberTypeDefinition.getName()); |
| if ((forceResolve || newMemberTypeDefinition.getContainer() != null) && newMemberTypeDefinition != theMemberTypeDefinition) |
| { |
| theMemberTypeDefinitions.set(newMemberTypeDefinition); |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| XSDSchema xsdSchema = getSchema(); |
| if (xsdSchema != null) |
| { |
| List<XSDSimpleFinal> newFinal = new ArrayList<XSDSimpleFinal>(); |
| if (!isSetLexicalFinal()) |
| { |
| for (XSDProhibitedSubstitutions value : xsdSchema.getFinalDefault()) |
| { |
| switch (value.getValue()) |
| { |
| case XSDProhibitedSubstitutions.ALL: |
| { |
| newFinal.add(XSDSimpleFinal.RESTRICTION_LITERAL); |
| newFinal.add(XSDSimpleFinal.LIST_LITERAL); |
| newFinal.add(XSDSimpleFinal.UNION_LITERAL); |
| break; |
| } |
| case XSDProhibitedSubstitutions.RESTRICTION: |
| { |
| newFinal.add(XSDSimpleFinal.RESTRICTION_LITERAL); |
| break; |
| } |
| } |
| } |
| } |
| else |
| { |
| for (XSDSimpleFinal value : getLexicalFinal()) |
| { |
| switch (value.getValue()) |
| { |
| case XSDSimpleFinal.ALL: |
| { |
| newFinal.add(XSDSimpleFinal.RESTRICTION_LITERAL); |
| newFinal.add(XSDSimpleFinal.LIST_LITERAL); |
| newFinal.add(XSDSimpleFinal.UNION_LITERAL); |
| break; |
| } |
| default: |
| { |
| newFinal.add(value); |
| break; |
| } |
| } |
| } |
| } |
| |
| Collection<XSDSimpleFinal> oldFinal = new ArrayList<XSDSimpleFinal>(getFinal()); |
| oldFinal.removeAll(newFinal); |
| if (!oldFinal.isEmpty()) |
| { |
| getFinal().removeAll(oldFinal); |
| } |
| setListContentAndOrder(getFinal(), newFinal); |
| } |
| } |
| |
| @Override |
| protected void traverseToRootForAnalysis() |
| { |
| analysisState = UNANALYZED; |
| super.traverseToRootForAnalysis(); |
| } |
| |
| protected XSDWhiteSpaceFacet effectiveWhiteSpaceFacet; |
| @Override |
| protected void handleAnalysis() |
| { |
| XSDSimpleTypeDefinition theBaseTypeDefinition = getBaseTypeDefinition(); |
| |
| XSDConcreteComponent container = getContainer(); |
| if (container instanceof XSDComplexTypeDefinition) |
| { |
| if (!getContents().contains(theBaseTypeDefinition)) |
| { |
| XSDComplexTypeDefinition xsdComplexTypeDefinition = (XSDComplexTypeDefinitionImpl)container; |
| XSDTypeDefinition complexBaseTypeDefinition = xsdComplexTypeDefinition.getBaseTypeDefinition(); |
| if (complexBaseTypeDefinition != null) |
| { |
| ((XSDConcreteComponentImpl)complexBaseTypeDefinition).analyze(); |
| theBaseTypeDefinition = handleNewBaseTypeDefinition(complexBaseTypeDefinition.getSimpleType()); |
| } |
| } |
| } |
| |
| if (getFundamentalFacets().isEmpty()) |
| { |
| createFundamentalFacets(); |
| } |
| |
| List<XSDConstrainingFacet> newFacets = null; |
| boolean newBounded = false; |
| XSDCardinality newCardinality = XSDCardinality.FINITE_LITERAL; |
| boolean newNumeric = false; |
| XSDOrdered newOrdered = XSDOrdered.FALSE_LITERAL; |
| XSDSimpleTypeDefinition newPrimitiveTypeDefinition = null; |
| XSDVariety newVariety = null; |
| EList<String> newValidFacets = null; |
| |
| if (theBaseTypeDefinition != null && theBaseTypeDefinition.getContainer() != null) |
| { |
| if (!((XSDConcreteComponentImpl)theBaseTypeDefinition).analyze() && !XSDConstants.isURType(theBaseTypeDefinition) && theBaseTypeDefinition.isCircular()) |
| { |
| analysisState = CIRCULAR; |
| } |
| if (theBaseTypeDefinition != this) |
| { |
| if (!XSDConstants.isURType(this)) |
| { |
| newVariety = XSDVariety.ATOMIC_LITERAL; |
| newPrimitiveTypeDefinition = this; |
| } |
| |
| if (!XSDConstants.isURType(theBaseTypeDefinition)) |
| { |
| newVariety = theBaseTypeDefinition.getVariety(); |
| newPrimitiveTypeDefinition = theBaseTypeDefinition.getPrimitiveTypeDefinition(); |
| newBounded = theBaseTypeDefinition.getBoundedFacet().isValue(); |
| newCardinality = theBaseTypeDefinition.getCardinalityFacet().getValue(); |
| newNumeric = theBaseTypeDefinition.getNumericFacet().isValue(); |
| newOrdered = theBaseTypeDefinition.getOrderedFacet().getValue(); |
| newValidFacets = theBaseTypeDefinition.getValidFacets(); |
| |
| if (XSDVariety.LIST_LITERAL == theBaseTypeDefinition.getVariety()) |
| { |
| XSDSimpleTypeDefinition newItemTypeDefinition = theBaseTypeDefinition.getItemTypeDefinition(); |
| if (newItemTypeDefinition != getItemTypeDefinition()) |
| { |
| setItemTypeDefinition(newItemTypeDefinition); |
| } |
| } |
| else if (XSDVariety.UNION_LITERAL == theBaseTypeDefinition.getVariety()) |
| { |
| List<XSDSimpleTypeDefinition> newMemberTypeDefinitions = theBaseTypeDefinition.getMemberTypeDefinitions(); |
| List<XSDSimpleTypeDefinition> remainingMemberTypeDefinitions = new ArrayList<XSDSimpleTypeDefinition>(getMemberTypeDefinitions()); |
| remainingMemberTypeDefinitions.removeAll(newMemberTypeDefinitions); |
| if (!remainingMemberTypeDefinitions.isEmpty()) |
| { |
| getMemberTypeDefinitions().removeAll(remainingMemberTypeDefinitions); |
| } |
| if (!newMemberTypeDefinitions.isEmpty()) |
| { |
| setListContentAndOrder(getMemberTypeDefinitions(), newMemberTypeDefinitions); |
| } |
| } |
| } |
| else |
| { |
| newFacets = new ArrayList<XSDConstrainingFacet>(getFacetContents()); |
| } |
| } |
| else |
| { |
| newFacets = new ArrayList<XSDConstrainingFacet>(getFacetContents()); |
| } |
| } |
| else |
| { |
| newFacets = new ArrayList<XSDConstrainingFacet>(getFacetContents()); |
| } |
| |
| if (theBaseTypeDefinition == null || XSDConstants.isURType(theBaseTypeDefinition)) |
| { |
| XSDSimpleTypeDefinition theItemTypeDefinition = getItemTypeDefinition(); |
| if (theItemTypeDefinition != null && theItemTypeDefinition.getContainer() != null) |
| { |
| newVariety = XSDVariety.LIST_LITERAL; |
| newPrimitiveTypeDefinition = null; |
| if (!((XSDConcreteComponentImpl)theItemTypeDefinition).analyze() && !XSDConstants.isURType(theItemTypeDefinition) && theItemTypeDefinition.isCircular()) |
| { |
| analysisState = CIRCULAR; |
| } |
| newValidFacets = getValidFacetsForList(); |
| if (effectiveWhiteSpaceFacet == null) |
| { |
| effectiveWhiteSpaceFacet = getXSDFactory().createXSDWhiteSpaceFacet(); |
| effectiveWhiteSpaceFacet.setLexicalValue("collapse"); |
| effectiveWhiteSpaceFacet.setFixed(true); |
| getSyntheticFacets().add(effectiveWhiteSpaceFacet); |
| } |
| if (newFacets != null) |
| { |
| newFacets.add(effectiveWhiteSpaceFacet); |
| } |
| } |
| else if (!getMemberTypeDefinitions().isEmpty()) |
| { |
| newVariety = XSDVariety.UNION_LITERAL; |
| newPrimitiveTypeDefinition = null; |
| newNumeric = true; |
| for (XSDSimpleTypeDefinition theMemberTypeDefinition : getMemberTypeDefinitions()) |
| { |
| if (theMemberTypeDefinition.getContainer() != null) |
| { |
| if (!((XSDConcreteComponentImpl)theMemberTypeDefinition).analyze() && !XSDConstants.isURType(theMemberTypeDefinition) && theMemberTypeDefinition.isCircular()) |
| { |
| analysisState = CIRCULAR; |
| } |
| if (!theMemberTypeDefinition.getNumericFacet().isValue()) |
| { |
| newNumeric = false; |
| } |
| } |
| } |
| |
| XSDTypeDefinition lowestCommonAncestor = getLowestCommonAncestor(getMemberTypeDefinitions()); |
| if (lowestCommonAncestor instanceof XSDSimpleTypeDefinition && lowestCommonAncestor.getContainer() != null) |
| { |
| newOrdered = ((XSDSimpleTypeDefinition)lowestCommonAncestor).getOrderedFacet().getValue(); |
| } |
| newValidFacets = getValidFacetsForUnion(); |
| } |
| else if (getElement() != null) |
| { |
| LOOP: |
| for (Node child = getElement().getFirstChild(); child != null; child = child.getNextSibling()) |
| { |
| switch (XSDConstants.nodeType(child)) |
| { |
| case XSDConstants.UNION_ELEMENT: |
| { |
| newVariety = XSDVariety.UNION_LITERAL; |
| newPrimitiveTypeDefinition = null; |
| newValidFacets = getValidFacetsForUnion(); |
| break LOOP; |
| } |
| case XSDConstants.LIST_ELEMENT: |
| { |
| newVariety = XSDVariety.LIST_LITERAL; |
| newPrimitiveTypeDefinition = null; |
| newValidFacets = getValidFacetsForList(); |
| break LOOP; |
| } |
| } |
| } |
| } |
| } |
| |
| if (newVariety != null) |
| { |
| if (!isSetVariety() || newVariety != getVariety()) |
| { |
| setVariety(newVariety); |
| } |
| } |
| else if (isSetVariety()) |
| { |
| unsetVariety(); |
| } |
| |
| if (newPrimitiveTypeDefinition != getPrimitiveTypeDefinition()) |
| { |
| setPrimitiveTypeDefinition(newPrimitiveTypeDefinition); |
| } |
| |
| // This ensures the the facets are analyzed when the containing type is relatively well-analyzed. |
| // |
| super.handleAnalysis(); |
| |
| if (newFacets == null) |
| { |
| newFacets = mergeFacets(); |
| } |
| |
| XSDAnnotation theAnnotation = getAnnotation(); |
| if (theAnnotation != null) |
| { |
| for (Element applicationInformationElement : theAnnotation.getApplicationInformation()) |
| { |
| for (Node child = applicationInformationElement.getFirstChild(); child != null; child = child.getNextSibling()) |
| { |
| switch (XSDConstants.hfpNodeType(child)) |
| { |
| case XSDConstants.HFP_HASFACET_ELEMENT: |
| { |
| Element childElement = (Element)child; |
| String facetName = childElement.getAttributeNS(null, XSDConstants.HFP_NAME_ATTRIBUTE); |
| if (newValidFacets == null) |
| { |
| newValidFacets = new BasicEList<String>(); |
| } |
| newValidFacets.add(facetName); |
| break; |
| } |
| case XSDConstants.HFP_HASPROPERTY_ELEMENT: |
| { |
| Element childElement = (Element)child; |
| String propertyName = childElement.getAttributeNS(null, XSDConstants.HFP_NAME_ATTRIBUTE); |
| String propertyValue = childElement.getAttributeNS(null, XSDConstants.HFP_VALUE_ATTRIBUTE); |
| if ("bounded".equals(propertyName)) |
| { |
| newBounded = "true".equals(propertyValue); |
| } |
| else if ("cardinality".equals(propertyName)) |
| { |
| newCardinality = |
| "countably infinite".equals(propertyValue) ? |
| XSDCardinality.COUNTABLY_INFINITE_LITERAL : |
| XSDCardinality.get(propertyValue); |
| } |
| else if ("numeric".equals(propertyName)) |
| { |
| newNumeric = "true".equals(propertyValue); |
| } |
| else if ("ordered".equals(propertyName)) |
| { |
| newOrdered = XSDOrdered.get(propertyValue); |
| } |
| break; |
| } |
| } |
| } |
| } |
| } |
| |
| |
| if (!XSDConstants.isURType(this)) |
| { |
| if (newBounded != getBoundedFacet().isValue() /* || !getBoundedFacet().isSetValue()*/) |
| { |
| getBoundedFacet().setValue(newBounded); |
| } |
| if (newCardinality != getCardinalityFacet().getValue() /* || !getCardinalityFacet().isSetValue()*/) |
| { |
| getCardinalityFacet().setValue(newCardinality); |
| } |
| if (newNumeric != getNumericFacet().isValue() /* || !getNumericFacet().isSetValue()*/) |
| { |
| getNumericFacet().setValue(newNumeric); |
| } |
| if (newOrdered == null) |
| { |
| newOrdered = XSDOrdered.FALSE_LITERAL; |
| } |
| if (newOrdered != getOrderedFacet().getValue() /* || !getOrderedFacet().isSetValue()*/) |
| { |
| getOrderedFacet().setValue(newOrdered); |
| } |
| } |
| |
| if (newFacets == null) |
| { |
| if (!getFacets().isEmpty()) |
| { |
| getFacets().clear(); |
| } |
| } |
| else |
| { |
| List<XSDFacet> remainingFacets = new ArrayList<XSDFacet>(getFacets()); |
| remainingFacets.removeAll(newFacets); |
| getFacets().removeAll(remainingFacets); |
| if (!newFacets.isEmpty()) |
| { |
| setListContentAndOrder(getFacets(), newFacets); |
| } |
| } |
| |
| if (newValidFacets == null) |
| { |
| if (!getValidFacets().isEmpty()) |
| { |
| getValidFacets().clear(); |
| } |
| } |
| else |
| { |
| List<String> remainingValidFacets = new ArrayList<String>(getValidFacets()); |
| remainingValidFacets.removeAll(newValidFacets); |
| getValidFacets().removeAll(remainingValidFacets); |
| if (!newValidFacets.isEmpty()) |
| { |
| setListContentAndOrder(getValidFacets(), newValidFacets); |
| } |
| } |
| } |
| |
| @Override |
| public void validate() |
| { |
| super.validate(); |
| |
| Element theElement = getElement(); |
| Element theRestrictionElement = null; |
| if (theElement != null) |
| { |
| String anchor; |
| if (getContainer() instanceof XSDComplexTypeDefinition) |
| { |
| checkAttributes |
| (XSDConstants.PART2, |
| anchor = "element-simpleContent", |
| theElement, |
| new String [] |
| { |
| XSDConstants.ID_ATTRIBUTE |
| }); |
| |
| XSDComplexTypeDefinition xsdComplexTypeDefinition = |
| (XSDComplexTypeDefinition)getSchema().getSchemaForSchema().resolveElementDeclaration("simpleContent").getTypeDefinition(); |
| |
| checkComplexContent(xsdComplexTypeDefinition, XSDConstants.PART2, "element-simpleContent", theElement); |
| for (Node child = theElement.getFirstChild(); child != null; child = child.getNextSibling()) |
| { |
| switch (XSDConstants.nodeType(child)) |
| { |
| case XSDConstants.RESTRICTION_ELEMENT: |
| { |
| Element childElement = (Element)child; |
| theRestrictionElement = childElement; |
| |
| checkAttributes |
| (XSDConstants.PART2, |
| "element-simpleContent::restriction", |
| childElement, |
| new String [] |
| { |
| XSDConstants.ID_ATTRIBUTE, |
| XSDConstants.BASE_ATTRIBUTE |
| }); |
| |
| checkBuiltInTypeConstraint |
| ("ID", |
| null, |
| XSDConstants.PART2, |
| "element-simpleContent::restriction", |
| childElement, |
| XSDConstants.ID_ATTRIBUTE, |
| false); |
| |
| checkComplexContent("simpleRestrictionType", XSDConstants.PART2, "element-simpleContent::restriction", childElement); |
| |
| // This is allowed https://bugs.eclipse.org/bugs/show_bug.cgi?id=177035 |
| // |
| // if (childElement.hasAttributeNS(null, XSDConstants.BASE_ATTRIBUTE) && !getContents().isEmpty()) |
| // { |
| // createDiagnostic(XSDDiagnosticSeverity.ERROR_LITERAL, "src-restriction-base-or-simpleType"); |
| // } |
| |
| break; |
| } |
| case XSDConstants.EXTENSION_ELEMENT: |
| { |
| Element childElement = (Element)child; |
| |
| checkAttributes |
| (XSDConstants.PART2, |
| "element-simpleContent::extension", |
| childElement, |
| new String [] |
| { |
| XSDConstants.ID_ATTRIBUTE, |
| XSDConstants.BASE_ATTRIBUTE |
| }); |
| |
| checkBuiltInTypeConstraint |
| ("ID", |
| null, |
| XSDConstants.PART2, |
| "element-simpleContent::extension", |
| childElement, |
| XSDConstants.ID_ATTRIBUTE, |
| false); |
| |
| checkComplexContent("simpleExtensionType", XSDConstants.PART2, "element-simpleContent::extension", childElement); |
| |
| if (childElement.hasAttributeNS(null, XSDConstants.BASE_ATTRIBUTE) && !getContents().isEmpty()) |
| { |
| createDiagnostic(XSDDiagnosticSeverity.ERROR_LITERAL, "src-restriction-base-or-simpleType"); |
| } |
| |
| break; |
| } |
| } |
| } |
| } |
| else |
| { |
| if (getContainer() instanceof XSDFeature || getContainer() instanceof XSDSimpleTypeDefinition) |
| { |
| checkAttributes |
| (XSDConstants.PART2, |
| anchor = "element-simpleType", |
| theElement, |
| new String [] |
| { |
| XSDConstants.ID_ATTRIBUTE, |
| }); |
| } |
| else |
| { |
| checkAttributes |
| (XSDConstants.PART2, |
| anchor = "element-simpleType", |
| theElement, |
| new String [] |
| { |
| XSDConstants.FINAL_ATTRIBUTE, |
| XSDConstants.ID_ATTRIBUTE, |
| XSDConstants.NAME_ATTRIBUTE |
| }); |
| |
| // EATM this is an error in the spec, I believe. |
| // |
| if (theElement.hasAttributeNS(null, XSDConstants.FINAL_ATTRIBUTE)) |
| { |
| String value = theElement.getAttributeNS(null, XSDConstants.FINAL_ATTRIBUTE); |
| for (StringTokenizer values = new StringTokenizer(value, " "); values.hasMoreTokens(); ) |
| { |
| String token = values.nextToken(); |
| |
| checkBuiltInTypeConstraint |
| ("simpleDerivationSet", |
| token, |
| XSDConstants.PART2, |
| anchor, |
| theElement, |
| XSDConstants.FINAL_ATTRIBUTE, |
| false); |
| } |
| } |
| } |
| |
| checkComplexContent("simpleType", XSDConstants.PART2, "element-simpleType", theElement); |
| |
| for (Node child = theElement.getFirstChild(); child != null; child = child.getNextSibling()) |
| { |
| switch (XSDConstants.nodeType(child)) |
| { |
| case XSDConstants.RESTRICTION_ELEMENT: |
| { |
| Element childElement = (Element)child; |
| theRestrictionElement = childElement; |
| |
| checkAttributes |
| (XSDConstants.PART2, |
| "element-restriction", |
| childElement, |
| new String [] |
| { |
| XSDConstants.ID_ATTRIBUTE, |
| XSDConstants.BASE_ATTRIBUTE |
| }); |
| |
| checkBuiltInTypeConstraint |
| ("ID", |
| null, |
| XSDConstants.PART2, |
| "element-restriction", |
| childElement, |
| XSDConstants.ID_ATTRIBUTE, |
| false); |
| |
| XSDComplexTypeDefinition xsdComplexTypeDefinition = |
| (XSDComplexTypeDefinition)getSchema().getSchemaForSchema().resolveElementDeclaration("restriction").getTypeDefinition(); |
| |
| checkComplexContent(xsdComplexTypeDefinition, XSDConstants.PART2, "element-restriction", childElement); |
| |
| if (childElement.hasAttributeNS(null, XSDConstants.BASE_ATTRIBUTE)) |
| { |
| if (!getContents().isEmpty()) |
| { |
| createDiagnostic(XSDDiagnosticSeverity.ERROR_LITERAL, "src-restriction-base-or-simpleType"); |
| } |
| } |
| else if (getContents().isEmpty()) |
| { |
| createDiagnostic(XSDDiagnosticSeverity.ERROR_LITERAL, "src-restriction-base-or-simpleType.0"); |
| } |
| |
| break; |
| } |
| case XSDConstants.UNION_ELEMENT: |
| { |
| Element childElement = (Element)child; |
| |
| checkAttributes |
| (XSDConstants.PART2, |
| "element-union", |
| childElement, |
| new String [] |
| { |
| XSDConstants.ID_ATTRIBUTE, |
| XSDConstants.MEMBERTYPES_ATTRIBUTE |
| }); |
| |
| checkBuiltInTypeConstraint |
| ("ID", |
| null, |
| XSDConstants.PART2, |
| "element-union", |
| childElement, |
| XSDConstants.ID_ATTRIBUTE, |
| false); |
| |
| XSDComplexTypeDefinition xsdComplexTypeDefinition = |
| (XSDComplexTypeDefinition)getSchema().getSchemaForSchema().resolveElementDeclaration("union").getTypeDefinition(); |
| |
| checkComplexContent(xsdComplexTypeDefinition, XSDConstants.PART2, "element-union", childElement); |
| |
| if (getMemberTypeDefinitions().isEmpty()) |
| { |
| createDiagnostic(XSDDiagnosticSeverity.ERROR_LITERAL, "src-union-memberTypes-or-simpleTypes"); |
| } |
| |
| break; |
| } |
| case XSDConstants.LIST_ELEMENT: |
| { |
| Element childElement = (Element)child; |
| |
| checkAttributes |
| (XSDConstants.PART2, |
| "element-list", |
| childElement, |
| new String [] |
| { |
| XSDConstants.ID_ATTRIBUTE, |
| XSDConstants.ITEMTYPE_ATTRIBUTE |
| }); |
| |
| checkBuiltInTypeConstraint |
| ("ID", |
| null, |
| XSDConstants.PART2, |
| "element-list", |
| childElement, |
| XSDConstants.ID_ATTRIBUTE, |
| false); |
| |
| XSDComplexTypeDefinition xsdComplexTypeDefinition = |
| (XSDComplexTypeDefinition)getSchema().getSchemaForSchema().resolveElementDeclaration("list").getTypeDefinition(); |
| |
| checkComplexContent(xsdComplexTypeDefinition, XSDConstants.PART2, "element-list", childElement); |
| |
| if (childElement.hasAttributeNS(null, XSDConstants.ITEMTYPE_ATTRIBUTE)) |
| { |
| if (!getContents().isEmpty()) |
| { |
| createDiagnostic(XSDDiagnosticSeverity.ERROR_LITERAL, "src-list-itemType-or-simpleType"); |
| } |
| } |
| else |
| { |
| if (getContents().isEmpty()) |
| { |
| createDiagnostic(XSDDiagnosticSeverity.ERROR_LITERAL, "src-list-itemType-or-simpleType.0"); |
| } |
| } |
| |
| break; |
| } |
| } |
| } |
| } |
| |
| checkBuiltInTypeConstraint |
| ("ID", |
| null, |
| XSDConstants.PART2, |
| anchor, |
| theElement, |
| XSDConstants.ID_ATTRIBUTE, |
| false); |
| } |
| |
| if (!(getContainer() instanceof XSDFeature) && !(getContainer() instanceof XSDTypeDefinition)) |
| { |
| checkBuiltInTypeConstraint |
| ("NCName", |
| getName(), |
| XSDConstants.PART2, |
| "element-simpleType", |
| theElement, |
| XSDConstants.NAME_ATTRIBUTE, |
| true); |
| } |
| |
| XSDSimpleTypeDefinition theBaseTypeDefinition = getBaseTypeDefinition(); |
| if (theBaseTypeDefinition == null) |
| { |
| createDiagnostic(XSDDiagnosticSeverity.ERROR_LITERAL, "_UI_UnresolvedTypeDefinition_message", ""); |
| } |
| else if (theBaseTypeDefinition.getContainer() == null) |
| { |
| createDiagnostic(XSDDiagnosticSeverity.ERROR_LITERAL, "_UI_UnresolvedTypeDefinition_message", theBaseTypeDefinition.getURI()); |
| } |
| else if (isSetVariety()) |
| { |
| switch (getVariety().getValue()) |
| { |
| case XSDVariety.ATOMIC: |
| { |
| if (theBaseTypeDefinition.getFinal().contains(XSDSimpleFinal.RESTRICTION_LITERAL)) |
| { |
| createDiagnostic(XSDDiagnosticSeverity.ERROR_LITERAL, "cos-st-restricts.1.2", theBaseTypeDefinition.getURI()); |
| } |
| if (isCircular()) |
| { |
| reportConstraintViolation |
| (XSDConstants.PART2, |
| "st-props-correct.2", |
| getElement(), |
| XSDConstants.BASE_ATTRIBUTE, |
| new Object [] {}); |
| } |
| if (!XSDConstants.isSchemaForSchemaNamespace(getTargetNamespace()) && |
| XSDConstants.isAnySimpleType(theBaseTypeDefinition) && |
| (theElement == null || |
| theRestrictionElement != null && theRestrictionElement.hasAttributeNS(null, XSDConstants.BASE_ATTRIBUTE))) |
| { |
| createDiagnostic(XSDDiagnosticSeverity.ERROR_LITERAL, "cos-st-retricts.0.0", theBaseTypeDefinition.getURI()); |
| } |
| break; |
| } |
| case XSDVariety.LIST: |
| { |
| if (!XSDConstants.isURType(theBaseTypeDefinition)) |
| { |
| if (theBaseTypeDefinition.getFinal().contains(XSDSimpleFinal.RESTRICTION_LITERAL)) |
| { |
| createDiagnostic(XSDDiagnosticSeverity.ERROR_LITERAL, "cos-st-restricts.1.2", theBaseTypeDefinition.getURI()); |
| } |
| } |
| else |
| { |
| XSDSimpleTypeDefinition theItemTypeDefinition = getItemTypeDefinition(); |
| if (theItemTypeDefinition == null) |
| { |
| createDiagnostic(XSDDiagnosticSeverity.ERROR_LITERAL, "_UI_UnresolvedTypeDefinition_message", ""); |
| } |
| else if (theItemTypeDefinition.getContainer() == null) |
| { |
| createDiagnostic |
| (XSDDiagnosticSeverity.ERROR_LITERAL, "_UI_UnresolvedTypeDefinition_message", theItemTypeDefinition.getURI()); |
| } |
| else if (XSDVariety.ATOMIC_LITERAL != theItemTypeDefinition.getVariety() && |
| XSDVariety.UNION_LITERAL != theItemTypeDefinition.getVariety()) |
| { |
| reportConstraintViolation |
| (XSDConstants.PART2, |
| "cos-list-of-atomic", |
| getElement(), |
| XSDConstants.ITEMTYPE_ATTRIBUTE, |
| new Object [] {}); |
| } |
| else if (theItemTypeDefinition.getFinal().contains(XSDSimpleFinal.LIST_LITERAL)) |
| { |
| createDiagnostic(XSDDiagnosticSeverity.ERROR_LITERAL, "cos-st-restricts.2.0", theBaseTypeDefinition.getURI()); |
| } |
| else if (!XSDConstants.isSchemaForSchemaNamespace(getTargetNamespace()) && |
| XSDConstants.isAnySimpleType(theItemTypeDefinition)) |
| { |
| createDiagnostic(XSDDiagnosticSeverity.ERROR_LITERAL, "cos-st-retricts.0.1", theItemTypeDefinition.getURI()); |
| } |
| } |
| if (isCircular()) |
| { |
| reportConstraintViolation |
| (XSDConstants.PART2, |
| "st-props-correct.2", |
| getElement(), |
| XSDConstants.ITEMTYPE_ATTRIBUTE, |
| new Object [] {}); |
| } |
| break; |
| } |
| case XSDVariety.UNION: |
| { |
| if (!XSDConstants.isURType(theBaseTypeDefinition)) |
| { |
| if (theBaseTypeDefinition.getFinal().contains(XSDSimpleFinal.RESTRICTION_LITERAL)) |
| { |
| createDiagnostic(XSDDiagnosticSeverity.ERROR_LITERAL, "cos-st-restricts.1.2", theBaseTypeDefinition.getURI()); |
| } |
| } |
| else |
| { |
| for (XSDSimpleTypeDefinition theMemberTypeDefinition : getMemberTypeDefinitions()) |
| { |
| if (theMemberTypeDefinition == null) |
| { |
| createDiagnostic(XSDDiagnosticSeverity.ERROR_LITERAL, "_UI_UnresolvedTypeDefinition_message", ""); |
| } |
| else if (theMemberTypeDefinition.getContainer() == null) |
| { |
| createDiagnostic |
| (XSDDiagnosticSeverity.ERROR_LITERAL, "_UI_UnresolvedTypeDefinition_message", theMemberTypeDefinition.getURI()); |
| } |
| else if (theMemberTypeDefinition.getFinal().contains(XSDSimpleFinal.UNION_LITERAL)) |
| { |
| createDiagnostic(XSDDiagnosticSeverity.ERROR_LITERAL, "cos-st-restricts.3.0", theBaseTypeDefinition.getURI()); |
| } |
| // Apparently this is allowed now. |
| // else if (!XSDConstants.isSchemaForSchemaNamespace(getTargetNamespace()) && |
| // XSDConstants.isAnySimpleType(theMemberTypeDefinition)) |
| // { |
| // createDiagnostic(XSDDiagnosticSeverity.ERROR_LITERAL, "cos-st-retricts.0.2", theMemberTypeDefinition.getURI()); |
| // } |
| } |
| } |
| if (isCircular()) |
| { |
| reportConstraintViolation |
| (XSDConstants.PART2, |
| "cos-no-circular-unions", |
| getElement(), |
| XSDConstants.MEMBERTYPES_ATTRIBUTE, |
| new Object [] {}); |
| } |
| break; |
| } |
| } |
| } |
| else if (isCircular()) |
| { |
| reportConstraintViolation |
| (XSDConstants.PART2, |
| "st-props-correct.2", |
| getElement(), |
| XSDConstants.BASE_ATTRIBUTE, |
| new Object [] {}); |
| } |
| } |
| |
| @Override |
| protected void reconcileAttributes(Element changedElement) |
| { |
| switch (XSDConstants.nodeType(changedElement)) |
| { |
| case XSDConstants.EXTENSION_ELEMENT: |
| case XSDConstants.RESTRICTION_ELEMENT: |
| { |
| if (!(getContainer() instanceof XSDComplexTypeDefinition)) |
| { |
| XSDSimpleTypeDefinition newBaseTypeDefinition = null; |
| if (changedElement.hasAttributeNS(null, XSDConstants.BASE_ATTRIBUTE)) |
| { |
| newBaseTypeDefinition = |
| resolveSimpleTypeDefinitionURI(XSDConstants.lookupQNameForAttribute(changedElement, XSDConstants.BASE_ATTRIBUTE)); |
| } |
| else if (getContents().contains(getBaseTypeDefinition())) |
| { |
| newBaseTypeDefinition = getBaseTypeDefinition(); |
| } |
| |
| handleNewBaseTypeDefinition(newBaseTypeDefinition); |
| } |
| else |
| { |
| XSDTypeDefinition newBaseTypeDefinition = null; |
| if (changedElement.hasAttributeNS(null, XSDConstants.BASE_ATTRIBUTE)) |
| { |
| newBaseTypeDefinition = |
| resolveTypeDefinitionURI(XSDConstants.lookupQNameForAttribute(changedElement, XSDConstants.BASE_ATTRIBUTE)); |
| } |
| else if (getContents().contains(getBaseTypeDefinition())) |
| { |
| newBaseTypeDefinition = getBaseTypeDefinition(); |
| } |
| |
| handleNewComplexBaseTypeDefinition(newBaseTypeDefinition); |
| } |
| |
| break; |
| } |
| case XSDConstants.LIST_ELEMENT: |
| { |
| XSDSimpleTypeDefinition newItemTypeDefinition = getItemTypeDefinition(); |
| if (changedElement.hasAttributeNS(null, XSDConstants.ITEMTYPE_ATTRIBUTE)) |
| { |
| newItemTypeDefinition = |
| resolveSimpleTypeDefinitionURI(XSDConstants.lookupQNameForAttribute(changedElement, XSDConstants.ITEMTYPE_ATTRIBUTE)); |
| } |
| else if (!getContents().contains(newItemTypeDefinition)) |
| { |
| newItemTypeDefinition = resolveSimpleTypeDefinition(null, "undefined"); |
| } |
| |
| if (newItemTypeDefinition != getItemTypeDefinition()) |
| { |
| setItemTypeDefinition(newItemTypeDefinition); |
| } |
| |
| handleNewBaseTypeDefinition(null); |
| break; |
| } |
| case XSDConstants.UNION_ELEMENT: |
| { |
| List<XSDSimpleTypeDefinition> newMemberTypeDefinitions = new ArrayList<XSDSimpleTypeDefinition>(); |
| if (changedElement.hasAttributeNS(null, XSDConstants.MEMBERTYPES_ATTRIBUTE)) |
| { |
| String memberTypes = changedElement.getAttributeNS(null, XSDConstants.MEMBERTYPES_ATTRIBUTE); |
| if (memberTypes != null) |
| { |
| for (StringTokenizer tokens = new StringTokenizer(memberTypes, " "); tokens.hasMoreTokens(); ) |
| { |
| String memberTypeQName = tokens.nextToken(); |
| XSDSimpleTypeDefinition newMemberTypeDefinition = |
| resolveSimpleTypeDefinitionURI(XSDConstants.lookupQName(changedElement, memberTypeQName)); |
| newMemberTypeDefinitions.add(newMemberTypeDefinition); |
| } |
| } |
| } |
| |
| newMemberTypeDefinitions.addAll(getContents()); |
| |
| List<XSDSimpleTypeDefinition> remainingMemberTypeDefinitions = new ArrayList<XSDSimpleTypeDefinition>(getMemberTypeDefinitions()); |
| remainingMemberTypeDefinitions.removeAll(newMemberTypeDefinitions); |
| getMemberTypeDefinitions().removeAll(remainingMemberTypeDefinitions); |
| if (!newMemberTypeDefinitions.isEmpty()) |
| { |
| setListContentAndOrder(getMemberTypeDefinitions(), newMemberTypeDefinitions); |
| } |
| |
| handleNewBaseTypeDefinition(null); |
| break; |
| } |
| case XSDConstants.SIMPLETYPE_ELEMENT: |
| case XSDConstants.SIMPLECONTENT_ELEMENT: |
| { |
| super.reconcileAttributes(changedElement); |
| |
| if (changedElement.hasAttributeNS(null, XSDConstants.FINAL_ATTRIBUTE)) |
| { |
| setStringLexicalFinal(changedElement.getAttributeNS(null, XSDConstants.FINAL_ATTRIBUTE)); |
| } |
| else if (isSetLexicalFinal()) |
| { |
| unsetLexicalFinal(); |
| } |
| |
| for (Node child = changedElement.getFirstChild(); child != null; child = child.getNextSibling()) |
| { |
| if (child.getNodeType() == Node.ELEMENT_NODE) |
| { |
| reconcileAttributes((Element)child); |
| } |
| } |
| break; |
| } |
| } |
| } |
| |
| protected void handleNewComplexBaseTypeDefinition(XSDTypeDefinition newComplexBaseTypeDefinition) |
| { |
| if (getContainer() instanceof XSDComplexTypeDefinition) |
| { |
| XSDComplexTypeDefinitionImpl xsdComplexTypeDefinition = (XSDComplexTypeDefinitionImpl)getContainer(); |
| boolean oldIsReconciling = xsdComplexTypeDefinition.isReconciling; |
| xsdComplexTypeDefinition.isReconciling = isReconciling; |
| xsdComplexTypeDefinition.handleNewBaseTypeDefinition(newComplexBaseTypeDefinition); |
| xsdComplexTypeDefinition.isReconciling = oldIsReconciling; |
| } |
| } |
| |
| protected XSDSimpleTypeDefinition handleNewBaseTypeDefinition(XSDSimpleTypeDefinition newBaseTypeDefinition) |
| { |
| if (newBaseTypeDefinition == null) |
| { |
| XSDSchema xsdSchema = getSchema(); |
| if (xsdSchema == null) |
| { |
| Element theElement = getElement(); |
| if (theElement != null) |
| { |
| newBaseTypeDefinition = |
| XSDSchemaImpl.getSchemaForSchema(theElement.getNamespaceURI()).resolveSimpleTypeDefinition("anySimpleType"); |
| } |
| else |
| { |
| newBaseTypeDefinition = this; |
| } |
| } |
| else |
| { |
| newBaseTypeDefinition = xsdSchema.getSchemaForSchema().resolveSimpleTypeDefinition("anySimpleType"); |
| } |
| } |
| |
| if (eContainer instanceof XSDRedefine) |
| { |
| XSDSchema redefinedSchema = ((XSDRedefine)eContainer).getIncorporatedSchema(); |
| if (redefinedSchema != null) |
| { |
| Map<XSDComponent, XSDComponent> redefinitionMap = ((XSDSchemaImpl)redefinedSchema).getRedefinitionMap(); |
| if (redefinitionMap.containsKey(newBaseTypeDefinition)) |
| { |
| XSDComponent replacement = redefinitionMap.get(this); |
| if (replacement != null) |
| { |
| newBaseTypeDefinition = (XSDSimpleTypeDefinition)replacement; |
| } |
| } |
| } |
| } |
| |
| if (newBaseTypeDefinition != getBaseTypeDefinition()) |
| { |
| setBaseTypeDefinition(newBaseTypeDefinition); |
| } |
| |
| return newBaseTypeDefinition; |
| } |
| |
| @Override |
| protected Node getAdoptionParentNode(EReference eReference) |
| { |
| if (eReference == XSDPackage.Literals.XSD_SIMPLE_TYPE_DEFINITION__FACET_CONTENTS || |
| eReference == XSDPackage.Literals.XSD_SIMPLE_TYPE_DEFINITION__CONTENTS || |
| eReference == XSDPackage.Literals.XSD_TYPE_DEFINITION__DERIVATION_ANNOTATION) |
| { |
| Element element = getElement(); |
| if (element == null) |
| { |
| return null; |
| } |
| else |
| { |
| for (Node child = element.getFirstChild(); child != null; child = child.getNextSibling()) |
| { |
| switch (XSDConstants.nodeType(child)) |
| { |
| case XSDConstants.EXTENSION_ELEMENT: |
| case XSDConstants.RESTRICTION_ELEMENT: |
| case XSDConstants.LIST_ELEMENT: |
| case XSDConstants.UNION_ELEMENT: |
| { |
| return child; |
| } |
| } |
| } |
| } |
| } |
| |
| return super.getAdoptionParentNode(eReference); |
| } |
| |
| @Override |
| protected Collection<Element> getContentNodes(Element changedElement) |
| { |
| Collection<Element> result = new ArrayList<Element>(); |
| for (Node child = getElement().getFirstChild(); child != null; child = child.getNextSibling()) |
| { |
| switch (XSDConstants.nodeType(child)) |
| { |
| case XSDConstants.ANNOTATION_ELEMENT: |
| { |
| result.add((Element)child); |
| break; |
| } |
| case XSDConstants.EXTENSION_ELEMENT: |
| case XSDConstants.RESTRICTION_ELEMENT: |
| case XSDConstants.LIST_ELEMENT: |
| case XSDConstants.UNION_ELEMENT: |
| { |
| for (Node grandChild = child.getFirstChild(); grandChild != null; grandChild = grandChild.getNextSibling()) |
| { |
| if (grandChild.getNodeType() == Node.ELEMENT_NODE) |
| { |
| result.add((Element)grandChild); |
| } |
| } |
| break; |
| } |
| } |
| } |
| return result; |
| } |
| |
| @Override |
| protected void handleUnreconciledElement(Element child, List<XSDConcreteComponent> newContents, List<XSDConcreteComponent> remainingContents) |
| { |
| switch (XSDConstants.nodeType(child)) |
| { |
| case XSDConstants.ANNOTATION_ELEMENT: |
| { |
| XSDAnnotation xsdAnnotation = XSDAnnotationImpl.createAnnotation(child); |
| newContents.add(xsdAnnotation); |
| break; |
| } |
| case XSDConstants.SIMPLETYPE_ELEMENT: |
| { |
| XSDSimpleTypeDefinition xsdSimpleTypeDefinition = XSDSimpleTypeDefinitionImpl.createSimpleTypeDefinition(child); |
| if (xsdSimpleTypeDefinition != null) |
| { |
| newContents.add(xsdSimpleTypeDefinition); |
| } |
| break; |
| } |
| default: |
| { |
| XSDConstrainingFacet xsdConstrainingFacet = XSDConstrainingFacetImpl.createConstrainingFacet(child); |
| if (xsdConstrainingFacet != null) |
| { |
| newContents.add(xsdConstrainingFacet); |
| } |
| } |
| } |
| } |
| |
| @Override |
| protected void handleReconciliation(List<XSDConcreteComponent> newContents, List<XSDConcreteComponent> remainingContents) |
| { |
| if (!newContents.isEmpty() && newContents.get(0).getElement().getParentNode() == getElement()) |
| { |
| handleAnnotationReconciliation(XSDPackage.Literals.XSD_TYPE_DEFINITION__ANNOTATION, newContents, remainingContents); |
| } |
| handleAnnotationReconciliation(XSDPackage.Literals.XSD_TYPE_DEFINITION__DERIVATION_ANNOTATION, newContents, remainingContents); |
| |
| XSDSimpleTypeDefinition newBaseTypeDefinition = null; |
| XSDTypeDefinition newComplexBaseTypeDefinition = null; |
| |
| boolean didContents = false; |
| Element theElement = getElement(); |
| LOOP: |
| for (Node child = theElement.getFirstChild(); child != null; child = child.getNextSibling()) |
| { |
| switch (XSDConstants.nodeType(child)) |
| { |
| case XSDConstants.LIST_ELEMENT: |
| { |
| Element elementChild = (Element)child; |
| XSDSimpleTypeDefinition newTypeContent = null; |
| XSDSimpleTypeDefinition newItemTypeDefinition = null; |
| if (!newContents.isEmpty()) |
| { |
| XSDConcreteComponent xsdConcreteComponent = newContents.get(0); |
| if (xsdConcreteComponent instanceof XSDSimpleTypeDefinition) |
| { |
| newItemTypeDefinition = (XSDSimpleTypeDefinition)xsdConcreteComponent; |
| newTypeContent = newItemTypeDefinition; |
| newContents.remove(0); |
| } |
| } |
| if (elementChild.hasAttributeNS(null, XSDConstants.ITEMTYPE_ATTRIBUTE) && newItemTypeDefinition == null) |
| { |
| newItemTypeDefinition = |
| resolveSimpleTypeDefinitionURI(XSDConstants.lookupQNameForAttribute((Element)child, XSDConstants.ITEMTYPE_ATTRIBUTE)); |
| } |
| if (newItemTypeDefinition == null) |
| { |
| newItemTypeDefinition = resolveSimpleTypeDefinition(null, "undefined"); |
| } |
| |
| getContents().removeAll(remainingContents); |
| if (newTypeContent != null) |
| { |
| getContents().add(newTypeContent); |
| } |
| |
| if (newItemTypeDefinition != getItemTypeDefinition()) |
| { |
| setItemTypeDefinition(newItemTypeDefinition); |
| } |
| |
| didContents = true; |
| break LOOP; |
| } |
| case XSDConstants.UNION_ELEMENT: |
| { |
| Element elementChild = (Element)child; |
| List<XSDSimpleTypeDefinition> newMemberTypeDefinitions = new ArrayList<XSDSimpleTypeDefinition>(); |
| if (elementChild.hasAttributeNS(null, XSDConstants.MEMBERTYPES_ATTRIBUTE)) |
| { |
| String memberTypes = elementChild.getAttributeNS(null, XSDConstants.MEMBERTYPES_ATTRIBUTE); |
| if (memberTypes != null) |
| { |
| for (StringTokenizer tokens = new StringTokenizer(memberTypes, " "); tokens.hasMoreTokens(); ) |
| { |
| String memberTypeQName = tokens.nextToken(); |
| XSDSimpleTypeDefinition newMemberTypeDefinition = |
| resolveSimpleTypeDefinitionURI(XSDConstants.lookupQName(elementChild, memberTypeQName)); |
| newMemberTypeDefinitions.add(newMemberTypeDefinition); |
| } |
| } |
| } |
| |
| List<XSDSimpleTypeDefinition> newTypeContents = new ArrayList<XSDSimpleTypeDefinition>(); |
| for (ListIterator<XSDConcreteComponent> i = newContents.listIterator(); i.hasNext(); ) |
| { |
| XSDConcreteComponent xsdConcreteComponent = i.next(); |
| if (xsdConcreteComponent instanceof XSDSimpleTypeDefinition) |
| { |
| XSDSimpleTypeDefinition xsdSimpleTypeDefinition = (XSDSimpleTypeDefinition)xsdConcreteComponent; |
| newTypeContents.add(xsdSimpleTypeDefinition); |
| newMemberTypeDefinitions.add(xsdSimpleTypeDefinition); |
| i.remove(); |
| } |
| else |
| { |
| break; |
| } |
| } |
| |
| getContents().removeAll(remainingContents); |
| if (!newTypeContents.isEmpty()) |
| { |
| setListContentAndOrder(getContents(), newTypeContents); |
| } |
| |
| List<XSDSimpleTypeDefinition> remainingMemberTypeDefinitions = new ArrayList<XSDSimpleTypeDefinition>(getMemberTypeDefinitions()); |
| remainingMemberTypeDefinitions.removeAll(newMemberTypeDefinitions); |
| if (!remainingMemberTypeDefinitions.isEmpty()) |
| { |
| getMemberTypeDefinitions().removeAll(remainingMemberTypeDefinitions); |
| } |
| if (!newMemberTypeDefinitions.isEmpty()) |
| { |
| setListContentAndOrder(getMemberTypeDefinitions(), newMemberTypeDefinitions); |
| } |
| |
| didContents = true; |
| break LOOP; |
| } |
| case XSDConstants.EXTENSION_ELEMENT: |
| case XSDConstants.RESTRICTION_ELEMENT: |
| { |
| Element elementChild = (Element)child; |
| if (!newContents.isEmpty()) |
| { |
| XSDConcreteComponent xsdConcreteComponent = newContents.get(0); |
| if (xsdConcreteComponent instanceof XSDSimpleTypeDefinition) |
| { |
| XSDSimpleTypeDefinition xsdSimpleTypeDefinition = (XSDSimpleTypeDefinition)xsdConcreteComponent; |
| List<XSDSimpleTypeDefinition> theContents = getContents(); |
| if (theContents.size() != 1 || theContents.get(0) != xsdConcreteComponent) |
| { |
| if (!theContents.isEmpty()) |
| { |
| remainingContents.removeAll(theContents); |
| theContents.clear(); |
| } |
| theContents.add(xsdSimpleTypeDefinition); |
| } |
| newBaseTypeDefinition = xsdSimpleTypeDefinition; |
| newContents.remove(0); |
| } |
| } |
| |
| if (!(getContainer() instanceof XSDComplexTypeDefinition)) |
| { |
| if (elementChild.hasAttributeNS(null, XSDConstants.BASE_ATTRIBUTE) && newBaseTypeDefinition == null) |
| { |
| newBaseTypeDefinition = |
| resolveSimpleTypeDefinitionURI(XSDConstants.lookupQNameForAttribute(elementChild, XSDConstants.BASE_ATTRIBUTE)); |
| } |
| } |
| else |
| { |
| if (elementChild.hasAttributeNS(null, XSDConstants.BASE_ATTRIBUTE)) |
| { |
| newComplexBaseTypeDefinition = |
| resolveTypeDefinitionURI(XSDConstants.lookupQNameForAttribute(elementChild, XSDConstants.BASE_ATTRIBUTE)); |
| } |
| } |
| |
| didContents = true; |
| break LOOP; |
| } |
| } |
| } |
| |
| if (!didContents && !getContents().isEmpty()) |
| { |
| getContents().clear(); |
| } |
| |
| if (!remainingContents.isEmpty()) |
| { |
| getFacetContents().removeAll(remainingContents); |
| } |
| |
| if (!newContents.isEmpty()) |
| { |
| for (Iterator<?> i = newContents.iterator(); i.hasNext(); ) |
| { |
| if (!(i.next() instanceof XSDFacet)) |
| { |
| i.remove(); |
| } |
| } |
| @SuppressWarnings("unchecked") List<XSDConstrainingFacet> list = (List<XSDConstrainingFacet>)(List<?>)newContents; |
| setListContentAndOrder(getFacetContents(), list); |
| } |
| |
| handleNewBaseTypeDefinition(newBaseTypeDefinition); |
| handleNewComplexBaseTypeDefinition(newComplexBaseTypeDefinition); |
| } |
| |
| @Override |
| protected void changeAttribute(EAttribute eAttribute) |
| { |
| super.changeAttribute(eAttribute); |
| Element theElement = getElement(); |
| if (eAttribute == null || eAttribute == XSDPackage.Literals.XSD_SIMPLE_TYPE_DEFINITION__LEXICAL_FINAL) |
| { |
| if (theElement != null) |
| { |
| niceSetAttribute |
| (theElement, |
| XSDConstants.FINAL_ATTRIBUTE, |
| getStringLexicalFinal()); |
| } |
| if (eAttribute != null) |
| { |
| traverseToRootForPatching(); |
| } |
| } |
| if (eAttribute == null || eAttribute == XSDPackage.Literals.XSD_SIMPLE_TYPE_DEFINITION__VARIETY) |
| { |
| if (theElement != null && eAttribute != null) |
| { |
| if (analysisState != ANALYZING) |
| { |
| LOOP: |
| for (Node child = theElement.getFirstChild(); child != null; child = child.getNextSibling()) |
| { |
| int childNodeType = XSDConstants.nodeType(child); |
| switch (childNodeType) |
| { |
| case XSDConstants.RESTRICTION_ELEMENT: |
| case XSDConstants.EXTENSION_ELEMENT: |
| case XSDConstants.UNION_ELEMENT: |
| case XSDConstants.LIST_ELEMENT: |
| { |
| if (childNodeType != getRequiredChildElementNodeType()) |
| { |
| Element newElement = createChildElement(); |
| forceReplace(newElement, (Element)child); |
| } |
| break LOOP; |
| } |
| } |
| } |
| traverseToRootForAnalysis(); |
| } |
| } |
| } |
| } |
| |
| @Override |
| protected void changeReference(EReference eReference) |
| { |
| super.changeReference(eReference); |
| Element theElement = getElement(); |
| if (theElement != null) |
| { |
| if (eReference == null || eReference == XSDPackage.Literals.XSD_SIMPLE_TYPE_DEFINITION__BASE_TYPE_DEFINITION) |
| { |
| if (!isReconciling && eReference != null) |
| { |
| traverseToRootForPatching(); |
| } |
| |
| if (!isReconciling && !(getContainer() instanceof XSDComplexTypeDefinition)) |
| { |
| XSDSimpleTypeDefinition theBaseTypeDefinition = getBaseTypeDefinition(); |
| if (theBaseTypeDefinition != null && !getContents().contains(theBaseTypeDefinition)) |
| { |
| LOOP: |
| for (Node child = theElement.getFirstChild(); child != null; child = child.getNextSibling()) |
| { |
| switch (XSDConstants.nodeType(child)) |
| { |
| case XSDConstants.EXTENSION_ELEMENT: |
| case XSDConstants.RESTRICTION_ELEMENT: |
| { |
| niceSetAttributeURIValue((Element)child, XSDConstants.BASE_ATTRIBUTE, theBaseTypeDefinition.getURI()); |
| break LOOP; |
| } |
| } |
| } |
| } |
| } |
| } |
| if (eReference == null || eReference == XSDPackage.Literals.XSD_SIMPLE_TYPE_DEFINITION__ITEM_TYPE_DEFINITION) |
| { |
| if (!isReconciling && eReference != null) |
| { |
| traverseToRootForPatching(); |
| } |
| |
| XSDSimpleTypeDefinition theItemTypeDefinition = getItemTypeDefinition(); |
| if (!isReconciling && theItemTypeDefinition != null && !getContents().contains(theItemTypeDefinition)) |
| { |
| LOOP: |
| for (Node child = theElement.getFirstChild(); child != null; child = child.getNextSibling()) |
| { |
| switch (XSDConstants.nodeType(child)) |
| { |
| case XSDConstants.LIST_ELEMENT: |
| { |
| niceSetAttributeURIValue((Element)child, XSDConstants.ITEMTYPE_ATTRIBUTE, theItemTypeDefinition.getURI()); |
| break LOOP; |
| } |
| } |
| } |
| } |
| } |
| if (eReference == null || eReference == XSDPackage.Literals.XSD_SIMPLE_TYPE_DEFINITION__MEMBER_TYPE_DEFINITIONS) |
| { |
| if (!isReconciling && eReference != null) |
| { |
| traverseToRootForPatching(); |
| } |
| |
| if (!isReconciling) |
| { |
| LOOP: |
| for (Node child = theElement.getFirstChild(); child != null; child = child.getNextSibling()) |
| { |
| switch (XSDConstants.nodeType(child)) |
| { |
| case XSDConstants.UNION_ELEMENT: |
| { |
| StringBuffer newMemberTypeDefinitions = null; |
| for (XSDSimpleTypeDefinition theMemberTypeDefinition : getMemberTypeDefinitions()) |
| { |
| if (getContents().contains(theMemberTypeDefinition)) |
| { |
| break; |
| } |
| if (newMemberTypeDefinitions == null) |
| { |
| newMemberTypeDefinitions = new StringBuffer(); |
| } |
| else |
| { |
| newMemberTypeDefinitions.append(' '); |
| } |
| newMemberTypeDefinitions.append(theMemberTypeDefinition.getURI()); |
| } |
| |
| niceSetAttributeURIValue |
| ((Element)child, |
| XSDConstants.MEMBERTYPES_ATTRIBUTE, |
| newMemberTypeDefinitions == null ? null : newMemberTypeDefinitions.toString()); |
| break LOOP; |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| @Override |
| protected void adoptContent(EReference eReference, XSDConcreteComponent xsdConcreteComponent) |
| { |
| super.adoptContent(eReference, xsdConcreteComponent); |
| if (eReference == XSDPackage.Literals.XSD_SIMPLE_TYPE_DEFINITION__CONTENTS || |
| eReference == XSDPackage.Literals.XSD_SIMPLE_TYPE_DEFINITION__FACET_CONTENTS) |
| { |
| traverseToRootForPatching(); |
| } |
| else if (eReference == XSDPackage.Literals.XSD_TYPE_DEFINITION__ANNOTATION) |
| { |
| getAnnotations().add(0, (XSDAnnotation)xsdConcreteComponent); |
| } |
| else if (eReference == XSDPackage.Literals.XSD_TYPE_DEFINITION__DERIVATION_ANNOTATION) |
| { |
| getAnnotations().add((XSDAnnotation)xsdConcreteComponent); |
| } |
| } |
| |
| @Override |
| protected void orphanContent(EReference eReference, XSDConcreteComponent xsdConcreteComponent) |
| { |
| super.orphanContent(eReference, xsdConcreteComponent); |
| if (eReference == XSDPackage.Literals.XSD_SIMPLE_TYPE_DEFINITION__CONTENTS || |
| eReference == XSDPackage.Literals.XSD_SIMPLE_TYPE_DEFINITION__FACET_CONTENTS) |
| { |
| traverseToRootForPatching(); |
| } |
| else if (eReference == XSDPackage.Literals.XSD_TYPE_DEFINITION__ANNOTATION || |
| eReference == XSDPackage.Literals.XSD_TYPE_DEFINITION__DERIVATION_ANNOTATION) |
| { |
| getAnnotations().remove(xsdConcreteComponent); |
| } |
| } |
| |
| public XSDTotalDigitsFacet getTotalDigitsFacet() |
| { |
| if (facetContents != null) |
| { |
| Object [] facets = facetContents.data(); |
| for (int i = 0, size = facetContents.size(); i < size; ++i) |
| { |
| Object facet = facets[i]; |
| if (facet instanceof XSDTotalDigitsFacet) |
| { |
| return (XSDTotalDigitsFacet)facet; |
| } |
| } |
| } |
| return null; |
| } |
| |
| public XSDTotalDigitsFacet getEffectiveTotalDigitsFacet() |
| { |
| if (facets != null) |
| { |
| Object [] facetData = facets.data(); |
| for (int i = 0, size = facets.size(); i < size; ++i) |
| { |
| Object facet = facetData[i]; |
| if (facet instanceof XSDTotalDigitsFacet) |
| { |
| return (XSDTotalDigitsFacet)facet; |
| } |
| } |
| } |
| return null; |
| } |
| |
| public XSDFractionDigitsFacet getFractionDigitsFacet() |
| { |
| if (facetContents != null) |
| { |
| Object [] facets = facetContents.data(); |
| for (int i = 0, size = facetContents.size(); i < size; ++i) |
| { |
| Object facet = facets[i]; |
| if (facet instanceof XSDFractionDigitsFacet) |
| { |
| return (XSDFractionDigitsFacet)facet; |
| } |
| } |
| } |
| return null; |
| } |
| |
| public XSDFractionDigitsFacet getEffectiveFractionDigitsFacet() |
| { |
| if (facets != null) |
| { |
| Object [] facetData = facets.data(); |
| for (int i = 0, size = facets.size(); i < size; ++i) |
| { |
| Object facet = facetData[i]; |
| if (facet instanceof XSDFractionDigitsFacet) |
| { |
| return (XSDFractionDigitsFacet)facet; |
| } |
| } |
| } |
| return null; |
| } |
| |
| public XSDLengthFacet getLengthFacet() |
| { |
| if (facetContents != null) |
| { |
| Object [] facets = facetContents.data(); |
| for (int i = 0, size = facetContents.size(); i < size; ++i) |
| { |
| Object facet = facets[i]; |
| if (facet instanceof XSDLengthFacet) |
| { |
| return (XSDLengthFacet)facet; |
| } |
| } |
| } |
| return null; |
| } |
| |
| public XSDLengthFacet getEffectiveLengthFacet() |
| { |
| if (facets != null) |
| { |
| Object [] facetData = facets.data(); |
| for (int i = 0, size = facets.size(); i < size; ++i) |
| { |
| Object facet = facetData[i]; |
| if (facet instanceof XSDLengthFacet) |
| { |
| return (XSDLengthFacet)facet; |
| } |
| } |
| } |
| return null; |
| } |
| |
| public XSDMaxLengthFacet getMaxLengthFacet() |
| { |
| if (facetContents != null) |
| { |
| Object [] facets = facetContents.data(); |
| for (int i = 0, size = facetContents.size(); i < size; ++i) |
| { |
| Object facet = facets[i]; |
| if (facet instanceof XSDMaxLengthFacet) |
| { |
| return (XSDMaxLengthFacet)facet; |
| } |
| } |
| } |
| return null; |
| } |
| |
| public XSDMaxLengthFacet getEffectiveMaxLengthFacet() |
| { |
| if (facets != null) |
| { |
| Object [] facetData = facets.data(); |
| for (int i = 0, size = facets.size(); i < size; ++i) |
| { |
| Object facet = facetData[i]; |
| if (facet instanceof XSDMaxLengthFacet) |
| { |
| return (XSDMaxLengthFacet)facet; |
| } |
| } |
| } |
| return null; |
| } |
| |
| public XSDMinLengthFacet getMinLengthFacet() |
| { |
| if (facetContents != null) |
| { |
| Object [] facets = facetContents.data(); |
| for (int i = 0, size = facetContents.size(); i < size; ++i) |
| { |
| Object facet = facets[i]; |
| if (facet instanceof XSDMinLengthFacet) |
| { |
| return (XSDMinLengthFacet)facet; |
| } |
| } |
| } |
| return null; |
| } |
| |
| public XSDMinLengthFacet getEffectiveMinLengthFacet() |
| { |
| if (facets != null) |
| { |
| Object [] facetData = facets.data(); |
| for (int i = 0, size = facets.size(); i < size; ++i) |
| { |
| Object facet = facetData[i]; |
| if (facet instanceof XSDMinLengthFacet) |
| { |
| return (XSDMinLengthFacet)facet; |
| } |
| } |
| } |
| return null; |
| } |
| |
| public XSDMaxExclusiveFacet getMaxExclusiveFacet() |
| { |
| if (facetContents != null) |
| { |
| Object [] facets = facetContents.data(); |
| for (int i = 0, size = facetContents.size(); i < size; ++i) |
| { |
| Object facet = facets[i]; |
| if (facet instanceof XSDMaxExclusiveFacet) |
| { |
| return (XSDMaxExclusiveFacet)facet; |
| } |
| } |
| } |
| return null; |
| } |
| |
| public XSDMaxInclusiveFacet getMaxInclusiveFacet() |
| { |
| if (facetContents != null) |
| { |
| Object [] facets = facetContents.data(); |
| for (int i = 0, size = facetContents.size(); i < size; ++i) |
| { |
| Object facet = facets[i]; |
| if (facet instanceof XSDMaxInclusiveFacet) |
| { |
| return (XSDMaxInclusiveFacet)facet; |
| } |
| } |
| } |
| return null; |
| } |
| |
| public XSDMaxFacet getMaxFacet() |
| { |
| if (facetContents != null) |
| { |
| Object [] facets = facetContents.data(); |
| for (int i = 0, size = facetContents.size(); i < size; ++i) |
| { |
| Object facet = facets[i]; |
| if (facet instanceof XSDMaxFacet) |
| { |
| return (XSDMaxFacet)facet; |
| } |
| } |
| } |
| return null; |
| } |
| |
| public XSDMaxFacet getEffectiveMaxFacet() |
| { |
| if (facets != null) |
| { |
| Object [] facetData = facets.data(); |
| for (int i = 0, size = facets.size(); i < size; ++i) |
| { |
| Object facet = facetData[i]; |
| if (facet instanceof XSDMaxFacet) |
| { |
| return (XSDMaxFacet)facet; |
| } |
| } |
| } |
| return null; |
| } |
| |
| public XSDMinExclusiveFacet getMinExclusiveFacet() |
| { |
| if (facetContents != null) |
| { |
| Object [] facets = facetContents.data(); |
| for (int i = 0, size = facetContents.size(); i < size; ++i) |
| { |
| Object facet = facets[i]; |
| if (facet instanceof XSDMinExclusiveFacet) |
| { |
| return (XSDMinExclusiveFacet)facet; |
| } |
| } |
| } |
| return null; |
| } |
| |
| public XSDMinInclusiveFacet getMinInclusiveFacet() |
| { |
| if (facetContents != null) |
| { |
| Object [] facets = facetContents.data(); |
| for (int i = 0, size = facetContents.size(); i < size; ++i) |
| { |
| Object facet = facets[i]; |
| if (facet instanceof XSDMinInclusiveFacet) |
| { |
| return (XSDMinInclusiveFacet)facet; |
| } |
| } |
| } |
| return null; |
| } |
| |
| public XSDMinFacet getMinFacet() |
| { |
| if (facetContents != null) |
| { |
| Object [] facets = facetContents.data(); |
| for (int i = 0, size = facetContents.size(); i < size; ++i) |
| { |
| Object facet = facets[i]; |
| if (facet instanceof XSDMinFacet) |
| { |
| return (XSDMinFacet)facet; |
| } |
| } |
| } |
| return null; |
| } |
| |
| public XSDMinFacet getEffectiveMinFacet() |
| { |
| if (facets != null) |
| { |
| Object [] facetData = facets.data(); |
| for (int i = 0, size = facets.size(); i < size; ++i) |
| { |
| Object facet = facetData[i]; |
| if (facet instanceof XSDMinFacet) |
| { |
| return (XSDMinFacet)facet; |
| } |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public EList<XSDFacet> getSyntheticFacets() |
| { |
| if (syntheticFacets == null) |
| { |
| syntheticFacets = new EObjectContainmentEList<XSDFacet>(XSDFacet.class, this, XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__SYNTHETIC_FACETS); |
| } |
| return syntheticFacets; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| @Override |
| public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) |
| { |
| switch (featureID) |
| { |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__CONTENTS: |
| return ((InternalEList<?>)getContents()).basicRemove(otherEnd, msgs); |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__FACET_CONTENTS: |
| return ((InternalEList<?>)getFacetContents()).basicRemove(otherEnd, msgs); |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__FUNDAMENTAL_FACETS: |
| return ((InternalEList<?>)getFundamentalFacets()).basicRemove(otherEnd, msgs); |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__SYNTHETIC_FACETS: |
| return ((InternalEList<?>)getSyntheticFacets()).basicRemove(otherEnd, msgs); |
| } |
| return super.eInverseRemove(otherEnd, featureID, msgs); |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| @Override |
| public Object eGet(int featureID, boolean resolve, boolean coreType) |
| { |
| switch (featureID) |
| { |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__VARIETY: |
| return getVariety(); |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__FINAL: |
| return getFinal(); |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__LEXICAL_FINAL: |
| return getLexicalFinal(); |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__VALID_FACETS: |
| return getValidFacets(); |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__CONTENTS: |
| return getContents(); |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__FACET_CONTENTS: |
| return getFacetContents(); |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__FACETS: |
| return getFacets(); |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__MEMBER_TYPE_DEFINITIONS: |
| return getMemberTypeDefinitions(); |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__FUNDAMENTAL_FACETS: |
| return getFundamentalFacets(); |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__BASE_TYPE_DEFINITION: |
| return getBaseTypeDefinition(); |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__PRIMITIVE_TYPE_DEFINITION: |
| return getPrimitiveTypeDefinition(); |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__ITEM_TYPE_DEFINITION: |
| return getItemTypeDefinition(); |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__ROOT_TYPE_DEFINITION: |
| return getRootTypeDefinition(); |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__MIN_FACET: |
| return getMinFacet(); |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__MAX_FACET: |
| return getMaxFacet(); |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__MAX_INCLUSIVE_FACET: |
| return getMaxInclusiveFacet(); |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__MIN_INCLUSIVE_FACET: |
| return getMinInclusiveFacet(); |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__MIN_EXCLUSIVE_FACET: |
| return getMinExclusiveFacet(); |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__MAX_EXCLUSIVE_FACET: |
| return getMaxExclusiveFacet(); |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__LENGTH_FACET: |
| return getLengthFacet(); |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__WHITE_SPACE_FACET: |
| return getWhiteSpaceFacet(); |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__ENUMERATION_FACETS: |
| return getEnumerationFacets(); |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__PATTERN_FACETS: |
| return getPatternFacets(); |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__CARDINALITY_FACET: |
| return getCardinalityFacet(); |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__NUMERIC_FACET: |
| return getNumericFacet(); |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__MAX_LENGTH_FACET: |
| return getMaxLengthFacet(); |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__MIN_LENGTH_FACET: |
| return getMinLengthFacet(); |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__TOTAL_DIGITS_FACET: |
| return getTotalDigitsFacet(); |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__FRACTION_DIGITS_FACET: |
| return getFractionDigitsFacet(); |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__ORDERED_FACET: |
| return getOrderedFacet(); |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__BOUNDED_FACET: |
| return getBoundedFacet(); |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__EFFECTIVE_MAX_FACET: |
| return getEffectiveMaxFacet(); |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__EFFECTIVE_WHITE_SPACE_FACET: |
| return getEffectiveWhiteSpaceFacet(); |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__EFFECTIVE_MAX_LENGTH_FACET: |
| return getEffectiveMaxLengthFacet(); |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__EFFECTIVE_FRACTION_DIGITS_FACET: |
| return getEffectiveFractionDigitsFacet(); |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__EFFECTIVE_PATTERN_FACET: |
| return getEffectivePatternFacet(); |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__EFFECTIVE_ENUMERATION_FACET: |
| return getEffectiveEnumerationFacet(); |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__EFFECTIVE_TOTAL_DIGITS_FACET: |
| return getEffectiveTotalDigitsFacet(); |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__EFFECTIVE_MIN_LENGTH_FACET: |
| return getEffectiveMinLengthFacet(); |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__EFFECTIVE_LENGTH_FACET: |
| return getEffectiveLengthFacet(); |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__EFFECTIVE_MIN_FACET: |
| return getEffectiveMinFacet(); |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__SYNTHETIC_FACETS: |
| return getSyntheticFacets(); |
| } |
| return super.eGet(featureID, resolve, coreType); |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| @SuppressWarnings("unchecked") |
| @Override |
| public void eSet(int featureID, Object newValue) |
| { |
| switch (featureID) |
| { |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__VARIETY: |
| setVariety((XSDVariety)newValue); |
| return; |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__FINAL: |
| getFinal().clear(); |
| getFinal().addAll((Collection<? extends XSDSimpleFinal>)newValue); |
| return; |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__LEXICAL_FINAL: |
| getLexicalFinal().clear(); |
| getLexicalFinal().addAll((Collection<? extends XSDSimpleFinal>)newValue); |
| return; |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__VALID_FACETS: |
| getValidFacets().clear(); |
| getValidFacets().addAll((Collection<? extends String>)newValue); |
| return; |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__CONTENTS: |
| getContents().clear(); |
| getContents().addAll((Collection<? extends XSDSimpleTypeDefinition>)newValue); |
| return; |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__FACET_CONTENTS: |
| getFacetContents().clear(); |
| getFacetContents().addAll((Collection<? extends XSDConstrainingFacet>)newValue); |
| return; |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__FACETS: |
| getFacets().clear(); |
| getFacets().addAll((Collection<? extends XSDConstrainingFacet>)newValue); |
| return; |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__MEMBER_TYPE_DEFINITIONS: |
| getMemberTypeDefinitions().clear(); |
| getMemberTypeDefinitions().addAll((Collection<? extends XSDSimpleTypeDefinition>)newValue); |
| return; |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__FUNDAMENTAL_FACETS: |
| getFundamentalFacets().clear(); |
| getFundamentalFacets().addAll((Collection<? extends XSDFundamentalFacet>)newValue); |
| return; |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__BASE_TYPE_DEFINITION: |
| setBaseTypeDefinition((XSDSimpleTypeDefinition)newValue); |
| return; |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__PRIMITIVE_TYPE_DEFINITION: |
| setPrimitiveTypeDefinition((XSDSimpleTypeDefinition)newValue); |
| return; |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__ITEM_TYPE_DEFINITION: |
| setItemTypeDefinition((XSDSimpleTypeDefinition)newValue); |
| return; |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__SYNTHETIC_FACETS: |
| getSyntheticFacets().clear(); |
| getSyntheticFacets().addAll((Collection<? extends XSDFacet>)newValue); |
| return; |
| } |
| super.eSet(featureID, newValue); |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| @Override |
| public void eUnset(int featureID) |
| { |
| switch (featureID) |
| { |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__VARIETY: |
| unsetVariety(); |
| return; |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__FINAL: |
| getFinal().clear(); |
| return; |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__LEXICAL_FINAL: |
| unsetLexicalFinal(); |
| return; |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__VALID_FACETS: |
| getValidFacets().clear(); |
| return; |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__CONTENTS: |
| getContents().clear(); |
| return; |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__FACET_CONTENTS: |
| getFacetContents().clear(); |
| return; |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__FACETS: |
| getFacets().clear(); |
| return; |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__MEMBER_TYPE_DEFINITIONS: |
| getMemberTypeDefinitions().clear(); |
| return; |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__FUNDAMENTAL_FACETS: |
| getFundamentalFacets().clear(); |
| return; |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__BASE_TYPE_DEFINITION: |
| setBaseTypeDefinition((XSDSimpleTypeDefinition)null); |
| return; |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__PRIMITIVE_TYPE_DEFINITION: |
| setPrimitiveTypeDefinition((XSDSimpleTypeDefinition)null); |
| return; |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__ITEM_TYPE_DEFINITION: |
| setItemTypeDefinition((XSDSimpleTypeDefinition)null); |
| return; |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__SYNTHETIC_FACETS: |
| getSyntheticFacets().clear(); |
| return; |
| } |
| super.eUnset(featureID); |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| @Override |
| public boolean eIsSet(int featureID) |
| { |
| switch (featureID) |
| { |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__VARIETY: |
| return isSetVariety(); |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__FINAL: |
| return final_ != null && !final_.isEmpty(); |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__LEXICAL_FINAL: |
| return isSetLexicalFinal(); |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__VALID_FACETS: |
| return validFacets != null && !validFacets.isEmpty(); |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__CONTENTS: |
| return contents != null && !contents.isEmpty(); |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__FACET_CONTENTS: |
| return facetContents != null && !facetContents.isEmpty(); |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__FACETS: |
| return facets != null && !facets.isEmpty(); |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__MEMBER_TYPE_DEFINITIONS: |
| return memberTypeDefinitions != null && !memberTypeDefinitions.isEmpty(); |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__FUNDAMENTAL_FACETS: |
| return fundamentalFacets != null && !fundamentalFacets.isEmpty(); |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__BASE_TYPE_DEFINITION: |
| return baseTypeDefinition != null; |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__PRIMITIVE_TYPE_DEFINITION: |
| return primitiveTypeDefinition != null; |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__ITEM_TYPE_DEFINITION: |
| return itemTypeDefinition != null; |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__ROOT_TYPE_DEFINITION: |
| return getRootTypeDefinition() != null; |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__MIN_FACET: |
| return getMinFacet() != null; |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__MAX_FACET: |
| return getMaxFacet() != null; |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__MAX_INCLUSIVE_FACET: |
| return getMaxInclusiveFacet() != null; |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__MIN_INCLUSIVE_FACET: |
| return getMinInclusiveFacet() != null; |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__MIN_EXCLUSIVE_FACET: |
| return getMinExclusiveFacet() != null; |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__MAX_EXCLUSIVE_FACET: |
| return getMaxExclusiveFacet() != null; |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__LENGTH_FACET: |
| return getLengthFacet() != null; |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__WHITE_SPACE_FACET: |
| return getWhiteSpaceFacet() != null; |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__ENUMERATION_FACETS: |
| return !getEnumerationFacets().isEmpty(); |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__PATTERN_FACETS: |
| return !getPatternFacets().isEmpty(); |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__CARDINALITY_FACET: |
| return getCardinalityFacet() != null; |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__NUMERIC_FACET: |
| return getNumericFacet() != null; |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__MAX_LENGTH_FACET: |
| return getMaxLengthFacet() != null; |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__MIN_LENGTH_FACET: |
| return getMinLengthFacet() != null; |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__TOTAL_DIGITS_FACET: |
| return getTotalDigitsFacet() != null; |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__FRACTION_DIGITS_FACET: |
| return getFractionDigitsFacet() != null; |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__ORDERED_FACET: |
| return getOrderedFacet() != null; |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__BOUNDED_FACET: |
| return getBoundedFacet() != null; |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__EFFECTIVE_MAX_FACET: |
| return getEffectiveMaxFacet() != null; |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__EFFECTIVE_WHITE_SPACE_FACET: |
| return getEffectiveWhiteSpaceFacet() != null; |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__EFFECTIVE_MAX_LENGTH_FACET: |
| return getEffectiveMaxLengthFacet() != null; |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__EFFECTIVE_FRACTION_DIGITS_FACET: |
| return getEffectiveFractionDigitsFacet() != null; |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__EFFECTIVE_PATTERN_FACET: |
| return getEffectivePatternFacet() != null; |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__EFFECTIVE_ENUMERATION_FACET: |
| return getEffectiveEnumerationFacet() != null; |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__EFFECTIVE_TOTAL_DIGITS_FACET: |
| return getEffectiveTotalDigitsFacet() != null; |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__EFFECTIVE_MIN_LENGTH_FACET: |
| return getEffectiveMinLengthFacet() != null; |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__EFFECTIVE_LENGTH_FACET: |
| return getEffectiveLengthFacet() != null; |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__EFFECTIVE_MIN_FACET: |
| return getEffectiveMinFacet() != null; |
| case XSDPackage.XSD_SIMPLE_TYPE_DEFINITION__SYNTHETIC_FACETS: |
| return syntheticFacets != null && !syntheticFacets.isEmpty(); |
| } |
| return super.eIsSet(featureID); |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| @Override |
| public String toString() |
| { |
| if (eIsProxy()) return super.toString(); |
| |
| StringBuffer result = new StringBuffer(super.toString()); |
| result.append(" (variety: "); |
| if ((eFlags & VARIETY_ESETFLAG) != 0) result.append(VARIETY_EFLAG_VALUES[(eFlags & VARIETY_EFLAG) >>> VARIETY_EFLAG_OFFSET]); else result.append("<unset>"); |
| result.append(", final: "); |
| result.append(final_); |
| result.append(", lexicalFinal: "); |
| result.append(lexicalFinal); |
| result.append(", validFacets: "); |
| result.append(validFacets); |
| result.append(')'); |
| return result.toString(); |
| } |
| |
| public XSDWhiteSpaceFacet getWhiteSpaceFacet() |
| { |
| if (facetContents != null) |
| { |
| Object [] facets = facetContents.data(); |
| for (int i = 0, size = facetContents.size(); i < size; ++i) |
| { |
| Object facet = facets[i]; |
| if (facet instanceof XSDWhiteSpaceFacet) |
| { |
| return (XSDWhiteSpaceFacet)facet; |
| } |
| } |
| } |
| return null; |
| } |
| |
| public XSDWhiteSpaceFacet getEffectiveWhiteSpaceFacet() |
| { |
| if (facets != null) |
| { |
| Object [] facetData = facets.data(); |
| for (int i = 0, size = facets.size(); i < size; ++i) |
| { |
| Object facet = facetData[i]; |
| if (facet instanceof XSDWhiteSpaceFacet) |
| { |
| return (XSDWhiteSpaceFacet)facet; |
| } |
| } |
| } |
| return null; |
| } |
| |
| public EList<XSDEnumerationFacet> getEnumerationFacets() |
| { |
| EList<XSDEnumerationFacet> result = new BasicEList<XSDEnumerationFacet>(); |
| if (facetContents != null) |
| { |
| Object [] facets = facetContents.data(); |
| for (int i = 0, size = facetContents.size(); i < size; ++i) |
| { |
| Object facet = facets[i]; |
| if (facet instanceof XSDEnumerationFacet) |
| { |
| result.add((XSDEnumerationFacet)facet); |
| } |
| } |
| } |
| return |
| new EcoreEList.UnmodifiableEList.FastCompare<XSDEnumerationFacet> |
| (this, XSDPackage.Literals.XSD_SIMPLE_TYPE_DEFINITION__ENUMERATION_FACETS, result.size(), result.toArray()); |
| } |
| |
| public XSDEnumerationFacet getEffectiveEnumerationFacet() |
| { |
| if (facets != null) |
| { |
| Object [] facetData = facets.data(); |
| for (int i = 0, size = facets.size(); i < size; ++i) |
| { |
| Object facet = facetData[i]; |
| if (facet instanceof XSDEnumerationFacet) |
| { |
| return (XSDEnumerationFacet)facet; |
| } |
| } |
| } |
| return null; |
| } |
| |
| public EList<XSDPatternFacet> getPatternFacets() |
| { |
| EList<XSDPatternFacet> result = new BasicEList<XSDPatternFacet>(); |
| if (facetContents != null) |
| { |
| Object [] facets = facetContents.data(); |
| for (int i = 0, size = facetContents.size(); i < size; ++i) |
| { |
| Object facet = facets[i]; |
| if (facet instanceof XSDPatternFacet) |
| { |
| result.add((XSDPatternFacet)facet); |
| } |
| } |
| } |
| return |
| new EcoreEList.UnmodifiableEList.FastCompare<XSDPatternFacet> |
| (this, XSDPackage.Literals.XSD_SIMPLE_TYPE_DEFINITION__PATTERN_FACETS, result.size(), result.toArray()); |
| } |
| |
| public XSDPatternFacet getEffectivePatternFacet() |
| { |
| if (facets != null) |
| { |
| Object [] facetData = facets.data(); |
| for (int i = 0, size = facets.size(); i < size; ++i) |
| { |
| Object facet = facetData[i]; |
| if (facet instanceof XSDPatternFacet) |
| { |
| return (XSDPatternFacet)facet; |
| } |
| } |
| } |
| return null; |
| } |
| |
| protected XSDBoundedFacet boundedFacet; |
| public XSDBoundedFacet getBoundedFacet() |
| { |
| if (boundedFacet == null) |
| { |
| createFundamentalFacets(); |
| } |
| return boundedFacet; |
| } |
| |
| protected XSDCardinalityFacet cardinalityFacet; |
| public XSDCardinalityFacet getCardinalityFacet() |
| { |
| if (cardinalityFacet == null) |
| { |
| createFundamentalFacets(); |
| } |
| return cardinalityFacet; |
| } |
| |
| protected XSDNumericFacet numericFacet; |
| public XSDNumericFacet getNumericFacet() |
| { |
| if (numericFacet == null) |
| { |
| createFundamentalFacets(); |
| } |
| return numericFacet; |
| } |
| |
| protected XSDOrderedFacet orderedFacet; |
| public XSDOrderedFacet getOrderedFacet() |
| { |
| if (orderedFacet == null) |
| { |
| createFundamentalFacets(); |
| } |
| return orderedFacet; |
| } |
| |
| protected void createFundamentalFacets() |
| { |
| List<XSDFundamentalFacet> theFundamentalFacets = getFundamentalFacets(); |
| boundedFacet = getXSDFactory().createXSDBoundedFacet(); |
| cardinalityFacet = getXSDFactory().createXSDCardinalityFacet(); |
| numericFacet = getXSDFactory().createXSDNumericFacet(); |
| orderedFacet = getXSDFactory().createXSDOrderedFacet(); |
| List<XSDFundamentalFacet> list = new ArrayList<XSDFundamentalFacet>(4); |
| list.add(boundedFacet); |
| list.add(cardinalityFacet); |
| list.add(numericFacet); |
| list.add(orderedFacet); |
| theFundamentalFacets.addAll(list); |
| } |
| |
| protected static EList<String> validFacetsForList; |
| public EList<String> getValidFacetsForList() |
| { |
| if (validFacetsForList == null) |
| { |
| validFacetsForList = new BasicEList<String>(); |
| validFacetsForList.add("length"); |
| validFacetsForList.add("maxLength"); |
| validFacetsForList.add("minLength"); |
| validFacetsForList.add("whiteSpace"); |
| validFacetsForList.add("enumeration"); |
| validFacetsForList.add("pattern"); |
| } |
| return validFacetsForList; |
| } |
| |
| protected static EList<String> validFacetsForUnion; |
| public EList<String> getValidFacetsForUnion() |
| { |
| if (validFacetsForUnion == null) |
| { |
| validFacetsForUnion = new BasicEList<String>(); |
| validFacetsForUnion.add("enumeration"); |
| validFacetsForUnion.add("pattern"); |
| } |
| return validFacetsForUnion; |
| } |
| |
| @Override |
| public XSDTypeDefinition getBaseType() |
| { |
| XSDTypeDefinition result = getBaseTypeDefinition(); |
| if (result == this && XSDConstants.isAnyType(this)) |
| { |
| XSDSchema xsdSchema = getSchema(); |
| if (xsdSchema != null) |
| { |
| String schemaForSchemaNamespace = xsdSchema.getSchemaForSchemaNamespace(); |
| XSDSchemaImpl.getSchemaForSchema(schemaForSchemaNamespace).resolveComplexTypeDefinition("anyType"); |
| } |
| } |
| return result; |
| } |
| |
| @Override |
| public XSDTypeDefinition getRootType() |
| { |
| return getRootTypeDefinition(); |
| } |
| |
| public XSDSimpleTypeDefinition getRootTypeDefinition() |
| { |
| XSDSimpleTypeDefinition result = this; |
| if (!isCircular()) |
| { |
| for (XSDSimpleTypeDefinition theBaseTypeDefinition = result.getBaseTypeDefinition(); |
| theBaseTypeDefinition != null && !XSDConstants.isURType(theBaseTypeDefinition); |
| theBaseTypeDefinition = theBaseTypeDefinition.getBaseTypeDefinition()) |
| { |
| result = theBaseTypeDefinition; |
| } |
| } |
| return result; |
| } |
| |
| @Override |
| public XSDSimpleTypeDefinition getSimpleType() |
| { |
| return this; |
| } |
| |
| @Override |
| public XSDParticle getComplexType() |
| { |
| return null; |
| } |
| |
| protected XSDEnumerationFacetImpl effectiveEnumerationFacet; |
| protected XSDPatternFacetImpl effectivePatternFacet; |
| |
| protected List<XSDConstrainingFacet> mergeFacets() |
| { |
| List<XSDConstrainingFacet> result = new ArrayList<XSDConstrainingFacet>(); |
| |
| XSDSimpleTypeDefinition theBaseTypeDefinition = getBaseTypeDefinition(); |
| |
| XSDWhiteSpaceFacet xsdWhiteSpaceFacet = getWhiteSpaceFacet(); |
| if (xsdWhiteSpaceFacet == null) |
| { |
| xsdWhiteSpaceFacet = theBaseTypeDefinition.getEffectiveWhiteSpaceFacet(); |
| } |
| if (xsdWhiteSpaceFacet != null) |
| { |
| result.add(xsdWhiteSpaceFacet); |
| } |
| |
| XSDTotalDigitsFacet xsdTotalDigitsFacet = getTotalDigitsFacet(); |
| if (xsdTotalDigitsFacet == null) |
| { |
| xsdTotalDigitsFacet = theBaseTypeDefinition.getEffectiveTotalDigitsFacet(); |
| } |
| if (xsdTotalDigitsFacet != null) |
| { |
| result.add(xsdTotalDigitsFacet); |
| } |
| |
| XSDFractionDigitsFacet xsdFractionDigitsFacet = getFractionDigitsFacet(); |
| if (xsdFractionDigitsFacet == null) |
| { |
| xsdFractionDigitsFacet = theBaseTypeDefinition.getEffectiveFractionDigitsFacet(); |
| } |
| if (xsdFractionDigitsFacet != null) |
| { |
| result.add(xsdFractionDigitsFacet); |
| } |
| |
| XSDLengthFacet xsdLengthFacet = getLengthFacet(); |
| if (xsdLengthFacet == null) |
| { |
| xsdLengthFacet = theBaseTypeDefinition.getEffectiveLengthFacet(); |
| } |
| if (xsdLengthFacet != null) |
| { |
| result.add(xsdLengthFacet); |
| } |
| |
| XSDMinLengthFacet xsdMinLengthFacet = getMinLengthFacet(); |
| if (xsdMinLengthFacet == null) |
| { |
| xsdMinLengthFacet = theBaseTypeDefinition.getEffectiveMinLengthFacet(); |
| } |
| if (xsdMinLengthFacet != null) |
| { |
| result.add(xsdMinLengthFacet); |
| } |
| |
| XSDMaxLengthFacet xsdMaxLengthFacet = getMaxLengthFacet(); |
| if (xsdMaxLengthFacet == null) |
| { |
| xsdMaxLengthFacet = theBaseTypeDefinition.getEffectiveMaxLengthFacet(); |
| } |
| if (xsdMaxLengthFacet != null) |
| { |
| result.add(xsdMaxLengthFacet); |
| } |
| |
| XSDConstrainingFacet maxFacet = getMaxFacet(); |
| if (maxFacet == null) |
| { |
| maxFacet = theBaseTypeDefinition.getEffectiveMaxFacet(); |
| } |
| if (maxFacet != null) |
| { |
| result.add(maxFacet); |
| } |
| |
| XSDConstrainingFacet minFacet = getMinFacet(); |
| if (minFacet == null) |
| { |
| minFacet = theBaseTypeDefinition.getEffectiveMinFacet(); |
| } |
| if (minFacet != null) |
| { |
| result.add(minFacet); |
| } |
| |
| List<XSDEnumerationFacet> enumerationFacets = getEnumerationFacets(); |
| if (enumerationFacets.isEmpty()) |
| { |
| XSDEnumerationFacet baseEnumerationFacet = theBaseTypeDefinition.getEffectiveEnumerationFacet(); |
| if (baseEnumerationFacet != null) |
| { |
| result.add(baseEnumerationFacet); |
| } |
| } |
| else |
| { |
| if (effectiveEnumerationFacet == null) |
| { |
| effectiveEnumerationFacet = (XSDEnumerationFacetImpl)getXSDFactory().createXSDEnumerationFacet(); |
| getSyntheticFacets().add(effectiveEnumerationFacet); |
| } |
| |
| StringBuffer newLexicalValue = new StringBuffer(); |
| List<Object> newValue = new UniqueEList<Object>(); |
| List<XSDAnnotation> newAnnotations = new ArrayList<XSDAnnotation>(); |
| |
| for (XSDEnumerationFacet enumerationFacet : enumerationFacets) |
| { |
| XSDAnnotation xsdAnnotation = enumerationFacet.getAnnotation(); |
| if (xsdAnnotation != null) |
| { |
| newAnnotations.add(xsdAnnotation); |
| } |
| |
| if (newValue.addAll(enumerationFacet.getValue())) |
| { |
| if (newLexicalValue.length() != 0) |
| { |
| newLexicalValue.append(", "); |
| } |
| newLexicalValue.append(enumerationFacet.getLexicalValue()); |
| } |
| } |
| String newLexicalValueString = newLexicalValue.toString(); |
| |
| List<Object> remainingValues = new ArrayList<Object>(effectiveEnumerationFacet.getValue()); |
| remainingValues.removeAll(newValue); |
| if (!remainingValues.isEmpty()) |
| { |
| effectiveEnumerationFacet.getValue().removeAll(remainingValues); |
| } |
| if (!newValue.isEmpty()) |
| { |
| setListContentAndOrder(effectiveEnumerationFacet.getValue(), newValue); |
| } |
| |
| List<XSDAnnotation> remainingAnnotations = new ArrayList<XSDAnnotation>(effectiveEnumerationFacet.getAnnotations()); |
| remainingAnnotations.removeAll(newAnnotations); |
| if (!remainingAnnotations.isEmpty()) |
| { |
| effectiveEnumerationFacet.getAnnotations().removeAll(remainingAnnotations); |
| } |
| if (!newAnnotations.isEmpty()) |
| { |
| setListContentAndOrder(effectiveEnumerationFacet.getAnnotations(), newAnnotations); |
| } |
| |
| if (!newLexicalValueString.equals(effectiveEnumerationFacet.getLexicalValue())) |
| { |
| effectiveEnumerationFacet.isReconciling = true; |
| effectiveEnumerationFacet.setLexicalValue(newLexicalValueString); |
| effectiveEnumerationFacet.isReconciling = false; |
| } |
| |
| result.add(effectiveEnumerationFacet); |
| } |
| |
| List<XSDPatternFacet> patternFacets = getPatternFacets(); |
| if (patternFacets.isEmpty()) |
| { |
| XSDPatternFacet basePatternFacet = theBaseTypeDefinition.getEffectivePatternFacet(); |
| if (basePatternFacet != null) |
| { |
| result.add(basePatternFacet); |
| } |
| } |
| else |
| { |
| if (effectivePatternFacet == null) |
| { |
| effectivePatternFacet = (XSDPatternFacetImpl)getXSDFactory().createXSDPatternFacet(); |
| getSyntheticFacets().add(effectivePatternFacet); |
| } |
| |
| List<String> newValue = new ArrayList<String>(); |
| List<XSDAnnotation> newAnnotations = new ArrayList<XSDAnnotation>(); |
| XSDPatternFacet effectiveBasePatternFacet = theBaseTypeDefinition.getEffectivePatternFacet(); |
| if (effectiveBasePatternFacet != null) |
| { |
| newValue.addAll(effectiveBasePatternFacet.getValue()); |
| } |
| |
| StringBuffer combinedPattern = new StringBuffer(); |
| if (patternFacets.size() == 1) |
| { |
| XSDPatternFacet xsdPatternFacet = patternFacets.get(0); |
| combinedPattern.append(xsdPatternFacet.getLexicalValue()); |
| XSDAnnotation xsdAnnotation = xsdPatternFacet.getAnnotation(); |
| if (xsdAnnotation != null) |
| { |
| newAnnotations.add(xsdAnnotation); |
| } |
| } |
| else |
| { |
| for (XSDPatternFacet xsdPatternFacet : patternFacets) |
| { |
| if (combinedPattern.length() != 0) |
| { |
| combinedPattern.append("|"); |
| } |
| combinedPattern.append("("); |
| combinedPattern.append(xsdPatternFacet.getLexicalValue()); |
| combinedPattern.append(")"); |
| XSDAnnotation xsdAnnotation = xsdPatternFacet.getAnnotation(); |
| if (xsdAnnotation != null) |
| { |
| newAnnotations.add(xsdAnnotation); |
| } |
| } |
| } |
| newValue.add(combinedPattern.toString()); |
| |
| List<String> remainingValues = new ArrayList<String>(effectivePatternFacet.getValue()); |
| remainingValues.removeAll(newValue); |
| if (!remainingValues.isEmpty()) |
| { |
| effectivePatternFacet.getValue().removeAll(remainingValues); |
| } |
| if (!newValue.isEmpty()) |
| { |
| setListContentAndOrder(effectivePatternFacet.getValue(), newValue); |
| } |
| |
| List<XSDAnnotation> remainingAnnotations = new ArrayList<XSDAnnotation>(effectivePatternFacet.getAnnotations()); |
| remainingAnnotations.removeAll(newAnnotations); |
| if (!remainingAnnotations.isEmpty()) |
| { |
| effectivePatternFacet.getAnnotations().removeAll(remainingAnnotations); |
| } |
| if (!newAnnotations.isEmpty()) |
| { |
| setListContentAndOrder(effectivePatternFacet.getAnnotations(), newAnnotations); |
| } |
| |
| StringBuffer newLexicalValue = new StringBuffer(); |
| if (newValue.size() == 1) |
| { |
| newLexicalValue.append(newValue.get(0)); |
| } |
| else |
| { |
| for (String string : newValue) |
| { |
| if (newLexicalValue.length() != 0) |
| { |
| newLexicalValue.append(" & "); |
| } |
| newLexicalValue.append("("); |
| newLexicalValue.append(string); |
| newLexicalValue.append(")"); |
| } |
| } |
| String newLexicalValueString = newLexicalValue.toString(); |
| if (!newLexicalValueString.equals(effectivePatternFacet.getLexicalValue())) |
| { |
| effectivePatternFacet.isReconciling = true; |
| effectivePatternFacet.setLexicalValue(newLexicalValueString); |
| effectivePatternFacet.isReconciling = false; |
| } |
| |
| result.add(effectivePatternFacet); |
| } |
| |
| return result; |
| } |
| |
| |
| public String getStringLexicalFinal() |
| { |
| if (isSetLexicalFinal()) |
| { |
| StringBuffer result = new StringBuffer(); |
| for (Object literal : getLexicalFinal()) |
| { |
| if (result.length() != 0) |
| { |
| result.append(' '); |
| } |
| if (literal.toString().equals("all")) |
| { |
| result.append("#all"); |
| } |
| else |
| { |
| result.append(literal); |
| } |
| } |
| return result.toString(); |
| } |
| else |
| { |
| return null; |
| } |
| } |
| |
| public void setStringLexicalFinal(String finalDefault) |
| { |
| if (finalDefault == null) |
| { |
| unsetLexicalFinal(); |
| } |
| else |
| { |
| List<XSDSimpleFinal> newLexicalFinal = new ArrayList<XSDSimpleFinal>(); |
| for (StringTokenizer stringTokenizer = new StringTokenizer(finalDefault); stringTokenizer.hasMoreTokens(); ) |
| { |
| String token = stringTokenizer.nextToken(); |
| if (token.equals("#all")) |
| { |
| token = "all"; |
| } |
| XSDSimpleFinal literal = XSDSimpleFinal.get(token); |
| if (literal != null) |
| { |
| newLexicalFinal.add(literal); |
| } |
| } |
| if (!newLexicalFinal.equals(getLexicalFinal())) |
| { |
| Collection<XSDSimpleFinal> oldContents = new ArrayList<XSDSimpleFinal>(getLexicalFinal()); |
| oldContents.removeAll(newLexicalFinal); |
| if (!oldContents.isEmpty()) |
| { |
| getLexicalFinal().removeAll(oldContents); |
| } |
| setListContentAndOrder(getLexicalFinal(), newLexicalFinal); |
| } |
| else if (newLexicalFinal.isEmpty() && !isSetLexicalFinal()) |
| { |
| getLexicalFinal().clear(); |
| } |
| } |
| } |
| |
| public String getStringFinal() |
| { |
| StringBuffer result = new StringBuffer(); |
| for (Object literal : getFinal()) |
| { |
| if (result.length() != 0) |
| { |
| result.append(' '); |
| } |
| result.append(literal); |
| } |
| return result.toString(); |
| } |
| |
| /** |
| * This is used to gather selectively |
| * the information determined when assessing a literal string |
| * with respect to a {@link XSDSimpleTypeDefinition}. |
| * It is intended to be very light-weight and flexible. |
| * |
| * You may begin assessment with a {@link #node}, which handles three cases: |
| * if the node is an attribute, it's value is used to determine the literal; |
| * if the node is a text node, it's value is used to determine the literal; |
| * if the node is an element, it's (one and only) child text node is used to determine the literal in the preceeding case. |
| * You may begin assessment with a {@link #literal} by not setting a node. |
| * And you may begin assessment with a {@link #normalizedLiteral} by setting neither the node nor the literal. |
| * |
| * Unless additional {@link #yield} flags are set, |
| * assessment will perform but one function: |
| * it will set the {@link #diagnostics} to Collections.EMPTY_LIST when the literal fails to assess as valid. |
| * Hence, this most-light-weight invocation will only determine validity. |
| * |
| * You may choose for assessment to yield additional results, |
| * i.e., the {@link #value}, the {@link #canonicalLiteral}, and the {@link #diagnostics}, |
| * using the flags {@link #YIELD_VALUE}, {@link #YIELD_CANONICAL_LITERAL}, {@link #YIELD_DIAGNOSTICS}. |
| */ |
| public static class AssessmentImpl implements XSDSimpleTypeDefinition.Assessment |
| { |
| public static final int YIELD_VALUE = 0x01; |
| public static final int YIELD_CANONICAL_LITERAL = 0x02; |
| public static final int YIELD_DIAGNOSTICS = 0x04; |
| |
| /** |
| * This is the simple type definition doing the assessment. |
| */ |
| public XSDSimpleTypeDefinitionImpl xsdSimpleTypeDefinition; |
| |
| /** |
| * This is the simple type definition doing the assessment for an atomic type. |
| */ |
| public XSDAnySimpleType xsdAnySimpleType; |
| |
| /** |
| * This is the context in which the prefix of QNames are resolved. |
| */ |
| public Element context; |
| |
| /** |
| * This is the node whose literal is being assessed. |
| */ |
| public Node node; |
| |
| /** |
| * This is the literal that is being assessed. |
| */ |
| public String literal; |
| |
| /** |
| * This is the normalized value of the literal being assessed. |
| */ |
| public String normalizedLiteral; |
| |
| /** |
| * This determines the results that will be yielded during assessment. |
| */ |
| public int yield; |
| |
| /** |
| * This is the value of the normalized literal in the Java representation of the value space. |
| */ |
| public Object value; |
| |
| /** |
| * This is the canonical literal representation of the literal. |
| */ |
| public String canonicalLiteral; |
| |
| /** |
| * These are the diagnostics that are collected. |
| */ |
| public Collection<XSDDiagnostic> diagnostics; |
| |
| /** |
| * This records any nested assessments that were performed. |
| */ |
| public Collection<Assessment> assessments; |
| |
| /** |
| * This creates an empty instance; |
| * minimally, the node or literal would need to be set before using this. |
| */ |
| public AssessmentImpl() |
| { |
| super(); |
| } |
| |
| /** |
| * This creates an instance to assess the given node and to yield the specified results. |
| */ |
| public AssessmentImpl(Node node, int yield) |
| { |
| this.yield = yield; |
| this.node = node; |
| } |
| |
| /** |
| * This creates an instance to assess the given node and to yield the specified results. |
| */ |
| public AssessmentImpl(Element context, Node node, int yield) |
| { |
| this.context = context; |
| this.yield = yield; |
| this.node = node; |
| } |
| |
| /** |
| * This creates an instance to assess the given literal and to yield the specified results. |
| */ |
| public AssessmentImpl(String literal, int yield) |
| { |
| this.yield = yield; |
| this.literal = literal; |
| } |
| |
| /** |
| * This creates an instance to assess the given literal and to yield the specified results. |
| */ |
| public AssessmentImpl(Element context, String literal, int yield) |
| { |
| this.context = context; |
| this.yield = yield; |
| this.literal = literal; |
| } |
| |
| public XSDSimpleTypeDefinition getTypeDefinition() |
| { |
| return xsdSimpleTypeDefinition; |
| } |
| |
| public Element getContext() |
| { |
| return context; |
| } |
| |
| public Node getNode() |
| { |
| return node; |
| } |
| |
| public String getLiteral() |
| { |
| return literal; |
| } |
| |
| public String getNormalizedLiteral() |
| { |
| return normalizedLiteral; |
| } |
| |
| public Object getValue() |
| { |
| return value; |
| } |
| |
| public String getCanonicalLiteral() |
| { |
| return normalizedLiteral; |
| } |
| |
| public XSDSimpleTypeDefinition getMemberTypeDefinition() |
| { |
| return null; |
| } |
| |
| public Collection<XSDDiagnostic> getLocalDiagnostics() |
| { |
| return diagnostics == null ? Collections.<XSDDiagnostic>emptyList() : diagnostics; |
| } |
| |
| public Collection<Assessment> getAssessments() |
| { |
| return assessments; |
| } |
| |
| public Collection<XSDDiagnostic> getDiagnostics() |
| { |
| Collection<XSDDiagnostic> result = new ArrayList<XSDDiagnostic>(); |
| getAllDiagnostics(result); |
| return result; |
| } |
| |
| protected void getAllDiagnostics(Collection<XSDDiagnostic> result) |
| { |
| if (diagnostics != null) |
| { |
| result.addAll(diagnostics); |
| } |
| if (assessments != null) |
| { |
| for (Assessment assessment : assessments) |
| { |
| ((AssessmentImpl)assessment).getAllDiagnostics(result); |
| } |
| } |
| } |
| |
| public void format(String noun, String name) |
| { |
| if (diagnostics != null) |
| { |
| for (XSDDiagnostic xsdDiagnostic : diagnostics) |
| { |
| xsdDiagnostic.setMessage(MessageFormat.format(xsdDiagnostic.getMessage(), new Object [] { noun, name })); |
| } |
| } |
| if (assessments != null) |
| { |
| for (Assessment assessment : assessments) |
| { |
| assessment.format(noun, name); |
| } |
| } |
| } |
| |
| public void assignDiagnostics(XSDConcreteComponent xsdConcreteComponent, Element element, String attributeName) |
| { |
| Collection<XSDDiagnostic> allDiagnostics = getDiagnostics(); |
| if (!allDiagnostics.isEmpty()) |
| { |
| Node theNode = element; |
| if (element != null && element.hasAttributeNS(null, attributeName)) |
| { |
| theNode = element.getAttributeNodeNS(null, attributeName); |
| } |
| |
| Object [] substitutions = new Object [] { XSDPlugin.INSTANCE.getString("attribute_noun"), attributeName }; |
| for (XSDDiagnostic xsdDiagnostic : allDiagnostics) |
| { |
| xsdDiagnostic.setMessage(MessageFormat.format(xsdDiagnostic.getMessage(), substitutions)); |
| xsdDiagnostic.getComponents().add(0, xsdConcreteComponent); |
| xsdDiagnostic.setNode(theNode); |
| } |
| } |
| } |
| |
| public void validate(XSDConstrainingFacet xsdConstrainingFacet) |
| { |
| if (xsdConstrainingFacet != null && |
| !(xsdConstrainingFacet instanceof XSDPatternFacet ? |
| ((XSDPatternFacet)xsdConstrainingFacet).isConstraintSatisfied(normalizedLiteral) : |
| xsdConstrainingFacet.isConstraintSatisfied(value))) |
| { |
| XSDDiagnostic result = ((XSDConcreteComponentImpl)xsdConstrainingFacet).getXSDFactory().createXSDDiagnostic(); |
| result.setSeverity(XSDDiagnosticSeverity.ERROR_LITERAL); |
| Object [] substitutions = createSubstitutions(5); |
| substitutions[3] = xsdConstrainingFacet.getLexicalValue(); |
| substitutions[4] = xsdConstrainingFacet.getSimpleTypeDefinition().getURI(); |
| |
| String message = populateDiagnostic(result, "cvc-" + xsdConstrainingFacet.getFacetName() + "-valid", substitutions); |
| if (node == null || node.getNodeType() == Node.TEXT_NODE) |
| { |
| message = requote(message); |
| } |
| result.setMessage(XSDPlugin.INSTANCE.getString("_UI_XSDError_message", new Object [] { message})); |
| result.setAnnotationURI(XSDConstants.PART2 + "#" + xsdConstrainingFacet.getFacetName()); |
| result.setPrimaryComponent(xsdConstrainingFacet); |
| result.setNode(node); |
| |
| if (diagnostics == null) |
| { |
| diagnostics = new ArrayList<XSDDiagnostic>(); |
| } |
| diagnostics.add(result); |
| } |
| } |
| |
| protected Object [] createSubstitutions(int length) |
| { |
| Object [] substitutions = new Object [length]; |
| if (normalizedLiteral != null) |
| { |
| substitutions[0] = normalizedLiteral; |
| } |
| else if (literal != null) |
| { |
| substitutions[0] = literal; |
| } |
| else |
| { |
| substitutions[0] = value; |
| } |
| |
| if (node == null || node.getNodeType() == Node.TEXT_NODE) |
| { |
| substitutions[1] = "\000"; |
| substitutions[2] = "\001"; |
| } |
| else if (node.getNodeType() == Node.ATTRIBUTE_NODE) |
| { |
| substitutions[1] = XSDPlugin.INSTANCE.getString("attribute_noun"); |
| substitutions[2] = node.getLocalName(); |
| } |
| else if (node.getNodeType() == Node.ELEMENT_NODE) |
| { |
| substitutions[1] = XSDPlugin.INSTANCE.getString("element_noun"); |
| substitutions[2] = node.getLocalName(); |
| } |
| |
| return substitutions; |
| } |
| |
| protected static String requote(String message) |
| { |
| StringBuffer stringBuffer = new StringBuffer(message); |
| for (int i = stringBuffer.length() - 1; i > 0; --i) |
| { |
| switch (stringBuffer.charAt(i)) |
| { |
| case 0: |
| { |
| stringBuffer.replace(i, i + 1, "{0}"); |
| break; |
| } |
| case 1: |
| { |
| stringBuffer.replace(i, i + 1, "{1}"); |
| break; |
| } |
| case '\'': |
| { |
| stringBuffer.insert(i, '\''); |
| break; |
| } |
| case '{': // } |
| { |
| stringBuffer.replace(i, i + 1, "'{'"); // } |
| break; |
| } |
| } |
| } |
| return stringBuffer.toString(); |
| } |
| |
| public void reportDatatypeDiagnostic() |
| { |
| XSDDiagnostic result = xsdSimpleTypeDefinition.getXSDFactory().createXSDDiagnostic(); |
| result.setSeverity(XSDDiagnosticSeverity.ERROR_LITERAL); |
| Object [] substitutions = createSubstitutions(4); |
| substitutions[3] = xsdSimpleTypeDefinition.getURI(); |
| XSDSimpleTypeDefinition primitiveTypeDefinition = xsdSimpleTypeDefinition.getPrimitiveTypeDefinition(); |
| String message = |
| populateDiagnostic |
| (result, |
| primitiveTypeDefinition == null ? |
| "cvc-datatype-valid.1.2.3" : |
| "cvc-datatype-valid.1.2.1", |
| substitutions); |
| if (node == null || node.getNodeType() == Node.TEXT_NODE) |
| { |
| message = requote(message); |
| } |
| result.setMessage(XSDPlugin.INSTANCE.getString("_UI_XSDError_message", new Object [] { message })); |
| if (primitiveTypeDefinition != null) |
| { |
| result.setAnnotationURI(XSDConstants.PART2 + "#" + primitiveTypeDefinition.getName()); |
| } |
| result.setPrimaryComponent(primitiveTypeDefinition); |
| result.setNode(node); |
| |
| if (diagnostics == null) |
| { |
| diagnostics = new ArrayList<XSDDiagnostic>(); |
| } |
| diagnostics.add(result); |
| } |
| } |
| |
| public XSDSimpleTypeDefinition.Assessment assess(Node node) |
| { |
| return assess(null, node); |
| } |
| |
| public XSDSimpleTypeDefinition.Assessment assess(Element context, Node node) |
| { |
| AssessmentImpl assessment = new AssessmentImpl(context, node, 0); |
| return assess(assessment); |
| } |
| |
| public XSDSimpleTypeDefinition.Assessment assess(String literal) |
| { |
| return assess(null, literal); |
| } |
| |
| public XSDSimpleTypeDefinition.Assessment assess(Element context, String literal) |
| { |
| AssessmentImpl assessment = new AssessmentImpl(context, literal, 0); |
| return assess(assessment); |
| } |
| |
| public AssessmentImpl assess(AssessmentImpl assessment) |
| { |
| return assess(assessment, true); |
| } |
| |
| public AssessmentImpl assess(AssessmentImpl assessment, boolean validate) |
| { |
| assessment.xsdSimpleTypeDefinition = this; |
| |
| // Determine the literal from the node. |
| // |
| if (assessment.literal == null && assessment.node != null) |
| { |
| switch (assessment.node.getNodeType()) |
| { |
| case Node.ATTRIBUTE_NODE: |
| { |
| assessment.literal = assessment.node.getNodeValue(); |
| break; |
| } |
| case Node.ELEMENT_NODE: |
| { |
| Element element = (Element)assessment.node; |
| StringBuffer text = new StringBuffer(); |
| for (Node child = element.getFirstChild(); child != null; child = child.getNextSibling()) |
| { |
| switch (child.getNodeType()) |
| { |
| case Node.TEXT_NODE: |
| case Node.CDATA_SECTION_NODE: |
| { |
| text.append(child.getNodeValue()); |
| break; |
| } |
| } |
| } |
| assessment.literal = text.toString(); |
| break; |
| } |
| case Node.TEXT_NODE: |
| case Node.CDATA_SECTION_NODE: |
| { |
| assessment.literal = assessment.node.getNodeValue(); |
| break; |
| } |
| } |
| } |
| |
| // Determine the normalized literal from the literal. |
| // |
| if (assessment.normalizedLiteral == null && assessment.literal != null) |
| { |
| assessment.normalizedLiteral = assessment.literal; |
| XSDWhiteSpaceFacet effectiveWhiteSpaceFacet = getEffectiveWhiteSpaceFacet(); |
| if (effectiveWhiteSpaceFacet != null) |
| { |
| assessment.normalizedLiteral = effectiveWhiteSpaceFacet.getNormalizedLiteral(assessment.literal); |
| } |
| } |
| |
| if (!isCircular()) |
| { |
| if (validate) |
| { |
| assessment.validate(getEffectivePatternFacet()); |
| } |
| |
| switch (getVariety().getValue()) |
| { |
| case XSDVariety.ATOMIC: |
| { |
| XSDSimpleTypeDefinition thePrimitiveTypeDefinition = getPrimitiveTypeDefinition(); |
| if (thePrimitiveTypeDefinition != null) |
| { |
| XSDAnySimpleType xsdAnySimpleType = XSDTypeRegister.getTypeImplementer(thePrimitiveTypeDefinition.getName()); |
| xsdAnySimpleType.assess(assessment); |
| if (validate && assessment.diagnostics == null) |
| { |
| assessment.validate(getEffectiveLengthFacet()); |
| assessment.validate(getEffectiveMinLengthFacet()); |
| assessment.validate(getEffectiveMaxLengthFacet()); |
| |
| assessment.validate(getEffectiveTotalDigitsFacet()); |
| assessment.validate(getEffectiveFractionDigitsFacet()); |
| |
| if (XSDOrdered.FALSE_LITERAL != getOrderedFacet().getValue()) |
| { |
| assessment.validate(getEffectiveMinFacet()); |
| assessment.validate(getEffectiveMaxFacet()); |
| } |
| } |
| } |
| break; |
| } |
| case XSDVariety.UNION: |
| { |
| boolean good = false; |
| for (XSDSimpleTypeDefinition memberTypeDefinition : getMemberTypeDefinitions()) |
| { |
| AssessmentImpl nestedAssessment = new AssessmentImpl(assessment.context, assessment.node, assessment.yield); |
| nestedAssessment.literal = nestedAssessment.normalizedLiteral = assessment.normalizedLiteral; |
| |
| ((XSDSimpleTypeDefinitionImpl)memberTypeDefinition).assess(nestedAssessment); |
| |
| if (nestedAssessment.diagnostics == null) |
| { |
| if (assessment.assessments == null) |
| { |
| assessment.assessments = new ArrayList<Assessment>(); |
| } |
| assessment.assessments.add(nestedAssessment); |
| assessment.value = nestedAssessment.value; |
| good = true; |
| break; |
| } |
| } |
| |
| if (validate && !good) |
| { |
| assessment.reportDatatypeDiagnostic(); |
| } |
| |
| break; |
| } |
| case XSDVariety.LIST: |
| { |
| XSDSimpleTypeDefinition theItemTypeDefinition = getItemTypeDefinition(); |
| if (theItemTypeDefinition != null) |
| { |
| List<Object> list = new ArrayList<Object>(); |
| assessment.value = list; |
| for (StringTokenizer tokens = new StringTokenizer(assessment.normalizedLiteral, " "); |
| tokens.hasMoreTokens(); ) |
| { |
| AssessmentImpl nestedAssessment = new AssessmentImpl(assessment.context, assessment.node, assessment.yield); |
| nestedAssessment.literal = nestedAssessment.normalizedLiteral = tokens.nextToken(); |
| ((XSDSimpleTypeDefinitionImpl)getItemTypeDefinition()).assess(nestedAssessment, validate); |
| if (nestedAssessment.value != null) |
| { |
| list.add(nestedAssessment.value); |
| } |
| if (assessment.assessments == null) |
| { |
| assessment.assessments = new ArrayList<Assessment>(); |
| } |
| assessment.assessments.add(nestedAssessment); |
| } |
| |
| if (validate) |
| { |
| assessment.validate(getEffectiveLengthFacet()); |
| assessment.validate(getEffectiveMinLengthFacet()); |
| assessment.validate(getEffectiveMaxLengthFacet()); |
| } |
| } |
| break; |
| } |
| } |
| |
| if (validate) |
| { |
| assessment.validate(getEffectiveEnumerationFacet()); |
| } |
| } |
| |
| return assessment; |
| } |
| |
| public boolean isValidLiteral(String literal) |
| { |
| return isValidLiteral(null, literal); |
| } |
| |
| public boolean isValidLiteral(Element context, String literal) |
| { |
| AssessmentImpl assessment = new AssessmentImpl(context, literal, 0); |
| assess(assessment); |
| return assessment.diagnostics == null; |
| } |
| |
| public Object getValue(String literal) |
| { |
| return getValue(null, literal); |
| |
| } |
| |
| public Object getValue(Element context, String literal) |
| { |
| AssessmentImpl assessment = new AssessmentImpl(context, literal, 0); |
| assess(assessment, false); |
| return assessment.value; |
| } |
| |
| public String getCanonicalLiteral(String literal) |
| { |
| AssessmentImpl assessment = new AssessmentImpl(null, literal, 0); |
| assess(assessment, false); |
| return assessment.normalizedLiteral; |
| } |
| |
| public String getNormalizedLiteral(String literal) |
| { |
| String result = literal; |
| XSDWhiteSpaceFacet effectiveWhiteSpaceFacet = getEffectiveWhiteSpaceFacet(); |
| if (effectiveWhiteSpaceFacet != null) |
| { |
| result = effectiveWhiteSpaceFacet.getNormalizedLiteral(result); |
| } |
| return result; |
| } |
| |
| public boolean equalValues(Object value1, Object value2) |
| { |
| return value1 == null ? value2 == null : value1.equals(value2); |
| } |
| |
| public boolean equalLiterals(String literal1, String literal2) |
| { |
| return equalLiterals(null, literal1, null, literal2); |
| } |
| |
| public boolean equalLiterals(Element context1, String literal1, Element context2, String literal2) |
| { |
| return equalValues(getValue(context1, literal1), getValue(context2, literal2)); |
| } |
| |
| public int compareValues(Object value1, Object value2) |
| { |
| if (XSDOrdered.FALSE_LITERAL != getOrderedFacet().getValue()) |
| { |
| XSDSimpleTypeDefinition thePrimitiveTypeDefinition = getPrimitiveTypeDefinition(); |
| if (thePrimitiveTypeDefinition != null) |
| { |
| XSDAnySimpleType xsdAnySimpleType = |
| XSDTypeRegister.getTypeImplementer(thePrimitiveTypeDefinition.getName()); |
| return |
| value1 == null ? |
| value2 == null ? |
| 0 : |
| -1 : |
| value2 == null ? |
| 1 : |
| xsdAnySimpleType.compareValues(value1, value2); |
| } |
| } |
| return 0; |
| } |
| |
| public int compareLiterals(String literal1, String literal2) |
| { |
| return compareLiterals(null, literal1, null, literal2); |
| } |
| |
| public int compareLiterals(Element context1, String literal1, Element context2, String literal2) |
| { |
| return compareValues(getValue(context1, literal1), getValue(context2, literal2)); |
| } |
| |
| @Override |
| public XSDTypeDefinition getBadTypeDerivation(XSDTypeDefinition xsdTypeDefinition, boolean extension, boolean restriction) |
| { |
| if (xsdTypeDefinition == this) |
| { |
| return null; |
| } |
| else if (!restriction || |
| getBaseTypeDefinition() == null || |
| getBaseTypeDefinition().getFinal().contains(XSDSimpleFinal.RESTRICTION_LITERAL)) |
| { |
| return this; |
| } |
| else |
| { |
| XSDTypeDefinition theBaseTypeDefinition = getBaseTypeDefinition(); |
| XSDTypeDefinition result = theBaseTypeDefinition; |
| if (theBaseTypeDefinition == xsdTypeDefinition) |
| { |
| return null; |
| } |
| else if (!XSDConstants.isURType(theBaseTypeDefinition)) |
| { |
| result = theBaseTypeDefinition.getBadTypeDerivation(xsdTypeDefinition, extension, restriction); |
| if (result == null) |
| { |
| return null; |
| } |
| } |
| |
| switch (getVariety().getValue()) |
| { |
| case XSDVariety.LIST: |
| case XSDVariety.UNION: |
| { |
| if (XSDConstants.isURType(xsdTypeDefinition)) |
| { |
| return null; |
| } |
| } |
| } |
| |
| if (xsdTypeDefinition instanceof XSDSimpleTypeDefinition) |
| { |
| XSDSimpleTypeDefinition xsdSimpleTypeDefinition = (XSDSimpleTypeDefinition)xsdTypeDefinition; |
| if (xsdSimpleTypeDefinition.getVariety() == XSDVariety.UNION_LITERAL) |
| { |
| for (XSDSimpleTypeDefinition memberTypeDefinition : xsdSimpleTypeDefinition.getMemberTypeDefinitions()) |
| { |
| XSDTypeDefinition memberResult = getBadTypeDerivation(memberTypeDefinition, extension, restriction); |
| if (memberResult == null) |
| { |
| return null; |
| } |
| } |
| } |
| } |
| else if (XSDConstants.isAnyType(xsdTypeDefinition)) |
| { |
| return null; |
| } |
| |
| return result; |
| } |
| } |
| |
| @Override |
| public XSDConcreteComponent cloneConcreteComponent(boolean deep, boolean shareDOM) |
| { |
| XSDSimpleTypeDefinitionImpl clonedSimpleTypeDefinition = |
| (XSDSimpleTypeDefinitionImpl)getXSDFactory().createXSDSimpleTypeDefinition(); |
| clonedSimpleTypeDefinition.isReconciling = true; |
| |
| XSDSimpleTypeDefinition theBaseTypeDefinition = getBaseTypeDefinition(); |
| |
| if (getName() != null) |
| { |
| clonedSimpleTypeDefinition.setName(getName()); |
| } |
| if (isSetLexicalFinal()) |
| { |
| if (!getLexicalFinal().isEmpty()) |
| { |
| clonedSimpleTypeDefinition.getLexicalFinal().addAll(getLexicalFinal()); |
| } |
| else |
| { |
| clonedSimpleTypeDefinition.getLexicalFinal().clear(); |
| } |
| } |
| |
| if (!(getContainer() instanceof XSDComplexTypeDefinition)) |
| { |
| if (getItemTypeDefinition() != null && (theBaseTypeDefinition == null || XSDConstants.isURType(theBaseTypeDefinition))) |
| { |
| if (!getContents().contains(getItemTypeDefinition())) |
| { |
| XSDSimpleTypeDefinition theItemTypeDefinition = getItemTypeDefinition(); |
| clonedSimpleTypeDefinition.setItemTypeDefinition |
| (createUnresolvedSimpleTypeDefinition |
| (theItemTypeDefinition.getTargetNamespace(), theItemTypeDefinition.getName())); |
| } |
| } |
| else if (!getMemberTypeDefinitions().isEmpty() && (theBaseTypeDefinition == null || XSDConstants.isURType(theBaseTypeDefinition))) |
| { |
| List<XSDSimpleTypeDefinition> unresolvedMembers = new ArrayList<XSDSimpleTypeDefinition>(getMemberTypeDefinitions().size()); |
| for (XSDSimpleTypeDefinition memberTypeDefinition : getMemberTypeDefinitions()) |
| { |
| if (getContents().contains(memberTypeDefinition)) |
| { |
| break; |
| } |
| else |
| { |
| unresolvedMembers.add |
| (createUnresolvedSimpleTypeDefinition |
| (memberTypeDefinition.getTargetNamespace(), memberTypeDefinition.getName())); |
| } |
| } |
| if (!unresolvedMembers.isEmpty()) |
| { |
| clonedSimpleTypeDefinition.getMemberTypeDefinitions().addAll(unresolvedMembers); |
| } |
| } |
| else |
| { |
| if (getBaseTypeDefinition() != null && !getContents().contains(getBaseTypeDefinition())) |
| { |
| clonedSimpleTypeDefinition.setBaseTypeDefinition |
| (createUnresolvedSimpleTypeDefinition |
| (theBaseTypeDefinition.getTargetNamespace(), theBaseTypeDefinition.getName())); |
| } |
| } |
| } |
| |
| if (deep) |
| { |
| if (getAnnotation() != null) |
| { |
| clonedSimpleTypeDefinition.setAnnotation((XSDAnnotation)getAnnotation().cloneConcreteComponent(deep, shareDOM)); |
| } |
| if (getDerivationAnnotation() != null) |
| { |
| clonedSimpleTypeDefinition.setDerivationAnnotation((XSDAnnotation)getDerivationAnnotation().cloneConcreteComponent(deep, shareDOM)); |
| } |
| if (!getContents().isEmpty()) |
| { |
| clonedSimpleTypeDefinition.getContents().addAll(cloneConcreteComponents(getContents(), deep, shareDOM)); |
| if (getItemTypeDefinition() != null && (theBaseTypeDefinition == null || XSDConstants.isURType(theBaseTypeDefinition))) |
| { |
| clonedSimpleTypeDefinition.setItemTypeDefinition(clonedSimpleTypeDefinition.getContents().get(0)); |
| } |
| else if (!getMemberTypeDefinitions().isEmpty() && (theBaseTypeDefinition == null || XSDConstants.isURType(theBaseTypeDefinition))) |
| { |
| clonedSimpleTypeDefinition.getMemberTypeDefinitions().addAll(clonedSimpleTypeDefinition.getContents()); |
| } |
| else |
| { |
| clonedSimpleTypeDefinition.setBaseTypeDefinition(clonedSimpleTypeDefinition.getContents().get(0)); |
| } |
| } |
| if (!getFacetContents().isEmpty()) |
| { |
| clonedSimpleTypeDefinition.getFacetContents().addAll(cloneConcreteComponents(getFacetContents(), deep, shareDOM)); |
| } |
| } |
| |
| if (shareDOM && getElement() != null) |
| { |
| clonedSimpleTypeDefinition.setElement(getElement()); |
| } |
| |
| clonedSimpleTypeDefinition.isReconciling = shareDOM; |
| return clonedSimpleTypeDefinition; |
| } |
| } |
