KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > eclipse > emf > codegen > ecore > genmodel > impl > GenDataTypeImpl


1 /**
2  * <copyright>
3  *
4  * Copyright (c) 2002-2004 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: GenDataTypeImpl.java,v 1.11 2005/06/20 15:10:42 davidms Exp $
16  */

17 package org.eclipse.emf.codegen.ecore.genmodel.impl;
18
19
20 import java.util.Arrays JavaDoc;
21 import java.util.ArrayList JavaDoc;
22 import java.util.Collections JavaDoc;
23 import java.util.Iterator JavaDoc;
24 import java.util.List JavaDoc;
25
26 import org.eclipse.emf.codegen.ecore.genmodel.GenClassifier;
27 import org.eclipse.emf.codegen.ecore.genmodel.GenDataType;
28 import org.eclipse.emf.codegen.ecore.genmodel.GenEnum;
29 import org.eclipse.emf.codegen.ecore.genmodel.GenModelPackage;
30 import org.eclipse.emf.common.notify.Notification;
31 import org.eclipse.emf.common.util.UniqueEList;
32 import org.eclipse.emf.ecore.EClass;
33 import org.eclipse.emf.ecore.EClassifier;
34 import org.eclipse.emf.ecore.EcoreFactory;
35 import org.eclipse.emf.ecore.EcorePackage;
36 import org.eclipse.emf.ecore.EDataType;
37 import org.eclipse.emf.ecore.EEnum;
38 import org.eclipse.emf.ecore.EStructuralFeature;
39 import org.eclipse.emf.ecore.InternalEObject;
40 import org.eclipse.emf.ecore.impl.ENotificationImpl;
41 import org.eclipse.emf.ecore.util.ExtendedMetaData;
42 import org.eclipse.emf.ecore.xml.type.XMLTypeFactory;
43 import org.eclipse.emf.ecore.xml.type.XMLTypePackage;
44
45
46 /**
47  * <!-- begin-user-doc -->
48  * An implementation of the model object '<em><b>Gen Data Type</b></em>'.
49  * <!-- end-user-doc -->
50  * <p>
51  * The following features are implemented:
52  * <ul>
53  * <li>{@link org.eclipse.emf.codegen.ecore.genmodel.impl.GenDataTypeImpl#getEcoreDataType <em>Ecore Data Type</em>}</li>
54  * </ul>
55  * </p>
56  *
57  * @generated
58  */

59 public class GenDataTypeImpl extends GenClassifierImpl implements GenDataType
60 {
61   /**
62    * The cached value of the '{@link #getEcoreDataType() <em>Ecore Data Type</em>}' reference.
63    * <!-- begin-user-doc -->
64    * <!-- end-user-doc -->
65    * @see #getEcoreDataType()
66    * @generated
67    * @ordered
68    */

69   protected EDataType ecoreDataType = null;
70
71   protected GenDataTypeImpl()
72   {
73     super();
74   }
75
76   /**
77    * <!-- begin-user-doc -->
78    * <!-- end-user-doc -->
79    * @generated
80    */

81   protected EClass eStaticClass()
82   {
83     return GenModelPackage.eINSTANCE.getGenDataType();
84   }
85
86   /**
87    * <!-- begin-user-doc -->
88    * <!-- end-user-doc -->
89    * @generated
90    */

91   public EDataType getEcoreDataType()
92   {
93     if (ecoreDataType != null && ecoreDataType.eIsProxy())
94     {
95       EDataType oldEcoreDataType = ecoreDataType;
96       ecoreDataType = (EDataType)eResolveProxy((InternalEObject)ecoreDataType);
97       if (ecoreDataType != oldEcoreDataType)
98       {
99         if (eNotificationRequired())
100           eNotify(new ENotificationImpl(this, Notification.RESOLVE, GenModelPackage.GEN_DATA_TYPE__ECORE_DATA_TYPE, oldEcoreDataType, ecoreDataType));
101       }
102     }
103     return ecoreDataType;
104   }
105
106   /**
107    * <!-- begin-user-doc -->
108    * <!-- end-user-doc -->
109    * @generated
110    */

111   public EDataType basicGetEcoreDataType()
112   {
113     return ecoreDataType;
114   }
115
116   /**
117    * <!-- begin-user-doc -->
118    * <!-- end-user-doc -->
119    * @generated
120    */

121   public void setEcoreDataType(EDataType newEcoreDataType)
122   {
123     EDataType oldEcoreDataType = ecoreDataType;
124     ecoreDataType = newEcoreDataType;
125     if (eNotificationRequired())
126       eNotify(new ENotificationImpl(this, Notification.SET, GenModelPackage.GEN_DATA_TYPE__ECORE_DATA_TYPE, oldEcoreDataType, ecoreDataType));
127   }
128
129   /**
130    * <!-- begin-user-doc -->
131    * <!-- end-user-doc -->
132    * @generated
133    */

134   public Object JavaDoc eGet(EStructuralFeature eFeature, boolean resolve)
135   {
136     switch (eDerivedStructuralFeatureID(eFeature))
137     {
138       case GenModelPackage.GEN_DATA_TYPE__GEN_PACKAGE:
139         return getGenPackage();
140       case GenModelPackage.GEN_DATA_TYPE__ECORE_DATA_TYPE:
141         if (resolve) return getEcoreDataType();
142         return basicGetEcoreDataType();
143     }
144     return eDynamicGet(eFeature, resolve);
145   }
146
147   /**
148    * <!-- begin-user-doc -->
149    * <!-- end-user-doc -->
150    * @generated
151    */

152   public void eSet(EStructuralFeature eFeature, Object JavaDoc newValue)
153   {
154     switch (eDerivedStructuralFeatureID(eFeature))
155     {
156       case GenModelPackage.GEN_DATA_TYPE__ECORE_DATA_TYPE:
157         setEcoreDataType((EDataType)newValue);
158         return;
159     }
160     eDynamicSet(eFeature, newValue);
161   }
162
163   /**
164    * <!-- begin-user-doc -->
165    * <!-- end-user-doc -->
166    * @generated
167    */

168   public void eUnset(EStructuralFeature eFeature)
169   {
170     switch (eDerivedStructuralFeatureID(eFeature))
171     {
172       case GenModelPackage.GEN_DATA_TYPE__ECORE_DATA_TYPE:
173         setEcoreDataType((EDataType)null);
174         return;
175     }
176     eDynamicUnset(eFeature);
177   }
178
179   /**
180    * <!-- begin-user-doc -->
181    * <!-- end-user-doc -->
182    * @generated
183    */

184   public boolean eIsSet(EStructuralFeature eFeature)
185   {
186     switch (eDerivedStructuralFeatureID(eFeature))
187     {
188       case GenModelPackage.GEN_DATA_TYPE__GEN_PACKAGE:
189         return getGenPackage() != null;
190       case GenModelPackage.GEN_DATA_TYPE__ECORE_DATA_TYPE:
191         return ecoreDataType != null;
192     }
193     return eDynamicIsSet(eFeature);
194   }
195
196   public EClassifier getEcoreClassifier()
197   {
198     return getEcoreDataType();
199   }
200
201   public String JavaDoc getImportedMetaType()
202   {
203     return getGenModel().getImportedName("org.eclipse.emf.ecore.EDataType");
204   }
205
206   public String JavaDoc getQualifiedInstanceClassName()
207   {
208     return getRawQualifiedInstanceClassName().replace('$','.');
209   }
210
211   public String JavaDoc getRawQualifiedInstanceClassName()
212   {
213     String JavaDoc name = getEcoreDataType().getInstanceClassName();
214     if (name == null) name = "java.lang.Object";
215
216     if (name.equals("org.eclipse.emf.common.util.Enumerator"))
217     {
218       EDataType baseType = getExtendedMetaData().getBaseType(getEcoreDataType());
219       if (baseType instanceof EEnum)
220       {
221         GenEnum genEnum = findGenEnum((EEnum)baseType);
222         if (genEnum != null)
223         {
224           name = genEnum.getQualifiedName();
225         }
226       }
227     }
228
229     return name;
230   }
231
232   public String JavaDoc getImportedInstanceClassName()
233   {
234    return getGenModel().getImportedName(getRawQualifiedInstanceClassName());
235   }
236
237   public String JavaDoc getObjectInstanceClassName()
238   {
239     return getImportedType(getEcoreDataType(), true);
240   }
241
242   public boolean isSerializable()
243   {
244     return getEcoreDataType().isSerializable();
245   }
246
247   public String JavaDoc getSerializableFlag()
248   {
249     String JavaDoc result = !getEcoreDataType().isSerializable() ? "!" : "";
250     return result + "IS_SERIALIZABLE";
251   }
252
253   public String JavaDoc getGeneratedInstanceClassFlag()
254   {
255     String JavaDoc result = this instanceof GenEnum || getBaseType() instanceof GenEnum ? "" : "!";
256     return result + "IS_GENERATED_INSTANCE_CLASS";
257   }
258
259   public boolean isPrimitiveType()
260   {
261     return isPrimitiveType(getEcoreDataType());
262   }
263
264   public boolean isArrayType()
265   {
266     return getEcoreDataType().getInstanceClassName().indexOf('[') != -1;
267   }
268
269   public boolean isObjectType()
270   {
271     return "java.lang.Object".equals(getEcoreDataType().getInstanceClassName());
272   }
273
274   public String JavaDoc getPrimitiveValueFunction()
275   {
276     Class JavaDoc instanceClass = getEcoreDataType().getInstanceClass();
277     if (instanceClass == java.lang.Boolean.TYPE)
278       return "booleanValue";
279     if (instanceClass == java.lang.Byte.TYPE)
280       return "byteValue";
281     if (instanceClass == java.lang.Character.TYPE)
282       return "charValue";
283     if (instanceClass == java.lang.Double.TYPE)
284       return "doubleValue";
285     if (instanceClass == java.lang.Float.TYPE)
286       return "floatValue";
287     if (instanceClass == java.lang.Integer.TYPE)
288       return "intValue";
289     if (instanceClass == java.lang.Long.TYPE)
290       return "longValue";
291     if (instanceClass == java.lang.Short.TYPE)
292       return "shortValue";
293     return null;
294   }
295
296   public String JavaDoc getModelInfo()
297   {
298     StringBuffer JavaDoc result = new StringBuffer JavaDoc();
299
300     result.append("instanceClass=\"" + getRawQualifiedInstanceClassName() + "\"");
301
302     if (!isSerializable())
303     {
304       result.append(" serializable=\"false\"");
305     }
306
307     appendAnnotationInfo(result, getEcoreDataType());
308
309     return result.toString();
310   }
311
312   public GenDataType getBaseType()
313   {
314     EDataType baseType = getExtendedMetaData().getBaseType(getEcoreDataType());
315     return baseType == null ? null : (GenDataType)findGenClassifier(baseType);
316   }
317
318   public GenDataType getItemType()
319   {
320     EDataType itemType = getExtendedMetaData().getItemType(getEcoreDataType());
321     return itemType == null ? null : (GenDataType)findGenClassifier(itemType);
322   }
323
324   public GenDataType getEffectiveItemType()
325   {
326     ExtendedMetaData extendedMetaData = getExtendedMetaData();
327     for (EDataType eDataType = getEcoreDataType(); eDataType != null; eDataType = extendedMetaData.getBaseType(eDataType))
328     {
329       EDataType itemType = getExtendedMetaData().getItemType(eDataType);
330       if (itemType != null)
331       {
332         return (GenDataType)findGenClassifier(itemType);
333       }
334     }
335     return null;
336   }
337
338   public List JavaDoc /*GenDataType*/ getMemberTypes()
339   {
340     List JavaDoc result = new ArrayList JavaDoc();
341     for (Iterator JavaDoc i = getExtendedMetaData().getMemberTypes(getEcoreDataType()).iterator(); i.hasNext(); )
342     {
343       EDataType memberType = (EDataType)i.next();
344       result.add(findGenClassifier(memberType));
345     }
346     return result;
347   }
348
349   public List JavaDoc /*GenDataType*/ getEffectiveMemberTypes()
350   {
351     ExtendedMetaData extendedMetaData = getExtendedMetaData();
352     for (EDataType eDataType = getEcoreDataType(); eDataType != null; eDataType = extendedMetaData.getBaseType(eDataType))
353     {
354       List JavaDoc result = new ArrayList JavaDoc();
355       for (Iterator JavaDoc i = getExtendedMetaData().getMemberTypes(eDataType).iterator(); i.hasNext(); )
356       {
357         EDataType memberType = (EDataType)i.next();
358         result.add(findGenClassifier(memberType));
359       }
360       if (result.isEmpty())
361       {
362         return result;
363       }
364     }
365     return null;
366   }
367
368   public String JavaDoc getMinLiteral()
369   {
370     ExtendedMetaData extendedMetaData = getExtendedMetaData();
371     for (EDataType eDataType = getEcoreDataType(); eDataType != null; eDataType = extendedMetaData.getBaseType(eDataType))
372     {
373       String JavaDoc min = extendedMetaData.getMinExclusiveFacet(eDataType);
374       if (min != null)
375       {
376         return min;
377       }
378       min = extendedMetaData.getMinInclusiveFacet(eDataType);
379       if (min != null)
380       {
381         return min;
382       }
383     }
384     return null;
385   }
386
387   public boolean isMinInclusive()
388   {
389     ExtendedMetaData extendedMetaData = getExtendedMetaData();
390     for (EDataType eDataType = getEcoreDataType(); eDataType != null; eDataType = extendedMetaData.getBaseType(eDataType))
391     {
392       String JavaDoc min = extendedMetaData.getMinExclusiveFacet(eDataType);
393       if (min != null)
394       {
395         return false;
396       }
397       min = extendedMetaData.getMinInclusiveFacet(eDataType);
398       if (min != null)
399       {
400         return true;
401       }
402     }
403     return true;
404   }
405
406   public String JavaDoc getMaxLiteral()
407   {
408     ExtendedMetaData extendedMetaData = getExtendedMetaData();
409     for (EDataType eDataType = getEcoreDataType(); eDataType != null; eDataType = extendedMetaData.getBaseType(eDataType))
410     {
411       String JavaDoc max = extendedMetaData.getMaxExclusiveFacet(eDataType);
412       if (max != null)
413       {
414         return max;
415       }
416       max = extendedMetaData.getMaxInclusiveFacet(eDataType);
417       if (max != null)
418       {
419         return max;
420       }
421     }
422     return null;
423   }
424
425   public boolean isMaxInclusive()
426   {
427     ExtendedMetaData extendedMetaData = getExtendedMetaData();
428     for (EDataType eDataType = getEcoreDataType(); eDataType != null; eDataType = extendedMetaData.getBaseType(eDataType))
429     {
430       String JavaDoc max = extendedMetaData.getMaxExclusiveFacet(eDataType);
431       if (max != null)
432       {
433         return false;
434       }
435       max = extendedMetaData.getMaxInclusiveFacet(eDataType);
436       if (max != null)
437       {
438         return true;
439       }
440     }
441     return true;
442   }
443
444   public String JavaDoc getLengthAccessorFunction()
445   {
446     if (isArrayType())
447     {
448       return "length";
449     }
450     else if ("java.lang.String".equals(getEcoreDataType().getInstanceClassName()))
451     {
452       return "length()";
453     }
454     else
455     {
456       return "size()";
457     }
458   }
459
460   public int getMinLength()
461   {
462     ExtendedMetaData extendedMetaData = getExtendedMetaData();
463     for (EDataType eDataType = getEcoreDataType(); eDataType != null; eDataType = extendedMetaData.getBaseType(eDataType))
464     {
465       int minLength = extendedMetaData.getMinLengthFacet(eDataType);
466       if (minLength != -1)
467       {
468         return minLength;
469       }
470       minLength = extendedMetaData.getLengthFacet(eDataType);
471       if (minLength != -1)
472       {
473         return minLength;
474       }
475     }
476     return -1;
477   }
478
479   public int getMaxLength()
480   {
481     ExtendedMetaData extendedMetaData = getExtendedMetaData();
482     for (EDataType eDataType = getEcoreDataType(); eDataType != null; eDataType = extendedMetaData.getBaseType(eDataType))
483     {
484       int maxLength = extendedMetaData.getMaxLengthFacet(eDataType);
485       if (maxLength != -1)
486       {
487         return maxLength;
488       }
489       maxLength = extendedMetaData.getLengthFacet(eDataType);
490       if (maxLength != -1)
491       {
492         return maxLength;
493       }
494     }
495     return -1;
496   }
497
498   public int getTotalDigits()
499   {
500     ExtendedMetaData extendedMetaData = getExtendedMetaData();
501     for (EDataType eDataType = getEcoreDataType(); eDataType != null; eDataType = extendedMetaData.getBaseType(eDataType))
502     {
503       int totalDigits = extendedMetaData.getTotalDigitsFacet(eDataType);
504       if (totalDigits != -1)
505       {
506         return totalDigits;
507       }
508     }
509     return -1;
510   }
511
512   public int getFractionDigits()
513   {
514     ExtendedMetaData extendedMetaData = getExtendedMetaData();
515     for (EDataType eDataType = getEcoreDataType(); eDataType != null; eDataType = extendedMetaData.getBaseType(eDataType))
516     {
517       int fractionDigits = extendedMetaData.getFractionDigitsFacet(eDataType);
518       if (fractionDigits != -1)
519       {
520         return fractionDigits;
521       }
522     }
523     return -1;
524   }
525
526   public List JavaDoc getEnumerationLiterals()
527   {
528     ExtendedMetaData extendedMetaData = getExtendedMetaData();
529     for (EDataType eDataType = getEcoreDataType(); eDataType != null; eDataType = extendedMetaData.getBaseType(eDataType))
530     {
531       List JavaDoc literals = extendedMetaData.getEnumerationFacet(eDataType);
532       if (!literals.isEmpty())
533       {
534         return literals;
535       }
536     }
537     return Collections.EMPTY_LIST;
538   }
539
540   public String JavaDoc getWhiteSpace()
541   {
542     ExtendedMetaData extendedMetaData = getExtendedMetaData();
543     for (EDataType eDataType = getEcoreDataType(); eDataType != null; eDataType = extendedMetaData.getBaseType(eDataType))
544     {
545       int whiteSpace = extendedMetaData.getWhiteSpaceFacet(eDataType);
546       if (whiteSpace != ExtendedMetaData.UNSPECIFIED_WHITE_SPACE)
547       {
548         return ExtendedMetaData.WHITE_SPACE_KINDS[whiteSpace];
549       }
550     }
551     return ExtendedMetaData.WHITE_SPACE_KINDS[ExtendedMetaData.UNSPECIFIED_WHITE_SPACE];
552   }
553
554   protected static final List JavaDoc xmlCalendarTypes =
555     Arrays.asList
556       (new String JavaDoc[]
557        {
558          "date",
559          "dateTime",
560          "gDay",
561          "gMonth",
562          "gMonthDay",
563          "gYear",
564          "gYearMonth",
565          "time"
566        });
567
568   public boolean isXMLCalendar()
569   {
570     ExtendedMetaData extendedMetaData = getExtendedMetaData();
571     for (EDataType eDataType = getEcoreDataType(); eDataType != null; eDataType = extendedMetaData.getBaseType(eDataType))
572     {
573       String JavaDoc namespace = extendedMetaData.getNamespace(eDataType);
574       String JavaDoc name = extendedMetaData.getName(eDataType);
575       if (XMLTypePackage.eNS_URI.equals(namespace) && xmlCalendarTypes.contains(name))
576       {
577         return true;
578       }
579     }
580     return false;
581   }
582
583   public boolean isXMLDuration()
584   {
585     ExtendedMetaData extendedMetaData = getExtendedMetaData();
586     for (EDataType eDataType = getEcoreDataType(); eDataType != null; eDataType = extendedMetaData.getBaseType(eDataType))
587     {
588       String JavaDoc namespace = extendedMetaData.getNamespace(eDataType);
589       String JavaDoc name = extendedMetaData.getName(eDataType);
590       if (XMLTypePackage.eNS_URI.equals(namespace) && "duration".equals(name))
591       {
592         return true;
593       }
594     }
595     return false;
596   }
597
598   public boolean isXMLBoolean()
599   {
600     ExtendedMetaData extendedMetaData = getExtendedMetaData();
601     for (EDataType eDataType = getEcoreDataType(); eDataType != null; eDataType = extendedMetaData.getBaseType(eDataType))
602     {
603       String JavaDoc namespace = extendedMetaData.getNamespace(eDataType);
604       String JavaDoc name = extendedMetaData.getName(eDataType);
605       if (XMLTypePackage.eNS_URI.equals(namespace) && "boolean".equals(name))
606       {
607         return true;
608       }
609     }
610     return false;
611   }
612
613   public List JavaDoc getPatterns()
614   {
615     List JavaDoc result = new ArrayList JavaDoc();
616     ExtendedMetaData extendedMetaData = getExtendedMetaData();
617     for (EDataType eDataType = getEcoreDataType(); eDataType != null; eDataType = extendedMetaData.getBaseType(eDataType))
618     {
619       List JavaDoc patterns = extendedMetaData.getPatternFacet(eDataType);
620       if (!patterns.isEmpty())
621       {
622         List JavaDoc literals = new ArrayList JavaDoc();
623         for (Iterator JavaDoc i = patterns.iterator(); i.hasNext(); )
624         {
625           literals.add(Literals.toLiteral(i.next()));
626         }
627         result.add(literals);
628       }
629     }
630     return result;
631   }
632
633   public void initialize(EDataType eDataType)
634   {
635     setEcoreDataType(eDataType);
636   }
637
638   public boolean reconcile(GenDataType oldGenDataTypeVersion)
639   {
640     if (getEcoreDataType().getName().equals(oldGenDataTypeVersion.getEcoreDataType().getName()))
641     {
642       reconcileSettings(oldGenDataTypeVersion);
643       return true;
644     }
645     else
646     {
647       return false;
648     }
649   }
650
651   protected void reconcileSettings(GenDataType oldGenDataTypeVersion)
652   {
653   }
654
655   public boolean reconcile()
656   {
657     EDataType eDataType = getEcoreDataType();
658     if (eDataType == null || eDataType.eIsProxy() || eDataType.eResource() == null)
659     {
660       return false;
661     }
662     else
663     {
664       return true;
665     }
666   }
667
668   public List JavaDoc getGenConstraints()
669   {
670     List JavaDoc constraints = new UniqueEList(super.getGenConstraints());
671     ExtendedMetaData extendedMetaData = getExtendedMetaData();
672     EDataType eDataType = getEcoreDataType();
673     // White space is not a constraint; it should affect createFromString only.
674
//
675
// if (extendedMetaData.getWhiteSpaceFacet(eDataType) != ExtendedMetaData.UNSPECIFIED_WHITE_SPACE)
676
// {
677
// constraints.add("WhiteSpace");
678
// }
679
if (!extendedMetaData.getEnumerationFacet(eDataType).isEmpty())
680     {
681       constraints.add("Enumeration");
682     }
683     if (!extendedMetaData.getPatternFacet(eDataType).isEmpty())
684     {
685       constraints.add("Pattern");
686     }
687     if (extendedMetaData.getTotalDigitsFacet(eDataType) != -1)
688     {
689       constraints.add("TotalDigits");
690     }
691     if (extendedMetaData.getFractionDigitsFacet(eDataType) != -1)
692     {
693       constraints.add("FractionDigits");
694     }
695     if (extendedMetaData.getLengthFacet(eDataType) != -1)
696     {
697       constraints.add("MinLength");
698       constraints.add("MaxLength");
699     }
700     if (extendedMetaData.getMinLengthFacet(eDataType) != -1)
701     {
702       constraints.add("MinLength");
703     }
704     if (extendedMetaData.getMaxLengthFacet(eDataType) != -1)
705     {
706       constraints.add("MaxLength");
707     }
708     if (extendedMetaData.getMinExclusiveFacet(eDataType) != null || extendedMetaData.getMinInclusiveFacet(eDataType) != null)
709     {
710       constraints.add("Min");
711     }
712     if (extendedMetaData.getMaxExclusiveFacet(eDataType) != null || extendedMetaData.getMaxInclusiveFacet(eDataType) != null)
713     {
714       constraints.add("Max");
715     }
716     if (getItemType() != null)
717     {
718       constraints.add("ItemType");
719     }
720     if (!getMemberTypes().isEmpty())
721     {
722       constraints.add("MemberTypes");
723     }
724     return constraints;
725   }
726
727   public List JavaDoc getAllGenConstraints()
728   {
729     List JavaDoc allBaseTypes = new ArrayList JavaDoc();
730     if (getExtendedMetaData().getEnumerationFacet(getEcoreDataType()).isEmpty())
731     {
732       for (GenDataType baseType = getBaseType(); baseType != null; baseType = baseType.getBaseType())
733       {
734         allBaseTypes.add(baseType);
735         if (!getExtendedMetaData().getEnumerationFacet(baseType.getEcoreDataType()).isEmpty())
736         {
737           break;
738         }
739       }
740     }
741     return collectGenConstraints(allBaseTypes, getGenConstraints(), null);
742   }
743
744   public GenClassifier getConstraintImplementor(String JavaDoc constraint)
745   {
746     for (GenDataType baseType = this; baseType != null; baseType = baseType.getBaseType())
747     {
748       if (baseType.getGenConstraints().contains(constraint))
749       {
750         return baseType;
751       }
752     }
753     return null;
754   }
755
756   public GenClassifier getConstraintDelegate(String JavaDoc constraint)
757   {
758     for (GenDataType baseType = getBaseType(); baseType != null; baseType = baseType.getBaseType())
759     {
760       if (baseType.getGenConstraints().contains(constraint))
761       {
762         return baseType;
763       }
764     }
765     return null;
766   }
767
768   public String JavaDoc getStaticValue(String JavaDoc literal)
769   {
770     EClassifier eDataType = getEcoreDataType();
771     if (eDataType instanceof EEnum)
772     {
773       GenEnum genEnum = findGenEnum((EEnum)eDataType);
774       return genEnum.getStaticValue(literal);
775     }
776
777     if (eDataType.getEPackage() != EcorePackage.eINSTANCE && literal != null)
778     {
779       boolean replaced = false;
780       for (Iterator JavaDoc i = EcorePackage.eINSTANCE.getEClassifiers().iterator(); i.hasNext(); )
781       {
782         EClassifier eClassifier = (EClassifier)i.next();
783         if (eClassifier instanceof EDataType &&
784             eClassifier.getInstanceClassName().equals(eDataType.getInstanceClassName()) &&
785             ((EDataType)eClassifier).isSerializable() &&
786             eClassifier != EcorePackage.eINSTANCE.getEDate())
787         {
788           replaced = true;
789           eDataType = eClassifier;
790           break;
791         }
792       }
793       if (!replaced)
794       {
795         String JavaDoc result =
796           getGenPackage().getImportedFactoryInterfaceName() +
797             ".eINSTANCE.createFromString(" +
798             getGenPackage().getImportedPackageInterfaceName() +
799             ".eINSTANCE.get" +
800             getName() +
801             "(), " +
802             Literals.toLiteral(literal) +
803             ")";
804         if (isPrimitiveType())
805         {
806           result = "((" + getObjectInstanceClassName() + ")" + result + ")." + getPrimitiveValueFunction() + "()";
807         }
808         else if (!isObjectType())
809         {
810           result = "(" + getImportedInstanceClassName() + ")" + result;
811         }
812         return result;
813       }
814     }
815
816     Object JavaDoc defaultObject = eDataType.getDefaultValue();
817     if (literal != null)
818     {
819       try
820       {
821         defaultObject =
822           isXMLBoolean() ?
823             XMLTypeFactory.eINSTANCE.createFromString(XMLTypePackage.eINSTANCE.getBoolean(), literal) :
824             EcoreFactory.eINSTANCE.createFromString((EDataType)eDataType, literal);
825       }
826       catch (Exception JavaDoc e)
827       {
828         return ""; // cause a syntax error
829
}
830     }
831     if (defaultObject == null) return "null";
832     String JavaDoc result = Literals.toLiteral(defaultObject, getGenModel());
833
834     // Include static field or constructor for wrapped primitive types.
835
//
836
Class JavaDoc typeClass = getInstanceClass(eDataType);
837     if (typeClass == Boolean JavaDoc.class)
838     {
839       StringBuffer JavaDoc wrapped = new StringBuffer JavaDoc(getGenModel().getImportedName("java.lang.Boolean"));
840       wrapped.append('.');
841       wrapped.append(result.toUpperCase());
842       result = wrapped.toString();
843     }
844     else if (typeClass == Character JavaDoc.class || typeClass == Byte JavaDoc.class || typeClass == Short JavaDoc.class || typeClass == Integer JavaDoc.class ||
845              typeClass == Long JavaDoc.class || typeClass == Float JavaDoc.class || typeClass == Double JavaDoc.class)
846     {
847       StringBuffer JavaDoc wrapped = new StringBuffer JavaDoc("new ");
848       wrapped.append(getGenModel().getImportedName(eDataType.getInstanceClassName()));
849       wrapped.append('(');
850       if (typeClass == Byte JavaDoc.class)
851       {
852         wrapped.append("(byte)");
853       }
854       else if (typeClass == Short JavaDoc.class)
855       {
856         wrapped.append("(short)");
857       }
858       wrapped.append(result);
859       wrapped.append(')');
860       result = wrapped.toString();
861     }
862     return result;
863   }
864 }
865
Popular Tags