Debian Codegraph @

plugins/org.eclipse.xsd/src/org/eclipse/xsd/impl/XSDPatternFacetImpl.java

raw
1 /**
2 * Copyright (c) 2002-2006 IBM Corporation and others.
3 * All rights reserved. This program and the accompanying materials
4 * are made available under the terms of the Eclipse Public License v2.0
5 * which accompanies this distribution, and is available at
6 * http://www.eclipse.org/legal/epl-v20.html
7 *
8 * Contributors:
9 * IBM - Initial API and implementation
10 */
11 package org.eclipse.xsd.impl;
12
13
14 import java.util.ArrayList;
15 import java.util.Collection;
16
17 import org.w3c.dom.Element;
18 import org.w3c.dom.Node;
19
20 import org.eclipse.emf.common.util.EList;
21 import org.eclipse.emf.ecore.EAttribute;
22 import org.eclipse.emf.ecore.EClass;
23 import org.eclipse.emf.ecore.util.EDataTypeUniqueEList;
24 import org.eclipse.emf.ecore.xml.type.internal.RegEx.ParseException;
25 import org.eclipse.emf.ecore.xml.type.internal.RegEx.RegularExpression;
26
27 import org.eclipse.xsd.XSDAnnotation;
28 import org.eclipse.xsd.XSDConcreteComponent;
29 import org.eclipse.xsd.XSDDiagnostic;
30 import org.eclipse.xsd.XSDDiagnosticSeverity;
31 import org.eclipse.xsd.XSDFactory;
32 import org.eclipse.xsd.XSDPackage;
33 import org.eclipse.xsd.XSDPatternFacet;
34 import org.eclipse.xsd.XSDPlugin;
35 import org.eclipse.xsd.XSDSimpleTypeDefinition;
36 import org.eclipse.xsd.util.XSDConstants;
37 import org.eclipse.xsd.util.XSDUtil;
38
39
40 /**
41 * <!-- begin-user-doc -->
42 * An implementation of the model object '<em><b>Pattern Facet</b></em>'.
43 * <!-- end-user-doc -->
44 * <p>
45 * The following features are implemented:
46 * </p>
47 * <ul>
48 * <li>{@link org.eclipse.xsd.impl.XSDPatternFacetImpl#getValue <em>Value</em>}</li>
49 * </ul>
50 *
51 * @generated
52 */
53 public class XSDPatternFacetImpl
54 extends XSDRepeatableFacetImpl
55 implements XSDPatternFacet
56 {
57 /**
58 * The cached value of the '{@link #getValue() <em>Value</em>}' attribute list.
59 * <!-- begin-user-doc -->
60 * <!-- end-user-doc -->
61 * @see #getValue()
62 * @generated
63 * @ordered
64 */
65 protected EList<String> value;
66
67 public static XSDPatternFacet createPatternFacet(Node node)
68 {
69 if (XSDConstants.nodeType(node) == XSDConstants.PATTERN_ELEMENT)
70 {
71 XSDPatternFacet xsdPatternFacet = XSDFactory.eINSTANCE.createXSDPatternFacet();
72 xsdPatternFacet.setElement((Element)node);
73 return xsdPatternFacet;
74 }
75
76 return null;
77 }
78
79 /**
80 * <!-- begin-user-doc -->
81 * <!-- end-user-doc -->
82 * @generated
83 */
84 protected XSDPatternFacetImpl()
85 {
86 super();
87 }
88
89 /**
90 * <!-- begin-user-doc -->
91 * <!-- end-user-doc -->
92 * @generated
93 */
94 @Override
95 protected EClass eStaticClass()
96 {
97 return XSDPackage.Literals.XSD_PATTERN_FACET;
98 }
99
100 /**
101 * <!-- begin-user-doc -->
102 * <!-- end-user-doc -->
103 * @generated
104 */
105 @Override
106 public EList<String> getValue()
107 {
108 if (value == null)
109 {
110 value = new EDataTypeUniqueEList<String>(String.class, this, XSDPackage.XSD_PATTERN_FACET__VALUE);
111 }
112 return value;
113 }
114
115 /**
116 * <!-- begin-user-doc -->
117 * <!-- end-user-doc -->
118 * @generated
119 */
120 @Override
121 public Object eGet(int featureID, boolean resolve, boolean coreType)
122 {
123 switch (featureID)
124 {
125 case XSDPackage.XSD_PATTERN_FACET__VALUE:
126 return getValue();
127 }
128 return super.eGet(featureID, resolve, coreType);
129 }
130
131 /**
132 * <!-- begin-user-doc -->
133 * <!-- end-user-doc -->
134 * @generated
135 */
136 @SuppressWarnings("unchecked")
137 @Override
138 public void eSet(int featureID, Object newValue)
139 {
140 switch (featureID)
141 {
142 case XSDPackage.XSD_PATTERN_FACET__VALUE:
143 getValue().clear();
144 getValue().addAll((Collection<? extends String>)newValue);
145 return;
146 }
147 super.eSet(featureID, newValue);
148 }
149
150 /**
151 * <!-- begin-user-doc -->
152 * <!-- end-user-doc -->
153 * @generated
154 */
155 @Override
156 public void eUnset(int featureID)
157 {
158 switch (featureID)
159 {
160 case XSDPackage.XSD_PATTERN_FACET__VALUE:
161 getValue().clear();
162 return;
163 }
164 super.eUnset(featureID);
165 }
166
167 /**
168 * <!-- begin-user-doc -->
169 * <!-- end-user-doc -->
170 * @generated
171 */
172 @Override
173 public boolean eIsSet(int featureID)
174 {
175 switch (featureID)
176 {
177 case XSDPackage.XSD_PATTERN_FACET__VALUE:
178 return value != null && !value.isEmpty();
179 }
180 return super.eIsSet(featureID);
181 }
182
183 /**
184 * <!-- begin-user-doc -->
185 * <!-- end-user-doc -->
186 * @generated
187 */
188 @Override
189 public String toString()
190 {
191 if (eIsProxy()) return super.toString();
192
193 StringBuilder result = new StringBuilder(super.toString());
194 result.append(" (value: ");
195 result.append(value);
196 result.append(')');
197 return result.toString();
198 }
199
200 @Override
201 public Element createElement()
202 {
203 Element newElement = createElement(XSDConstants.PATTERN_ELEMENT);
204 setElement(newElement);
205 return newElement;
206 }
207
208 protected Collection<RegularExpression> patterns;
209 public Collection<RegularExpression> getPatterns(boolean withDiagnostics)
210 {
211 if (patterns == null || withDiagnostics)
212 {
213 ArrayList<RegularExpression> result = new ArrayList<RegularExpression>();
214 Collection<String> theValues = getValue();
215 XSDSimpleTypeDefinition xsdSimpleTypeDefinition = getSimpleTypeDefinition();
216 if (theValues.isEmpty())
217 {
218 if (xsdSimpleTypeDefinition != null && !xsdSimpleTypeDefinition.getSyntheticFacets().contains(this))
219 {
220 createRequiredAttributeDiagnostic(XSDConstants.PART1, "element-pattern", getElement(), XSDConstants.VALUE_ATTRIBUTE);
221 }
222 }
223 else
224 {
225 for (String value : theValues)
226 {
227 try
228 {
229 if (value.contains("child:") && xsdSimpleTypeDefinition != null && XSDUtil.isSchemaForSchemaNamespace(xsdSimpleTypeDefinition.getTargetNamespace()))
230 {
231 value = value.replaceAll("\\\\\\.|@|//?|\\\\\\|", "\\\\s*$0\\\\s*");
232 }
233
234 result.add(new RegularExpression(value, "X"));
235 }
236 catch (ParseException parseException)
237 {
238 if (withDiagnostics)
239 {
240 createPatternDiagnostic(parseException.getMessage(), parseException.getLocation());
241 }
242 }
243 }
244 }
245 patterns = result;
246 }
247 return patterns;
248 }
249
250 @Override
251 public void validateValue()
252 {
253 getPatterns(true);
254 }
255
256 protected XSDDiagnostic createPatternDiagnostic(String parseError, int location)
257 {
258 XSDDiagnostic result = getXSDFactory().createXSDDiagnostic();
259 result.setSeverity(XSDDiagnosticSeverity.ERROR_LITERAL);
260 result.setMessage
261 (XSDPlugin.INSTANCE.getString
262 ("_UI_XSDError_message",
263 new Object []
264 {
265 populateDiagnostic(result, "dt-regex", new Object [] { getLexicalValue(), location, parseError })
266 }));
267 result.setAnnotationURI(XSDConstants.PART1 + "#dt-regex");
268 result.setPrimaryComponent(this);
269 result.setNode(getElement());
270 getDiagnostics().add(result);
271 return result;
272 }
273
274 @Override
275 protected boolean analyze()
276 {
277 super.analyze();
278 XSDSimpleTypeDefinition xsdSimpleTypeDefinition = (XSDSimpleTypeDefinition)getContainer();
279 if (xsdSimpleTypeDefinition != null && !xsdSimpleTypeDefinition.getSyntheticFacets().contains(this))
280 {
281 String newValue = getLexicalValue();
282 if (!getValue().contains(newValue))
283 {
284 getValue().clear();
285 if (newValue != null)
286 {
287 getValue().add(newValue);
288 }
289 patterns = null;
290 }
291 }
292 return true;
293 }
294
295 @Override
296 protected void changeAttribute(EAttribute eAttribute)
297 {
298 super.changeAttribute(eAttribute);
299 if (eAttribute == XSDPackage.Literals.XSD_FACET__LEXICAL_VALUE)
300 {
301 traverseToRootForAnalysis();
302 patterns = null;
303 }
304 }
305 @Override
306 public boolean isConstraintSatisfied(Object value)
307 {
308 if (value == null)
309 {
310 return false;
311 }
312 else
313 {
314 for (RegularExpression pattern : getPatterns(false))
315 {
316 if (!pattern.matches((String)value))
317 {
318 return false;
319 }
320 }
321 return true;
322 }
323 }
324
325 @Override
326 public Object getEffectiveValue()
327 {
328 return getValue();
329 }
330
331 @Override
332 public XSDConcreteComponent cloneConcreteComponent(boolean deep, boolean shareDOM)
333 {
334 XSDPatternFacetImpl clonedPatternFacet =
335 (XSDPatternFacetImpl)getXSDFactory().createXSDPatternFacet();
336 clonedPatternFacet.isReconciling = true;
337
338 if (getLexicalValue() != null)
339 {
340 clonedPatternFacet.setLexicalValue(getLexicalValue());
341 }
342
343 if (shareDOM && getElement() != null)
344 {
345 clonedPatternFacet.setElement(getElement());
346 }
347
348 if (deep)
349 {
350 if (getAnnotation() != null)
351 {
352 clonedPatternFacet.setAnnotation((XSDAnnotation)getAnnotation().cloneConcreteComponent(deep, shareDOM));
353 }
354 }
355
356 clonedPatternFacet.isReconciling = shareDOM;
357 return clonedPatternFacet;
358 }
359 }