1 17 package org.eclipse.emf.codegen.ecore.genmodel.impl; 18 19 20 import java.util.Arrays ; 21 import java.util.ArrayList ; 22 import java.util.Collections ; 23 import java.util.Iterator ; 24 import java.util.List ; 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 59 public class GenDataTypeImpl extends GenClassifierImpl implements GenDataType 60 { 61 69 protected EDataType ecoreDataType = null; 70 71 protected GenDataTypeImpl() 72 { 73 super(); 74 } 75 76 81 protected EClass eStaticClass() 82 { 83 return GenModelPackage.eINSTANCE.getGenDataType(); 84 } 85 86 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 111 public EDataType basicGetEcoreDataType() 112 { 113 return ecoreDataType; 114 } 115 116 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 134 public Object 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 152 public void eSet(EStructuralFeature eFeature, Object 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 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 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 getImportedMetaType() 202 { 203 return getGenModel().getImportedName("org.eclipse.emf.ecore.EDataType"); 204 } 205 206 public String getQualifiedInstanceClassName() 207 { 208 return getRawQualifiedInstanceClassName().replace('$','.'); 209 } 210 211 public String getRawQualifiedInstanceClassName() 212 { 213 String 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 getImportedInstanceClassName() 233 { 234 return getGenModel().getImportedName(getRawQualifiedInstanceClassName()); 235 } 236 237 public String getObjectInstanceClassName() 238 { 239 return getImportedType(getEcoreDataType(), true); 240 } 241 242 public boolean isSerializable() 243 { 244 return getEcoreDataType().isSerializable(); 245 } 246 247 public String getSerializableFlag() 248 { 249 String result = !getEcoreDataType().isSerializable() ? "!" : ""; 250 return result + "IS_SERIALIZABLE"; 251 } 252 253 public String getGeneratedInstanceClassFlag() 254 { 255 String 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 getPrimitiveValueFunction() 275 { 276 Class 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 getModelInfo() 297 { 298 StringBuffer result = new StringBuffer (); 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 getMemberTypes() 339 { 340 List result = new ArrayList (); 341 for (Iterator 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 getEffectiveMemberTypes() 350 { 351 ExtendedMetaData extendedMetaData = getExtendedMetaData(); 352 for (EDataType eDataType = getEcoreDataType(); eDataType != null; eDataType = extendedMetaData.getBaseType(eDataType)) 353 { 354 List result = new ArrayList (); 355 for (Iterator 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 getMinLiteral() 369 { 370 ExtendedMetaData extendedMetaData = getExtendedMetaData(); 371 for (EDataType eDataType = getEcoreDataType(); eDataType != null; eDataType = extendedMetaData.getBaseType(eDataType)) 372 { 373 String 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 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 getMaxLiteral() 407 { 408 ExtendedMetaData extendedMetaData = getExtendedMetaData(); 409 for (EDataType eDataType = getEcoreDataType(); eDataType != null; eDataType = extendedMetaData.getBaseType(eDataType)) 410 { 411 String 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 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 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 getEnumerationLiterals() 527 { 528 ExtendedMetaData extendedMetaData = getExtendedMetaData(); 529 for (EDataType eDataType = getEcoreDataType(); eDataType != null; eDataType = extendedMetaData.getBaseType(eDataType)) 530 { 531 List literals = extendedMetaData.getEnumerationFacet(eDataType); 532 if (!literals.isEmpty()) 533 { 534 return literals; 535 } 536 } 537 return Collections.EMPTY_LIST; 538 } 539 540 public String 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 xmlCalendarTypes = 555 Arrays.asList 556 (new String [] 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 namespace = extendedMetaData.getNamespace(eDataType); 574 String 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 namespace = extendedMetaData.getNamespace(eDataType); 589 String 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 namespace = extendedMetaData.getNamespace(eDataType); 604 String 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 getPatterns() 614 { 615 List result = new ArrayList (); 616 ExtendedMetaData extendedMetaData = getExtendedMetaData(); 617 for (EDataType eDataType = getEcoreDataType(); eDataType != null; eDataType = extendedMetaData.getBaseType(eDataType)) 618 { 619 List patterns = extendedMetaData.getPatternFacet(eDataType); 620 if (!patterns.isEmpty()) 621 { 622 List literals = new ArrayList (); 623 for (Iterator 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 getGenConstraints() 669 { 670 List constraints = new UniqueEList(super.getGenConstraints()); 671 ExtendedMetaData extendedMetaData = getExtendedMetaData(); 672 EDataType eDataType = getEcoreDataType(); 673 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 getAllGenConstraints() 728 { 729 List allBaseTypes = new ArrayList (); 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 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 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 getStaticValue(String 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 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 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 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 e) 827 { 828 return ""; } 830 } 831 if (defaultObject == null) return "null"; 832 String result = Literals.toLiteral(defaultObject, getGenModel()); 833 834 Class typeClass = getInstanceClass(eDataType); 837 if (typeClass == Boolean .class) 838 { 839 StringBuffer wrapped = new StringBuffer (getGenModel().getImportedName("java.lang.Boolean")); 840 wrapped.append('.'); 841 wrapped.append(result.toUpperCase()); 842 result = wrapped.toString(); 843 } 844 else if (typeClass == Character .class || typeClass == Byte .class || typeClass == Short .class || typeClass == Integer .class || 845 typeClass == Long .class || typeClass == Float .class || typeClass == Double .class) 846 { 847 StringBuffer wrapped = new StringBuffer ("new "); 848 wrapped.append(getGenModel().getImportedName(eDataType.getInstanceClassName())); 849 wrapped.append('('); 850 if (typeClass == Byte .class) 851 { 852 wrapped.append("(byte)"); 853 } 854 else if (typeClass == Short .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 |