org.eclipse.xsd.impl.XSDRedefineImpl Maven / Gradle / Ivy
/**
* Copyright (c) 2002-2006 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v2.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v20.html
*
* Contributors:
* IBM - Initial API and implementation
*/
package org.eclipse.xsd.impl;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.eclipse.emf.common.notify.NotificationChain;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EReference;
import org.eclipse.emf.ecore.InternalEObject;
import org.eclipse.emf.ecore.util.EObjectContainmentEList;
import org.eclipse.emf.ecore.util.EObjectEList;
import org.eclipse.emf.ecore.util.InternalEList;
import org.eclipse.xsd.XSDAnnotation;
import org.eclipse.xsd.XSDAttributeGroupDefinition;
import org.eclipse.xsd.XSDComplexTypeDefinition;
import org.eclipse.xsd.XSDConcreteComponent;
import org.eclipse.xsd.XSDDiagnosticSeverity;
import org.eclipse.xsd.XSDFactory;
import org.eclipse.xsd.XSDModelGroupDefinition;
import org.eclipse.xsd.XSDPackage;
import org.eclipse.xsd.XSDParticle;
import org.eclipse.xsd.XSDRedefine;
import org.eclipse.xsd.XSDRedefineContent;
import org.eclipse.xsd.XSDSchema;
import org.eclipse.xsd.XSDTypeDefinition;
import org.eclipse.xsd.util.XSDConstants;
/**
*
* An implementation of the model object 'Redefine'.
*
*
* The following features are implemented:
*
*
* - {@link org.eclipse.xsd.impl.XSDRedefineImpl#getAnnotations Annotations}
* - {@link org.eclipse.xsd.impl.XSDRedefineImpl#getContents Contents}
*
*
* @generated
*/
public class XSDRedefineImpl
extends XSDSchemaCompositorImpl
implements XSDRedefine
{
/**
* The cached value of the '{@link #getAnnotations() Annotations}' reference list.
*
*
* @see #getAnnotations()
* @generated
* @ordered
*/
protected EList annotations;
/**
* The cached value of the '{@link #getContents() Contents}' containment reference list.
*
*
* @see #getContents()
* @generated
* @ordered
*/
protected EList contents;
public static XSDRedefine createRedefine(Node node)
{
if (XSDConstants.nodeType(node) == XSDConstants.REDEFINE_ELEMENT)
{
XSDRedefine xsdRedefine = XSDFactory.eINSTANCE.createXSDRedefine();
xsdRedefine.setElement((Element)node);
return xsdRedefine;
}
return null;
}
/**
*
*
* @generated
*/
protected XSDRedefineImpl()
{
super();
}
/**
*
*
* @generated
*/
@Override
protected EClass eStaticClass()
{
return XSDPackage.Literals.XSD_REDEFINE;
}
/**
*
*
* @generated
*/
@Override
public EList getAnnotations()
{
if (annotations == null)
{
annotations = new EObjectEList(XSDAnnotation.class, this, XSDPackage.XSD_REDEFINE__ANNOTATIONS);
}
return annotations;
}
/**
*
*
* @generated
*/
@Override
public EList getContents()
{
if (contents == null)
{
contents = new EObjectContainmentEList(XSDRedefineContent.class, this, XSDPackage.XSD_REDEFINE__CONTENTS);
}
return contents;
}
/**
*
*
* @generated
*/
@Override
public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs)
{
switch (featureID)
{
case XSDPackage.XSD_REDEFINE__CONTENTS:
return ((InternalEList)getContents()).basicRemove(otherEnd, msgs);
}
return super.eInverseRemove(otherEnd, featureID, msgs);
}
/**
*
*
* @generated
*/
@Override
public Object eGet(int featureID, boolean resolve, boolean coreType)
{
switch (featureID)
{
case XSDPackage.XSD_REDEFINE__ANNOTATIONS:
return getAnnotations();
case XSDPackage.XSD_REDEFINE__CONTENTS:
return getContents();
}
return super.eGet(featureID, resolve, coreType);
}
/**
*
*
* @generated
*/
@SuppressWarnings("unchecked")
@Override
public void eSet(int featureID, Object newValue)
{
switch (featureID)
{
case XSDPackage.XSD_REDEFINE__ANNOTATIONS:
getAnnotations().clear();
getAnnotations().addAll((Collection)newValue);
return;
case XSDPackage.XSD_REDEFINE__CONTENTS:
getContents().clear();
getContents().addAll((Collection)newValue);
return;
}
super.eSet(featureID, newValue);
}
/**
*
*
* @generated
*/
@Override
public void eUnset(int featureID)
{
switch (featureID)
{
case XSDPackage.XSD_REDEFINE__ANNOTATIONS:
getAnnotations().clear();
return;
case XSDPackage.XSD_REDEFINE__CONTENTS:
getContents().clear();
return;
}
super.eUnset(featureID);
}
/**
*
*
* @generated
*/
@Override
public boolean eIsSet(int featureID)
{
switch (featureID)
{
case XSDPackage.XSD_REDEFINE__ANNOTATIONS:
return annotations != null && !annotations.isEmpty();
case XSDPackage.XSD_REDEFINE__CONTENTS:
return contents != null && !contents.isEmpty();
}
return super.eIsSet(featureID);
}
@Override
public Element createElement()
{
Element newElement = createElement(XSDConstants.REDEFINE_ELEMENT);
setElement(newElement);
for (XSDRedefineContent xsdRedefineContent : getContents())
{
Element contentElement = ((XSDConcreteComponentImpl)xsdRedefineContent).createElement();
newElement.appendChild(contentElement);
}
return newElement;
}
@Override
protected void patch()
{
if (getSchemaLocation() != null && getSchemaLocation().length() > 0)
{
XSDSchemaImpl containingSchema = (XSDSchemaImpl)getContainer();
String oldPendingSchemaLocation = containingSchema.pendingSchemaLocation;
if (containingSchema.getSchemaLocation() != null)
{
containingSchema.pendingSchemaLocation = containingSchema.getSchemaLocation();
}
resolve("", getSchemaLocation());
containingSchema.pendingSchemaLocation = oldPendingSchemaLocation;
super.patch();
if (oldPendingSchemaLocation == null)
{
List redefinitions = containingSchema.getSchemasToRedefine();
containingSchema.schemasToRedefine = null;
for (XSDSchemaImpl schemaToRedefine : redefinitions)
{
if (schemaToRedefine != containingSchema)
{
schemaToRedefine.forceResolve = true;
schemaToRedefine.setSchemaLocation(schemaToRedefine.pendingSchemaLocation);
schemaToRedefine.forceResolve = false;
schemaToRedefine.pendingSchemaLocation = null;
}
}
}
}
else
{
super.patch();
}
}
@Override
protected void handleResolvedSchema(XSDSchema xsdSchema)
{
if (xsdSchema == null)
{
setResolvedSchema(null);
setIncorporatedSchema(null);
}
else
{
((XSDSchemaImpl)xsdSchema).redefined(this);
}
}
@Override
public void validate()
{
super.validate();
Element theElement = getElement();
if (theElement != null)
{
checkAttributes
(XSDConstants.PART1,
"element-redefine",
theElement,
new String []
{
XSDConstants.ID_ATTRIBUTE,
XSDConstants.SCHEMALOCATION_ATTRIBUTE,
});
XSDComplexTypeDefinition xsdComplexTypeDefinition =
(XSDComplexTypeDefinition)getSchema().getSchemaForSchema().resolveElementDeclaration("redefine").getTypeDefinition();
checkComplexContent(xsdComplexTypeDefinition, XSDConstants.PART1, "element-redefine", theElement);
checkBuiltInTypeConstraint
("ID",
null,
XSDConstants.PART1,
"element-redefine",
theElement,
XSDConstants.ID_ATTRIBUTE,
false);
}
checkBuiltInTypeConstraint
("anyURI",
getSchemaLocation(),
XSDConstants.PART1,
"element-redefine",
theElement,
XSDConstants.SCHEMALOCATION_ATTRIBUTE,
true);
XSDSchema theResolvedSchema = getResolvedSchema();
if (theResolvedSchema == null)
{
boolean hasRedefinitions = false;
for (XSDRedefineContent content : getContents())
{
if (!(content instanceof XSDAnnotation))
{
hasRedefinitions = true;
break;
}
}
if (hasRedefinitions)
{
createDiagnostic
(XSDDiagnosticSeverity.ERROR_LITERAL,
"src-redefine.1",
getSchemaLocation() == null ? "" : getSchemaLocation());
}
else
{
createDiagnostic
(XSDDiagnosticSeverity.WARNING_LITERAL,
"src-redefine.0",
getSchemaLocation() == null ? "" : getSchemaLocation());
}
}
else
{
if (theResolvedSchema.eResource() == null ||
theResolvedSchema.getElement() == null ||
XSDConstants.nodeType(theResolvedSchema.getElement()) != XSDConstants.SCHEMA_ELEMENT)
{
createDiagnostic
(XSDDiagnosticSeverity.ERROR_LITERAL,
"src-redefine.2",
getSchemaLocation() == null ? "" : getSchemaLocation());
}
else
{
XSDSchema theSchema = getSchema();
if (theSchema.getTargetNamespace() == null ?
theResolvedSchema.getTargetNamespace() != null :
!theSchema.getTargetNamespace().equals(theResolvedSchema.getTargetNamespace()) &&
theResolvedSchema.getTargetNamespace() != null)
{
createDiagnostic
(XSDDiagnosticSeverity.ERROR_LITERAL,
"src-redefine.3",
theResolvedSchema.getTargetNamespace() == null ? "" : theResolvedSchema.getTargetNamespace(),
theSchema.getTargetNamespace() == null ? "" : theSchema.getTargetNamespace());
}
else
{
for (XSDRedefineContent xsdRedefineContent : getContents())
{
if (xsdRedefineContent instanceof XSDTypeDefinition)
{
XSDTypeDefinition xsdTypeDefinition = (XSDTypeDefinition)xsdRedefineContent;
XSDTypeDefinition baseType = xsdTypeDefinition.getBaseType();
if (baseType == null ||
!baseType.hasSameNameAndTargetNamespace(xsdTypeDefinition) ||
resolveTypeDefinition(xsdTypeDefinition.getName()).getContainer() == null)
{
getDiagnosticTarget(xsdTypeDefinition).createDiagnostic
(XSDDiagnosticSeverity.ERROR_LITERAL,
"src-redefine.5",
xsdTypeDefinition.getName());
}
}
else if (xsdRedefineContent instanceof XSDModelGroupDefinition)
{
XSDModelGroupDefinition xsdModelGroupDefinition = (XSDModelGroupDefinition)xsdRedefineContent;
Collection selfReferences = new ArrayList();
for (Iterator j = xsdModelGroupDefinition.eAllContents(); j.hasNext(); )
{
Object component = j.next();
if (component instanceof XSDModelGroupDefinition)
{
XSDModelGroupDefinition otherXSDModelGroupDefinition = (XSDModelGroupDefinition)component;
if (xsdModelGroupDefinition.hasSameNameAndTargetNamespace
(otherXSDModelGroupDefinition.getResolvedModelGroupDefinition()))
{
selfReferences.add(otherXSDModelGroupDefinition);
}
}
}
if (selfReferences.isEmpty())
{
XSDModelGroupDefinition otherXSDModelGroupDefinition =
(XSDModelGroupDefinition)((XSDSchemaImpl)getContainer()).getRedefinitionMap().get(xsdModelGroupDefinition);
if (otherXSDModelGroupDefinition == null || otherXSDModelGroupDefinition.getContainer() == null)
{
((XSDConcreteComponentImpl)xsdModelGroupDefinition).createDiagnostic
(XSDDiagnosticSeverity.ERROR_LITERAL,
"src-redefine.6.2.1",
xsdModelGroupDefinition.getName());
}
else
{
XSDParticle xsdParticle = XSDFactory.eINSTANCE.createXSDParticle();
xsdParticle.setTerm(xsdModelGroupDefinition.getModelGroup());
XSDParticle otherXSDParticle = XSDFactory.eINSTANCE.createXSDParticle();
otherXSDParticle.setTerm(otherXSDModelGroupDefinition.getModelGroup());
// EATM This doesn't really work for retargeted schemas.
//
if (!((XSDParticleImpl)xsdParticle).isSubset(otherXSDParticle, true))
{
((XSDConcreteComponentImpl)xsdModelGroupDefinition).createDiagnostic
(XSDDiagnosticSeverity.ERROR_LITERAL,
"src-redefine.6.2.2");
}
}
}
else
{
Iterator j = selfReferences.iterator();
XSDModelGroupDefinition otherXSDModelGroupDefinition = j.next();
XSDParticle xsdParticle = (XSDParticle)otherXSDModelGroupDefinition.getContainer();
if (xsdParticle.getMinOccurs() != 1 || xsdParticle.getMaxOccurs() != 1)
{
((XSDConcreteComponentImpl)xsdParticle).createDiagnostic
(XSDDiagnosticSeverity.ERROR_LITERAL,
"src-redefine.6.1.2");
}
while (j.hasNext())
{
XSDConcreteComponentImpl xsdConcreteComponent = (XSDConcreteComponentImpl)j.next();
xsdConcreteComponent.createDiagnostic
(XSDDiagnosticSeverity.ERROR_LITERAL,
"src-redefine.6.1.1");
}
}
}
else if (xsdRedefineContent instanceof XSDAttributeGroupDefinition)
{
XSDAttributeGroupDefinition xsdAttributeGroupDefinition = (XSDAttributeGroupDefinition)xsdRedefineContent;
Collection selfReferences = new ArrayList();
for (Iterator j = xsdAttributeGroupDefinition.eAllContents(); j.hasNext(); )
{
Object component = j.next();
if (component instanceof XSDAttributeGroupDefinition)
{
XSDAttributeGroupDefinition otherXSDAttributeGroupDefinition = (XSDAttributeGroupDefinition)component;
if (xsdAttributeGroupDefinition.hasSameNameAndTargetNamespace
(otherXSDAttributeGroupDefinition.getResolvedAttributeGroupDefinition()))
{
selfReferences.add(otherXSDAttributeGroupDefinition);
}
}
}
if (selfReferences.isEmpty())
{
XSDAttributeGroupDefinition otherXSDAttributeGroupDefinition =
(XSDAttributeGroupDefinition)((XSDSchemaImpl)getContainer()).getRedefinitionMap().get(xsdAttributeGroupDefinition);
if (otherXSDAttributeGroupDefinition == null || otherXSDAttributeGroupDefinition.getContainer() == null)
{
((XSDConcreteComponentImpl)xsdAttributeGroupDefinition).createDiagnostic
(XSDDiagnosticSeverity.ERROR_LITERAL,
"src-redefine.7.2.1",
xsdAttributeGroupDefinition.getName());
}
else
{
// EATM This doesn't really work for retargeted schemas.
//
XSDComplexTypeDefinitionImpl.validateAttributeGroup
((XSDConcreteComponentImpl)xsdAttributeGroupDefinition,
xsdAttributeGroupDefinition.getAttributeWildcardContent(),
otherXSDAttributeGroupDefinition.getAttributeUses(),
xsdAttributeGroupDefinition.getAttributeUses(),
otherXSDAttributeGroupDefinition.getAttributeWildcard(),
xsdAttributeGroupDefinition.getAttributeWildcard());
}
}
else
{
Iterator j = selfReferences.iterator();
j.next();
while (j.hasNext())
{
XSDConcreteComponentImpl xsdConcreteComponent = (XSDConcreteComponentImpl)j.next();
xsdConcreteComponent.createDiagnostic
(XSDDiagnosticSeverity.ERROR_LITERAL,
"src-redefine.7.1");
}
}
}
}
}
}
}
}
@Override
protected void handleUnreconciledElement(Element child, List newContents, List remainingContents)
{
XSDRedefineContent xsdRedefineContent = XSDRedefineContentImpl.createRedefineContent(child);
if (xsdRedefineContent != null)
{
newContents.add(xsdRedefineContent);
}
}
@Override
protected void handleReconciliation(List newContents, List remainingContents)
{
if (!remainingContents.isEmpty())
{
getContents().removeAll(remainingContents);
}
@SuppressWarnings("unchecked") List list = (List)(List)newContents;
setListContentAndOrder(getContents(), list);
}
@Override
protected void adoptContent(EReference eReference, XSDConcreteComponent xsdConcreteComponent)
{
super.adoptContent(eReference, xsdConcreteComponent);
if (xsdConcreteComponent instanceof XSDAnnotation)
{
getAnnotations().add((XSDAnnotation)xsdConcreteComponent);
}
}
@Override
protected void orphanContent(EReference eReference, XSDConcreteComponent xsdConcreteComponent)
{
super.orphanContent(eReference, xsdConcreteComponent);
if (xsdConcreteComponent instanceof XSDAnnotation)
{
getAnnotations().remove(xsdConcreteComponent);
}
}
@Override
public XSDConcreteComponent cloneConcreteComponent(boolean deep, boolean shareDOM)
{
XSDRedefineImpl clonedRedefine =
(XSDRedefineImpl)getXSDFactory().createXSDRedefine();
clonedRedefine.isReconciling = true;
clonedRedefine.setSchemaLocation(getSchemaLocation());
if (deep)
{
if (!getContents().isEmpty())
{
clonedRedefine.getContents().addAll(cloneConcreteComponents(getContents(), true, shareDOM));
}
}
if (shareDOM && getElement() != null)
{
clonedRedefine.setElement(getElement());
}
clonedRedefine.isReconciling = shareDOM;
return clonedRedefine;
}
}