KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > eclipse > emf > ecore > xml > type > impl > XMLTypeFactoryImpl


1 /**
2  * <copyright>
3  *
4  * Copyright (c) 2003-2005 IBM Corporation and others.
5  * All rights reserved. This program and the accompanying materials
6  * are made available under the terms of the Eclipse Public License v1.0
7  * which accompanies this distribution, and is available at
8  * http://www.eclipse.org/legal/epl-v10.html
9  *
10  * Contributors:
11  * IBM - Initial API and implementation
12  *
13  * </copyright>
14  *
15  * $Id: XMLTypeFactoryImpl.java,v 1.17 2005/07/06 19:45:15 davidms Exp $
16  */

17 package org.eclipse.emf.ecore.xml.type.impl;
18
19 import java.math.BigDecimal JavaDoc;
20 import java.math.BigInteger JavaDoc;
21 import java.text.DateFormat JavaDoc;
22 import java.text.FieldPosition JavaDoc;
23 import java.text.ParseException JavaDoc;
24 import java.text.SimpleDateFormat JavaDoc;
25 import java.util.ArrayList JavaDoc;
26 import java.util.Date JavaDoc;
27 import java.util.Iterator JavaDoc;
28 import java.util.List JavaDoc;
29 import java.util.StringTokenizer JavaDoc;
30
31 import org.eclipse.emf.ecore.EClass;
32 import org.eclipse.emf.ecore.EDataType;
33 import org.eclipse.emf.ecore.EObject;
34 import org.eclipse.emf.ecore.impl.EFactoryImpl;
35 import org.eclipse.emf.ecore.xml.type.*;
36 import org.eclipse.emf.ecore.xml.type.internal.QName;
37 import org.eclipse.emf.ecore.xml.type.internal.XMLCalendar;
38 import org.eclipse.emf.ecore.xml.type.internal.XMLDuration;
39 import org.eclipse.emf.ecore.xml.type.internal.DataValue.Base64;
40 import org.eclipse.emf.ecore.xml.type.internal.DataValue.HexBin;
41 import org.eclipse.emf.ecore.xml.type.internal.DataValue.XMLChar;
42
43 /**
44  * <!-- begin-user-doc -->
45  * An implementation of the model <b>Factory</b>.
46  * <!-- end-user-doc -->
47  * @generated
48  */

49 public class XMLTypeFactoryImpl extends EFactoryImpl implements XMLTypeFactory
50 {
51
52   protected static final DateFormat JavaDoc [] EDATE_FORMATS =
53   {
54     new SafeSimpleDateFormat("yyyy-MM-dd'T'HH:mm:ssZ"),
55     new SafeSimpleDateFormat("yyyy-MM-ddZ")
56   };
57
58   /**
59    * Creates an instance of the factory.
60    * <!-- begin-user-doc -->
61    * <!-- end-user-doc -->
62    * @generated
63    */

64   public XMLTypeFactoryImpl()
65   {
66     super();
67   }
68
69   /**
70    * <!-- begin-user-doc -->
71    * <!-- end-user-doc -->
72    * @generated
73    */

74   public EObject create(EClass eClass)
75   {
76     switch (eClass.getClassifierID())
77     {
78       case XMLTypePackage.ANY_TYPE: return createAnyType();
79       case XMLTypePackage.SIMPLE_ANY_TYPE: return createSimpleAnyType();
80       case XMLTypePackage.XML_TYPE_DOCUMENT_ROOT: return createXMLTypeDocumentRoot();
81       default:
82         throw new IllegalArgumentException JavaDoc("The class '" + eClass.getName() + "' is not a valid classifier");
83     }
84   }
85
86   /**
87    * <!-- begin-user-doc -->
88    * <!-- end-user-doc -->
89    * @generated
90    */

91   public Object JavaDoc createFromString(EDataType eDataType, String JavaDoc initialValue)
92   {
93     switch (eDataType.getClassifierID())
94     {
95       case XMLTypePackage.ANY_SIMPLE_TYPE:
96         return createAnySimpleTypeFromString(eDataType, initialValue);
97       case XMLTypePackage.ANY_URI:
98         return createAnyURIFromString(eDataType, initialValue);
99       case XMLTypePackage.BASE64_BINARY:
100         return createBase64BinaryFromString(eDataType, initialValue);
101       case XMLTypePackage.BOOLEAN:
102         return createBooleanFromString(eDataType, initialValue);
103       case XMLTypePackage.BOOLEAN_OBJECT:
104         return createBooleanObjectFromString(eDataType, initialValue);
105       case XMLTypePackage.BYTE:
106         return createByteFromString(eDataType, initialValue);
107       case XMLTypePackage.BYTE_OBJECT:
108         return createByteObjectFromString(eDataType, initialValue);
109       case XMLTypePackage.DATE:
110         return createDateFromString(eDataType, initialValue);
111       case XMLTypePackage.DATE_TIME:
112         return createDateTimeFromString(eDataType, initialValue);
113       case XMLTypePackage.DECIMAL:
114         return createDecimalFromString(eDataType, initialValue);
115       case XMLTypePackage.DOUBLE:
116         return createDoubleFromString(eDataType, initialValue);
117       case XMLTypePackage.DOUBLE_OBJECT:
118         return createDoubleObjectFromString(eDataType, initialValue);
119       case XMLTypePackage.DURATION:
120         return createDurationFromString(eDataType, initialValue);
121       case XMLTypePackage.ENTITIES:
122         return createENTITIESFromString(eDataType, initialValue);
123       case XMLTypePackage.ENTITIES_BASE:
124         return createENTITIESBaseFromString(eDataType, initialValue);
125       case XMLTypePackage.ENTITY:
126         return createENTITYFromString(eDataType, initialValue);
127       case XMLTypePackage.FLOAT:
128         return createFloatFromString(eDataType, initialValue);
129       case XMLTypePackage.FLOAT_OBJECT:
130         return createFloatObjectFromString(eDataType, initialValue);
131       case XMLTypePackage.GDAY:
132         return createGDayFromString(eDataType, initialValue);
133       case XMLTypePackage.GMONTH:
134         return createGMonthFromString(eDataType, initialValue);
135       case XMLTypePackage.GMONTH_DAY:
136         return createGMonthDayFromString(eDataType, initialValue);
137       case XMLTypePackage.GYEAR:
138         return createGYearFromString(eDataType, initialValue);
139       case XMLTypePackage.GYEAR_MONTH:
140         return createGYearMonthFromString(eDataType, initialValue);
141       case XMLTypePackage.HEX_BINARY:
142         return createHexBinaryFromString(eDataType, initialValue);
143       case XMLTypePackage.ID:
144         return createIDFromString(eDataType, initialValue);
145       case XMLTypePackage.IDREF:
146         return createIDREFFromString(eDataType, initialValue);
147       case XMLTypePackage.IDREFS:
148         return createIDREFSFromString(eDataType, initialValue);
149       case XMLTypePackage.IDREFS_BASE:
150         return createIDREFSBaseFromString(eDataType, initialValue);
151       case XMLTypePackage.INT:
152         return createIntFromString(eDataType, initialValue);
153       case XMLTypePackage.INTEGER:
154         return createIntegerFromString(eDataType, initialValue);
155       case XMLTypePackage.INT_OBJECT:
156         return createIntObjectFromString(eDataType, initialValue);
157       case XMLTypePackage.LANGUAGE:
158         return createLanguageFromString(eDataType, initialValue);
159       case XMLTypePackage.LONG:
160         return createLongFromString(eDataType, initialValue);
161       case XMLTypePackage.LONG_OBJECT:
162         return createLongObjectFromString(eDataType, initialValue);
163       case XMLTypePackage.NAME:
164         return createNameFromString(eDataType, initialValue);
165       case XMLTypePackage.NC_NAME:
166         return createNCNameFromString(eDataType, initialValue);
167       case XMLTypePackage.NEGATIVE_INTEGER:
168         return createNegativeIntegerFromString(eDataType, initialValue);
169       case XMLTypePackage.NMTOKEN:
170         return createNMTOKENFromString(eDataType, initialValue);
171       case XMLTypePackage.NMTOKENS:
172         return createNMTOKENSFromString(eDataType, initialValue);
173       case XMLTypePackage.NMTOKENS_BASE:
174         return createNMTOKENSBaseFromString(eDataType, initialValue);
175       case XMLTypePackage.NON_NEGATIVE_INTEGER:
176         return createNonNegativeIntegerFromString(eDataType, initialValue);
177       case XMLTypePackage.NON_POSITIVE_INTEGER:
178         return createNonPositiveIntegerFromString(eDataType, initialValue);
179       case XMLTypePackage.NORMALIZED_STRING:
180         return createNormalizedStringFromString(eDataType, initialValue);
181       case XMLTypePackage.NOTATION:
182         return createNOTATIONFromString(eDataType, initialValue);
183       case XMLTypePackage.POSITIVE_INTEGER:
184         return createPositiveIntegerFromString(eDataType, initialValue);
185       case XMLTypePackage.QNAME:
186         return createQNameFromString(eDataType, initialValue);
187       case XMLTypePackage.SHORT:
188         return createShortFromString(eDataType, initialValue);
189       case XMLTypePackage.SHORT_OBJECT:
190         return createShortObjectFromString(eDataType, initialValue);
191       case XMLTypePackage.STRING:
192         return createStringFromString(eDataType, initialValue);
193       case XMLTypePackage.TIME:
194         return createTimeFromString(eDataType, initialValue);
195       case XMLTypePackage.TOKEN:
196         return createTokenFromString(eDataType, initialValue);
197       case XMLTypePackage.UNSIGNED_BYTE:
198         return createUnsignedByteFromString(eDataType, initialValue);
199       case XMLTypePackage.UNSIGNED_BYTE_OBJECT:
200         return createUnsignedByteObjectFromString(eDataType, initialValue);
201       case XMLTypePackage.UNSIGNED_INT:
202         return createUnsignedIntFromString(eDataType, initialValue);
203       case XMLTypePackage.UNSIGNED_INT_OBJECT:
204         return createUnsignedIntObjectFromString(eDataType, initialValue);
205       case XMLTypePackage.UNSIGNED_LONG:
206         return createUnsignedLongFromString(eDataType, initialValue);
207       case XMLTypePackage.UNSIGNED_SHORT:
208         return createUnsignedShortFromString(eDataType, initialValue);
209       case XMLTypePackage.UNSIGNED_SHORT_OBJECT:
210         return createUnsignedShortObjectFromString(eDataType, initialValue);
211       default:
212         throw new IllegalArgumentException JavaDoc("The datatype '" + eDataType.getName() + "' is not a valid classifier");
213     }
214   }
215
216   /**
217    * <!-- begin-user-doc -->
218    * <!-- end-user-doc -->
219    * @generated
220    */

221   public String JavaDoc convertToString(EDataType eDataType, Object JavaDoc instanceValue)
222   {
223     switch (eDataType.getClassifierID())
224     {
225       case XMLTypePackage.ANY_SIMPLE_TYPE:
226         return convertAnySimpleTypeToString(eDataType, instanceValue);
227       case XMLTypePackage.ANY_URI:
228         return convertAnyURIToString(eDataType, instanceValue);
229       case XMLTypePackage.BASE64_BINARY:
230         return convertBase64BinaryToString(eDataType, instanceValue);
231       case XMLTypePackage.BOOLEAN:
232         return convertBooleanToString(eDataType, instanceValue);
233       case XMLTypePackage.BOOLEAN_OBJECT:
234         return convertBooleanObjectToString(eDataType, instanceValue);
235       case XMLTypePackage.BYTE:
236         return convertByteToString(eDataType, instanceValue);
237       case XMLTypePackage.BYTE_OBJECT:
238         return convertByteObjectToString(eDataType, instanceValue);
239       case XMLTypePackage.DATE:
240         return convertDateToString(eDataType, instanceValue);
241       case XMLTypePackage.DATE_TIME:
242         return convertDateTimeToString(eDataType, instanceValue);
243       case XMLTypePackage.DECIMAL:
244         return convertDecimalToString(eDataType, instanceValue);
245       case XMLTypePackage.DOUBLE:
246         return convertDoubleToString(eDataType, instanceValue);
247       case XMLTypePackage.DOUBLE_OBJECT:
248         return convertDoubleObjectToString(eDataType, instanceValue);
249       case XMLTypePackage.DURATION:
250         return convertDurationToString(eDataType, instanceValue);
251       case XMLTypePackage.ENTITIES:
252         return convertENTITIESToString(eDataType, instanceValue);
253       case XMLTypePackage.ENTITIES_BASE:
254         return convertENTITIESBaseToString(eDataType, instanceValue);
255       case XMLTypePackage.ENTITY:
256         return convertENTITYToString(eDataType, instanceValue);
257       case XMLTypePackage.FLOAT:
258         return convertFloatToString(eDataType, instanceValue);
259       case XMLTypePackage.FLOAT_OBJECT:
260         return convertFloatObjectToString(eDataType, instanceValue);
261       case XMLTypePackage.GDAY:
262         return convertGDayToString(eDataType, instanceValue);
263       case XMLTypePackage.GMONTH:
264         return convertGMonthToString(eDataType, instanceValue);
265       case XMLTypePackage.GMONTH_DAY:
266         return convertGMonthDayToString(eDataType, instanceValue);
267       case XMLTypePackage.GYEAR:
268         return convertGYearToString(eDataType, instanceValue);
269       case XMLTypePackage.GYEAR_MONTH:
270         return convertGYearMonthToString(eDataType, instanceValue);
271       case XMLTypePackage.HEX_BINARY:
272         return convertHexBinaryToString(eDataType, instanceValue);
273       case XMLTypePackage.ID:
274         return convertIDToString(eDataType, instanceValue);
275       case XMLTypePackage.IDREF:
276         return convertIDREFToString(eDataType, instanceValue);
277       case XMLTypePackage.IDREFS:
278         return convertIDREFSToString(eDataType, instanceValue);
279       case XMLTypePackage.IDREFS_BASE:
280         return convertIDREFSBaseToString(eDataType, instanceValue);
281       case XMLTypePackage.INT:
282         return convertIntToString(eDataType, instanceValue);
283       case XMLTypePackage.INTEGER:
284         return convertIntegerToString(eDataType, instanceValue);
285       case XMLTypePackage.INT_OBJECT:
286         return convertIntObjectToString(eDataType, instanceValue);
287       case XMLTypePackage.LANGUAGE:
288         return convertLanguageToString(eDataType, instanceValue);
289       case XMLTypePackage.LONG:
290         return convertLongToString(eDataType, instanceValue);
291       case XMLTypePackage.LONG_OBJECT:
292         return convertLongObjectToString(eDataType, instanceValue);
293       case XMLTypePackage.NAME:
294         return convertNameToString(eDataType, instanceValue);
295       case XMLTypePackage.NC_NAME:
296         return convertNCNameToString(eDataType, instanceValue);
297       case XMLTypePackage.NEGATIVE_INTEGER:
298         return convertNegativeIntegerToString(eDataType, instanceValue);
299       case XMLTypePackage.NMTOKEN:
300         return convertNMTOKENToString(eDataType, instanceValue);
301       case XMLTypePackage.NMTOKENS:
302         return convertNMTOKENSToString(eDataType, instanceValue);
303       case XMLTypePackage.NMTOKENS_BASE:
304         return convertNMTOKENSBaseToString(eDataType, instanceValue);
305       case XMLTypePackage.NON_NEGATIVE_INTEGER:
306         return convertNonNegativeIntegerToString(eDataType, instanceValue);
307       case XMLTypePackage.NON_POSITIVE_INTEGER:
308         return convertNonPositiveIntegerToString(eDataType, instanceValue);
309       case XMLTypePackage.NORMALIZED_STRING:
310         return convertNormalizedStringToString(eDataType, instanceValue);
311       case XMLTypePackage.NOTATION:
312         return convertNOTATIONToString(eDataType, instanceValue);
313       case XMLTypePackage.POSITIVE_INTEGER:
314         return convertPositiveIntegerToString(eDataType, instanceValue);
315       case XMLTypePackage.QNAME:
316         return convertQNameToString(eDataType, instanceValue);
317       case XMLTypePackage.SHORT:
318         return convertShortToString(eDataType, instanceValue);
319       case XMLTypePackage.SHORT_OBJECT:
320         return convertShortObjectToString(eDataType, instanceValue);
321       case XMLTypePackage.STRING:
322         return convertStringToString(eDataType, instanceValue);
323       case XMLTypePackage.TIME:
324         return convertTimeToString(eDataType, instanceValue);
325       case XMLTypePackage.TOKEN:
326         return convertTokenToString(eDataType, instanceValue);
327       case XMLTypePackage.UNSIGNED_BYTE:
328         return convertUnsignedByteToString(eDataType, instanceValue);
329       case XMLTypePackage.UNSIGNED_BYTE_OBJECT:
330         return convertUnsignedByteObjectToString(eDataType, instanceValue);
331       case XMLTypePackage.UNSIGNED_INT:
332         return convertUnsignedIntToString(eDataType, instanceValue);
333       case XMLTypePackage.UNSIGNED_INT_OBJECT:
334         return convertUnsignedIntObjectToString(eDataType, instanceValue);
335       case XMLTypePackage.UNSIGNED_LONG:
336         return convertUnsignedLongToString(eDataType, instanceValue);
337       case XMLTypePackage.UNSIGNED_SHORT:
338         return convertUnsignedShortToString(eDataType, instanceValue);
339       case XMLTypePackage.UNSIGNED_SHORT_OBJECT:
340         return convertUnsignedShortObjectToString(eDataType, instanceValue);
341       default:
342         throw new IllegalArgumentException JavaDoc("The datatype '" + eDataType.getName() + "' is not a valid classifier");
343     }
344   }
345
346   /**
347    * <!-- begin-user-doc -->
348    * <!-- end-user-doc -->
349    * @generated
350    */

351   public AnyType createAnyType()
352   {
353     AnyTypeImpl anyType = new AnyTypeImpl();
354     return anyType;
355   }
356
357   /**
358    * <!-- begin-user-doc -->
359    * <!-- end-user-doc -->
360    * @generated
361    */

362   public SimpleAnyType createSimpleAnyType()
363   {
364     SimpleAnyTypeImpl simpleAnyType = new SimpleAnyTypeImpl();
365     return simpleAnyType;
366   }
367
368   /**
369    * <!-- begin-user-doc -->
370    * <!-- end-user-doc -->
371    * @generated
372    */

373   public XMLTypeDocumentRoot createXMLTypeDocumentRoot()
374   {
375     XMLTypeDocumentRootImpl xmlTypeDocumentRoot = new XMLTypeDocumentRootImpl();
376     return xmlTypeDocumentRoot;
377   }
378
379   /**
380    * <!-- begin-user-doc -->
381    * <!-- end-user-doc -->
382    * @generated NOT
383    */

384   public Object JavaDoc createAnySimpleTypeFromString(EDataType eDataType, String JavaDoc initialValue)
385   {
386     return initialValue;
387   }
388
389   /**
390    * <!-- begin-user-doc -->
391    * <!-- end-user-doc -->
392    * @generated NOT
393    */

394   public String JavaDoc convertAnySimpleTypeToString(EDataType eDataType, Object JavaDoc instanceValue)
395   {
396     return instanceValue == null ? null : instanceValue.toString();
397   }
398
399   /**
400    * <!-- begin-user-doc -->
401    * <!-- end-user-doc -->
402    * @generated NOT
403    */

404   public String JavaDoc createAnyURIFromString(EDataType eDataType, String JavaDoc initialValue)
405   {
406     // Per Schema 1.0 it is not clear if the result returned should be a valid URI.
407
// For the future if we plant to surport IRIs then it is better not to massage
408
// the initialValue.
409
// We should thought consider where would be the best way to validate anyURI values -- EL
410

411     /*initialValue = collapseWhiteSpace(initialValue);
412     if (initialValue != null)
413     {
414       //encode special characters using XLink 5.4 algorithm
415       initialValue = URI.encode(initialValue);
416       // Support for relative URLs
417       // According to Java 1.1: URLs may also be specified with a
418       // String and the URL object that it is related to.
419       try
420       {
421         new URI(URI.BASE_URI, initialValue);
422       }
423       catch (URI.MalformedURIException e)
424       {
425         throw new InvalidDatatypeValueException("Invalid anyURI value: '"+initialValue+"' :"+e.toString());
426       }
427     }*/

428     return initialValue;
429   }
430
431   /**
432    * <!-- begin-user-doc -->
433    * <!-- end-user-doc -->
434    * @generated NOT
435    */

436   public String JavaDoc convertAnyURIToString(EDataType eDataType, Object JavaDoc instanceValue)
437   {
438     return (String JavaDoc)instanceValue;
439   }
440
441   /**
442    * <!-- begin-user-doc -->
443    * <!-- end-user-doc -->
444    * @generated NOT
445    */

446   public byte[] createBase64BinaryFromString(EDataType eDataType, String JavaDoc initialValue)
447   {
448     if (initialValue == null) return null;
449     byte[] value = Base64.decode(collapseWhiteSpace(initialValue));
450     if (value == null)
451     {
452       throw new InvalidDatatypeValueException("Invalid base64Binary value: '"+initialValue+"'");
453     }
454     return value;
455   }
456
457   /**
458    * <!-- begin-user-doc -->
459    * <!-- end-user-doc -->
460    * @generated NOT
461    */

462   public String JavaDoc convertBase64BinaryToString(EDataType eDataType, Object JavaDoc instanceValue)
463   {
464     return instanceValue == null ? null : Base64.encode((byte[])instanceValue);
465   }
466
467   /**
468    * <!-- begin-user-doc -->
469    * <!-- end-user-doc -->
470    * @generated NOT
471    */

472   public Boolean JavaDoc createBooleanFromString(EDataType eDataType, String JavaDoc initialValue)
473   {
474     return initialValue == null ? null : booleanValueOf(initialValue);
475   }
476
477   /**
478    * <!-- begin-user-doc -->
479    * <!-- end-user-doc -->
480    * @generated NOT
481    */

482   public String JavaDoc convertBooleanToString(EDataType eDataType, Object JavaDoc instanceValue)
483   {
484     return instanceValue == null ? null : instanceValue.toString();
485   }
486
487   /**
488    * <!-- begin-user-doc -->
489    * <!-- end-user-doc -->
490    * @generated NOT
491    */

492   public Boolean JavaDoc createBooleanObjectFromString(EDataType eDataType, String JavaDoc initialValue)
493   {
494     return initialValue == null ? null : booleanValueOf(initialValue);
495   }
496
497   /**
498    * <!-- begin-user-doc -->
499    * <!-- end-user-doc -->
500    * @generated NOT
501    */

502   public String JavaDoc convertBooleanObjectToString(EDataType eDataType, Object JavaDoc instanceValue)
503   {
504     return instanceValue == null ? null : instanceValue.toString();
505   }
506
507   /**
508    * <!-- begin-user-doc -->
509    * <!-- end-user-doc -->
510    * @generated NOT
511    */

512   public BigDecimal JavaDoc createDecimalFromString(EDataType eDataType, String JavaDoc initialValue)
513   {
514     return initialValue == null ? null : new BigDecimal JavaDoc(collapseWhiteSpace(initialValue));
515   }
516
517   /**
518    * <!-- begin-user-doc -->
519    * <!-- end-user-doc -->
520    * @generated NOT
521    */

522   public String JavaDoc convertDecimalToString(EDataType eDataType, Object JavaDoc instanceValue)
523   {
524     return instanceValue == null ? null : instanceValue.toString();
525   }
526
527   /**
528    * <!-- begin-user-doc -->
529    * <!-- end-user-doc -->
530    * @generated NOT
531    */

532   public BigInteger JavaDoc createIntegerFromString(EDataType eDataType, String JavaDoc initialValue)
533   {
534     return initialValue == null ? null : new BigInteger JavaDoc(collapseWhiteSpace(initialValue));
535   }
536
537   /**
538    * <!-- begin-user-doc -->
539    * <!-- end-user-doc -->
540    * @generated NOT
541    */

542   public String JavaDoc convertIntegerToString(EDataType eDataType, Object JavaDoc instanceValue)
543   {
544     return instanceValue == null ? null : instanceValue.toString();
545   }
546
547   /**
548    * <!-- begin-user-doc -->
549    * <!-- end-user-doc -->
550    * @generated NOT
551    */

552   public Integer JavaDoc createIntObjectFromString(EDataType eDataType, String JavaDoc initialValue)
553   {
554     return initialValue == null ? null : Integer.valueOf(collapseWhiteSpace(initialValue));
555   }
556
557   /**
558    * <!-- begin-user-doc -->
559    * <!-- end-user-doc -->
560    * @generated NOT
561    */

562   public String JavaDoc convertIntObjectToString(EDataType eDataType, Object JavaDoc instanceValue)
563   {
564     return instanceValue == null ? null : instanceValue.toString();
565   }
566
567   /**
568    * <!-- begin-user-doc -->
569    * <!-- end-user-doc -->
570    * @generated NOT
571    */

572   public Long JavaDoc createLongFromString(EDataType eDataType, String JavaDoc initialValue)
573   {
574     return initialValue == null ? null : Long.valueOf(collapseWhiteSpace(initialValue));
575   }
576
577   /**
578    * <!-- begin-user-doc -->
579    * <!-- end-user-doc -->
580    * @generated NOT
581    */

582   public String JavaDoc convertLongToString(EDataType eDataType, Object JavaDoc instanceValue)
583   {
584     return instanceValue == null ? null : instanceValue.toString();
585   }
586
587   /**
588    * <!-- begin-user-doc -->
589    * <!-- end-user-doc -->
590    * @generated NOT
591    */

592   public Long JavaDoc createLongObjectFromString(EDataType eDataType, String JavaDoc initialValue)
593   {
594     return initialValue == null ? null : Long.valueOf(collapseWhiteSpace(initialValue));
595   }
596
597   /**
598    * <!-- begin-user-doc -->
599    * <!-- end-user-doc -->
600    * @generated NOT
601    */

602   public String JavaDoc convertLongObjectToString(EDataType eDataType, Object JavaDoc instanceValue)
603   {
604     return instanceValue == null ? null : instanceValue.toString();
605   }
606
607   /**
608    * <!-- begin-user-doc -->
609    * <!-- end-user-doc -->
610    * @generated NOT
611    */

612   public Integer JavaDoc createIntFromString(EDataType eDataType, String JavaDoc initialValue)
613   {
614     return initialValue == null ? null : Integer.valueOf(collapseWhiteSpace(initialValue));
615   }
616
617   /**
618    * <!-- begin-user-doc -->
619    * <!-- end-user-doc -->
620    * @generated NOT
621    */

622   public String JavaDoc convertIntToString(EDataType eDataType, Object JavaDoc instanceValue)
623   {
624     return instanceValue == null ? null : instanceValue.toString();
625   }
626
627   /**
628    * <!-- begin-user-doc -->
629    * <!-- end-user-doc -->
630    * @generated NOT
631    */

632   public Short JavaDoc createShortFromString(EDataType eDataType, String JavaDoc initialValue)
633   {
634     return initialValue == null ? null : Short.valueOf(collapseWhiteSpace(initialValue));
635   }
636
637   /**
638    * <!-- begin-user-doc -->
639    * <!-- end-user-doc -->
640    * @generated NOT
641    */

642   public String JavaDoc convertShortToString(EDataType eDataType, Object JavaDoc instanceValue)
643   {
644     return instanceValue == null ? null : instanceValue.toString();
645   }
646
647   /**
648    * <!-- begin-user-doc -->
649    * <!-- end-user-doc -->
650    * @generated NOT
651    */

652   public Short JavaDoc createShortObjectFromString(EDataType eDataType, String JavaDoc initialValue)
653   {
654     return initialValue == null ? null : Short.valueOf(collapseWhiteSpace(initialValue));
655   }
656
657   /**
658    * <!-- begin-user-doc -->
659    * <!-- end-user-doc -->
660    * @generated NOT
661    */

662   public String JavaDoc convertShortObjectToString(EDataType eDataType, Object JavaDoc instanceValue)
663   {
664     return instanceValue == null ? null : instanceValue.toString();
665   }
666
667   /**
668    * <!-- begin-user-doc -->
669    * <!-- end-user-doc -->
670    * @generated NOT
671    */

672   public Byte JavaDoc createByteFromString(EDataType eDataType, String JavaDoc initialValue)
673   {
674     return initialValue == null ? null : Byte.valueOf(collapseWhiteSpace(initialValue));
675   }
676
677   /**
678    * <!-- begin-user-doc -->
679    * <!-- end-user-doc -->
680    * @generated NOT
681    */

682   public String JavaDoc convertByteToString(EDataType eDataType, Object JavaDoc instanceValue)
683   {
684     return instanceValue == null ? null : instanceValue.toString();
685   }
686
687   /**
688    * <!-- begin-user-doc -->
689    * <!-- end-user-doc -->
690    * @generated NOT
691    */

692   public Byte JavaDoc createByteObjectFromString(EDataType eDataType, String JavaDoc initialValue)
693   {
694     return initialValue == null ? null : Byte.valueOf(collapseWhiteSpace(initialValue));
695   }
696
697   /**
698    * <!-- begin-user-doc -->
699    * <!-- end-user-doc -->
700    * @generated NOT
701    */

702   public String JavaDoc convertByteObjectToString(EDataType eDataType, Object JavaDoc instanceValue)
703   {
704     return instanceValue == null ? null : instanceValue.toString();
705   }
706
707   /**
708    * <!-- begin-user-doc -->
709    * <!-- end-user-doc -->
710    * @generated NOT
711    */

712   public Object JavaDoc createDateFromString(EDataType eDataType, String JavaDoc initialValue)
713   {
714     return initialValue == null ? null : new XMLCalendar(collapseWhiteSpace(initialValue), XMLCalendar.DATE);
715
716   }
717
718   /**
719    * <!-- begin-user-doc -->
720    * <!-- end-user-doc -->
721    * @generated NOT
722    */

723   public String JavaDoc convertDateToString(EDataType eDataType, Object JavaDoc instanceValue)
724   {
725     if (instanceValue == null)
726     {
727       return null;
728     }
729     if (instanceValue instanceof Date JavaDoc)
730     {
731       return EDATE_FORMATS[1].format((Date JavaDoc)instanceValue);
732     }
733     return instanceValue.toString();
734   }
735
736   /**
737    * <!-- begin-user-doc -->
738    * <!-- end-user-doc -->
739    * @generated NOT
740    */

741   public Object JavaDoc createDateTimeFromString(EDataType eDataType, String JavaDoc initialValue)
742   {
743     return initialValue == null ? null : new XMLCalendar(collapseWhiteSpace(initialValue), XMLCalendar.DATETIME);
744   }
745
746   /**
747    * <!-- begin-user-doc -->
748    * <!-- end-user-doc -->
749    * @generated NOT
750    */

751   public String JavaDoc convertDateTimeToString(EDataType eDataType, Object JavaDoc instanceValue)
752   {
753     if (instanceValue == null)
754     {
755       return null;
756     }
757     if (instanceValue instanceof Date JavaDoc)
758     {
759       return EDATE_FORMATS[0].format((Date JavaDoc)instanceValue);
760     }
761     return instanceValue.toString();
762   }
763
764   /**
765    * <!-- begin-user-doc -->
766    * <!-- end-user-doc -->
767    * @generated NOT
768    */

769   public String JavaDoc createStringFromString(EDataType eDataType, String JavaDoc initialValue)
770   {
771     return initialValue;
772   }
773
774   /**
775    * <!-- begin-user-doc -->
776    * <!-- end-user-doc -->
777    * @generated NOT
778    */

779   public String JavaDoc convertStringToString(EDataType eDataType, Object JavaDoc instanceValue)
780   {
781     return (String JavaDoc)instanceValue;
782   }
783
784   /**
785    * <!-- begin-user-doc -->
786    * <!-- end-user-doc -->
787    * @generated NOT
788    */

789   public Double JavaDoc createDoubleFromString(EDataType eDataType, String JavaDoc initialValue)
790   {
791     return initialValue == null ? null : Double.valueOf(collapseWhiteSpace(initialValue));
792   }
793
794   /**
795    * <!-- begin-user-doc -->
796    * <!-- end-user-doc -->
797    * @generated NOT
798    */

799   public String JavaDoc convertDoubleToString(EDataType eDataType, Object JavaDoc instanceValue)
800   {
801     return instanceValue == null ? null : instanceValue.toString();
802   }
803
804   /**
805    * <!-- begin-user-doc -->
806    * <!-- end-user-doc -->
807    * @generated NOT
808    */

809   public Double JavaDoc createDoubleObjectFromString(EDataType eDataType, String JavaDoc initialValue)
810   {
811     return initialValue == null ? null : Double.valueOf(collapseWhiteSpace(initialValue));
812   }
813
814   /**
815    * <!-- begin-user-doc -->
816    * <!-- end-user-doc -->
817    * @generated NOT
818    */

819   public String JavaDoc convertDoubleObjectToString(EDataType eDataType, Object JavaDoc instanceValue)
820   {
821     return instanceValue == null ? null : instanceValue.toString();
822   }
823
824   /**
825    * <!-- begin-user-doc -->
826    * <!-- end-user-doc -->
827    * @generated NOT
828    */

829   public Object JavaDoc createDurationFromString(EDataType eDataType, String JavaDoc initialValue)
830   {
831     return initialValue == null ? null : new XMLDuration(collapseWhiteSpace(initialValue));
832   }
833
834   /**
835    * <!-- begin-user-doc -->
836    * <!-- end-user-doc -->
837    * @generated NOT
838    */

839   public String JavaDoc convertDurationToString(EDataType eDataType, Object JavaDoc instanceValue)
840   {
841     return instanceValue == null ? null : instanceValue.toString();
842   }
843
844   /**
845    * <!-- begin-user-doc -->
846    * <!-- end-user-doc -->
847    * @generated
848    */

849   public List JavaDoc createENTITIESBaseFromString(EDataType eDataType, String JavaDoc initialValue)
850   {
851     if (initialValue == null) return null;
852     List JavaDoc result = new ArrayList JavaDoc();
853     for (StringTokenizer JavaDoc stringTokenizer = new StringTokenizer JavaDoc(initialValue); stringTokenizer.hasMoreTokens(); )
854     {
855       String JavaDoc item = stringTokenizer.nextToken();
856       result.add(XMLTypeFactory.eINSTANCE.createFromString(XMLTypePackage.eINSTANCE.getENTITY(), item));
857     }
858     return result;
859   }
860
861   /**
862    * <!-- begin-user-doc -->
863    * <!-- end-user-doc -->
864    * @generated
865    */

866   public String JavaDoc convertENTITIESBaseToString(EDataType eDataType, Object JavaDoc instanceValue)
867   {
868     if (instanceValue == null) return null;
869     List JavaDoc list = (List JavaDoc)instanceValue;
870     if (list.isEmpty()) return "";
871     StringBuffer JavaDoc result = new StringBuffer JavaDoc();
872     for (Iterator JavaDoc i = list.iterator(); i.hasNext(); )
873     {
874       result.append(XMLTypeFactory.eINSTANCE.convertToString(XMLTypePackage.eINSTANCE.getENTITY(), i.next()));
875       result.append(' ');
876     }
877     return result.substring(0, result.length() - 1);
878   }
879
880   /**
881    * <!-- begin-user-doc -->
882    * <!-- end-user-doc -->
883    * @generated NOT
884    */

885   public String JavaDoc createNormalizedStringFromString(EDataType eDataType, String JavaDoc initialValue)
886   {
887     return replaceWhiteSpace(initialValue);
888   }
889
890   /**
891    * <!-- begin-user-doc -->
892    * <!-- end-user-doc -->
893    * @generated NOT
894    */

895   public String JavaDoc convertNormalizedStringToString(EDataType eDataType, Object JavaDoc instanceValue)
896   {
897     return (String JavaDoc)instanceValue;
898   }
899
900   /**
901    * <!-- begin-user-doc -->
902    * <!-- end-user-doc -->
903    * @generated NOT
904    */

905   public String JavaDoc createTokenFromString(EDataType eDataType, String JavaDoc initialValue)
906   {
907     return collapseWhiteSpace(initialValue);
908   }
909
910   /**
911    * <!-- begin-user-doc -->
912    * <!-- end-user-doc -->
913    * @generated NOT
914    */

915   public String JavaDoc convertTokenToString(EDataType eDataType, Object JavaDoc instanceValue)
916   {
917     return (String JavaDoc)instanceValue;
918   }
919
920   /**
921    * <!-- begin-user-doc -->
922    * <!-- end-user-doc -->
923    * @generated NOT
924    */

925   public String JavaDoc createNameFromString(EDataType eDataType, String JavaDoc initialValue)
926   {
927     // do not validate on load. Check validity using Diagnostician.
928
return initialValue;
929   }
930
931   /**
932    * <!-- begin-user-doc -->
933    * <!-- end-user-doc -->
934    * @generated NOT
935    */

936   public String JavaDoc convertNameToString(EDataType eDataType, Object JavaDoc instanceValue)
937   {
938     return (String JavaDoc)instanceValue;
939   }
940
941   /**
942    * <!-- begin-user-doc -->
943    * <!-- end-user-doc -->
944    * @generated NOT
945    */

946   public String JavaDoc createNCNameFromString(EDataType eDataType, String JavaDoc initialValue)
947   {
948     // do not validate on load. Check validity using Diagnostician.
949
return initialValue;
950   }
951
952   /**
953    * <!-- begin-user-doc -->
954    * <!-- end-user-doc -->
955    * @generated NOT
956    */

957   public String JavaDoc convertNCNameToString(EDataType eDataType, Object JavaDoc instanceValue)
958   {
959     return (String JavaDoc)instanceValue;
960   }
961
962   /**
963    * <!-- begin-user-doc -->
964    * <!-- end-user-doc -->
965    * @generated NOT
966    */

967   public String JavaDoc createENTITYFromString(EDataType eDataType, String JavaDoc initialValue)
968   {
969     return (String JavaDoc)XMLTypeFactory.eINSTANCE.createFromString(XMLTypePackage.eINSTANCE.getNCName(), initialValue);
970   }
971
972   /**
973    * <!-- begin-user-doc -->
974    * <!-- end-user-doc -->
975    * @generated NOT
976    */

977   public String JavaDoc convertENTITYToString(EDataType eDataType, Object JavaDoc instanceValue)
978   {
979     return (String JavaDoc)instanceValue;
980   }
981
982   /**
983    * <!-- begin-user-doc -->
984    * <!-- end-user-doc -->
985    * @generated
986    */

987   public List JavaDoc createENTITIESFromString(EDataType eDataType, String JavaDoc initialValue)
988   {
989     return (List JavaDoc)XMLTypeFactory.eINSTANCE.createFromString(XMLTypePackage.eINSTANCE.getENTITIESBase(), initialValue);
990   }
991
992   /**
993    * <!-- begin-user-doc -->
994    * <!-- end-user-doc -->
995    * @generated
996    */

997   public String JavaDoc convertENTITIESToString(EDataType eDataType, Object JavaDoc instanceValue)
998   {
999     return XMLTypeFactory.eINSTANCE.convertToString(XMLTypePackage.eINSTANCE.getENTITIESBase(), instanceValue);
1000  }
1001
1002  /**
1003   * <!-- begin-user-doc -->
1004   * <!-- end-user-doc -->
1005   * @generated NOT
1006   */

1007  public Float JavaDoc createFloatFromString(EDataType eDataType, String JavaDoc initialValue)
1008  {
1009    return initialValue == null ? null : Float.valueOf(collapseWhiteSpace(initialValue));
1010  }
1011
1012  /**
1013   * <!-- begin-user-doc -->
1014   * <!-- end-user-doc -->
1015   * @generated NOT
1016   */

1017  public String JavaDoc convertFloatToString(EDataType eDataType, Object JavaDoc instanceValue)
1018  {
1019    return instanceValue == null ? null : instanceValue.toString();
1020  }
1021
1022  /**
1023   * <!-- begin-user-doc -->
1024   * <!-- end-user-doc -->
1025   * @generated NOT
1026   */

1027  public Float JavaDoc createFloatObjectFromString(EDataType eDataType, String JavaDoc initialValue)
1028  {
1029    return initialValue == null ? null : Float.valueOf(collapseWhiteSpace(initialValue));
1030  }
1031
1032  /**
1033   * <!-- begin-user-doc -->
1034   * <!-- end-user-doc -->
1035   * @generated NOT
1036   */

1037  public String JavaDoc convertFloatObjectToString(EDataType eDataType, Object JavaDoc instanceValue)
1038  {
1039    return instanceValue == null ? null : instanceValue.toString();
1040  }
1041
1042  /**
1043   * <!-- begin-user-doc -->
1044   * <!-- end-user-doc -->
1045   * @generated NOT
1046   */

1047  public Object JavaDoc createGDayFromString(EDataType eDataType, String JavaDoc initialValue)
1048  {
1049    return initialValue == null ? null : new XMLCalendar(collapseWhiteSpace(initialValue), XMLCalendar.GDAY);
1050
1051  }
1052
1053  /**
1054   * <!-- begin-user-doc -->
1055   * <!-- end-user-doc -->
1056   * @generated NOT
1057   */

1058  public String JavaDoc convertGDayToString(EDataType eDataType, Object JavaDoc instanceValue)
1059  {
1060    return instanceValue == null ? null : instanceValue.toString();
1061  }
1062
1063  /**
1064   * <!-- begin-user-doc -->
1065   * <!-- end-user-doc -->
1066   * @generated NOT
1067   */

1068  public Object JavaDoc createGMonthFromString(EDataType eDataType, String JavaDoc initialValue)
1069  {
1070    return initialValue == null ? null : new XMLCalendar(collapseWhiteSpace(initialValue), XMLCalendar.GMONTH);
1071}
1072
1073  /**
1074   * <!-- begin-user-doc -->
1075   * <!-- end-user-doc -->
1076   * @generated NOT
1077   */

1078  public String JavaDoc convertGMonthToString(EDataType eDataType, Object JavaDoc instanceValue)
1079  {
1080    return instanceValue == null ? null : instanceValue.toString();
1081  }
1082
1083  /**
1084   * <!-- begin-user-doc -->
1085   * <!-- end-user-doc -->
1086   * @generated NOT
1087   */

1088  public Object JavaDoc createGMonthDayFromString(EDataType eDataType, String JavaDoc initialValue)
1089  {
1090    return initialValue == null ? null : new XMLCalendar(collapseWhiteSpace(initialValue), XMLCalendar.GMONTHDAY);
1091  }
1092
1093  /**
1094   * <!-- begin-user-doc -->
1095   * <!-- end-user-doc -->
1096   * @generated NOT
1097   */

1098  public String JavaDoc convertGMonthDayToString(EDataType eDataType, Object JavaDoc instanceValue)
1099  {
1100    return instanceValue == null ? null : instanceValue.toString();
1101  }
1102
1103  /**
1104   * <!-- begin-user-doc -->
1105   * <!-- end-user-doc -->
1106   * @generated NOT
1107   */

1108  public Object JavaDoc createGYearFromString(EDataType eDataType, String JavaDoc initialValue)
1109  {
1110    return initialValue == null ? null : new XMLCalendar(collapseWhiteSpace(initialValue), XMLCalendar.GYEAR);
1111}
1112
1113  /**
1114   * <!-- begin-user-doc -->
1115   * <!-- end-user-doc -->
1116   * @generated NOT
1117   */

1118  public String JavaDoc convertGYearToString(EDataType eDataType, Object JavaDoc instanceValue)
1119  {
1120    return instanceValue == null ? null : instanceValue.toString();
1121  }
1122
1123  /**
1124   * <!-- begin-user-doc -->
1125   * <!-- end-user-doc -->
1126   * @generated NOT
1127   */

1128  public Object JavaDoc createGYearMonthFromString(EDataType eDataType, String JavaDoc initialValue)
1129  {
1130    return initialValue == null ? null : new XMLCalendar(collapseWhiteSpace(initialValue), XMLCalendar.GYEARMONTH);
1131}
1132
1133  /**
1134   * <!-- begin-user-doc -->
1135   * <!-- end-user-doc -->
1136   * @generated NOT
1137   */

1138  public String JavaDoc convertGYearMonthToString(EDataType eDataType, Object JavaDoc instanceValue)
1139  {
1140    return instanceValue == null ? null : instanceValue.toString();
1141  }
1142
1143  /**
1144   * <!-- begin-user-doc -->
1145   * <!-- end-user-doc -->
1146   * @generated NOT
1147   */

1148  public byte[] createHexBinaryFromString(EDataType eDataType, String JavaDoc initialValue)
1149  {
1150    if (initialValue == null) return null;
1151    byte[] value = HexBin.decode(collapseWhiteSpace(initialValue));
1152    if (value == null)
1153    {
1154      throw new InvalidDatatypeValueException("Invalid hexBinary value: '"+initialValue+"'");
1155    }
1156    return value;
1157  }
1158
1159  /**
1160   * <!-- begin-user-doc -->
1161   * <!-- end-user-doc -->
1162   * @generated NOT
1163   */

1164  public String JavaDoc convertHexBinaryToString(EDataType eDataType, Object JavaDoc instanceValue)
1165  {
1166    return instanceValue == null ? null : HexBin.encode((byte[])instanceValue);
1167  }
1168
1169  /**
1170   * <!-- begin-user-doc -->
1171   * <!-- end-user-doc -->
1172   * @generated
1173   */

1174  public String JavaDoc createIDFromString(EDataType eDataType, String JavaDoc initialValue)
1175  {
1176    return (String JavaDoc)XMLTypeFactory.eINSTANCE.createFromString(XMLTypePackage.eINSTANCE.getNCName(), initialValue);
1177  }
1178
1179  /**
1180   * <!-- begin-user-doc -->
1181   * <!-- end-user-doc -->
1182   * @generated NOT
1183   */

1184  public String JavaDoc convertIDToString(EDataType eDataType, Object JavaDoc instanceValue)
1185  {
1186    return (String JavaDoc)instanceValue;
1187  }
1188
1189  /**
1190   * <!-- begin-user-doc -->
1191   * <!-- end-user-doc -->
1192   * @generated
1193   */

1194  public String JavaDoc createIDREFFromString(EDataType eDataType, String JavaDoc initialValue)
1195  {
1196    return (String JavaDoc)XMLTypeFactory.eINSTANCE.createFromString(XMLTypePackage.eINSTANCE.getNCName(), initialValue);
1197  }
1198
1199  /**
1200   * <!-- begin-user-doc -->
1201   * <!-- end-user-doc -->
1202   * @generated NOT
1203   */

1204  public String JavaDoc convertIDREFToString(EDataType eDataType, Object JavaDoc instanceValue)
1205  {
1206    return (String JavaDoc)instanceValue;
1207  }
1208
1209  /**
1210   * <!-- begin-user-doc -->
1211   * <!-- end-user-doc -->
1212   * @generated
1213   */

1214  public List JavaDoc createIDREFSBaseFromString(EDataType eDataType, String JavaDoc initialValue)
1215  {
1216    if (initialValue == null) return null;
1217    List JavaDoc result = new ArrayList JavaDoc();
1218    for (StringTokenizer JavaDoc stringTokenizer = new StringTokenizer JavaDoc(initialValue); stringTokenizer.hasMoreTokens(); )
1219    {
1220      String JavaDoc item = stringTokenizer.nextToken();
1221      result.add(XMLTypeFactory.eINSTANCE.createFromString(XMLTypePackage.eINSTANCE.getIDREF(), item));
1222    }
1223    return result;
1224  }
1225
1226  /**
1227   * <!-- begin-user-doc -->
1228   * <!-- end-user-doc -->
1229   * @generated
1230   */

1231  public String JavaDoc convertIDREFSBaseToString(EDataType eDataType, Object JavaDoc instanceValue)
1232  {
1233    if (instanceValue == null) return null;
1234    List JavaDoc list = (List JavaDoc)instanceValue;
1235    if (list.isEmpty()) return "";
1236    StringBuffer JavaDoc result = new StringBuffer JavaDoc();
1237    for (Iterator JavaDoc i = list.iterator(); i.hasNext(); )
1238    {
1239      result.append(XMLTypeFactory.eINSTANCE.convertToString(XMLTypePackage.eINSTANCE.getIDREF(), i.next()));
1240      result.append(' ');
1241    }
1242    return result.substring(0, result.length() - 1);
1243  }
1244
1245  /**
1246   * <!-- begin-user-doc -->
1247   * <!-- end-user-doc -->
1248   * @generated
1249   */

1250  public List JavaDoc createIDREFSFromString(EDataType eDataType, String JavaDoc initialValue)
1251  {
1252    return (List JavaDoc)XMLTypeFactory.eINSTANCE.createFromString(XMLTypePackage.eINSTANCE.getIDREFSBase(), initialValue);
1253  }
1254
1255  /**
1256   * <!-- begin-user-doc -->
1257   * <!-- end-user-doc -->
1258   * @generated
1259   */

1260  public String JavaDoc convertIDREFSToString(EDataType eDataType, Object JavaDoc instanceValue)
1261  {
1262    return XMLTypeFactory.eINSTANCE.convertToString(XMLTypePackage.eINSTANCE.getIDREFSBase(), instanceValue);
1263  }
1264
1265  /**
1266   * <!-- begin-user-doc -->
1267   * <!-- end-user-doc -->
1268   * @generated NOT
1269   */

1270  public String JavaDoc createLanguageFromString(EDataType eDataType, String JavaDoc initialValue)
1271  {
1272    return collapseWhiteSpace(initialValue);
1273  }
1274
1275  /**
1276   * <!-- begin-user-doc -->
1277   * <!-- end-user-doc -->
1278   * @generated NOT
1279   */

1280  public String JavaDoc convertLanguageToString(EDataType eDataType, Object JavaDoc instanceValue)
1281  {
1282    return (String JavaDoc)instanceValue;
1283  }
1284
1285  /**
1286   * <!-- begin-user-doc -->
1287   * <!-- end-user-doc -->
1288   * @generated NOT
1289   */

1290  public BigInteger JavaDoc createNonPositiveIntegerFromString(EDataType eDataType, String JavaDoc initialValue)
1291  {
1292    return initialValue == null ? null : new BigInteger JavaDoc(collapseWhiteSpace(initialValue));
1293  }
1294
1295  /**
1296   * <!-- begin-user-doc -->
1297   * <!-- end-user-doc -->
1298   * @generated NOT
1299   */

1300  public String JavaDoc convertNonPositiveIntegerToString(EDataType eDataType, Object JavaDoc instanceValue)
1301  {
1302    return instanceValue == null ? null : instanceValue.toString();
1303  }
1304
1305  /**
1306   * <!-- begin-user-doc -->
1307   * <!-- end-user-doc -->
1308   * @generated
1309   */

1310  public BigInteger JavaDoc createNegativeIntegerFromString(EDataType eDataType, String JavaDoc initialValue)
1311  {
1312    return (BigInteger JavaDoc)XMLTypeFactory.eINSTANCE.createFromString(XMLTypePackage.eINSTANCE.getNonPositiveInteger(), initialValue);
1313  }
1314
1315  /**
1316   * <!-- begin-user-doc -->
1317   * <!-- end-user-doc -->
1318   * @generated
1319   */

1320  public String JavaDoc convertNegativeIntegerToString(EDataType eDataType, Object JavaDoc instanceValue)
1321  {
1322    return XMLTypeFactory.eINSTANCE.convertToString(XMLTypePackage.eINSTANCE.getNonPositiveInteger(), instanceValue);
1323  }
1324
1325  /**
1326   * <!-- begin-user-doc -->
1327   * <!-- end-user-doc -->
1328   * @generated NOT
1329   */

1330  public String JavaDoc createNMTOKENFromString(EDataType eDataType, String JavaDoc initialValue)
1331  {
1332    if (initialValue == null) return null;
1333    if (!XMLChar.isValidNmtoken(initialValue))
1334    {
1335      throw new InvalidDatatypeValueException("Invalid NMTOKEN value: '" + initialValue + "'");
1336    }
1337    return initialValue;
1338  }
1339
1340  /**
1341   * <!-- begin-user-doc -->
1342   * <!-- end-user-doc -->
1343   * @generated NOT
1344   */

1345  public String JavaDoc convertNMTOKENToString(EDataType eDataType, Object JavaDoc instanceValue)
1346  {
1347    return (String JavaDoc)instanceValue;
1348  }
1349
1350  /**
1351   * <!-- begin-user-doc -->
1352   * <!-- end-user-doc -->
1353   * @generated
1354   */

1355  public List JavaDoc createNMTOKENSBaseFromString(EDataType eDataType, String JavaDoc initialValue)
1356  {
1357    if (initialValue == null) return null;
1358    List JavaDoc result = new ArrayList JavaDoc();
1359    for (StringTokenizer JavaDoc stringTokenizer = new StringTokenizer JavaDoc(initialValue); stringTokenizer.hasMoreTokens(); )
1360    {
1361      String JavaDoc item = stringTokenizer.nextToken();
1362      result.add(XMLTypeFactory.eINSTANCE.createFromString(XMLTypePackage.eINSTANCE.getNMTOKEN(), item));
1363    }
1364    return result;
1365  }
1366
1367  /**
1368   * <!-- begin-user-doc -->
1369   * <!-- end-user-doc -->
1370   * @generated
1371   */

1372  public String JavaDoc convertNMTOKENSBaseToString(EDataType eDataType, Object JavaDoc instanceValue)
1373  {
1374    if (instanceValue == null) return null;
1375    List JavaDoc list = (List JavaDoc)instanceValue;
1376    if (list.isEmpty()) return "";
1377    StringBuffer JavaDoc result = new StringBuffer JavaDoc();
1378    for (Iterator JavaDoc i = list.iterator(); i.hasNext(); )
1379    {
1380      result.append(XMLTypeFactory.eINSTANCE.convertToString(XMLTypePackage.eINSTANCE.getNMTOKEN(), i.next()));
1381      result.append(' ');
1382    }
1383    return result.substring(0, result.length() - 1);
1384  }
1385
1386  /**
1387   * <!-- begin-user-doc -->
1388   * <!-- end-user-doc -->
1389   * @generated
1390   */

1391  public List JavaDoc createNMTOKENSFromString(EDataType eDataType, String JavaDoc initialValue)
1392  {
1393    return (List JavaDoc)XMLTypeFactory.eINSTANCE.createFromString(XMLTypePackage.eINSTANCE.getNMTOKENSBase(), initialValue);
1394  }
1395
1396  /**
1397   * <!-- begin-user-doc -->
1398   * <!-- end-user-doc -->
1399   * @generated
1400   */

1401  public String JavaDoc convertNMTOKENSToString(EDataType eDataType, Object JavaDoc instanceValue)
1402  {
1403    return XMLTypeFactory.eINSTANCE.convertToString(XMLTypePackage.eINSTANCE.getNMTOKENSBase(), instanceValue);
1404  }
1405
1406  /**
1407   * <!-- begin-user-doc -->
1408   * <!-- end-user-doc -->
1409   * @generated NOT
1410   */

1411  public BigInteger JavaDoc createNonNegativeIntegerFromString(EDataType eDataType, String JavaDoc initialValue)
1412  {
1413    return initialValue == null ? null : new BigInteger JavaDoc(collapseWhiteSpace(initialValue));
1414  }
1415
1416  /**
1417   * <!-- begin-user-doc -->
1418   * <!-- end-user-doc -->
1419   * @generated NOT
1420   */

1421  public String JavaDoc convertNonNegativeIntegerToString(EDataType eDataType, Object JavaDoc instanceValue)
1422  {
1423    return instanceValue == null ? null : instanceValue.toString();
1424  }
1425
1426  /**
1427   * <!-- begin-user-doc -->
1428   * <!-- end-user-doc -->
1429   * @generated NOT
1430   */

1431  public Object JavaDoc createNOTATIONFromString(EDataType eDataType, String JavaDoc initialValue)
1432  {
1433    return initialValue == null ? null : new QName(collapseWhiteSpace(initialValue));
1434  }
1435
1436  /**
1437   * <!-- begin-user-doc -->
1438   * <!-- end-user-doc -->
1439   * @generated NOT
1440   */

1441  public String JavaDoc convertNOTATIONToString(EDataType eDataType, Object JavaDoc instanceValue)
1442  {
1443    return instanceValue == null ? null : instanceValue.toString();
1444  }
1445
1446  /**
1447   * <!-- begin-user-doc -->
1448   * <!-- end-user-doc -->
1449   * @generated
1450   */

1451  public BigInteger JavaDoc createPositiveIntegerFromString(EDataType eDataType, String JavaDoc initialValue)
1452  {
1453    return (BigInteger JavaDoc)XMLTypeFactory.eINSTANCE.createFromString(XMLTypePackage.eINSTANCE.getNonNegativeInteger(), initialValue);
1454  }
1455
1456  /**
1457   * <!-- begin-user-doc -->
1458   * <!-- end-user-doc -->
1459   * @generated
1460   */

1461  public String JavaDoc convertPositiveIntegerToString(EDataType eDataType, Object JavaDoc instanceValue)
1462  {
1463    return XMLTypeFactory.eINSTANCE.convertToString(XMLTypePackage.eINSTANCE.getNonNegativeInteger(), instanceValue);
1464  }
1465
1466  /**
1467   * <!-- begin-user-doc -->
1468   * <!-- end-user-doc -->
1469   * @generated NOT
1470   */

1471  public Object JavaDoc createQNameFromString(EDataType eDataType, String JavaDoc initialValue)
1472  {
1473    return initialValue == null ? null : new QName(collapseWhiteSpace(initialValue));
1474  }
1475
1476  /**
1477   * <!-- begin-user-doc -->
1478   * <!-- end-user-doc -->
1479   * @generated NOT
1480   */

1481  public String JavaDoc convertQNameToString(EDataType eDataType, Object JavaDoc instanceValue)
1482  {
1483    return instanceValue == null ? null : instanceValue.toString();
1484  }
1485
1486  /**
1487   * <!-- begin-user-doc -->
1488   * <!-- end-user-doc -->
1489   * @generated NOT
1490   */

1491  public Object JavaDoc createTimeFromString(EDataType eDataType, String JavaDoc initialValue)
1492  {
1493    return initialValue == null ? null : new XMLCalendar(collapseWhiteSpace(initialValue), XMLCalendar.TIME);
1494}
1495
1496  /**
1497   * <!-- begin-user-doc -->
1498   * <!-- end-user-doc -->
1499   * @generated NOT
1500   */

1501  public String JavaDoc convertTimeToString(EDataType eDataType, Object JavaDoc instanceValue)
1502  {
1503    return instanceValue == null ? null : instanceValue.toString();
1504  }
1505
1506  /**
1507   * <!-- begin-user-doc -->
1508   * <!-- end-user-doc -->
1509   * @generated
1510   */

1511  public BigInteger JavaDoc createUnsignedLongFromString(EDataType eDataType, String JavaDoc initialValue)
1512  {
1513    return (BigInteger JavaDoc)XMLTypeFactory.eINSTANCE.createFromString(XMLTypePackage.eINSTANCE.getNonNegativeInteger(), initialValue);
1514  }
1515
1516  /**
1517   * <!-- begin-user-doc -->
1518   * <!-- end-user-doc -->
1519   * @generated
1520   */

1521  public String JavaDoc convertUnsignedLongToString(EDataType eDataType, Object JavaDoc instanceValue)
1522  {
1523    return XMLTypeFactory.eINSTANCE.convertToString(XMLTypePackage.eINSTANCE.getNonNegativeInteger(), instanceValue);
1524  }
1525
1526  /**
1527   * <!-- begin-user-doc -->
1528   * <!-- end-user-doc -->
1529   * @generated NOT
1530   */

1531  public Long JavaDoc createUnsignedIntFromString(EDataType eDataType, String JavaDoc initialValue)
1532  {
1533    return initialValue == null ? null : Long.valueOf(collapseWhiteSpace(initialValue));
1534  }
1535
1536  /**
1537   * <!-- begin-user-doc -->
1538   * <!-- end-user-doc -->
1539   * @generated NOT
1540   */

1541  public String JavaDoc convertUnsignedIntToString(EDataType eDataType, Object JavaDoc instanceValue)
1542  {
1543    return instanceValue == null ? null : instanceValue.toString();
1544  }
1545
1546  /**
1547   * <!-- begin-user-doc -->
1548   * <!-- end-user-doc -->
1549   * @generated NOT
1550   */

1551  public Long JavaDoc createUnsignedIntObjectFromString(EDataType eDataType, String JavaDoc initialValue)
1552  {
1553    return initialValue == null ? null : Long.valueOf(collapseWhiteSpace(initialValue));
1554  }
1555
1556  /**
1557   * <!-- begin-user-doc -->
1558   * <!-- end-user-doc -->
1559   * @generated NOT
1560   */

1561  public String JavaDoc convertUnsignedIntObjectToString(EDataType eDataType, Object JavaDoc instanceValue)
1562  {
1563    return instanceValue == null ? null : instanceValue.toString();
1564  }
1565
1566  /**
1567   * <!-- begin-user-doc -->
1568   * <!-- end-user-doc -->
1569   * @generated NOT
1570   */

1571  public Integer JavaDoc createUnsignedShortFromString(EDataType eDataType, String JavaDoc initialValue)
1572  {
1573    return initialValue == null ? null : Integer.valueOf(collapseWhiteSpace(initialValue));
1574  }
1575
1576  /**
1577   * <!-- begin-user-doc -->
1578   * <!-- end-user-doc -->
1579   * @generated NOT
1580   */

1581  public String JavaDoc convertUnsignedShortToString(EDataType eDataType, Object JavaDoc instanceValue)
1582  {
1583    return instanceValue == null ? null : instanceValue.toString();
1584  }
1585
1586  /**
1587   * <!-- begin-user-doc -->
1588   * <!-- end-user-doc -->
1589   * @generated NOT
1590   */

1591  public Integer JavaDoc createUnsignedShortObjectFromString(EDataType eDataType, String JavaDoc initialValue)
1592  {
1593    return initialValue == null ? null : Integer.valueOf(collapseWhiteSpace(initialValue));
1594  }
1595
1596  /**
1597   * <!-- begin-user-doc -->
1598   * <!-- end-user-doc -->
1599   * @generated NOT
1600   */

1601  public String JavaDoc convertUnsignedShortObjectToString(EDataType eDataType, Object JavaDoc instanceValue)
1602  {
1603    return instanceValue == null ? null : instanceValue.toString();
1604  }
1605
1606  /**
1607   * <!-- begin-user-doc -->
1608   * <!-- end-user-doc -->
1609   * @generated NOT
1610   */

1611  public Short JavaDoc createUnsignedByteFromString(EDataType eDataType, String JavaDoc initialValue)
1612  {
1613    return initialValue == null ? null : new Short JavaDoc(initialValue);
1614  }
1615
1616  /**
1617   * <!-- begin-user-doc -->
1618   * <!-- end-user-doc -->
1619   * @generated NOT
1620   */

1621  public String JavaDoc convertUnsignedByteToString(EDataType eDataType, Object JavaDoc instanceValue)
1622  {
1623    return instanceValue == null ? null : instanceValue.toString();
1624  }
1625
1626  /**
1627   * <!-- begin-user-doc -->
1628   * <!-- end-user-doc -->
1629   * @generated NOT
1630   */

1631  public Short JavaDoc createUnsignedByteObjectFromString(EDataType eDataType, String JavaDoc initialValue)
1632  {
1633    return initialValue == null ? null : new Short JavaDoc(initialValue);
1634  }
1635
1636  /**
1637   * <!-- begin-user-doc -->
1638   * <!-- end-user-doc -->
1639   * @generated NOT
1640   */

1641  public String JavaDoc convertUnsignedByteObjectToString(EDataType eDataType, Object JavaDoc instanceValue)
1642  {
1643    return instanceValue == null ? null : instanceValue.toString();
1644  }
1645
1646  /**
1647   * <!-- begin-user-doc -->
1648   * <!-- end-user-doc -->
1649   * @generated
1650   */

1651  public XMLTypePackage getXMLTypePackage()
1652  {
1653    return (XMLTypePackage)getEPackage();
1654  }
1655
1656  /**
1657   * <!-- begin-user-doc -->
1658   * <!-- end-user-doc -->
1659   * @deprecated
1660   * @generated
1661   */

1662  public static XMLTypePackage getPackage()
1663  {
1664    return XMLTypePackage.eINSTANCE;
1665  }
1666
1667  protected Boolean JavaDoc booleanValueOf(String JavaDoc initialValue)
1668  {
1669    initialValue = collapseWhiteSpace(initialValue);
1670    if ("true".equals(initialValue) || "1".equals(initialValue))
1671    {
1672      return Boolean.TRUE;
1673    }
1674    else if ("false".equals(initialValue) || "0".equals(initialValue))
1675    {
1676      return Boolean.FALSE;
1677    }
1678    throw new InvalidDatatypeValueException("Invalid boolean value: '" + initialValue + "'");
1679  }
1680
1681  private static class SafeSimpleDateFormat extends SimpleDateFormat JavaDoc
1682  {
1683    public SafeSimpleDateFormat(String JavaDoc pattern)
1684    {
1685      super(pattern);
1686    }
1687
1688    public synchronized Date JavaDoc parse(String JavaDoc source) throws ParseException JavaDoc
1689    {
1690      return super.parse(source);
1691    }
1692
1693    public StringBuffer JavaDoc format(Date JavaDoc date, StringBuffer JavaDoc toAppendTo, FieldPosition JavaDoc pos)
1694    {
1695      StringBuffer JavaDoc result = super.format(date, toAppendTo, pos);
1696      result.insert(result.length() - 2, ":");
1697      return result;
1698    }
1699  }
1700
1701} //XMLTypeFactoryImpl
1702
Popular Tags