/*******************************************************************************
* Copyright (c) 2010 SAP AG.
* 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:
* Emil Simeonov - initial API and implementation.
* Dimitar Donchev - initial API and implementation.
* Dimitar Tenev - initial API and implementation.
* Nevena Manova - initial API and implementation.
* Georgi Konstantinov - initial API and implementation.
* Keshav Veerapaneni - initial API and implementation.
*******************************************************************************/
package org.eclipse.wst.sse.sieditor.model.xsd.impl;
import static org.eclipse.wst.sse.sieditor.model.utils.EmfXsdUtils.getXSDPackage;
import java.util.ArrayList;
import java.util.List;
import org.eclipse.core.commands.ExecutionException;
import org.eclipse.xsd.XSDEnumerationFacet;
import org.eclipse.xsd.XSDFacet;
import org.eclipse.xsd.XSDFractionDigitsFacet;
import org.eclipse.xsd.XSDLengthFacet;
import org.eclipse.xsd.XSDMaxExclusiveFacet;
import org.eclipse.xsd.XSDMaxInclusiveFacet;
import org.eclipse.xsd.XSDMaxLengthFacet;
import org.eclipse.xsd.XSDMinExclusiveFacet;
import org.eclipse.xsd.XSDMinInclusiveFacet;
import org.eclipse.xsd.XSDMinLengthFacet;
import org.eclipse.xsd.XSDPatternFacet;
import org.eclipse.xsd.XSDSimpleTypeDefinition;
import org.eclipse.xsd.XSDTotalDigitsFacet;
import org.eclipse.xsd.XSDTypeDefinition;
import org.eclipse.xsd.XSDWhiteSpace;
import org.eclipse.xsd.XSDWhiteSpaceFacet;
import org.w3c.dom.Element;
import org.eclipse.wst.sse.sieditor.command.emf.xsd.AddFacetCommand;
import org.eclipse.wst.sse.sieditor.command.emf.xsd.DeleteFacetCommand;
import org.eclipse.wst.sse.sieditor.command.emf.xsd.RenameNamedComponent;
import org.eclipse.wst.sse.sieditor.command.emf.xsd.SetBaseTypeCommand;
import org.eclipse.wst.sse.sieditor.core.common.Nil;
import org.eclipse.wst.sse.sieditor.model.api.IModelObject;
import org.eclipse.wst.sse.sieditor.model.api.IXSDModelRoot;
import org.eclipse.wst.sse.sieditor.model.generic.DuplicateException;
import org.eclipse.wst.sse.sieditor.model.generic.IllegalInputException;
import org.eclipse.wst.sse.sieditor.model.utils.EmfXsdUtils;
import org.eclipse.wst.sse.sieditor.model.xsd.api.IFacet;
import org.eclipse.wst.sse.sieditor.model.xsd.api.ISchema;
import org.eclipse.wst.sse.sieditor.model.xsd.api.ISimpleType;
import org.eclipse.wst.sse.sieditor.model.xsd.api.IType;
/**
*/
public class SimpleType extends AbstractType implements ISimpleType,
org.eclipse.wst.sse.sieditor.model.write.xsd.api.ISimpleType {
private final XSDSimpleTypeDefinition _simpleType;
public SimpleType(final IXSDModelRoot modelRoot, final ISchema schema, final XSDSimpleTypeDefinition type) {
this(modelRoot, schema, schema, type);
}
public SimpleType(final IXSDModelRoot modelRoot, final ISchema schema, final IModelObject parent,
final XSDSimpleTypeDefinition type) {
super(modelRoot, type, schema, parent);
this._simpleType = type;
}
public String getDocumentation() {
final Element documentation = getFirstElement(_simpleType.getAnnotations());
return super.getDocumentation(documentation);
}
public IType getBaseType() {
final XSDTypeDefinition baseType = _simpleType.getBaseType();
if (null == baseType)
return null;
final Schema parentSchema = (Schema) getParent();
if (null == baseType.getName()) {
return UnresolvedType.instance();
}
return (IType) parentSchema.resolveComponent(baseType, true);
}
public void setBaseType(final IType baseType) throws ExecutionException {
if (!(baseType instanceof ISimpleType))
return;
final SetBaseTypeCommand command = new SetBaseTypeCommand(getModelRoot(), this, baseType);
getModelRoot().getEnv().execute(command);
}
public String getLength() {
return _simpleType.getLengthFacet() == null ? null : _simpleType.getLengthFacet().getLexicalValue();
}
public String getMaxExclusive() {
return _simpleType.getMaxExclusiveFacet() == null ? null : _simpleType.getMaxExclusiveFacet().getLexicalValue();
}
public String getMaxInclusive() {
return _simpleType.getMaxInclusiveFacet() == null ? null : _simpleType.getMaxInclusiveFacet().getLexicalValue();
}
public String getMaxLength() {
return _simpleType.getMaxLengthFacet() == null ? null : _simpleType.getMaxLengthFacet().getLexicalValue();
}
public String getMinExclusive() {
return _simpleType.getMinExclusiveFacet() == null ? null : _simpleType.getMinExclusiveFacet().getLexicalValue();
}
public String getMinInclusive() {
return _simpleType.getMinInclusiveFacet() == null ? null : _simpleType.getMinInclusiveFacet().getLexicalValue();
}
public String getMinLength() {
return _simpleType.getMinLengthFacet() == null ? null : _simpleType.getMinLengthFacet().getLexicalValue();
}
public IFacet[] getPatterns() {
final List<XSDPatternFacet> patterns = _simpleType.getPatternFacets();
final List<IFacet> enums = new ArrayList<IFacet>(1);
for (final XSDPatternFacet pattern : patterns) {
enums.add(new Facet(getModelRoot(), pattern, this, getXSDPackage().getXSDPatternFacet()));
}
return enums.toArray(new IFacet[enums.size()]);
}
public IFacet[] getEnumerations() {
final List<XSDEnumerationFacet> enumerations = _simpleType.getEnumerationFacets();
final List<IFacet> enums = new ArrayList<IFacet>(1);
for (final XSDEnumerationFacet enumFacet : enumerations) {
enums.add(new Facet(getModelRoot(), enumFacet, this, getXSDPackage().getXSDEnumerationFacet()));
}
return enums.toArray(new IFacet[enums.size()]);
}
public boolean getCollapseWhiteSpaces() {
return _simpleType.getWhiteSpaceFacet() == null ? false
: _simpleType.getWhiteSpaceFacet().getValue() == XSDWhiteSpace.COLLAPSE_LITERAL;
}
public void addEnumeration(final String value) throws ExecutionException {
Nil.checkNil(value, "value"); //$NON-NLS-1$
final AddFacetCommand command = new AddFacetCommand(getModelRoot(), this, getXSDPackage().getXSDEnumerationFacet(), null,
value);
getModelRoot().getEnv().execute(command);
}
public void addPattern(final String pattern) throws ExecutionException {
Nil.checkNil(pattern, "value"); //$NON-NLS-1$
final AddFacetCommand command = new AddFacetCommand(getModelRoot(), this, getXSDPackage().getXSDPatternFacet(), null,
pattern);
getModelRoot().getEnv().execute(command);
}
public void setLength(final int length) throws ExecutionException {
Nil.checkNil(length, "length"); //$NON-NLS-1$
final XSDLengthFacet facet = _simpleType.getLengthFacet();
final AddFacetCommand command = new AddFacetCommand(getModelRoot(), this, getXSDPackage().getXSDLengthFacet(), facet,
length + ""); //$NON-NLS-1$
getModelRoot().getEnv().execute(command);
}
public void setMaxExclusive(final String value) throws ExecutionException {
Nil.checkNil(value, "length"); //$NON-NLS-1$
final XSDMaxExclusiveFacet facet = _simpleType.getMaxExclusiveFacet();
final AddFacetCommand command = new AddFacetCommand(getModelRoot(), this, getXSDPackage().getXSDMaxExclusiveFacet(),
facet, value);
getModelRoot().getEnv().execute(command);
}
public void setMaxInclusive(final String value) throws ExecutionException {
Nil.checkNil(value, "length"); //$NON-NLS-1$
final XSDMaxInclusiveFacet facet = _simpleType.getMaxInclusiveFacet();
final AddFacetCommand command = new AddFacetCommand(getModelRoot(), this, getXSDPackage().getXSDMaxInclusiveFacet(),
facet, value);
getModelRoot().getEnv().execute(command);
}
public void setMaxLength(final int length) throws ExecutionException {
Nil.checkNil(length, "length"); //$NON-NLS-1$
final XSDMaxLengthFacet facet = _simpleType.getMaxLengthFacet();
final AddFacetCommand command = new AddFacetCommand(getModelRoot(), this, getXSDPackage().getXSDMaxLengthFacet(), facet,
length + ""); //$NON-NLS-1$
getModelRoot().getEnv().execute(command);
}
public void setMinExclusive(final String value) throws ExecutionException {
Nil.checkNil(value, "length"); //$NON-NLS-1$
final XSDMinExclusiveFacet facet = _simpleType.getMinExclusiveFacet();
final AddFacetCommand command = new AddFacetCommand(getModelRoot(), this, getXSDPackage().getXSDMinExclusiveFacet(),
facet, value);
getModelRoot().getEnv().execute(command);
}
public void setMinInclusive(final String value) throws ExecutionException {
Nil.checkNil(value, "length"); //$NON-NLS-1$
final XSDMinInclusiveFacet facet = _simpleType.getMinInclusiveFacet();
final AddFacetCommand command = new AddFacetCommand(getModelRoot(), this, getXSDPackage().getXSDMinInclusiveFacet(),
facet, value + ""); //$NON-NLS-1$
getModelRoot().getEnv().execute(command);
}
public void setMinLength(final int length) throws ExecutionException {
Nil.checkNil(length, "length"); //$NON-NLS-1$
final XSDMinLengthFacet facet = _simpleType.getMinLengthFacet();
final AddFacetCommand command = new AddFacetCommand(getModelRoot(), this, getXSDPackage().getXSDMinLengthFacet(), facet,
length + ""); //$NON-NLS-1$
getModelRoot().getEnv().execute(command);
}
public void setCollapseWhiteSpaces(final boolean collapse) throws ExecutionException {
final XSDWhiteSpaceFacet facet = _simpleType.getWhiteSpaceFacet();
if (collapse) {
final AddFacetCommand command = new AddFacetCommand(getModelRoot(), this, getXSDPackage().getXSDWhiteSpaceFacet(),
facet, XSDWhiteSpace.COLLAPSE_LITERAL + ""); //$NON-NLS-1$
getModelRoot().getEnv().execute(command);
} else if (null != facet) {
final DeleteFacetCommand command = new DeleteFacetCommand(getModelRoot(), this, facet);
getModelRoot().getEnv().execute(command);
}
}
public void setName(final String name) throws IllegalInputException, DuplicateException, ExecutionException {
Nil.checkNil(name, "name"); //$NON-NLS-1$
if (!EmfXsdUtils.isValidNCName(name))
throw new IllegalInputException("Entered Type name '" + name + "' is not valid"); //$NON-NLS-1$ //$NON-NLS-2$
final XSDTypeDefinition resolvedTypeDefinition = getParent().getComponent().resolveTypeDefinition(name);
if (resolvedTypeDefinition.eContainer() != null) {
throw new DuplicateException("Type with name '" + name + "' already exists"); //$NON-NLS-1$ //$NON-NLS-2$
}
final RenameNamedComponent command = new RenameNamedComponent(getModelRoot(), this, name);
getModelRoot().getEnv().execute(command);
}
/*
* public Element setDocumentation(String description) throws
* ExecutionException { Nil.checkNil(description, "description");
* //$NON-NLS-1$ XSDAnnotation annotation = _simpleType.getAnnotation(); if
* (null == annotation) { AddAnotationCommand command = new
* AddAnotationCommand(_simpleType, getModelRoot(), this); if
* (getModelRoot().getEnv().execute(command).isOK()) annotation =
* command.getAnnotation(); } if (annotation != null) {
* super.setDocumentation(annotation, description); } // TODO inform user of
* failure and log??? return null; }
*/
public void setNamespace(final String namespace) {
// Do Nothing
}
public void removeEnumeration(final IFacet facet) throws ExecutionException {
Nil.checkNil(facet, "facet"); //$NON-NLS-1$
if (facet instanceof Facet && equals(((Facet) facet).getParent())) {
final XSDFacet enumeration = facet.getComponent();
if (enumeration instanceof XSDEnumerationFacet) {
final DeleteFacetCommand command = new DeleteFacetCommand(getModelRoot(), this, enumeration);
getModelRoot().getEnv().execute(command);
}
}
}
public void removePattern(final IFacet facet) throws ExecutionException {
Nil.checkNil(facet, "facet"); //$NON-NLS-1$
if (facet instanceof Facet && equals(((Facet) facet).getParent())) {
final XSDFacet pattern = facet.getComponent();
if (pattern instanceof XSDPatternFacet) {
final DeleteFacetCommand command = new DeleteFacetCommand(getModelRoot(), this, pattern);
getModelRoot().getEnv().execute(command);
}
}
}
public Whitespace getWhitespace() {
final XSDWhiteSpaceFacet whiteSpaceFacet = _simpleType.getWhiteSpaceFacet();
if (whiteSpaceFacet == null) {
return null;
}
final XSDWhiteSpace value = whiteSpaceFacet.getValue();
if (value == XSDWhiteSpace.COLLAPSE_LITERAL) {
return Whitespace.COLLAPSE;
} else if (value == XSDWhiteSpace.PRESERVE_LITERAL) {
return Whitespace.PRESERVE;
} else if (value == XSDWhiteSpace.REPLACE_LITERAL) {
return Whitespace.REPLACE;
}
return null;
}
public String getTotalDigits() {
final XSDTotalDigitsFacet totalDigitsFacet = _simpleType.getTotalDigitsFacet();
if (totalDigitsFacet == null) {
return null;
}
return totalDigitsFacet.getLexicalValue();
}
public String getFractionDigits() {
final XSDFractionDigitsFacet fractionDigitsFacet = _simpleType.getFractionDigitsFacet();
if (fractionDigitsFacet == null) {
return null;
}
return fractionDigitsFacet.getLexicalValue();
}
}