private static EClassifier toEType(Class<?> typeClass) { if (typeClass == null) { typeClass = String.class; } for (EDataType type : ETYPES) { if (type.getInstanceClass() == typeClass) { return type; } } throw new IllegalArgumentException("Type for type class " + typeClass + " is not supported"); }
@Override public Object caseEDataType(EDataType eDataType) { try { eDataType.getInstanceClass(); } catch (Exception e) { eDataType .setInstanceClassName(EcorePackage.Literals.ESTRING .getInstanceClassName()); } return eDataType; }
private static EClassifier toEType(Class<?> typeClass) { if (typeClass == null) { typeClass = String.class; } for (EDataType type : ETYPES) { if (type.getInstanceClass() == typeClass) { return type; } } throw new IllegalArgumentException("Type for type class " + typeClass + " is not supported"); }
/** * @since 1.5 */ public Class<?> getJavaClass(final EDataTypeInSlotsKey key) { try { Class<?> dataTypeClass = key.getEmfKey().getInstanceClass(); if ((dataTypeClass == null)) { dataTypeClass = this.classLoaderProvider.getClassLoader(key.getEmfKey()).loadClass(key.getEmfKey().getInstanceClassName()); } boolean _isPrimitive = dataTypeClass.isPrimitive(); if (_isPrimitive) { Class<?> _wrapperClassForType = null; if (dataTypeClass!=null) { _wrapperClassForType=AbstractTypeSystem.getWrapperClassForType(dataTypeClass); } dataTypeClass = _wrapperClassForType; } return dataTypeClass; } catch (Throwable _e) { throw Exceptions.sneakyThrow(_e); } }
@Override public EClassifier caseEDataType(EDataType eDataType) { return otherEType instanceof EDataType && eDataType.getInstanceClass().equals( ((EDataType) otherEType).getInstanceClass()) ? eDataType : EcorePackage.eINSTANCE.getEJavaObject(); }
SingleProvider() { super(); // Initialize attributes final EDataType eDataType = mock(EDataType.class); when(eDataType.getInstanceClass()).thenAnswer(new Returns(String.class)); when(eDataType.getInstanceClassName()).thenReturn(String.class.getTypeName()); singleAttribute = mock(EAttribute.class); when(singleAttribute.isMany()).thenReturn(false); when(singleAttribute.getEAttributeType()).thenReturn(eDataType); // Initialize references singleReference = mock(EReference.class); when(singleReference.isMany()).thenReturn(false); when(singleReference.isContainment()).thenReturn(false); }
@Override public EClassifier caseEDataType(EDataType eDataType) { return otherEType instanceof EDataType && eDataType.getInstanceClass().equals( ((EDataType) otherEType).getInstanceClass()) ? eDataType : EcorePackage.eINSTANCE.getEJavaObject(); }
private boolean isSuperTypeOf(EDataType eDataType1, EDataType eDataType2) { Class<?> instanceClass1 = eDataType1.getInstanceClass(); if (instanceClass1 == null && eDataType1 instanceof EEnum) { instanceClass1 = Enumerator.class; } Class<?> instanceClass2 = eDataType2.getInstanceClass(); if (instanceClass2 == null && eDataType2 instanceof EEnum) { instanceClass2 = Enumerator.class; } if (instanceClass1 == null || instanceClass2 == null) { return true; } else { return instanceClass1.isAssignableFrom(instanceClass2) || instanceClass1.isAssignableFrom(EcoreUtil.wrapperClassFor(instanceClass2)); } }
private boolean isSuperTypeOf(EClassifier eClassifier1, EClassifier eClassifier2) { if (eClassifier1 instanceof EClass && eClassifier2 instanceof EClass) { EClass eClass1 = (EClass)eClassifier1; EClass eClass2 = (EClass)eClassifier2; return eClass1.isSuperTypeOf(eClass2); } else if (eClassifier1 instanceof EDataType && eClassifier2 instanceof EDataType) { EDataType eDataType1 = (EDataType)eClassifier1; EDataType eDataType2 = (EDataType)eClassifier2; Class<?> instanceClass1 = eDataType1.getInstanceClass(); Class<?> instanceClass2 = eDataType2.getInstanceClass(); if (instanceClass1 == null || instanceClass2 == null) { return true; } else { return instanceClass1.isAssignableFrom(instanceClass2); } } else { return false; } }
public String getPrimitiveValueFunction() { Class<?> instanceClass = getEcoreDataType().getInstanceClass(); if (instanceClass == java.lang.Boolean.TYPE) return "booleanValue"; if (instanceClass == java.lang.Byte.TYPE) return "byteValue"; if (instanceClass == java.lang.Character.TYPE) return "charValue"; if (instanceClass == java.lang.Double.TYPE) return "doubleValue"; if (instanceClass == java.lang.Float.TYPE) return "floatValue"; if (instanceClass == java.lang.Integer.TYPE) return "intValue"; if (instanceClass == java.lang.Long.TYPE) return "longValue"; if (instanceClass == java.lang.Short.TYPE) return "shortValue"; return null; }
public String getPrimitiveValueFunction() { Class<?> instanceClass = getEcoreDataType().getInstanceClass(); if (instanceClass == java.lang.Boolean.TYPE) return "booleanValue"; if (instanceClass == java.lang.Byte.TYPE) return "byteValue"; if (instanceClass == java.lang.Character.TYPE) return "charValue"; if (instanceClass == java.lang.Double.TYPE) return "doubleValue"; if (instanceClass == java.lang.Float.TYPE) return "floatValue"; if (instanceClass == java.lang.Integer.TYPE) return "intValue"; if (instanceClass == java.lang.Long.TYPE) return "longValue"; if (instanceClass == java.lang.Short.TYPE) return "shortValue"; return null; }
@Override public Object deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException { final EDataType dataType = EMFContext.getDataType(ctxt); if (dataType == null) { return null; } else { Class<?> type = dataType.getInstanceClass(); if (type == null || dataType instanceof EEnum || EJAVA_CLASS.equals(dataType) || EJAVA_OBJECT.equals(dataType)) { return EcoreUtil.createFromString(dataType, jp.getText()); } else { return ctxt.readValue(jp, type); } } }
@Override public Object deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException { final EDataType dataType = EMFContext.getDataType(ctxt); if (dataType == null) { return null; } else { Class<?> type = dataType.getInstanceClass(); if (type == null || dataType instanceof EEnum || EJAVA_CLASS.equals(dataType) || EJAVA_OBJECT.equals(dataType)) { return EcoreUtil.createFromString(dataType, jp.getText()); } else { return ctxt.readValue(jp, type); } } }
/** * {@inheritDoc} * <p> * Converts an instance of the {@code attribute} to a string literal representation. * * @param value the value of the attribute * @param attribute the attribute to instantiate * * @return the string literal representation of the value, or {@code null} if the {@code value} is {@code null} * * @see #revert(Object, EAttribute) * @see EcoreUtil#convertToString(EDataType, Object) */ @Override public Object convert(@Nullable String value, EAttribute attribute) { if (isNull(value)) { return null; } final EDataType dataType = attribute.getEAttributeType(); if (!(dataType instanceof EEnum) && Primitives.isPrimitiveOrString(dataType.getInstanceClass())) { return EcoreUtil.createFromString(dataType, value); } if (FeatureMapUtil.isFeatureMapEntry(dataType)) { throw new UnsupportedOperationException("FeatureMaps are not supported yet: Use standard EMF to import your model"); } return value; }
protected EStructuralFeature getLabelFeature(EClass eClass) { EAttribute result = null; for (EAttribute eAttribute : eClass.getEAllAttributes()) { if (!eAttribute.isMany() && eAttribute.getEType().getInstanceClass() != FeatureMap.Entry.class) { if ("name".equalsIgnoreCase(eAttribute.getName())) { result = eAttribute; break; } else if (result == null) { result = eAttribute; } else if (eAttribute.getEAttributeType().getInstanceClass() == String.class && result.getEAttributeType().getInstanceClass() != String.class) { result = eAttribute; } } } return result; } }
@Test void testConvertPrimitive() { Class<?> type = Boolean.class; EDataType dataType = mock(EDataType.class); when(dataType.getInstanceClass()).thenAnswer(new Returns(type)); EAttribute attribute = mock(EAttribute.class); when(attribute.getEAttributeType()).thenReturn(dataType); assertThat(converter.convert(true, attribute)).isNotNull().isEqualTo(true); }
@Test void testRevertPrimitive() { Class<?> type = Boolean.class; EDataType dataType = mock(EDataType.class); when(dataType.getInstanceClass()).thenAnswer(new Returns(type)); EAttribute attribute = mock(EAttribute.class); when(attribute.getEAttributeType()).thenReturn(dataType); assertThat(converter.revert(true, attribute)).isNotNull().isEqualTo(true); }
/** */ protected EStructuralFeature getLabelFeature(EClass eClass) { EAttribute result = null; for (EAttribute eAttribute : eClass.getEAllAttributes()) { if (!eAttribute.isMany() && eAttribute.getEType().getInstanceClass() != FeatureMap.Entry.class) { if ("name".equalsIgnoreCase(eAttribute.getName())) { result = eAttribute; break; } else if (result == null) { result = eAttribute; } else if (eAttribute.getEAttributeType().getInstanceClass() == String.class && result.getEAttributeType().getInstanceClass() != String.class) { result = eAttribute; } } } return result; }
/** * @since 1.3 */ @Override public Set<IInputKey> minimizeTypeInformation(final Set<IInputKey> types, final boolean mergeWithSupertypes) { int _size = types.size(); boolean _equals = (_size == 1); if (_equals) { return types; } final Iterable<JavaTransitiveInstancesKey> eJavaTypes = this.minimizeJavaTypeList(IterableExtensions.<JavaTransitiveInstancesKey>filterNull(Iterables.<JavaTransitiveInstancesKey>filter(types, JavaTransitiveInstancesKey.class))); final Function1<EDataTypeInSlotsKey, Boolean> _function = (EDataTypeInSlotsKey it) -> { boolean _xblockexpression = false; { Class<?> _wrapperClassForType = AbstractTypeSystem.getWrapperClassForType(it.getEmfKey().getInstanceClass()); final JavaTransitiveInstancesKey javaType = new JavaTransitiveInstancesKey(_wrapperClassForType); final Function1<JavaTransitiveInstancesKey, Boolean> _function_1 = (JavaTransitiveInstancesKey it_1) -> { return Boolean.valueOf(Objects.equal(it_1, javaType)); }; boolean _exists = IterableExtensions.<JavaTransitiveInstancesKey>exists(eJavaTypes, _function_1); _xblockexpression = (!_exists); } return Boolean.valueOf(_xblockexpression); }; final Iterable<EDataTypeInSlotsKey> eDataTypes = IterableExtensions.<EDataTypeInSlotsKey>filter(this.minimizeEDataTypeList(IterableExtensions.<EDataTypeInSlotsKey>filterNull(Iterables.<EDataTypeInSlotsKey>filter(types, EDataTypeInSlotsKey.class))), _function); final Iterable<EClassTransitiveInstancesKey> eClassTypes = this.minimizeEClassKeyList(IterableExtensions.<EClassTransitiveInstancesKey>filterNull(Iterables.<EClassTransitiveInstancesKey>filter(types, EClassTransitiveInstancesKey.class)), mergeWithSupertypes); return IterableExtensions.<IInputKey>toSet(Iterables.<IInputKey>concat(eClassTypes, Iterables.<IInputKey>concat(eDataTypes, eJavaTypes))); }
public Object toValue(String string, INode node) throws ValueConverterException { try { Object value = dataType.getEPackage().getEFactoryInstance().createFromString(dataType, string); if (value == null && dataType.getInstanceClass().isPrimitive()) { throw new ValueConverterException("Couldn't convert '" + Strings.notNull(string) + "' to " + dataType.getName() + ".", node, null); } return value; } catch (Exception exc) { throw new ValueConverterException("Error converting string to value", node, exc); } }